diff --git a/sys/powerpc/psim/iobus.c b/sys/powerpc/psim/iobus.c
--- a/sys/powerpc/psim/iobus.c
+++ b/sys/powerpc/psim/iobus.c
@@ -70,13 +70,21 @@
 static void iobus_probe_nomatch(device_t, device_t);
 static int  iobus_read_ivar(device_t, device_t, int, uintptr_t *);
 static int  iobus_write_ivar(device_t, device_t, int, uintptr_t);
+static struct rman *iobus_get_rman(device_t, int, u_int);
 static struct   resource *iobus_alloc_resource(device_t, device_t, int, int *,
 					       rman_res_t, rman_res_t, rman_res_t,
 					       u_int);
+static int  iobus_adjust_resource(device_t, device_t, int, struct resource *,
+				  rman_res_t, rman_res_t);
 static int  iobus_activate_resource(device_t, device_t, int, int,
 				    struct resource *);
 static int  iobus_deactivate_resource(device_t, device_t, int, int,
 				      struct resource *);
+static int  iobus_map_resource(device_t, device_t, int, struct resource *,
+			       struct resource_map_request *,
+			       struct resource_map *);
+static int  iobus_unmap_resource(device_t, device_t, int, struct resource *,
+				 struct resource_map *);
 static int  iobus_release_resource(device_t, device_t, int, int,
 				   struct resource *);
 
@@ -100,10 +108,14 @@
         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
 
+	DEVMETHOD(bus_get_rman,		iobus_get_rman),
         DEVMETHOD(bus_alloc_resource,   iobus_alloc_resource),
+	DEVMETHOD(bus_adjust_resource,	iobus_adjust_resource),
         DEVMETHOD(bus_release_resource, iobus_release_resource),
         DEVMETHOD(bus_activate_resource, iobus_activate_resource),
         DEVMETHOD(bus_deactivate_resource, iobus_deactivate_resource),
+	DEVMETHOD(bus_map_resource,	iobus_map_resource),
+	DEVMETHOD(bus_unmap_resource,	iobus_unmap_resource),
         { 0, 0 }
 };
 
@@ -293,26 +305,32 @@
         return (EINVAL);
 }
 
-static struct resource *
-iobus_alloc_resource(device_t bus, device_t child, int type, int *rid,
-		     rman_res_t start, rman_res_t end, rman_res_t count,
-		     u_int flags)
+static struct rman *
+iobus_get_rman(device_t bus, int type, u_int flags)
 {
 	struct iobus_softc *sc;
-	int  needactivate;
-	struct  resource *rv;
-	struct  rman *rm;
 
 	sc = device_get_softc(bus);
+	switch (type) {
+	case SYS_RES_MEMORY:
+	case SYS_RES_IOPORT:
+		return (&sc->sc_mem_rman);
+	default:
+		return (NULL);
+	}
+}
 
-	needactivate = flags & RF_ACTIVE;
-	flags &= ~RF_ACTIVE;
+static struct resource *
+iobus_alloc_resource(device_t bus, device_t child, int type, int *rid,
+		     rman_res_t start, rman_res_t end, rman_res_t count,
+		     u_int flags)
+{
 
 	switch (type) {
 	case SYS_RES_MEMORY:
 	case SYS_RES_IOPORT:
-		rm = &sc->sc_mem_rman;
-		break;
+		return (bus_generic_rman_alloc_resource(bus, child, type, rid,
+		    start, end, count, flags));
 	case SYS_RES_IRQ:
 		return (bus_alloc_resource(bus, type, rid, start, end, count,
 		    flags));
@@ -321,80 +339,125 @@
 		    device_get_nameunit(child));
 		return (NULL);
 	}
+}
 
-	rv = rman_reserve_resource(rm, start, end, count, flags, child);
-	if (rv == NULL) {
-		device_printf(bus, "failed to reserve resource for %s\n",
-			      device_get_nameunit(child));
-		return (NULL);
-	}
-
-	rman_set_rid(rv, *rid);
-
-	if (needactivate) {
-		if (bus_activate_resource(child, type, *rid, rv) != 0) {
-                        device_printf(bus,
-				      "failed to activate resource for %s\n",
-				      device_get_nameunit(child));
-			rman_release_resource(rv);
-			return (NULL);
-                }
-        }
+static int
+iobus_adjust_resource(device_t bus, device_t child, int type,
+    struct resource *r, rman_res_t start, rman_res_t end)
+{
 
-	return (rv);	
+	switch (type) {
+	case SYS_RES_MEMORY:
+	case SYS_RES_IOPORT:
+		return (bus_generic_rman_adjust_resource(bus, child, type, r,
+		    start, end));
+	case SYS_RES_IRQ:
+		return (bus_adjust_resource(bus, type, r, start, end));
+	default:
+		return (EINVAL);
+	}
 }
 
 static int
 iobus_release_resource(device_t bus, device_t child, int type, int rid,
 		       struct resource *res)
 {
-	if (rman_get_flags(res) & RF_ACTIVE) {
-		int error = bus_deactivate_resource(child, type, rid, res);
-		if (error)
-			return error;
-	}
 
-	return (rman_release_resource(res));
+	switch (type) {
+	case SYS_RES_MEMORY:
+	case SYS_RES_IOPORT:
+		return (bus_generic_rman_release_resource(bus, child, type, rid,
+		   res));
+	case SYS_RES_IRQ:
+		return (bus_release_resource(bus, type, rid, res));
+	default:
+		return (EINVAL);
+	}
 }
 
 static int
 iobus_activate_resource(device_t bus, device_t child, int type, int rid,
 			   struct resource *res)
 {
-	struct iobus_softc *sc;
-	void    *p;
-
-	sc = device_get_softc(bus);
 
-	if (type == SYS_RES_IRQ)
+	switch (type) {
+	case SYS_RES_IRQ:
                 return (bus_activate_resource(bus, type, rid, res));
-
-	if ((type == SYS_RES_MEMORY) || (type == SYS_RES_IOPORT)) {
-		p = pmap_mapdev((vm_paddr_t)rman_get_start(res) + sc->sc_addr,
-				(vm_size_t)rman_get_size(res));
-		if (p == NULL)
-			return (ENOMEM);
-		rman_set_virtual(res, p);
-		rman_set_bustag(res, &bs_le_tag);
-		rman_set_bushandle(res, (u_long)p);
+	case SYS_RES_IOPORT:
+	case SYS_RES_MEMORY:
+		return (bus_generic_rman_activate_resource(bus, child, type,
+		    rid, res));
+	default:
+		return (EINVAL);
 	}
-
-	return (rman_activate_resource(res));
 }
 
 static int
 iobus_deactivate_resource(device_t bus, device_t child, int type, int rid,
 			  struct resource *res)
 {
-        /*
-         * If this is a memory resource, unmap it.
-         */
-        if ((type == SYS_RES_MEMORY) || (type == SYS_RES_IOPORT)) {
-		u_int32_t psize;
 
-		psize = rman_get_size(res);
-		pmap_unmapdev(rman_get_virtual(res), psize);
+	switch (type) {
+	case SYS_RES_IRQ:
+                return (bus_deactivate_resource(bus, type, rid, res));
+	case SYS_RES_IOPORT:
+	case SYS_RES_MEMORY:
+		return (bus_generic_rman_deactivate_resource(bus, child, type,
+		    rid, res));
+	default:
+		return (EINVAL);
 	}
+}
 
-	return (rman_deactivate_resource(res));
+static int
+iobus_map_resource(device_t bus, device_t child, int type, struct resource *r,
+    struct resource_map_request *argsp, struct resource_map *map)
+{
+	struct resource_map_request args;
+	struct iobus_softc *sc;
+	rman_res_t length, start;
+	int error;
+
+	/* Resources must be active to be mapped. */
+	if (!(rman_get_flags(r) & RF_ACTIVE))
+		return (ENXIO);
+
+	/* Mappings are only supported on I/O and memory resources. */
+	switch (type) {
+	case SYS_RES_IOPORT:
+	case SYS_RES_MEMORY:
+		break;
+	default:
+		return (EINVAL);
+	}
+
+	resource_init_map_request(&args);
+	error = resource_validate_map_request(r, argsp, &args, &start, &length);
+	if (error)
+		return (error);
+
+	sc = device_get_softc(bus);
+	map->r_vaddr = pmap_mapdev_attr((vm_paddr_t)start + sc->sc_addr,
+	    (vm_size_t)length, args.memattr);
+	if (map->r_vaddr == NULL)
+		return (ENOMEM);
+	map->r_bustag = &bs_le_tag;
+	map->r_bushandle = (vm_offset_t)map->r_vaddr;
+	map->r_size = length;
+	return (0);
+}
+
+static int
+iobus_unmap_resource(device_t bus, device_t child, int type, struct resource *r,
+    struct resource_map *map)
+{
+
+	switch (type) {
+	case SYS_RES_IOPORT:
+	case SYS_RES_MEMORY:
+		pmap_unmapdev(map->r_vaddr, map->r_size);
+		return (0);
+	default:
+		return (EINVAL);
+	}
 }