9 files changed, 303 insertions, 291 deletions

diff --git a/sys/alpha/tlsb/dwlpx.c b/sys/alpha/tlsb/dwlpx.c
index e9f2aa5..14317b6 100644
--- a/sys/alpha/tlsb/dwlpx.c
+++ b/sys/alpha/tlsb/dwlpx.c
@@ -23,7 +23,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	$Id$
+ *	$Id: dwlpx.c,v 1.1 1998/06/10 10:55:41 dfr Exp $
  */
 
 #include "opt_simos.h"
@@ -231,33 +231,37 @@ dwlpx_cfgwritel(u_int b, u_int s, u_int f, u_int r, u_int32_t data)
 	SPARSE_WRITE_LONG(sc->cfg_base, off, data);
 }
 
-static driver_probe_t	dwlpx_probe;
-static driver_attach_t	dwlpx_attach;
+static int dwlpx_probe(device_t dev);
+static int dwlpx_attach(device_t dev);
 static driver_intr_t	dwlpx_intr;
 
+static device_method_t dwlpx_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		dwlpx_probe),
+	DEVMETHOD(device_attach,	dwlpx_attach),
+
+	{ 0, 0 }
+};
+
 static driver_t dwlpx_driver = {
 	"dwlpx",
-	dwlpx_probe,
-	dwlpx_attach,
-	NULL,
-	NULL,
+	dwlpx_methods,
 	DRIVER_TYPE_MISC,
 	sizeof(struct dwlpx_softc),
-	NULL,
 };
 
-
 static int
-dwlpx_probe(bus_t bus, device_t dev)
+dwlpx_probe(device_t dev)
 {
 	if (dwlpx0)
 		return ENXIO;
+	dwlpx0 = dev;
 	device_set_desc(dev, "DWLPA or DWLPB PCI adapter");
 	return 0;
 }
 
 static int
-dwlpx_attach(bus_t bus, device_t dev)
+dwlpx_attach(device_t dev)
 {
 	struct dwlpx_softc* sc = DWLPX_SOFTC(dev);
 	vm_offset_t regs;
@@ -273,7 +277,7 @@ dwlpx_attach(bus_t bus, device_t dev)
 
 	*(u_int32_t*) (regs + PCIA_CTL(0)) = 1;	/* Type1 config cycles */
 
-	bus_map_intr(bus, dev, dwlpx_intr, 0);
+	BUS_MAP_INTR(device_get_parent(dev), dev, dwlpx_intr, 0);
 
 	return 0;
 }
diff --git a/sys/alpha/tlsb/gbus.c b/sys/alpha/tlsb/gbus.c
index 5235284..c7a1191 100644
--- a/sys/alpha/tlsb/gbus.c
+++ b/sys/alpha/tlsb/gbus.c
@@ -75,54 +75,33 @@ struct gbus_device gbus_children[] = {
 static devclass_t gbus_devclass;
 
 /*
- * Bus handlers.
+ * Device methods
  */
-static bus_print_device_t	gbus_print_device;
-static bus_read_ivar_t		gbus_read_ivar;
-
-static bus_ops_t gbus_bus_ops = {
-	gbus_print_device,
-	gbus_read_ivar,
-	null_write_ivar,
-	null_map_intr,
+static int gbus_probe(device_t dev);
+static void gbus_print_child(device_t dev, device_t child);
+static int gbus_read_ivar(device_t dev, device_t child, int which, u_long *result);;
+
+static device_method_t gbus_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		gbus_probe),
+	DEVMETHOD(device_attach,	bus_generic_attach),
+	DEVMETHOD(device_detach,	bus_generic_detach),
+	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
+
+	/* Bus interface */
+	DEVMETHOD(bus_print_child,	gbus_print_child),
+	DEVMETHOD(bus_read_ivar,	gbus_read_ivar),
+	DEVMETHOD(bus_write_ivar,	bus_generic_write_ivar),
+	DEVMETHOD(bus_map_intr,		bus_generic_map_intr),
+
+	{ 0, 0 }
 };
 
-static void
-gbus_print_device(bus_t bus, device_t dev)
-{
-	struct gbus_device* gdev = DEVTOGBUS(dev);
-	device_t gbusdev = bus_get_device(bus);
-
-	printf(" at %s%d offset 0x%lx",
-	       device_get_name(gbusdev), device_get_unit(gbusdev),
-	       gdev->gd_offset);
-}
-
-static int
-gbus_read_ivar(bus_t bus, device_t dev,
-	       int index, u_long* result)
-{
-	struct gbus_device* gdev = DEVTOGBUS(dev);
-
-	switch (index) {
-	case GBUS_IVAR_OFFSET:
-		*result = gdev->gd_offset;
-		break;
-	}
-	return ENOENT;
-}
-
-static driver_probe_t gbus_bus_probe;
-
-static driver_t gbus_bus_driver = {
+static driver_t gbus_driver = {
 	"gbus",
-	gbus_bus_probe,
-	bus_generic_attach,
-	bus_generic_detach,
-	bus_generic_shutdown,
+	gbus_methods,
 	DRIVER_TYPE_MISC,
-	sizeof(struct bus),
-	NULL,
+	1,			/* no softc */
 };
 
 /*
@@ -131,9 +110,8 @@ static driver_t gbus_bus_driver = {
  * are alive.
  */
 static int
-gbus_bus_probe(bus_t parent, device_t dev)
+gbus_probe(device_t dev)
 {
-	bus_t bus = device_get_softc(dev);
 	struct gbus_device *gdev;
 
 	/*
@@ -144,12 +122,34 @@ gbus_bus_probe(bus_t parent, device_t dev)
 	if (!TLDEV_ISCPU(tlsb_get_dtype(dev)))
 		return ENXIO;
 
-	bus_init(bus, dev, &gbus_bus_ops);
-
 	for (gdev = gbus_children; gdev->gd_name; gdev++)
-		bus_add_device(bus, gdev->gd_name, -1, gdev);
+		device_add_child(dev, gdev->gd_name, -1, gdev);
 
 	return 0;
 }
 
-DRIVER_MODULE(gbus, tlsb, gbus_bus_driver, gbus_devclass, 0, 0);
+static void
+gbus_print_child(device_t bus, device_t dev)
+{
+	struct gbus_device* gdev = DEVTOGBUS(dev);
+
+	printf(" at %s%d offset 0x%lx",
+	       device_get_name(bus), device_get_unit(bus),
+	       gdev->gd_offset);
+}
+
+static int
+gbus_read_ivar(device_t bus, device_t dev,
+	       int index, u_long* result)
+{
+	struct gbus_device* gdev = DEVTOGBUS(dev);
+
+	switch (index) {
+	case GBUS_IVAR_OFFSET:
+		*result = gdev->gd_offset;
+		break;
+	}
+	return ENOENT;
+}
+
+DRIVER_MODULE(gbus, tlsb, gbus_driver, gbus_devclass, 0, 0);
diff --git a/sys/alpha/tlsb/gbusvar.h b/sys/alpha/tlsb/gbusvar.h
index 1575817..5ece6e0 100644
--- a/sys/alpha/tlsb/gbusvar.h
+++ b/sys/alpha/tlsb/gbusvar.h
@@ -23,7 +23,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	$Id$
+ *	$Id: gbusvar.h,v 1.2 1998/06/10 20:40:59 dfr Exp $
  */
 /* $NetBSD: gbusvar.h,v 1.1 1998/05/13 02:50:29 thorpej Exp $ */
 
@@ -81,7 +81,7 @@ enum gbus_device_ivars {
 static __inline T gbus_get_ ## A(device_t dev)				 \
 {									 \
 	u_long v;							 \
-	bus_read_ivar(device_get_parent(dev), dev, GBUS_IVAR_ ## B, &v); \
+	BUS_READ_IVAR(device_get_parent(dev), dev, GBUS_IVAR_ ## B, &v); \
 	return (T) v;							 \
 }
 
diff --git a/sys/alpha/tlsb/kftxx.c b/sys/alpha/tlsb/kftxx.c
index 9f41b62..d2b19d2 100644
--- a/sys/alpha/tlsb/kftxx.c
+++ b/sys/alpha/tlsb/kftxx.c
@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $Id: kftxx.c,v 1.1 1998/06/10 10:55:49 dfr Exp $ */
 /* $NetBSD: kftxx.c,v 1.9 1998/05/14 00:01:32 thorpej Exp $ */
 
 /*
@@ -53,7 +53,6 @@
 #include <alpha/tlsb/kftxxvar.h>
 
 struct kft_softc {
-	struct bus	sc_bus;		/* bus common */
 	int		sc_node;	/* TLSB node */
 	u_int16_t	sc_dtype;	/* device type */
 };
@@ -73,72 +72,37 @@ struct kft_device {
 static devclass_t kft_devclass;
 
 /*
- * Bus handlers.
+ * Device methods
  */
-static bus_print_device_t	kft_print_device;
-static bus_read_ivar_t		kft_read_ivar;
-
-static bus_ops_t kft_bus_ops = {
-	kft_print_device,
-	kft_read_ivar,
-	null_write_ivar,
-	null_map_intr,
+static int kft_probe(device_t dev);
+static void kft_print_child(device_t dev, device_t child);
+static int kft_read_ivar(device_t dev, device_t child, int which, u_long *result);;
+
+static device_method_t kft_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		kft_probe),
+	DEVMETHOD(device_attach,	bus_generic_attach),
+	DEVMETHOD(device_detach,	bus_generic_detach),
+	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
+
+	/* Bus interface */
+	DEVMETHOD(bus_print_child,	kft_print_child),
+	DEVMETHOD(bus_read_ivar,	kft_read_ivar),
+	DEVMETHOD(bus_write_ivar,	bus_generic_write_ivar),
+	DEVMETHOD(bus_map_intr,		bus_generic_map_intr),
+
+	{ 0, 0 }
 };
 
-static void
-kft_print_device(bus_t bus, device_t dev)
-{
-	struct kft_device *kd = (struct kft_device*) device_get_ivars(dev);
-	device_t busdev = bus_get_device(bus);
-
-	printf(" at %s%d hose %d",
-	       device_get_name(busdev), device_get_unit(busdev),
-	       kd->kd_hosenum);
-}
-
-static int
-kft_read_ivar(bus_t bus, device_t dev,
-	       int index, u_long* result)
-{
-	struct kft_device *kd = (struct kft_device*) device_get_ivars(dev);
-
-	switch (index) {
-	case KFT_IVAR_NAME:
-		*result = (u_long) kd->kd_name;
-		return 0;
-
-	case KFT_IVAR_NODE:
-		*result = (u_long) kd->kd_node;
-		return 0;
-
-	case KFT_IVAR_DTYPE:
-		*result = (u_long) kd->kd_dtype;
-		return 0;
-
-	case KFT_IVAR_HOSENUM:
-		*result = (u_long) kd->kd_hosenum;
-		return 0;
-
-	default:
-		return ENOENT;
-	}
-}
-
-static driver_probe_t kft_bus_probe;
-
-static driver_t kft_bus_driver = {
+static driver_t kft_driver = {
 	"kft",
-	kft_bus_probe,
-	bus_generic_attach,
-	bus_generic_detach,
-	bus_generic_shutdown,
+	kft_methods,
 	DRIVER_TYPE_MISC,
-	sizeof(struct kft_softc),
-	NULL,
+	1,			/* no softc */
 };
 
 static int
-kft_bus_probe(bus_t parent, device_t dev)
+kft_probe(device_t dev)
 {
 	struct kft_softc *sc = (struct kft_softc *) device_get_softc(dev);
 	struct kft_device* kd;
@@ -147,8 +111,6 @@ kft_bus_probe(bus_t parent, device_t dev)
 	if (!TLDEV_ISIOPORT(tlsb_get_dtype(dev)))
 		return ENXIO;
 
-	bus_init(&sc->sc_bus, dev, &kft_bus_ops);
-
 	sc->sc_node = tlsb_get_node(dev);
 	sc->sc_dtype = tlsb_get_dtype(dev);
 
@@ -183,10 +145,48 @@ kft_bus_probe(bus_t parent, device_t dev)
 		kd->kd_node = sc->sc_node;
 		kd->kd_dtype = sc->sc_dtype;
 		kd->kd_hosenum = hoseno;
-		bus_add_device(&sc->sc_bus, kd->kd_name, -1, kd);
+		device_add_child(dev, kd->kd_name, -1, kd);
 	}
 
 	return 0;
 }
 
-DRIVER_MODULE(kft, tlsb, kft_bus_driver, kft_devclass, 0, 0);
+static void
+kft_print_child(device_t bus, device_t dev)
+{
+	struct kft_device *kd = (struct kft_device*) device_get_ivars(dev);
+
+	printf(" at %s%d hose %d",
+	       device_get_name(bus), device_get_unit(bus),
+	       kd->kd_hosenum);
+}
+
+static int
+kft_read_ivar(device_t bus, device_t dev,
+	      int index, u_long* result)
+{
+	struct kft_device *kd = (struct kft_device*) device_get_ivars(dev);
+
+	switch (index) {
+	case KFT_IVAR_NAME:
+		*result = (u_long) kd->kd_name;
+		return 0;
+
+	case KFT_IVAR_NODE:
+		*result = (u_long) kd->kd_node;
+		return 0;
+
+	case KFT_IVAR_DTYPE:
+		*result = (u_long) kd->kd_dtype;
+		return 0;
+
+	case KFT_IVAR_HOSENUM:
+		*result = (u_long) kd->kd_hosenum;
+		return 0;
+
+	default:
+		return ENOENT;
+	}
+}
+
+DRIVER_MODULE(kft, tlsb, kft_driver, kft_devclass, 0, 0);
diff --git a/sys/alpha/tlsb/kftxxvar.h b/sys/alpha/tlsb/kftxxvar.h
index 40c7424..56168e6 100644
--- a/sys/alpha/tlsb/kftxxvar.h
+++ b/sys/alpha/tlsb/kftxxvar.h
@@ -23,7 +23,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	$Id$
+ *	$Id: kftxxvar.h,v 1.2 1998/06/10 20:48:03 dfr Exp $
  */
 
 /*
@@ -45,7 +45,7 @@ enum kft_dev_ivars {
 static __inline T kft_get_ ## A(device_t dev)				 \
 {									 \
 	u_long v;							 \
-	bus_read_ivar(device_get_parent(dev), dev, KFT_IVAR_ ## B, &v);  \
+	BUS_READ_IVAR(device_get_parent(dev), dev, KFT_IVAR_ ## B, &v);  \
 	return (T) v;							 \
 }
 
diff --git a/sys/alpha/tlsb/mcclock_tlsb.c b/sys/alpha/tlsb/mcclock_tlsb.c
index 15974fc..593b00f 100644
--- a/sys/alpha/tlsb/mcclock_tlsb.c
+++ b/sys/alpha/tlsb/mcclock_tlsb.c
@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $Id: mcclock_tlsb.c,v 1.1 1998/06/10 10:55:52 dfr Exp $ */
 /* $NetBSD: mcclock_tlsb.c,v 1.8 1998/05/13 02:50:29 thorpej Exp $ */
 
 /*
@@ -37,7 +37,7 @@
 #include <sys/module.h>
 #include <sys/bus.h>
 
-#include <dev/dec/clockvar.h>
+#include <machine/clockvar.h>
 #include <dev/dec/mcclockvar.h>
 
 #include <alpha/tlsb/gbusvar.h>
@@ -53,71 +53,73 @@
 #define	REGSHIFT	6
 
 struct mcclock_tlsb_softc {
-	struct mcclock_softc	sc_mcclock;
 	unsigned long regbase;
 };
 
-static int mcclock_tlsb_probe(bus_t, device_t);
-static int mcclock_tlsb_attach(bus_t, device_t);
+static int	mcclock_tlsb_probe(device_t dev);
+static int	mcclock_tlsb_attach(device_t dev);
+static void	mcclock_tlsb_write(device_t, u_int, u_int);
+static u_int	mcclock_tlsb_read(device_t, u_int);
 
-static devclass_t mcclock_devclass;
+static device_method_t mcclock_tlsb_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		mcclock_tlsb_probe),
+	DEVMETHOD(device_attach,	mcclock_tlsb_attach),
+
+	/* mcclock interface */
+	DEVMETHOD(mcclock_write,	mcclock_tlsb_write),
+	DEVMETHOD(mcclock_read,		mcclock_tlsb_read),
+
+	/* clock interface */
+	DEVMETHOD(clock_init,		mcclock_init),
+	DEVMETHOD(clock_get,		mcclock_get),
+	DEVMETHOD(clock_set,		mcclock_set),
+
+	{ 0, 0 }
+};
 
-driver_t mcclock_tlsb_driver = {
+static driver_t mcclock_tlsb_driver = {
 	"mcclock",
-	mcclock_tlsb_probe,
-	mcclock_tlsb_attach,
-	NULL,
-	NULL,
+	mcclock_tlsb_methods,
 	DRIVER_TYPE_MISC,
 	sizeof(struct mcclock_tlsb_softc),
-	NULL,
 };
 
-static void	mcclock_tlsb_write __P((struct mcclock_softc *, u_int, u_int));
-static u_int	mcclock_tlsb_read __P((struct mcclock_softc *, u_int));
-
-const struct mcclock_busfns mcclock_tlsb_busfns = {
-	mcclock_tlsb_write, mcclock_tlsb_read,
-};
+static devclass_t mcclock_devclass;
 
 int
-mcclock_tlsb_probe(bus_t bus, device_t dev)
+mcclock_tlsb_probe(device_t dev)
 {
 	device_set_desc(dev, "MC146818A real time clock");
 	return 0;
 }
 
 int
-mcclock_tlsb_attach(bus_t bus, device_t dev)
+mcclock_tlsb_attach(device_t dev)
 {
 	struct mcclock_tlsb_softc *sc = device_get_softc(dev);
 
 	/* XXX Should be bus.h'd, so we can accomodate the kn7aa. */
 
-	sc->sc_mcclock.sc_dev = dev;
 	sc->regbase = TLSB_GBUS_BASE + gbus_get_offset(dev);
 
-	mcclock_attach(&sc->sc_mcclock, &mcclock_tlsb_busfns);
+	mcclock_attach(dev);
 	return 0;
 }
 
 static void
-mcclock_tlsb_write(mcsc, reg, val)
-	struct mcclock_softc *mcsc;
-	u_int reg, val;
+mcclock_tlsb_write(device_t dev, u_int reg, u_int val)
 {
-	struct mcclock_tlsb_softc *sc = (struct mcclock_tlsb_softc *)mcsc;
+	struct mcclock_tlsb_softc *sc = device_get_softc(dev);
 	unsigned char *ptr = (unsigned char *)
 		KV(sc->regbase + (reg << REGSHIFT));
 	*ptr = val;
 }
 
 static u_int
-mcclock_tlsb_read(mcsc, reg)
-	struct mcclock_softc *mcsc;
-	u_int reg;
+mcclock_tlsb_read(device_t dev, u_int reg)
 {
-	struct mcclock_tlsb_softc *sc = (struct mcclock_tlsb_softc *)mcsc;
+	struct mcclock_tlsb_softc *sc = device_get_softc(dev);
 	unsigned char *ptr = (unsigned char *)
 		KV(sc->regbase + (reg << REGSHIFT));
 	return *ptr;
diff --git a/sys/alpha/tlsb/tlsb.c b/sys/alpha/tlsb/tlsb.c
index 7b778ac..cb9639f 100644
--- a/sys/alpha/tlsb/tlsb.c
+++ b/sys/alpha/tlsb/tlsb.c
@@ -78,7 +78,6 @@ struct intr_mapping {
 };
 
 struct tlsb_softc {
-	struct bus bus;
 	STAILQ_HEAD(, intr_mapping) intr_handlers;
 };
 
@@ -86,88 +85,39 @@ static char	*tlsb_node_type_str(u_int32_t);
 static void	tlsb_intr(void* frame, u_long vector);
 
 /* There can be only one. */
-static int	tlsb_found;
-static struct tlsb_softc* tlsb0_softc;
+static int			tlsb_found;
+static struct tlsb_softc*	tlsb0_softc;
+static devclass_t		tlsb_devclass;
 
 /*
- * Bus handlers.
+ * Device methods
  */
-static bus_print_device_t	tlsb_print_device;
-static bus_read_ivar_t		tlsb_read_ivar;
-static bus_map_intr_t		tlsb_map_intr;
-
-static bus_ops_t tlsb_bus_ops = {
-	tlsb_print_device,
-	tlsb_read_ivar,
-	null_write_ivar,
-	tlsb_map_intr,
+static int tlsb_probe(device_t dev);
+static void tlsb_print_child(device_t dev, device_t child);
+static int tlsb_read_ivar(device_t dev, device_t child, int which, u_long* result);
+static int tlsb_map_intr(device_t dev, device_t child, driver_intr_t *intr, void *arg);
+
+static device_method_t tlsb_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		tlsb_probe),
+	DEVMETHOD(device_attach,	bus_generic_attach),
+	DEVMETHOD(device_detach,	bus_generic_detach),
+	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
+
+	/* Bus interface */
+	DEVMETHOD(bus_print_child,	tlsb_print_child),
+	DEVMETHOD(bus_read_ivar,	tlsb_read_ivar),
+	DEVMETHOD(bus_write_ivar,	bus_generic_write_ivar),
+	DEVMETHOD(bus_map_intr,		tlsb_map_intr),
+
+	{ 0, 0 }
 };
 
-static void
-tlsb_print_device(bus_t bus, device_t dev)
-{
-	device_t busdev = bus_get_device(bus);
-	struct tlsb_device* tdev = DEVTOTLSB(dev);
-
-	printf(" at %s%d node %d",
-	       device_get_name(busdev),
-	       device_get_unit(busdev),
-	       tdev->td_node);
-}
-
-static int
-tlsb_read_ivar(bus_t bus, device_t dev,
-	       int index, u_long* result)
-{
-	struct tlsb_device* tdev = DEVTOTLSB(dev);
-
-	switch (index) {
-	case TLSB_IVAR_NODE:
-		*result = tdev->td_node;
-		break;
-
-	case TLSB_IVAR_DTYPE:
-		*result = tdev->td_dtype;
-		break;
-
-	case TLSB_IVAR_SWREV:
-		*result = tdev->td_swrev;
-		break;
-
-	case TLSB_IVAR_HWREV:
-		*result = tdev->td_hwrev;
-		break;
-	}
-	return ENOENT;
-}
-
-static int
-tlsb_map_intr(bus_t bus, device_t dev, driver_intr_t *intr, void *arg)
-{
-	struct tlsb_softc* sc = (struct tlsb_softc*) bus;
-	struct intr_mapping* i;
-	i = malloc(sizeof(struct intr_mapping), M_DEVBUF, M_NOWAIT);
-	if (!i)
-		return ENOMEM;
-	i->intr = intr;
-	i->arg = arg;
-	STAILQ_INSERT_TAIL(&sc->intr_handlers, i, queue);
-
-	return 0;
-}
-
-static driver_probe_t tlsb_bus_probe;
-static devclass_t tlsb_devclass;
-
-static driver_t tlsb_bus_driver = {
+static driver_t tlsb_driver = {
 	"tlsb",
-	tlsb_bus_probe,
-	bus_generic_attach,
-	bus_generic_detach,
-	bus_generic_shutdown,
+	tlsb_methods,
 	DRIVER_TYPE_MISC,
 	sizeof(struct tlsb_softc),
-	NULL,
 };
 
 /*
@@ -176,17 +126,17 @@ static driver_t tlsb_bus_driver = {
  * are alive.
  */
 static int
-tlsb_bus_probe(bus_t parent, device_t dev)
+tlsb_probe(device_t dev)
 {
 	struct tlsb_softc* sc = device_get_softc(dev);
 	struct tlsb_device *tdev;
 	u_int32_t tldev;
 	u_int8_t vid;
 	int node;
-	device_t subdev;
+	device_t child;
 
 	device_set_desc(dev, "TurboLaser bus");
-	bus_init(&sc->bus, dev, &tlsb_bus_ops);
+
 	STAILQ_INIT(&sc->intr_handlers);
 	tlsb0_softc = sc;
 
@@ -252,8 +202,8 @@ tlsb_bus_probe(bus_t parent, device_t dev)
 		tdev->td_swrev = TLDEV_SWREV(tldev);
 		tdev->td_hwrev = TLDEV_HWREV(tldev);
 
-		subdev = bus_add_device(&sc->bus, NULL, -1, tdev);
-		device_set_desc(subdev, tlsb_node_type_str(tdev->td_dtype));
+		child = device_add_child(dev, NULL, -1, tdev);
+		device_set_desc(child, tlsb_node_type_str(tdev->td_dtype));
 
 		/*
 		 * Deal with hooking CPU instances to TurboLaser nodes.
@@ -277,6 +227,58 @@ tlsb_bus_probe(bus_t parent, device_t dev)
 }
 
 static void
+tlsb_print_child(device_t dev, device_t child)
+{
+	struct tlsb_device* tdev = DEVTOTLSB(child);
+
+	printf(" at %s%d node %d",
+	       device_get_name(dev),
+	       device_get_unit(dev),
+	       tdev->td_node);
+}
+
+static int
+tlsb_read_ivar(device_t dev, device_t child,
+	       int index, u_long* result)
+{
+	struct tlsb_device* tdev = DEVTOTLSB(child);
+
+	switch (index) {
+	case TLSB_IVAR_NODE:
+		*result = tdev->td_node;
+		break;
+
+	case TLSB_IVAR_DTYPE:
+		*result = tdev->td_dtype;
+		break;
+
+	case TLSB_IVAR_SWREV:
+		*result = tdev->td_swrev;
+		break;
+
+	case TLSB_IVAR_HWREV:
+		*result = tdev->td_hwrev;
+		break;
+	}
+	return ENOENT;
+}
+
+static int
+tlsb_map_intr(device_t dev, device_t child, driver_intr_t *intr, void *arg)
+{
+	struct tlsb_softc* sc = device_get_softc(dev);
+	struct intr_mapping* i;
+	i = malloc(sizeof(struct intr_mapping), M_DEVBUF, M_NOWAIT);
+	if (!i)
+		return ENOMEM;
+	i->intr = intr;
+	i->arg = arg;
+	STAILQ_INSERT_TAIL(&sc->intr_handlers, i, queue);
+
+	return 0;
+}
+
+static void
 tlsb_intr(void* frame, u_long vector)
 {
 	struct tlsb_softc* sc = tlsb0_softc;
@@ -291,7 +293,7 @@ tlsb_intr(void* frame, u_long vector)
 		i->intr(i->arg);
 }
 
-DRIVER_MODULE(tlsb, root, tlsb_bus_driver, tlsb_devclass, 0, 0);
+DRIVER_MODULE(tlsb, root, tlsb_driver, tlsb_devclass, 0, 0);
 
 static char *
 tlsb_node_type_str(u_int32_t dtype)
diff --git a/sys/alpha/tlsb/tlsbvar.h b/sys/alpha/tlsb/tlsbvar.h
index bfb24ed..6b72785 100644
--- a/sys/alpha/tlsb/tlsbvar.h
+++ b/sys/alpha/tlsb/tlsbvar.h
@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $Id: tlsbvar.h,v 1.1 1998/06/10 10:55:58 dfr Exp $ */
 /* $NetBSD: tlsbvar.h,v 1.5 1998/05/13 23:23:23 thorpej Exp $ */
 
 /*
@@ -55,7 +55,7 @@ enum tlsb_device_instvars {
 static __inline T tlsb_get_ ## A(device_t dev)				 \
 {									 \
 	u_long v;							 \
-	bus_read_ivar(device_get_parent(dev), dev, TLSB_IVAR_ ## B, &v); \
+	BUS_READ_IVAR(device_get_parent(dev), dev, TLSB_IVAR_ ## B, &v); \
 	return v;							 \
 }
 
diff --git a/sys/alpha/tlsb/zs_tlsb.c b/sys/alpha/tlsb/zs_tlsb.c
index 8532ed3..bc20705 100644
--- a/sys/alpha/tlsb/zs_tlsb.c
+++ b/sys/alpha/tlsb/zs_tlsb.c
@@ -23,7 +23,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	$Id$
+ *	$Id: zs_tlsb.c,v 1.1 1998/06/10 10:55:59 dfr Exp $
  */
 /*
  * This driver is a hopeless hack to get the SimOS console working.  A real
@@ -47,6 +47,7 @@
 #include <alpha/tlsb/gbusvar.h>
 #include <alpha/tlsb/tlsbreg.h>		/* XXX */
 #include <alpha/tlsb/zsreg.h>
+#include <alpha/tlsb/zsvar.h>
 
 #define	KV(_addr)	((caddr_t)ALPHA_PHYS_TO_K0SEG((_addr)))
 
@@ -96,31 +97,35 @@ struct consdev zs_cons = {
 static caddr_t zs_console_addr;
 static int zs_console;
 
-static int zs_probe(bus_t, device_t);
-static int zs_attach(bus_t, device_t);
+static int zs_probe(device_t);
+static int zs_attach(device_t);
 
 static devclass_t zs_devclass;
 static devclass_t zsc_devclass;
 
-driver_t zs_driver = {
+static device_method_t zs_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		zs_probe),
+	DEVMETHOD(device_attach,	zs_attach),
+
+	{ 0, 0 }
+};
+
+static driver_t zs_driver = {
 	"zs",
-	zs_probe,
-	zs_attach,
-	NULL,
-	NULL,
+	zs_methods,
 	DRIVER_TYPE_MISC,
 	sizeof(struct zs_softc),
-	NULL,
 };
 
 static int
-zs_probe(bus_t bus, device_t dev)
+zs_probe(device_t dev)
 {
 	return 0;
 }
 
 static int
-zs_attach(bus_t bus, device_t dev)
+zs_attach(device_t dev)
 {
 	struct zs_softc *sc = device_get_softc(dev);
 
@@ -355,34 +360,38 @@ CDEV_DRIVER_MODULE(zs, zsc, zs_driver, zs_devclass,
  */
 
 struct zsc_softc {
-	struct bus bus;
 	caddr_t base;
 	struct zs_softc* sc_a;
 	struct zs_softc* sc_b;
 };
 
-static driver_probe_t		zsc_tlsb_probe;
-static driver_attach_t		zsc_tlsb_attach;
-static driver_intr_t		zsc_tlsb_intr;
-static bus_print_device_t	zsc_tlsb_print_device;
+static int zsc_tlsb_probe(device_t dev);
+static int zsc_tlsb_attach(device_t dev);
+static void zsc_tlsb_print_child(device_t dev, device_t child);
+static driver_intr_t zsc_tlsb_intr;
+
+
+static device_method_t zsc_tlsb_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		zsc_tlsb_probe),
+	DEVMETHOD(device_attach,	zsc_tlsb_attach),
+	DEVMETHOD(device_detach,	bus_generic_detach),
+	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
+
+	/* Bus interface */
+	DEVMETHOD(bus_print_child,	zsc_tlsb_print_child),
+	DEVMETHOD(bus_read_ivar,	bus_generic_read_ivar),
+	DEVMETHOD(bus_write_ivar,	bus_generic_write_ivar),
+	DEVMETHOD(bus_map_intr,		bus_generic_map_intr),
 
-driver_t zsc_tlsb_driver = {
+	{ 0, 0 }
+};
+
+static driver_t zsc_tlsb_driver = {
 	"zsc",
-	zsc_tlsb_probe,
-	zsc_tlsb_attach,
-	NULL,
-	NULL,
+	zsc_tlsb_methods,
 	DRIVER_TYPE_MISC,
 	sizeof(struct zsc_softc),
-	NULL,
-};
-
-
-static bus_ops_t zsc_tlsb_ops = {
-	zsc_tlsb_print_device,
-	null_read_ivar,
-	null_write_ivar,
-	null_map_intr,
 };
 
 static int
@@ -394,56 +403,51 @@ zsc_get_channel(device_t dev)
 static caddr_t
 zsc_get_base(device_t dev)
 {
-	device_t busdev = bus_get_device(device_get_parent(dev));
-	struct zsc_softc* sc = device_get_softc(busdev);
+	device_t bus = device_get_parent(dev);
+	struct zsc_softc* sc = device_get_softc(bus);
 	return sc->base;
 }
 
-static void
-zsc_tlsb_print_device(bus_t bus, device_t dev)
-{
-	device_t busdev = bus_get_device(bus);
-
-	printf(" at %s%d channel %c",
-	       device_get_name(busdev), device_get_unit(busdev),
-	       'A' + (device_get_unit(dev) & 1));
-}
-
 static int
-zsc_tlsb_probe(bus_t parent, device_t dev)
+zsc_tlsb_probe(device_t dev)
 {
 	struct zsc_softc* sc = device_get_softc(dev);
 
 	device_set_desc(dev, "Z8530 uart");
 
-	bus_init(&sc->bus, dev, &zsc_tlsb_ops);
-
 	sc->base = (caddr_t) ALPHA_PHYS_TO_K0SEG(TLSB_GBUS_BASE
 						 + gbus_get_offset(dev));
 
 	/*
 	 * Add channel A for now.
 	 */
-	bus_add_device(&sc->bus, "zs", -1, (void*) 0);
+	device_add_child(dev, "zs", -1, (void*) 0);
 
 	return 0;
 }
 
 static int
-zsc_tlsb_attach(bus_t parent, device_t dev)
+zsc_tlsb_attach(device_t dev)
 {
 	struct zsc_softc* sc = device_get_softc(dev);
 
-	bus_generic_attach(parent, dev);
+	bus_generic_attach(dev);
 	
 	/* XXX */
 	sc->sc_a = ZS_SOFTC(0);
 
-	bus_map_intr(parent, dev, zsc_tlsb_intr, sc);
+	BUS_MAP_INTR(device_get_parent(dev), dev, zsc_tlsb_intr, sc);
 
 	return 0;
 }
 
+static void
+zsc_tlsb_print_child(device_t bus, device_t dev)
+{
+	printf(" at %s%d channel %c",
+	       device_get_name(bus), device_get_unit(bus),
+	       'A' + (device_get_unit(dev) & 1));
+}
 
 static void
 zsc_tlsb_intr(void* arg)