diff --git a/sys/dev/ata/ata-all.c b/sys/dev/ata/ata-all.c
index 45786e374790..df11eb9aaa4b 100644
--- a/sys/dev/ata/ata-all.c
+++ b/sys/dev/ata/ata-all.c
@@ -123,10 +123,10 @@ ata_attach(device_t dev)
     TAILQ_INIT(&ch->ata_queue);
 
     /* initialise device(s) on this channel */
-    while (ATA_LOCKING(device_get_parent(dev), dev, ATA_LF_LOCK) != ch->unit)
+    while (ATA_LOCKING(dev, ATA_LF_LOCK) != ch->unit)
 	tsleep(&error, PRIBIO, "ataatch", 1);
     ch->hw.reset(ch);
-    ATA_LOCKING(device_get_parent(dev), dev, ATA_LF_UNLOCK);
+    ATA_LOCKING(dev, ATA_LF_UNLOCK);
 
     /* setup interrupt delivery */
     rid = ATA_IRQ_RID;
@@ -197,7 +197,7 @@ ata_reinit(device_t dev)
 	device_printf(dev, "reiniting channel ..\n");
 
     /* poll for locking the channel */
-    while (ATA_LOCKING(device_get_parent(dev), dev, ATA_LF_LOCK) != ch->unit)
+    while (ATA_LOCKING(dev, ATA_LF_LOCK) != ch->unit)
 	tsleep(&dev, PRIBIO, "atarini", 1);
 
     /* grap the channel lock */
@@ -234,7 +234,7 @@ ata_reinit(device_t dev)
     mtx_lock(&ch->state_mtx);
     ch->state = ATA_IDLE;
     mtx_unlock(&ch->state_mtx);
-    ATA_LOCKING(device_get_parent(dev), dev, ATA_LF_UNLOCK);
+    ATA_LOCKING(dev, ATA_LF_UNLOCK);
 
     if (bootverbose)
 	device_printf(dev, "reinit done ..\n");
@@ -263,7 +263,7 @@ ata_suspend(device_t dev)
 	mtx_unlock(&ch->state_mtx);
 	tsleep(ch, PRIBIO, "atasusp", hz/10);
     }
-    ATA_LOCKING(device_get_parent(dev), dev, ATA_LF_UNLOCK);
+    ATA_LOCKING(dev, ATA_LF_UNLOCK);
     return 0;
 }
 
@@ -324,7 +324,7 @@ ata_interrupt(void *data)
 	    if (ch->state == ATA_ACTIVE)
 		ch->state = ATA_IDLE;
 	    mtx_unlock(&ch->state_mtx);
-	    ATA_LOCKING(device_get_parent(ch->dev), ch->dev, ATA_LF_UNLOCK);
+	    ATA_LOCKING(ch->dev, ATA_LF_UNLOCK);
 	    ata_finish(request);
 	    return;
 	}
@@ -426,12 +426,12 @@ ata_ioctl(struct cdev *dev, u_long cmd, caddr_t addr,
 
 		    if (atadev->unit == ATA_MASTER) {
 			atadev->mode = iocmd->u.mode.mode[0];
-			ATA_SETMODE(device_get_parent(device), children[i]);
+			ATA_SETMODE(device, children[i]);
 			iocmd->u.mode.mode[0] = atadev->mode;
 		    }
 		    if (atadev->unit == ATA_SLAVE) {
 			atadev->mode = iocmd->u.mode.mode[1];
-			ATA_SETMODE(device_get_parent(device), children[i]);
+			ATA_SETMODE(device, children[i]);
 			iocmd->u.mode.mode[1] = atadev->mode;
 		    }
 		}
@@ -622,7 +622,7 @@ ata_identify(driver_t *driver, device_t parent, int type, const char *name)
     slave->unit = ATA_SLAVE;
 
     /* wait for the channel to be IDLE then grab it before touching HW */
-    while (ATA_LOCKING(device_get_parent(parent),parent,ATA_LF_LOCK)!=ch->unit)
+    while (ATA_LOCKING(parent, ATA_LF_LOCK) != ch->unit)
 	tsleep(ch, PRIBIO, "ataidnt2", 1);
     while (1) {
 	mtx_lock(&ch->state_mtx);
@@ -665,7 +665,7 @@ ata_identify(driver_t *driver, device_t parent, int type, const char *name)
     mtx_lock(&ch->state_mtx);
     ch->state = ATA_IDLE;
     mtx_unlock(&ch->state_mtx);
-    ATA_LOCKING(device_get_parent(parent), parent, ATA_LF_UNLOCK);
+    ATA_LOCKING(parent, ATA_LF_UNLOCK);
 }
 
 void
diff --git a/sys/dev/ata/ata-cbus.c b/sys/dev/ata/ata-cbus.c
index 46b009cad9c6..15932c967073 100644
--- a/sys/dev/ata/ata-cbus.c
+++ b/sys/dev/ata/ata-cbus.c
@@ -67,7 +67,7 @@ struct ata_cbus_controller {
 
 /* local prototypes */
 static void ata_cbus_intr(void *);
-static int ata_cbus_banking(device_t parent, device_t dev, int flags);
+static int ata_cbuschannel_banking(device_t dev, int flags);
 
 static int
 ata_cbus_probe(device_t dev)
@@ -229,16 +229,69 @@ ata_cbus_intr(void *data)
     for (unit = 0; unit < 2; unit++) {
 	if (!(ch = ctlr->interrupt[unit].argument))
 	    continue;
-	if (ata_cbus_banking(device_get_parent(ch->dev), ch->dev,
-			     ATA_LF_WHICH) == unit)
+	if (ata_cbuschannel_banking(ch->dev, ATA_LF_WHICH) == unit)
 	    ctlr->interrupt[unit].function(ch);
     }
 }
 
+static device_method_t ata_cbus_methods[] = {
+    /* device interface */
+    DEVMETHOD(device_probe,             ata_cbus_probe),
+    DEVMETHOD(device_attach,            ata_cbus_attach),
+//  DEVMETHOD(device_detach,            ata_cbus_detach),
+
+    /* bus methods */
+    DEVMETHOD(bus_alloc_resource,       ata_cbus_alloc_resource),
+    DEVMETHOD(bus_setup_intr,           ata_cbus_setup_intr),
+    DEVMETHOD(bus_print_child,          ata_cbus_print_child),
+
+    { 0, 0 }
+};
+
+static driver_t ata_cbus_driver = {
+    "atacbus",
+    ata_cbus_methods,
+    sizeof(struct ata_cbus_controller),
+};
+
+static devclass_t ata_cbus_devclass;
+
+DRIVER_MODULE(atacbus, isa, ata_cbus_driver, ata_cbus_devclass, 0, 0);
+
 static int
-ata_cbus_banking(device_t parent, device_t dev, int flags)
+ata_cbuschannel_probe(device_t dev)
 {
-    struct ata_cbus_controller *ctlr = device_get_softc(parent);
+    struct ata_cbus_controller *ctlr = device_get_softc(device_get_parent(dev));
+    struct ata_channel *ch = device_get_softc(dev);
+    device_t *children;
+    int count, i;
+
+    /* find channel number on this controller */
+    device_get_children(device_get_parent(dev), &children, &count);
+    for (i = 0; i < count; i++) {
+	if (children[i] == dev) 
+	    ch->unit = i;
+    }
+    free(children, M_TEMP);
+
+    /* setup the resource vectors */
+    for (i = ATA_DATA; i <= ATA_STATUS; i ++) {
+	ch->r_io[i].res = ctlr->io;
+	ch->r_io[i].offset = i << 1;
+    }
+    ch->r_io[ATA_ALTSTAT].res = ctlr->altio;
+    ch->r_io[ATA_ALTSTAT].offset = 0;
+
+    /* initialize softc for this channel */
+    ch->flags |= ATA_USE_16BIT;
+    ata_generic_hw(ch);
+    return ata_probe(dev);
+}
+
+static int
+ata_cbuschannel_banking(device_t dev, int flags)
+{
+    struct ata_cbus_controller *ctlr = device_get_softc(device_get_parent(dev));
     struct ata_channel *ch = device_get_softc(dev);
     int res;
 
@@ -277,77 +330,25 @@ ata_cbus_banking(device_t parent, device_t dev, int flags)
     return res;
 }
 
-static device_method_t ata_cbus_methods[] = {
+static device_method_t ata_cbuschannel_methods[] = {
     /* device interface */
-    DEVMETHOD(device_probe,             ata_cbus_probe),
-    DEVMETHOD(device_attach,            ata_cbus_attach),
-//  DEVMETHOD(device_detach,            ata_cbus_detach),
-
-    /* bus methods */
-    DEVMETHOD(bus_alloc_resource,       ata_cbus_alloc_resource),
-    DEVMETHOD(bus_setup_intr,           ata_cbus_setup_intr),
-    DEVMETHOD(bus_print_child,          ata_cbus_print_child),
-
-    /* ATA methods */
-    DEVMETHOD(ata_locking,              ata_cbus_banking),
-    { 0, 0 }
-};
-
-static driver_t ata_cbus_driver = {
-    "atacbus",
-    ata_cbus_methods,
-    sizeof(struct ata_cbus_controller),
-};
-
-static devclass_t ata_cbus_devclass;
-
-DRIVER_MODULE(atacbus, isa, ata_cbus_driver, ata_cbus_devclass, 0, 0);
-
-static int
-ata_cbussub_probe(device_t dev)
-{
-    struct ata_cbus_controller *ctlr = device_get_softc(device_get_parent(dev));
-    struct ata_channel *ch = device_get_softc(dev);
-    device_t *children;
-    int count, i;
-
-    /* find channel number on this controller */
-    device_get_children(device_get_parent(dev), &children, &count);
-    for (i = 0; i < count; i++) {
-	if (children[i] == dev) 
-	    ch->unit = i;
-    }
-    free(children, M_TEMP);
-
-    /* setup the resource vectors */
-    for (i = ATA_DATA; i <= ATA_STATUS; i ++) {
-	ch->r_io[i].res = ctlr->io;
-	ch->r_io[i].offset = i << 1;
-    }
-    ch->r_io[ATA_ALTSTAT].res = ctlr->altio;
-    ch->r_io[ATA_ALTSTAT].offset = 0;
-
-    /* initialize softc for this channel */
-    ch->flags |= ATA_USE_16BIT;
-    ata_generic_hw(ch);
-    return ata_probe(dev);
-}
-
-static device_method_t ata_cbussub_methods[] = {
-    /* device interface */
-    DEVMETHOD(device_probe,     ata_cbussub_probe),
+    DEVMETHOD(device_probe,     ata_cbuschannel_probe),
     DEVMETHOD(device_attach,    ata_attach),
     DEVMETHOD(device_detach,    ata_detach),
     DEVMETHOD(device_suspend,   ata_suspend),
     DEVMETHOD(device_resume,    ata_resume),
+
+    /* ATA methods */
+    DEVMETHOD(ata_locking,      ata_cbuschannel_banking),
+
     { 0, 0 }
 };
 
-static driver_t ata_cbussub_driver = {
+static driver_t ata_cbuschannel_driver = {
     "ata",
-    ata_cbussub_methods,
+    ata_cbuschannel_methods,
     sizeof(struct ata_channel),
 };
 
-DRIVER_MODULE(ata, atacbus, ata_cbussub_driver, ata_devclass, 0, 0);
+DRIVER_MODULE(ata, atacbus, ata_cbuschannel_driver, ata_devclass, 0, 0);
 MODULE_DEPEND(ata, ata, 1, 1, 1);
diff --git a/sys/dev/ata/ata-chipset.c b/sys/dev/ata/ata-chipset.c
index fedb863d7b67..1fc680cb8f6a 100644
--- a/sys/dev/ata/ata-chipset.c
+++ b/sys/dev/ata/ata-chipset.c
@@ -305,8 +305,7 @@ ata_acard_intr(void *data)
 	if (!(ch = ctlr->interrupt[unit].argument))
 	    continue;
 	if (ctlr->chip->cfg1 == ATPOLD &&
-	    ATA_LOCKING(device_get_parent(ch->dev),
-			ch->dev, ATA_LF_WHICH) != unit)
+	    ATA_LOCKING(ch->dev, ATA_LF_WHICH) != unit)
 	    continue;
 	if (ch->dma && (ch->dma->flags & ATA_DMA_ACTIVE)) {
 	    int bmstat = ATA_IDX_INB(ch, ATA_BMSTAT_PORT) & ATA_BMSTAT_MASK;
diff --git a/sys/dev/ata/ata-disk.c b/sys/dev/ata/ata-disk.c
index 91836452124a..3d0f5edbfdc2 100644
--- a/sys/dev/ata/ata-disk.c
+++ b/sys/dev/ata/ata-disk.c
@@ -337,7 +337,7 @@ ad_init(device_t dev)
 {
     struct ata_device *atadev = device_get_softc(dev);
 
-    ATA_SETMODE(GRANDPARENT(dev), dev);
+    ATA_SETMODE(device_get_parent(dev), dev);
 
     /* enable read caching */
     ata_controlcmd(atadev, ATA_SETFEATURES, ATA_SF_ENAB_RCACHE, 0, 0);
@@ -434,7 +434,7 @@ static device_method_t ad_methods[] = {
 static driver_t ad_driver = {
     "ad",
     ad_methods,
-    sizeof(struct ad_softc)
+    0,
 };
 
 devclass_t ad_devclass;
diff --git a/sys/dev/ata/ata-lowlevel.c b/sys/dev/ata/ata-lowlevel.c
index bb9d9e03ad1c..304b56c85686 100644
--- a/sys/dev/ata/ata-lowlevel.c
+++ b/sys/dev/ata/ata-lowlevel.c
@@ -619,7 +619,7 @@ ata_generic_reset(struct ata_channel *ch)
     }
 
     /* reset host end of channel (if supported) */
-    ATA_RESET(device_get_parent(ch->dev), ch->dev);
+    ATA_RESET(ch->dev);
 
     /* do we have any signs of ATA/ATAPI HW being present ? */
     ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_D_LBA | ATA_MASTER);
diff --git a/sys/dev/ata/ata-pci.c b/sys/dev/ata/ata-pci.c
index 523ee8e46d29..2f5aeba53df3 100644
--- a/sys/dev/ata/ata-pci.c
+++ b/sys/dev/ata/ata-pci.c
@@ -391,14 +391,12 @@ ata_pci_allocate(device_t dev, struct ata_channel *ch)
     int i, rid;
 
     rid = ATA_IOADDR_RID;
-    io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
-			    0, ~0, ATA_IOSIZE, RF_ACTIVE);
+    io = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid, RF_ACTIVE);
     if (!io)
 	return ENXIO;
 
     rid = ATA_ALTADDR_RID;
-    altio = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
-			       0, ~0, ATA_ALTIOSIZE, RF_ACTIVE);
+    altio = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid, RF_ACTIVE);
     if (!altio) {
 	bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, io);
 	return ENXIO;
@@ -424,40 +422,6 @@ ata_pci_allocate(device_t dev, struct ata_channel *ch)
     return 0;
 }
 
-static void
-ata_pci_setmode(device_t parent, device_t dev)
-{
-    struct ata_pci_controller *ctlr = device_get_softc(parent);
-    struct ata_device *atadev = device_get_softc(dev);
-    int mode = atadev->mode;
-
-    ctlr->setmode(atadev, ATA_PIO_MAX);
-    if (mode >= ATA_DMA)
-	ctlr->setmode(atadev, mode);
-}
-
-static int
-ata_pci_locking(device_t parent, device_t dev, int mode)
-{
-    struct ata_pci_controller *ctlr = device_get_softc(parent);
-    struct ata_channel *ch = device_get_softc(dev);
-
-    if (ctlr->locking)
-	return ctlr->locking(ch, mode);
-    else
-	return ch->unit;
-}
-
-static void
-ata_pci_reset(device_t parent, device_t dev)
-{
-    struct ata_pci_controller *ctlr = device_get_softc(parent);
-    struct ata_channel *ch = device_get_softc(dev);
-
-    if (ctlr->reset)
-	ctlr->reset(ch);
-}
-
 static int
 ata_pci_dmastart(struct ata_channel *ch)
 {
@@ -512,10 +476,6 @@ static device_method_t ata_pci_methods[] = {
     DEVMETHOD(bus_setup_intr,           ata_pci_setup_intr),
     DEVMETHOD(bus_teardown_intr,        ata_pci_teardown_intr),
 
-    /* ATA methods */
-    DEVMETHOD(ata_setmode,              ata_pci_setmode),
-    DEVMETHOD(ata_locking,              ata_pci_locking),
-    DEVMETHOD(ata_reset,                ata_pci_reset),
     { 0, 0 }
 };
 
@@ -532,7 +492,7 @@ MODULE_VERSION(atapci, 1);
 MODULE_DEPEND(atapci, ata, 1, 1, 1);
 
 static int
-ata_channel_probe(device_t dev)
+ata_pcichannel_probe(device_t dev)
 {
     struct ata_channel *ch = device_get_softc(dev);
     device_t *children;
@@ -557,7 +517,7 @@ ata_channel_probe(device_t dev)
 }
 
 static int
-ata_channel_attach(device_t dev)
+ata_pcichannel_attach(device_t dev)
 {
     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
     struct ata_channel *ch = device_get_softc(dev);
@@ -575,7 +535,7 @@ ata_channel_attach(device_t dev)
 }
 
 static int
-ata_channel_detach(device_t dev)
+ata_pcichannel_detach(device_t dev)
 {
     struct ata_channel *ch = device_get_softc(dev);
     int error;
@@ -589,21 +549,61 @@ ata_channel_detach(device_t dev)
     return 0;
 }
 
-static device_method_t ata_channel_methods[] = {
+static int
+ata_pcichannel_locking(device_t dev, int mode)
+{
+    struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
+    struct ata_channel *ch = device_get_softc(dev);
+
+    if (ctlr->locking)
+	return ctlr->locking(ch, mode);
+    else
+	return ch->unit;
+}
+
+static void
+ata_pcichannel_reset(device_t dev)
+{
+    struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
+    struct ata_channel *ch = device_get_softc(dev);
+
+    if (ctlr->reset)
+	ctlr->reset(ch);
+}
+
+static void
+ata_pcichannel_setmode(device_t parent, device_t dev)
+{
+    struct ata_pci_controller *ctlr = device_get_softc(GRANDPARENT(dev));
+    struct ata_device *atadev = device_get_softc(dev);
+    int mode = atadev->mode;
+
+    ctlr->setmode(atadev, ATA_PIO_MAX);
+    if (mode >= ATA_DMA)
+	ctlr->setmode(atadev, mode);
+}
+
+static device_method_t ata_pcichannel_methods[] = {
     /* device interface */
-    DEVMETHOD(device_probe,     ata_channel_probe),
-    DEVMETHOD(device_attach,    ata_channel_attach),
-    DEVMETHOD(device_detach,    ata_channel_detach),
+    DEVMETHOD(device_probe,     ata_pcichannel_probe),
+    DEVMETHOD(device_attach,    ata_pcichannel_attach),
+    DEVMETHOD(device_detach,    ata_pcichannel_detach),
     DEVMETHOD(device_shutdown,  bus_generic_shutdown),
     DEVMETHOD(device_suspend,   bus_generic_suspend),
     DEVMETHOD(device_resume,    bus_generic_resume),
+
+    /* ATA methods */
+    DEVMETHOD(ata_setmode,      ata_pcichannel_setmode),
+    DEVMETHOD(ata_locking,      ata_pcichannel_locking),
+    DEVMETHOD(ata_reset,        ata_pcichannel_reset),
+
     { 0, 0 }
 };
 
-driver_t ata_channel_driver = {
+driver_t ata_pcichannel_driver = {
     "ata",
-    ata_channel_methods,
+    ata_pcichannel_methods,
     sizeof(struct ata_channel),
 };
 
-DRIVER_MODULE(ata, atapci, ata_channel_driver, ata_devclass, 0, 0);
+DRIVER_MODULE(ata, atapci, ata_pcichannel_driver, ata_devclass, 0, 0);
diff --git a/sys/dev/ata/ata-queue.c b/sys/dev/ata/ata-queue.c
index 603e85d6818c..f4bdce16f4ae 100644
--- a/sys/dev/ata/ata-queue.c
+++ b/sys/dev/ata/ata-queue.c
@@ -172,7 +172,7 @@ ata_start(device_t dev)
     if ((request = TAILQ_FIRST(&ch->ata_queue))) {
 
 	/* we need the locking function to get the lock for this channel */
-	if (ATA_LOCKING(device_get_parent(dev), dev, ATA_LF_LOCK) == ch->unit) {
+	if (ATA_LOCKING(dev, ATA_LF_LOCK) == ch->unit) {
 
 	    /* check for composite dependencies */
 	    if ((cptr = request->composite)) {
@@ -211,7 +211,7 @@ ata_start(device_t dev)
 		    ch->state = ATA_IDLE;
 		    mtx_unlock(&ch->state_mtx);
 		    mtx_unlock(&ch->queue_mtx);
-		    ATA_LOCKING(device_get_parent(dev), dev, ATA_LF_UNLOCK);
+		    ATA_LOCKING(dev, ATA_LF_UNLOCK);
 		    ata_finish(request);
 		    return;
 		}
@@ -492,7 +492,7 @@ ata_timeout(struct ata_request *request)
 	ch->hw.end_transaction(request);
 	ch->state |= ATA_TIMEOUT;
 	mtx_unlock(&ch->state_mtx);
-	ATA_LOCKING(device_get_parent(ch->dev), ch->dev, ATA_LF_UNLOCK);
+	ATA_LOCKING(ch->dev, ATA_LF_UNLOCK);
 	ata_finish(request);
     }
     else {
diff --git a/sys/dev/ata/ata_if.m b/sys/dev/ata/ata_if.m
index b11734c4dbc2..0f8444710be6 100644
--- a/sys/dev/ata/ata_if.m
+++ b/sys/dev/ata/ata_if.m
@@ -41,24 +41,17 @@
 INTERFACE ata;
 
 CODE {
-	static int ata_null_locking(device_t parent, device_t dev, int mode)
+	static int ata_null_locking(device_t dev, int mode)
 	{
 	    struct ata_channel *ch = device_get_softc(dev);
 	
 	    return ch->unit;
 	}
 };
-METHOD void setmode {
-    device_t    parent;
-    device_t    dev;
-};
-
 METHOD int locking {
-    device_t    parent;
-    device_t    dev;
+    device_t    channel;
     int         mode;
 } DEFAULT ata_null_locking;
-
 HEADER {
 #define         ATA_LF_LOCK             0x0001
 #define         ATA_LF_UNLOCK           0x0002
@@ -66,10 +59,16 @@ HEADER {
 };
 
 METHOD void reset {
-    device_t    parent;
+    device_t    channel;
+};
+
+METHOD void setmode {
+    device_t    channel;
     device_t    dev;
 };
 
 METHOD int reinit {
     device_t    dev;
 };
+
+
diff --git a/sys/dev/ata/atapi-cd.c b/sys/dev/ata/atapi-cd.c
index 7f7efa779db9..2875dfbc23c7 100644
--- a/sys/dev/ata/atapi-cd.c
+++ b/sys/dev/ata/atapi-cd.c
@@ -130,7 +130,7 @@ acd_attach(device_t dev)
     }
     cdp->block_size = 2048;
     device_set_ivars(dev, cdp);
-    ATA_SETMODE(GRANDPARENT(dev), dev);
+    ATA_SETMODE(device_get_parent(dev), dev);
     acd_get_cap(dev);
     g_post_event(acd_geom_attach, dev, M_WAITOK, NULL);
 
@@ -168,7 +168,7 @@ acd_reinit(device_t dev)
 	free(cdp, M_ACD);
 	return 1;   
     }
-    ATA_SETMODE(GRANDPARENT(dev), dev);
+    ATA_SETMODE(device_get_parent(dev), dev);
     return 0;
 }
 
@@ -1935,7 +1935,7 @@ static device_method_t acd_methods[] = {
 static driver_t acd_driver = {
     "acd",
     acd_methods,
-    sizeof(struct acd_softc)
+    0,
 };
 
 static devclass_t acd_devclass;
diff --git a/sys/dev/ata/atapi-fd.c b/sys/dev/ata/atapi-fd.c
index 0c701c4a38f8..b2ffbc7b4efb 100644
--- a/sys/dev/ata/atapi-fd.c
+++ b/sys/dev/ata/atapi-fd.c
@@ -88,7 +88,7 @@ afd_attach(device_t dev)
 	return ENOMEM;
     }
     device_set_ivars(dev, fdp);
-    ATA_SETMODE(GRANDPARENT(dev), dev);
+    ATA_SETMODE(device_get_parent(dev), dev);
 
     if (afd_sense(dev)) {
 	device_set_ivars(dev, NULL);
@@ -161,7 +161,7 @@ afd_reinit(device_t dev)
 	free(fdp, M_AFD);
 	return 1;
     }
-    ATA_SETMODE(GRANDPARENT(dev), dev);
+    ATA_SETMODE(device_get_parent(dev), dev);
     return 0;
 }
 
@@ -415,7 +415,7 @@ static device_method_t afd_methods[] = {
 static driver_t afd_driver = {
     "afd",
     afd_methods,
-    sizeof(struct afd_softc)
+    0,
 };
 
 static devclass_t afd_devclass;
diff --git a/sys/dev/ata/atapi-tape.c b/sys/dev/ata/atapi-tape.c
index b1e90f06fb30..72761c76fa25 100644
--- a/sys/dev/ata/atapi-tape.c
+++ b/sys/dev/ata/atapi-tape.c
@@ -115,7 +115,7 @@ ast_attach(device_t dev)
 	return ENOMEM;
     }
     device_set_ivars(dev, stp);
-    ATA_SETMODE(GRANDPARENT(dev), dev);
+    ATA_SETMODE(device_get_parent(dev), dev);
 
     if (ast_sense(dev)) {
 	device_set_ivars(dev, NULL);
@@ -213,7 +213,7 @@ ast_reinit(device_t dev)
 	free(stp, M_AST);
 	return 1;
     }
-    ATA_SETMODE(GRANDPARENT(dev), dev);
+    ATA_SETMODE(device_get_parent(dev), dev);
     return 0;
 }
 
@@ -767,7 +767,7 @@ static device_method_t ast_methods[] = {
 static driver_t ast_driver = {
     "ast",
     ast_methods,
-    sizeof(struct ast_softc)
+    0,
 };
 
 static devclass_t ast_devclass;