Provide the interface to atacontrol and associated logic.

see atacontrol(8) for more.

Also the ATA_ENABLE_ATAPI_DMA, ATA_ENABLE_WC and ATA_ENABLE_TAGS
options are gone, use the tuneables listed in ata.4 instead from
the loader (this makes it possible to switch off DMA before the
driver has to touch the devices on broken hardware).

10 files changed, 503 insertions, 455 deletions

diff --git a/sys/dev/ata/ata-all.c b/sys/dev/ata/ata-all.c
index 75788e9..d0da258 100644
--- a/sys/dev/ata/ata-all.c
+++ b/sys/dev/ata/ata-all.c
@@ -32,7 +32,9 @@
 #include "opt_ata.h"
 #include <sys/param.h>
 #include <sys/systm.h>
+#include <sys/ata.h>
 #include <sys/kernel.h>
+#include <sys/conf.h>
 #include <sys/disk.h>
 #include <sys/module.h>
 #include <sys/bus.h>
@@ -51,6 +53,25 @@
 #include <dev/ata/ata-disk.h>
 #include <dev/ata/atapi-all.h>
 
+/* device structures */
+static  d_ioctl_t       ataioctl;
+static struct cdevsw ata_cdevsw = {  
+	/* open */	nullopen,
+	/* close */	nullclose,
+	/* read */	noread,
+	/* write */	nowrite,
+	/* ioctl */	ataioctl,
+	/* poll */	nopoll,
+	/* mmap */	nommap,
+	/* strategy */	nostrategy,
+	/* name */	"ata",
+	/* maj */	159,
+	/* dump */	nodump,
+	/* psize */	nopsize,
+	/* flags */	0,
+	/* bmaj */	-1
+};
+
 /* prototypes */
 static void ata_boot_attach(void);
 static void ata_intr(void *);
@@ -60,13 +81,13 @@ static char *active2str(int);
 static void bswap(int8_t *, int);
 static void btrim(int8_t *, int);
 static void bpack(int8_t *, int8_t *, int);
+static void ata_change_mode(struct ata_softc *, int, int);
 
 /* global vars */
 devclass_t ata_devclass;
 
 /* local vars */
 static struct intr_config_hook *ata_delayed_attach = NULL;
-static char ata_conf[256];
 static MALLOC_DEFINE(M_ATA, "ATA generic", "ATA driver generic layer");
 
 /* misc defines */
@@ -243,6 +264,10 @@ ata_detach(device_t dev)
 	bus_release_resource(dev, SYS_RES_IOPORT, ATA_BMADDR_RID, scp->r_bmio);
     bus_release_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, scp->r_altio);
     bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, scp->r_io);
+    scp->r_io = NULL;
+    scp->r_altio = NULL;
+    scp->r_bmio = NULL;
+    scp->r_irq = NULL;
     scp->active = ATA_IDLE;
     return 0;
 }
@@ -257,6 +282,124 @@ ata_resume(device_t dev)
 }
 
 static int
+ataioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct proc *p)
+{
+    int error = 0;
+
+    switch (cmd) {
+	case ATAATTACH: {
+	    device_t device = devclass_get_device(ata_devclass, *(int *)addr);
+	    /* should enable channel HW on controller that can SOS XXX */   
+	    if (!device)
+		error = ENXIO;
+	    if (!error)
+		error = ata_probe(device);
+	    if (!error)
+		error = ata_attach(device);
+	    break;
+	}
+
+	case ATADETACH: {
+	    device_t device = devclass_get_device(ata_devclass, *(int *)addr);
+	    if (!device)
+		error = ENXIO;
+	    if (!error)
+		error = ata_detach(device);
+	    /* should disable channel HW on controller that can SOS XXX */   
+	    break;
+	}
+
+	case ATAREINIT: {
+	    device_t device = devclass_get_device(ata_devclass, *(int *)addr);
+	    struct ata_softc *scp;
+	    int s;
+
+	    if (!device)
+		return ENXIO;
+	    scp = device_get_softc(device);
+	    if (!scp)
+		return ENXIO;
+
+	    /* make sure channel is not busy SOS XXX */
+	    s = splbio();
+	    while (!atomic_cmpset_int(&scp->active, ATA_IDLE, ATA_ACTIVE))
+        	tsleep((caddr_t)&s, PRIBIO, "atachm", hz/4);
+	    splx(s);
+	    error = ata_reinit(scp);
+	    break;
+	}
+
+	case ATAGMODE: {
+	    struct ata_modes *mode = (struct ata_modes *)addr;
+	    device_t device = devclass_get_device(ata_devclass, mode->channel);
+	    struct ata_softc *scp;
+
+	    if (!device)
+		return ENXIO;
+	    scp = device_get_softc(device);
+	    if (!scp)
+		return ENXIO;
+	    mode->mode[MASTER] = scp->mode[MASTER];
+	    mode->mode[SLAVE] = scp->mode[SLAVE];
+	    break;
+	}
+
+	case ATASMODE: {
+	    struct ata_modes *mode = (struct ata_modes *)addr;
+	    device_t device = devclass_get_device(ata_devclass, mode->channel);
+	    struct ata_softc *scp;
+
+	    if (!device)
+		return ENXIO;
+	    scp = device_get_softc(device);
+	    if (!scp)
+		return ENXIO;
+	    if (mode->mode[MASTER] >= 0)
+		ata_change_mode(scp, ATA_MASTER, mode->mode[MASTER]);
+	    if (mode->mode[SLAVE] >= 0)
+		ata_change_mode(scp, ATA_SLAVE, mode->mode[SLAVE]);
+	    mode->mode[MASTER] = scp->mode[MASTER];
+	    mode->mode[SLAVE] = scp->mode[SLAVE];
+	    break;
+	}
+
+	case ATAGPARM: {
+	    struct ata_param *parm = (struct ata_param *)addr;
+	    device_t device = devclass_get_device(ata_devclass, parm->channel);
+	    struct ata_softc *scp;
+
+	    if (!device)
+		return ENXIO;
+	    scp = device_get_softc(device);
+	    if (!scp)
+		return ENXIO;
+
+	    parm->type[MASTER] = 
+		scp->devices & (ATA_ATA_MASTER | ATA_ATAPI_MASTER);
+	    parm->type[SLAVE] =
+		scp->devices & (ATA_ATA_SLAVE | ATA_ATAPI_SLAVE);
+
+	    if (scp->dev_name[MASTER])
+		strcpy(parm->name[MASTER], scp->dev_name[MASTER]);
+	    if (scp->dev_name[SLAVE])
+		strcpy(parm->name[SLAVE], scp->dev_name[SLAVE]);
+
+	    if (scp->dev_param[MASTER])
+		bcopy(scp->dev_param[MASTER], &parm->params[MASTER],
+		      sizeof(struct ata_params));
+	    if (scp->dev_param[SLAVE])
+		bcopy(scp->dev_param[SLAVE], &parm->params[SLAVE],
+		      sizeof(struct ata_params));
+	    break;
+	}
+
+	default:
+	    error = ENOTTY;
+    }
+    return error;
+}
+
+static int
 ata_getparam(struct ata_softc *scp, int device, u_int8_t command)
 {
     struct ata_params *ata_parm;
@@ -612,6 +755,8 @@ ata_reinit(struct ata_softc *scp)
 {
     int devices, misdev, newdev;
 
+    if (!scp->r_io || !scp->r_altio || !scp->r_irq)
+	return ENXIO;
     scp->active = ATA_REINITING;
     scp->running = NULL;
     devices = scp->devices;
@@ -619,6 +764,8 @@ ata_reinit(struct ata_softc *scp)
     ata_reset(scp);
 
     if ((misdev = devices & ~scp->devices)) {
+	if (misdev)
+	    printf("\n");
 #ifdef DEV_ATADISK
 	if (misdev & ATA_ATA_MASTER && scp->dev_softc[MASTER])
 	    ad_detach(scp->dev_softc[MASTER], 0);
@@ -653,10 +800,10 @@ ata_reinit(struct ata_softc *scp)
 	if (newdev & ATA_ATAPI_SLAVE)
 	    if (ata_getparam(scp, ATA_SLAVE, ATA_C_ATAPI_IDENTIFY))
 		newdev &= ~ATA_ATAPI_SLAVE;
-	if (newdev)
-	    printf("\n");
     }
     scp->active = ATA_IDLE;
+    if (!misdev && newdev)
+	printf("\n");
 #ifdef DEV_ATADISK
     if (newdev & ATA_ATA_MASTER && !scp->dev_softc[MASTER])
 	ad_attach(scp, ATA_MASTER);
@@ -834,6 +981,21 @@ ata_command(struct ata_softc *scp, int device, u_int8_t command,
     return error;
 }
 
+void
+ata_set_name(struct ata_softc *scp, int device, char *name)
+{
+    scp->dev_name[ATA_DEV(device)] = malloc(strlen(name) + 1, M_ATA, M_NOWAIT);
+    if (scp->dev_name[ATA_DEV(device)])
+	strcpy(scp->dev_name[ATA_DEV(device)], name);
+}
+
+void
+ata_free_name(struct ata_softc *scp, int device)
+{
+    if (scp->dev_name[ATA_DEV(device)])
+	free(scp->dev_name[ATA_DEV(device)], M_ATA);
+}
+    
 int
 ata_get_lun(u_int32_t *map)
 {
@@ -863,9 +1025,13 @@ ata_printf(struct ata_softc *scp, int device, const char * fmt, ...)
 
     if (device == -1)
 	ret = printf("ata%d: ", device_get_unit(scp->dev));
-    else
-	ret = printf("ata%d-%s: ", device_get_unit(scp->dev),
-		     (device == ATA_MASTER) ? "master" : "slave");
+    else {
+	if (scp->dev_name[ATA_DEV(device)])
+	    ret = printf("%s: ", scp->dev_name[ATA_DEV(device)]);
+	else
+	    ret = printf("ata%d-%s: ", device_get_unit(scp->dev),
+			 (device == ATA_MASTER) ? "master" : "slave");
+    }
     va_start(ap, fmt);
     ret += vprintf(fmt, ap);
     va_end(ap);
@@ -1029,72 +1195,45 @@ bpack(int8_t *src, int8_t *dst, int len)
 static void
 ata_change_mode(struct ata_softc *scp, int device, int mode)
 {
+    int umode, wmode, pmode;
     int s = splbio();
 
     while (!atomic_cmpset_int(&scp->active, ATA_IDLE, ATA_ACTIVE))
 	tsleep((caddr_t)&s, PRIBIO, "atachm", hz/4);
 
-    ata_dmainit(scp, device, ata_pmode(ATA_PARAM(scp, device)),
-		mode < ATA_DMA ?  -1 : ata_wmode(ATA_PARAM(scp, device)),
-		mode < ATA_DMA ?  -1 : ata_umode(ATA_PARAM(scp, device)));
+    umode = ata_umode(ATA_PARAM(scp, device));
+    wmode = ata_wmode(ATA_PARAM(scp, device));
+    pmode = ata_pmode(ATA_PARAM(scp, device));
+    
+    switch (mode & ATA_DMA_MASK) {
+    case ATA_UDMA:
+	if ((mode & ATA_MODE_MASK) < umode)
+	    umode = mode & ATA_MODE_MASK;
+	break;
+    case ATA_WDMA:
+	if ((mode & ATA_MODE_MASK) < wmode)
+	    wmode = mode & ATA_MODE_MASK;
+	umode = -1;
+	break;
+    default:
+	if (((mode & ATA_MODE_MASK) - ATA_PIO0) < pmode)
+	    pmode = (mode & ATA_MODE_MASK) - ATA_PIO0;
+	umode = -1;
+	wmode = -1;
+    }
+    ata_dmainit(scp, device, pmode, wmode, umode);
+
     scp->active = ATA_IDLE;
     ata_start(scp);
     splx(s);
 }
 
-static int
-sysctl_hw_ata(SYSCTL_HANDLER_ARGS)
-{
-    struct ata_softc *scp;
-    int ctlr, error, i;
-
-    /* readout internal state */
-    bzero(ata_conf, sizeof(ata_conf));
-    for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) {
-	if (!(scp = devclass_get_softc(ata_devclass, ctlr)))
-	    continue;
-	for (i = 0; i < 2; i++) {
-	    if (!scp->dev_softc[i])
-		strcat(ata_conf, "---,");
-	    else if (scp->mode[i] >= ATA_DMA)
-		strcat(ata_conf, "dma,");
-	    else
-		strcat(ata_conf, "pio,");
-	}
-    }
-    error = sysctl_handle_string(oidp, ata_conf, sizeof(ata_conf), req);   
-    if (error == 0 && req->newptr != NULL) {
-	char *ptr = ata_conf;
-
-        /* update internal state */
-	i = 0;
-        while (*ptr) {
-	    if (!strncmp(ptr, "pio", 3) || !strncmp(ptr, "PIO", 3)) {
-		if ((scp = devclass_get_softc(ata_devclass, i >> 1)) &&
-		    scp->dev_softc[i & 1] && scp->mode[i & 1] >= ATA_DMA)
-		    ata_change_mode(scp, (i & 1)?ATA_SLAVE:ATA_MASTER, ATA_PIO);
-	    }
-	    else if (!strncmp(ptr, "dma", 3) || !strncmp(ptr, "DMA", 3)) {
-		if ((scp = devclass_get_softc(ata_devclass, i >> 1)) &&
-		    scp->dev_softc[i & 1] && scp->mode[i & 1] < ATA_DMA)
-		    ata_change_mode(scp, (i & 1)?ATA_SLAVE:ATA_MASTER, ATA_DMA);
-	    }
-	    else if (strncmp(ptr, "---", 3))
-		break;
-	    ptr+=3;
-	    if (*ptr++ != ',' ||
-		++i > (devclass_get_maxunit(ata_devclass) << 1))
-		break; 
-        }
-    }
-    return error;
-}
-SYSCTL_PROC(_hw, OID_AUTO, atamodes, CTLTYPE_STRING | CTLFLAG_RW,
-            0, sizeof(ata_conf), sysctl_hw_ata, "A", "");
-
 static void
 ata_init(void)
 {
+    /* register controlling device */
+    make_dev(&ata_cdevsw, 0, UID_ROOT, GID_OPERATOR, 0666, "ata");
+
     /* register boot attach to be run when interrupts are enabled */
     if (!(ata_delayed_attach = (struct intr_config_hook *)
 			       malloc(sizeof(struct intr_config_hook),
diff --git a/sys/dev/ata/ata-all.h b/sys/dev/ata/ata-all.h
index b02fd3b..77e81ab 100644
--- a/sys/dev/ata/ata-all.h
+++ b/sys/dev/ata/ata-all.h
@@ -149,137 +149,6 @@ struct ata_dmaentry {
 	u_int32_t count;
 };  
 
-/* ATA/ATAPI device parameter information */
-struct ata_params {
-    u_int8_t    cmdsize         :2;             /* packet command size */
-#define         ATAPI_PSIZE_12          0       /* 12 bytes */
-#define         ATAPI_PSIZE_16          1       /* 16 bytes */
-
-    u_int8_t                    :3;
-    u_int8_t    drqtype         :2;             /* DRQ type */
-#define         ATAPI_DRQT_MPROC        0       /* cpu    3 ms delay */
-#define         ATAPI_DRQT_INTR         1       /* intr  10 ms delay */
-#define         ATAPI_DRQT_ACCEL        2       /* accel 50 us delay */
-
-    u_int8_t    removable       :1;             /* device is removable */
-    u_int8_t    device_type     :5;             /* device type */
-#define         ATAPI_TYPE_DIRECT       0       /* disk/floppy */
-#define         ATAPI_TYPE_TAPE         1       /* streaming tape */
-#define         ATAPI_TYPE_CDROM        5       /* CD-ROM device */
-#define         ATAPI_TYPE_OPTICAL      7       /* optical disk */
-
-    u_int8_t                    :1;
-    u_int8_t    proto           :2;             /* command protocol */
-#define         ATAPI_PROTO_ATAPI       2
-
-    u_int16_t	cylinders;			/* number of cylinders */
-    u_int16_t	reserved2;
-    u_int16_t	heads;				/* # heads */
-    u_int16_t	unfbytespertrk;			/* # unformatted bytes/track */
-    u_int16_t	unfbytes;			/* # unformatted bytes/sector */
-    u_int16_t	sectors;			/* # sectors/track */
-    u_int16_t	vendorunique0[3];
-    u_int8_t	serial[20];			/* serial number */
-    u_int16_t	buffertype;			/* buffer type */
-#define ATA_BT_SINGLEPORTSECTOR		1	/* 1 port, 1 sector buffer */
-#define ATA_BT_DUALPORTMULTI		2	/* 2 port, mult sector buffer */
-#define ATA_BT_DUALPORTMULTICACHE	3	/* above plus track cache */
-
-    u_int16_t	buffersize;			/* buf size, 512-byte units */
-    u_int16_t	necc;				/* ecc bytes appended */
-    u_int8_t	revision[8];			/* firmware revision */
-    u_int8_t	model[40];			/* model name */
-    u_int8_t	nsecperint;			/* sectors per interrupt */
-    u_int8_t	vendorunique1;
-    u_int16_t	usedmovsd;			/* double word read/write? */
-
-    u_int8_t	vendorcap;			/* vendor capabilities */
-    u_int8_t	dmaflag		:1;		/* DMA supported - always 1 */
-    u_int8_t	lbaflag		:1;		/* LBA supported - always 1 */
-    u_int8_t	iordydis	:1;		/* IORDY may be disabled */
-    u_int8_t	iordyflag	:1;		/* IORDY supported */
-    u_int8_t	softreset	:1;		/* needs softreset when busy */
-    u_int8_t	stdby_ovlap	:1;		/* standby/overlap supported */
-    u_int8_t	queueing	:1;		/* supports queuing overlap */
-    u_int8_t	idmaflag	:1;		/* interleaved DMA supported */
-    u_int16_t	capvalidate;			/* validation for above */
-
-    u_int8_t	vendorunique3;
-    u_int8_t	opiomode;			/* PIO modes 0-2 */
-    u_int8_t	vendorunique4;
-    u_int8_t	odmamode;			/* old DMA modes, not ATA-3 */
-
-    u_int16_t	atavalid;			/* fields valid */
-#define		ATA_FLAG_54_58	      1		/* words 54-58 valid */
-#define		ATA_FLAG_64_70	      2		/* words 64-70 valid */
-#define		ATA_FLAG_88	      4		/* word 88 valid */
-
-    u_int16_t	currcyls;
-    u_int16_t	currheads;
-    u_int16_t	currsectors;
-    u_int16_t	currsize0;
-    u_int16_t	currsize1;
-    u_int8_t	currmultsect;
-    u_int8_t	multsectvalid;
-    u_int32_t	lbasize;
-
-    u_int16_t	sdmamodes;			/* singleword DMA modes */ 
-    u_int16_t	wdmamodes;			/* multiword DMA modes */ 
-    u_int16_t	apiomodes;			/* advanced PIO modes */ 
-
-    u_int16_t	mwdmamin;			/* min. M/W DMA time/word ns */
-    u_int16_t	mwdmarec;			/* rec. M/W DMA time ns */
-    u_int16_t	pioblind;			/* min. PIO cycle w/o flow */
-    u_int16_t	pioiordy;			/* min. PIO cycle IORDY flow */
-
-    u_int16_t	reserved69;
-    u_int16_t	reserved70;
-    u_int16_t	rlsovlap;			/* rel time (us) for overlap */
-    u_int16_t	rlsservice;			/* rel time (us) for service */
-    u_int16_t	reserved73;
-    u_int16_t	reserved74;
-    u_int16_t	queuelen:5;
-    u_int16_t	:11;
-    u_int16_t	reserved76;
-    u_int16_t	reserved77;
-    u_int16_t	reserved78;
-    u_int16_t	reserved79;
-    u_int16_t	versmajor;
-    u_int16_t	versminor;
-    u_int16_t	featsupp1;	/* 82 */
-    u_int16_t	supmicrocode:1;
-    u_int16_t	supqueued:1;
-    u_int16_t	supcfa:1;
-    u_int16_t	supapm:1;
-    u_int16_t	suprmsn:1;
-    u_int16_t	:11;
-    u_int16_t	featsupp3;	/* 84 */
-    u_int16_t	featenab1;	/* 85 */
-    u_int16_t	enabmicrocode:1;
-    u_int16_t	enabqueued:1;
-    u_int16_t	enabcfa:1;
-    u_int16_t	enabapm:1;
-    u_int16_t	enabrmsn:1;
-    u_int16_t	:11;
-    u_int16_t	featenab3;	/* 87 */
-    u_int16_t	udmamodes;			/* UltraDMA modes */
-    u_int16_t	erasetime;
-    u_int16_t	enherasetime;
-    u_int16_t	apmlevel;
-    u_int16_t	masterpasswdrev;
-    u_int16_t	masterhwres	:8;
-    u_int16_t	slavehwres	:5;
-    u_int16_t	cblid		:1;
-    u_int16_t	reserved93_1415	:2;
-    u_int16_t	reserved94[32];
-    u_int16_t	rmvstat;
-    u_int16_t	securstat;
-    u_int16_t	reserved129[30];
-    u_int16_t	cfapwrmode;
-    u_int16_t	reserved161[84];
-    u_int16_t	integrity;
-};
-
 /* structure describing an ATA device */
 struct ata_softc {
     struct device		*dev;		/* device handle */
@@ -292,21 +161,10 @@ struct ata_softc {
     int (*intr_func)(struct ata_softc *);	/* interrupt function */
     u_int32_t			chiptype;	/* pciid of controller chip */
     u_int32_t			alignment;	/* dma engine min alignment */
+    char			*dev_name[2];	/* name of device */
     struct ata_params		*dev_param[2];	/* ptr to devices params */
     void			*dev_softc[2];	/* ptr to devices softc's */
     int 			mode[2];	/* transfer mode for devices */
-#define 	ATA_PIO			0x00
-#define 	ATA_PIO0		0x08
-#define		ATA_PIO1		0x09
-#define		ATA_PIO2		0x0a
-#define		ATA_PIO3		0x0b
-#define		ATA_PIO4		0x0c
-#define		ATA_DMA			0x10
-#define		ATA_WDMA2		0x22
-#define		ATA_UDMA2		0x42
-#define		ATA_UDMA4		0x44
-#define		ATA_UDMA5		0x45
-
     int				flags;		/* controller flags */
 #define		ATA_DMA_ACTIVE		0x01
 #define		ATA_ATAPI_DMA_RO	0x02
@@ -352,6 +210,8 @@ int ata_reinit(struct ata_softc *);
 int ata_wait(struct ata_softc *, int, u_int8_t);
 int ata_command(struct ata_softc *, int, u_int8_t, u_int16_t, u_int8_t, u_int8_t, u_int8_t, u_int8_t, int);
 int ata_printf(struct ata_softc *, int, const char *, ...) __printflike(3, 4);
+void ata_set_name(struct ata_softc *, int, char *);
+void ata_free_name(struct ata_softc *, int);
 int ata_get_lun(u_int32_t *);
 int ata_test_lun(u_int32_t *, int);
 void ata_free_lun(u_int32_t *, int);
diff --git a/sys/dev/ata/ata-disk.c b/sys/dev/ata/ata-disk.c
index e7d15ed..7910e94 100644
--- a/sys/dev/ata/ata-disk.c
+++ b/sys/dev/ata/ata-disk.c
@@ -32,6 +32,7 @@
 #include "opt_ata.h"
 #include <sys/param.h>
 #include <sys/systm.h>
+#include <sys/ata.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/bio.h>
@@ -81,6 +82,10 @@ static int ad_version(u_int16_t);
 /* internal vars */
 static u_int32_t adp_lun_map = 0;
 static MALLOC_DEFINE(M_AD, "AD driver", "ATA disk driver");
+static int ata_dma, ata_wc, ata_tags; 
+TUNABLE_INT_DECL("hw.ata.ata_dma", 1, ata_dma);
+TUNABLE_INT_DECL("hw.ata.wc", 0, ata_wc);
+TUNABLE_INT_DECL("hw.ata.tags", 0, ata_tags);
 
 /* defines */
 #define	AD_MAX_RETRIES	3
@@ -95,6 +100,7 @@ ad_attach(struct ata_softc *scp, int device)
     struct ad_softc *adp;
     dev_t dev;
     int secsperint;
+    char name[16];
 
     if (!(adp = malloc(sizeof(struct ad_softc), M_AD, M_NOWAIT | M_ZERO))) {
 	ata_printf(scp, device, "failed to allocate driver storage\n");
@@ -107,6 +113,8 @@ ad_attach(struct ata_softc *scp, int device)
 #else
     adp->lun = ata_get_lun(&adp_lun_map);
 #endif
+    sprintf(name, "ad%d", adp->lun);
+    ata_set_name(scp, device, name);
     adp->heads = AD_PARAM->heads;
     adp->sectors = AD_PARAM->sectors;
     adp->total_secs = AD_PARAM->cylinders * adp->heads * adp->sectors;	
@@ -127,35 +135,41 @@ ad_attach(struct ata_softc *scp, int device)
         adp->transfersize *= secsperint;
     }
 
-    /* enable read/write cacheing if not default on device */
+    /* enable read cacheing if not default on device */
     if (ata_command(adp->controller, adp->unit, ATA_C_SETFEATURES,
 		    0, 0, 0, 0, ATA_C_F_ENAB_RCACHE, ATA_WAIT_INTR))
-	printf("ad%d: enabling readahead cache failed\n", adp->lun);
+	ata_printf(scp, device, "enabling readahead cache failed\n");
 
-#if defined(ATA_ENABLE_WC) || defined(ATA_ENABLE_TAGS)
-    if (ata_command(adp->controller, adp->unit, ATA_C_SETFEATURES,
-		    0, 0, 0, 0, ATA_C_F_ENAB_WCACHE, ATA_WAIT_INTR))
-	printf("ad%d: enabling write cache failed\n", adp->lun);
-#else
-    if (ata_command(adp->controller, adp->unit, ATA_C_SETFEATURES,
-		    0, 0, 0, 0, ATA_C_F_DIS_WCACHE, ATA_WAIT_INTR))
-	printf("ad%d: disabling write cache failed\n", adp->lun);
-#endif
-    /* use DMA if drive & controller supports it */
-    ata_dmainit(adp->controller, adp->unit,
-    		ata_pmode(AD_PARAM), ata_wmode(AD_PARAM), ata_umode(AD_PARAM));
+    /* enable write cacheing if allowed and not default on device */
+    if (ata_wc || ata_tags) {
+	if (ata_command(adp->controller, adp->unit, ATA_C_SETFEATURES,
+			0, 0, 0, 0, ATA_C_F_ENAB_WCACHE, ATA_WAIT_INTR))
+	    ata_printf(scp, device, "enabling write cache failed\n");
+    }
+    else {
+	if (ata_command(adp->controller, adp->unit, ATA_C_SETFEATURES,
+			0, 0, 0, 0, ATA_C_F_DIS_WCACHE, ATA_WAIT_INTR))
+	    ata_printf(scp, device, "disabling write cache failed\n");
+    }
 
-    /* use tagged queueing if supported */
-    if (ad_tagsupported(adp)) {
+    /* use DMA if allowed and if drive/controller supports it */
+    if (ata_dma)
+	ata_dmainit(adp->controller, adp->unit, ata_pmode(AD_PARAM), 
+		    ata_wmode(AD_PARAM), ata_umode(AD_PARAM));
+    else
+	ata_dmainit(adp->controller, adp->unit, ata_pmode(AD_PARAM), -1, -1);
+
+    /* use tagged queueing if allowed and supported */
+    if (ata_tags && ad_tagsupported(adp)) {
 	adp->num_tags = AD_PARAM->queuelen;
 	adp->flags |= AD_F_TAG_ENABLED;
 	adp->controller->flags |= ATA_QUEUED;
 	if (ata_command(adp->controller, adp->unit, ATA_C_SETFEATURES,
 			0, 0, 0, 0, ATA_C_F_DIS_RELIRQ, ATA_WAIT_INTR))
-	    printf("ad%d: disabling release interrupt failed\n", adp->lun);
+	    ata_printf(scp, device, "disabling release interrupt failed\n");
 	if (ata_command(adp->controller, adp->unit, ATA_C_SETFEATURES,
 			0, 0, 0, 0, ATA_C_F_DIS_SRVIRQ, ATA_WAIT_INTR))
-	    printf("ad%d: disabling service interrupt failed\n", adp->lun);
+	    ata_printf(scp, device, "disabling service interrupt failed\n");
     }
 
     devstat_add_entry(&adp->stats, "ad", adp->lun, DEV_BSIZE,
@@ -170,32 +184,31 @@ ad_attach(struct ata_softc *scp, int device)
     bioq_init(&adp->queue);
 
     if (bootverbose) {
-	printf("ad%d: <%.40s/%.8s> ATA-%d disk at ata%d-%s\n", 
-	       adp->lun, AD_PARAM->model, AD_PARAM->revision,
-	       ad_version(AD_PARAM->versmajor), device_get_unit(scp->dev),
-	       (adp->unit == ATA_MASTER) ? "master" : "slave");
-
-	 printf("ad%d: %luMB (%u sectors), %u cyls, %u heads, %u S/T, %u B/S\n",
-	       adp->lun, adp->total_secs / ((1024L * 1024L)/DEV_BSIZE),
-	       adp->total_secs, 
-	       adp->total_secs / (adp->heads * adp->sectors),
-	       adp->heads, adp->sectors, DEV_BSIZE);
-
-	printf("ad%d: %d secs/int, %d depth queue, %s%s\n", 
-	       adp->lun, adp->transfersize / DEV_BSIZE, adp->num_tags + 1,
-	       (adp->flags & AD_F_TAG_ENABLED) ? "tagged " : "",
-	       ata_mode2str(adp->controller->mode[ATA_DEV(adp->unit)]));
+	ata_printf(scp, device, "<%.40s/%.8s> ATA-%d disk at ata%d-%s\n", 
+		   AD_PARAM->model, AD_PARAM->revision,
+		   ad_version(AD_PARAM->versmajor), device_get_unit(scp->dev),
+		   (adp->unit == ATA_MASTER) ? "master" : "slave");
 
-	printf("ad%d: piomode=%d dmamode=%d udmamode=%d cblid=%d\n",
-	       adp->lun, ata_pmode(AD_PARAM), ata_wmode(AD_PARAM), 
-	       ata_umode(AD_PARAM), AD_PARAM->cblid);
+	ata_printf(scp, device, "%luMB (%u sectors), %u C, %u H, %u S, %u B\n",
+		   adp->total_secs / ((1024L*1024L)/DEV_BSIZE), adp->total_secs,
+		   adp->total_secs / (adp->heads * adp->sectors),
+		   adp->heads, adp->sectors, DEV_BSIZE);
+
+	ata_printf(scp, device, "%d secs/int, %d depth queue, %s%s\n", 
+		   adp->transfersize / DEV_BSIZE, adp->num_tags + 1,
+		   (adp->flags & AD_F_TAG_ENABLED) ? "tagged " : "",
+		   ata_mode2str(adp->controller->mode[ATA_DEV(adp->unit)]));
+
+	ata_printf(scp, device, "piomode=%d dmamode=%d udmamode=%d cblid=%d\n",
+		   ata_pmode(AD_PARAM), ata_wmode(AD_PARAM), 
+		   ata_umode(AD_PARAM), AD_PARAM->cblid);
 
     }
 
     /* if this disk belongs to an ATA RAID dont print the probe */
     if (ar_probe(adp))
-	printf("ad%d: %luMB <%.40s> [%d/%d/%d] at ata%d-%s %s%s\n",
-	       adp->lun, adp->total_secs / ((1024L * 1024L) / DEV_BSIZE),
+	ata_printf(scp, device, "%luMB <%.40s> [%d/%d/%d] at ata%d-%s %s%s\n",
+	       adp->total_secs / ((1024L * 1024L) / DEV_BSIZE),
 	       AD_PARAM->model, adp->total_secs / (adp->heads * adp->sectors),
 	       adp->heads, adp->sectors, device_get_unit(scp->dev),
 	       (adp->unit == ATA_MASTER) ? "master" : "slave",
@@ -213,7 +226,7 @@ ad_detach(struct ad_softc *adp, int flush)
     struct bio *bp;
 
     adp->flags |= AD_F_DETACHING;
-    printf("\nad%d: being removed from configuration", adp->lun);
+    ata_printf(adp->controller, adp->unit, "removed from configuration\n");
     TAILQ_FOREACH(request, &adp->controller->ata_queue, chain) {
 	if (request->device != adp)
 	    continue;
@@ -234,7 +247,8 @@ ad_detach(struct ad_softc *adp, int flush)
     if (flush) {
 	if (ata_command(adp->controller, adp->unit, ATA_C_FLUSHCACHE,
 			0, 0, 0, 0, 0, ATA_WAIT_INTR))
-	    printf("ad%d: flushing cache on detach failed\n", adp->lun);
+    	    ata_printf(adp->controller, adp->unit,
+		       "flushing cache on detach failed\n");
     }
     ata_free_lun(&adp_lun_map, adp->lun);
     adp->controller->dev_softc[ATA_DEV(adp->unit)] = NULL;
@@ -354,8 +368,8 @@ addump(dev_t dev)
     }
 
     if (ata_wait(adp->controller, adp->unit, ATA_S_READY | ATA_S_DSC) < 0)
-	printf("ad%d: timeout waiting for final ready\n", adp->lun);
-
+	ata_printf(adp->controller, adp->unit,
+		   "timeout waiting for final ready\n");
     return 0;
 }
 
@@ -388,7 +402,7 @@ ad_start(struct ad_softc *adp)
     }
 
     if (!(request = malloc(sizeof(struct ad_request), M_AD, M_NOWAIT|M_ZERO))) {
-	printf("ad%d: out of memory in start\n", adp->lun);
+	ata_printf(adp->controller, adp->unit, "out of memory in start\n");
 	return;
     }
 
@@ -442,8 +456,8 @@ ad_transfer(struct ad_request *request)
 	count = howmany(request->bytecount, DEV_BSIZE);
 	if (count > 256) {
 	    count = 256;
-	    printf("ad%d: count %d size transfers not supported\n",
-		   adp->lun, count);
+	    ata_printf(adp->controller, adp->unit,
+		       "count %d size transfers not supported\n", count);
 	}
 
 	if (adp->flags & AD_F_LBA_ENABLED) {
@@ -479,11 +493,13 @@ ad_transfer(struct ad_request *request)
 		if (ata_command(adp->controller, adp->unit, cmd, 
 		    		cylinder, head, sector, request->tag << 3,
 				count, ATA_IMMEDIATE)) {
-		    printf("ad%d: error executing command", adp->lun);
+		    ata_printf(adp->controller, adp->unit,
+			       "error executing command");
 		    goto transfer_failed;
 		}
 		if (ata_wait(adp->controller, adp->unit, ATA_S_READY)) {
-		    printf("ad%d: timeout waiting for READY\n", adp->lun);
+		    ata_printf(adp->controller, adp->unit,
+			       "timeout waiting for READY\n");
 		    goto transfer_failed;
 		}
 		adp->outstanding++;
@@ -500,7 +516,8 @@ ad_transfer(struct ad_request *request)
 
 		if (ata_command(adp->controller, adp->unit, cmd, cylinder, 
 		    		head, sector, count, 0, ATA_IMMEDIATE)) {
-		    printf("ad%d: error executing command", adp->lun);
+		    ata_printf(adp->controller, adp->unit,
+			       "error executing command");
 		    goto transfer_failed;
 		}
 #if 0
@@ -514,7 +531,8 @@ ad_transfer(struct ad_request *request)
 		 */
 		if (ata_wait(adp->controller, adp->unit, 
 		    	     ATA_S_READY | ATA_S_DRQ)) {
-		    printf("ad%d: timeout waiting for data phase\n", adp->lun);
+		    ata_printf(adp->controller, adp->unit,
+			       "timeout waiting for data phase\n");
 		    goto transfer_failed;
 		}
 #endif
@@ -536,7 +554,7 @@ ad_transfer(struct ad_request *request)
 
 	if (ata_command(adp->controller, adp->unit, cmd, 
 			cylinder, head, sector, count, 0, ATA_IMMEDIATE)) {
-	    printf("ad%d: error executing command", adp->lun);
+	    ata_printf(adp->controller, adp->unit, "error executing command");
 	    goto transfer_failed;
 	}
     }
@@ -551,7 +569,7 @@ ad_transfer(struct ad_request *request)
     /* ready to write PIO data ? */
     if (ata_wait(adp->controller, adp->unit, 
 		 (ATA_S_READY | ATA_S_DSC | ATA_S_DRQ)) < 0) {
-	printf("ad%d: timeout waiting for DRQ", adp->lun);
+	ata_printf(adp->controller, adp->unit, "timeout waiting for DRQ");
 	goto transfer_failed;
     }
 
@@ -650,7 +668,8 @@ ad_interrupt(struct ad_request *request)
 
     /* if we arrived here with forced PIO mode, DMA doesn't work right */
     if (request->flags & ADR_F_FORCE_PIO)
-	printf("ad%d: DMA problem fallback to PIO mode\n", adp->lun);
+	ata_printf(adp->controller, adp->unit,
+		   "DMA problem fallback to PIO mode\n");
 
     /* if this was a PIO read operation, get the data */
     if (!(request->flags & ADR_F_DMA_USED) &&
@@ -659,11 +678,13 @@ ad_interrupt(struct ad_request *request)
 	/* ready to receive data? */
 	if ((adp->controller->status & (ATA_S_READY | ATA_S_DSC | ATA_S_DRQ))
 	    != (ATA_S_READY | ATA_S_DSC | ATA_S_DRQ))
-	    printf("ad%d: read interrupt arrived early", adp->lun);
+	    ata_printf(adp->controller, adp->unit,
+		       "read interrupt arrived early");
 
 	if (ata_wait(adp->controller, adp->unit, 
 		     (ATA_S_READY | ATA_S_DSC | ATA_S_DRQ)) != 0) {
-	    printf("ad%d: read error detected (too) late", adp->lun);
+	    ata_printf(adp->controller, adp->unit,
+		       "read error detected (too) late");
 	    request->flags |= ADR_F_ERROR;
 	}
 	else {
@@ -703,7 +724,7 @@ ad_interrupt(struct ad_request *request)
 	request->flags |= ADR_F_FLUSHCACHE;
 	if (ata_command(adp->controller, adp->unit, ATA_C_FLUSHCACHE,
 			0, 0, 0, 0, 0, ATA_IMMEDIATE))
-	    printf("ad%d: flushing cache failed\n", adp->lun);
+	    ata_printf(adp->controller, adp->unit, "flushing cache failed\n");
 	else
 	    return ATA_OP_CONTINUES;
     }
@@ -758,8 +779,9 @@ ad_service(struct ad_softc *adp, int change)
 
 	/* check for error */
 	if (adp->controller->status & ATA_S_ERROR) {
-	    printf("ad%d: Oops! controller says s=0x%02x e=0x%02x\n",
-	           adp->lun, adp->controller->status,  adp->controller->error);
+	    ata_printf(adp->controller, adp->unit,
+		       "Oops! controller says s=0x%02x e=0x%02x\n",
+		       adp->controller->status,  adp->controller->error);
 	    ad_invalidatequeue(adp, NULL);
 	    return ATA_OP_FINISHED;
 	}
@@ -767,22 +789,25 @@ ad_service(struct ad_softc *adp, int change)
 	/* issue SERVICE cmd */
 	if (ata_command(adp->controller, adp->unit, ATA_C_SERVICE, 
 	    		0, 0, 0, 0, 0, ATA_IMMEDIATE)) {
-	    printf("ad%d: problem executing SERVICE cmd\n", adp->lun);
+	    ata_printf(adp->controller, adp->unit,
+		       "problem executing SERVICE cmd\n");
 	    ad_invalidatequeue(adp, NULL);
 	    return ATA_OP_FINISHED;
 	}
 
 	/* setup the transfer environment when ready */
 	if (ata_wait(adp->controller, adp->unit, ATA_S_READY)) {
-	    printf("ad%d: problem issueing SERVICE tag=%d s=0x%02x e=0x%02x\n",
-	           adp->lun, ATA_INB(adp->controller->r_io, ATA_COUNT) >> 3,
-		   adp->controller->status, adp->controller->error);
+	    ata_printf(adp->controller, adp->unit,
+		       "problem issueing SERVICE tag=%d s=0x%02x e=0x%02x\n",
+		       ATA_INB(adp->controller->r_io, ATA_COUNT) >> 3,
+		       adp->controller->status, adp->controller->error);
 	    ad_invalidatequeue(adp, NULL);
 	    return ATA_OP_FINISHED;
 	}
 	tag = ATA_INB(adp->controller->r_io, ATA_COUNT) >> 3;
 	if (!(request = adp->tags[tag])) {
-	    printf("ad%d: no request for this tag=%d??\n", adp->lun, tag);	
+	    ata_printf(adp->controller, adp->unit,
+		       "no request for tag=%d\n", tag);	
 	    ad_invalidatequeue(adp, NULL);
 	    return ATA_OP_FINISHED;
 	}
@@ -792,8 +817,9 @@ ad_service(struct ad_softc *adp, int change)
 
 	/* start DMA transfer when ready */
 	if (ata_wait(adp->controller, adp->unit, ATA_S_READY | ATA_S_DRQ)) {
-	    printf("ad%d: timeout waiting for data phase s=%02x e=%02x\n",
-		   adp->lun, adp->controller->status, adp->controller->error);
+	    ata_printf(adp->controller, adp->unit,
+		       "timeout waiting for data phase s=%02x e=%02x\n",
+		       adp->controller->status, adp->controller->error);
 	    ad_invalidatequeue(adp, NULL);
 	    return ATA_OP_FINISHED;
 	}
@@ -825,7 +851,7 @@ ad_invalidatequeue(struct ad_softc *adp, struct ad_request *request)
 	struct ad_request *tmpreq;
 	int tag;
 
-        printf("ad%d: invalidating queued requests\n", adp->lun);
+        ata_printf(adp->controller, adp->unit,"invalidating queued requests\n");
 	for (tag = 0; tag <= adp->num_tags; tag++) {
 	    tmpreq = adp->tags[tag];
 	    adp->tags[tag] = NULL;
@@ -836,7 +862,7 @@ ad_invalidatequeue(struct ad_softc *adp, struct ad_request *request)
 	}
 	if (ata_command(adp->controller, adp->unit, ATA_C_NOP,
 			0, 0, 0, 0, ATA_C_F_FLUSHQUEUE, ATA_WAIT_READY))
-	    printf("ad%d: flushing queue failed\n", adp->lun);
+	    ata_printf(adp->controller, adp->unit, "flush queue failed\n");
 	adp->outstanding = 0;
     }
 }
@@ -844,7 +870,6 @@ ad_invalidatequeue(struct ad_softc *adp, struct ad_request *request)
 static int
 ad_tagsupported(struct ad_softc *adp)
 {
-#ifdef ATA_ENABLE_TAGS
     const char *drives[] = {"IBM-DPTA", "IBM-DTLA", NULL};
     int i = 0;
 
@@ -852,15 +877,15 @@ ad_tagsupported(struct ad_softc *adp)
     if ((adp->controller->chiptype & 0x0000ffff) == 0x0000105a)
 	return 0;
 
-    /* check that drive has tags enabled, and is one we know works */
-    if (AD_PARAM->supqueued && AD_PARAM->enabqueued) {
+    /* check that drive does DMA, has tags enabled, and is one we know works */
+    if (adp->controller->mode[ATA_DEV(adp->unit)] >= ATA_DMA &&
+	AD_PARAM->supqueued && AD_PARAM->enabqueued) {
 	while (drives[i] != NULL) {
 	    if (!strncmp(AD_PARAM->model, drives[i], strlen(drives[i])))
 		return 1;
 	    i++;
 	}
     }
-#endif
     return 0;
 }
 
@@ -871,9 +896,10 @@ ad_timeout(struct ad_request *request)
     int s = splbio();
 
     adp->controller->running = NULL;
-    printf("ad%d: %s command timeout tag=%d serv=%d - resetting\n",
-	   adp->lun, (request->flags & ADR_F_READ) ? "READ" : "WRITE",
-	   request->tag, request->serv);
+    ata_printf(adp->controller, adp->unit,
+	       "%s command timeout tag=%d serv=%d - resetting\n",
+	       (request->flags & ADR_F_READ) ? "READ" : "WRITE",
+	       request->tag, request->serv);
 
     if (request->flags & ADR_F_DMA_USED) {
 	ata_dmadone(adp->controller);
@@ -881,7 +907,8 @@ ad_timeout(struct ad_request *request)
         if (request->retries == AD_MAX_RETRIES) {
 	    ata_dmainit(adp->controller, adp->unit,
 	    		ata_pmode(AD_PARAM), -1, -1);
-	    printf("ad%d: trying fallback to PIO mode\n", adp->lun);
+	    ata_printf(adp->controller, adp->unit,
+		       "trying fallback to PIO mode\n");
 	    request->retries = 0;
 	}
     }
diff --git a/sys/dev/ata/ata-dma.c b/sys/dev/ata/ata-dma.c
index 4832248..e6cf1ca 100644
--- a/sys/dev/ata/ata-dma.c
+++ b/sys/dev/ata/ata-dma.c
@@ -31,6 +31,7 @@
 #include "pci.h"
 #include <sys/param.h>
 #include <sys/systm.h>
+#include <sys/ata.h>
 #include <sys/bio.h>
 #include <sys/malloc.h> 
 #include <sys/bus.h>
diff --git a/sys/dev/ata/ata-raid.c b/sys/dev/ata/ata-raid.c
index 19f6a34..8f876a3 100644
--- a/sys/dev/ata/ata-raid.c
+++ b/sys/dev/ata/ata-raid.c
@@ -32,6 +32,7 @@
 #include "opt_ata.h"
 #include <sys/param.h>
 #include <sys/systm.h> 
+#include <sys/ata.h> 
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/bio.h>
diff --git a/sys/dev/ata/atapi-all.c b/sys/dev/ata/atapi-all.c
index 002288b..c19e0d8 100644
--- a/sys/dev/ata/atapi-all.c
+++ b/sys/dev/ata/atapi-all.c
@@ -32,6 +32,7 @@
 #include "opt_ata.h"
 #include <sys/param.h>
 #include <sys/systm.h>
+#include <sys/ata.h>
 #include <sys/kernel.h>
 #include <sys/bus.h>
 #include <sys/malloc.h>
@@ -51,6 +52,8 @@ static char *atapi_skey2str(u_int8_t);
 
 /* internal vars */
 static MALLOC_DEFINE(M_ATAPI, "ATAPI generic", "ATAPI driver generic layer");
+static int atapi_dma;
+TUNABLE_INT_DECL("hw.ata.atapi_dma", 0, atapi_dma);
 
 /* defines */
 #define ATAPI_MAX_RETRIES  	3
@@ -73,8 +76,7 @@ atapi_attach(struct ata_softc *scp, int device)
 		   ata_pmode(ATP_PARAM), ata_wmode(ATP_PARAM),
 		   ata_umode(ATP_PARAM), ATP_PARAM->dmaflag);
 
-#ifdef ATA_ENABLE_ATAPI_DMA
-    if (!(ATP_PARAM->drqtype == ATAPI_DRQT_INTR)) {
+    if (atapi_dma && !(ATP_PARAM->drqtype == ATAPI_DRQT_INTR)){
 	ata_dmainit(atp->controller, atp->unit,
 		    (ata_pmode(ATP_PARAM) < 0) ? 
 		    (ATP_PARAM->dmaflag ? 4 : 0) : ata_pmode(ATP_PARAM),
@@ -83,10 +85,8 @@ atapi_attach(struct ata_softc *scp, int device)
 		    ata_umode(ATP_PARAM));
     }
     else
-#endif
-	/* set PIO mode */
 	ata_dmainit(atp->controller, atp->unit,
-		    ata_pmode(ATP_PARAM)<0 ? 0 : ata_pmode(ATP_PARAM), -1, -1);
+		    ata_pmode(ATP_PARAM) < 0 ? 0 : ata_pmode(ATP_PARAM), -1,-1);
 
     switch (ATP_PARAM->device_type) {
 #ifdef DEV_ATAPICD
@@ -126,7 +126,7 @@ atapi_detach(struct atapi_softc *atp)
     struct atapi_request *request;
 
     atp->flags |= ATAPI_F_DETACHING;
-    printf("\n%s: being removed from configuration", atp->devname);
+    ata_printf(atp->controller, atp->unit, "removed from configuration\n");
     switch (ATP_PARAM->device_type) {
 #ifdef DEV_ATAPICD
     case ATAPI_TYPE_CDROM:
@@ -200,8 +200,8 @@ atapi_queue_cmd(struct atapi_softc *atp, int8_t *ccb, caddr_t data,
 
     /* append onto controller queue and try to start controller */
 #ifdef ATAPI_DEBUG
-    printf("%s: queueing %s ", 
-	   request->device->devname, atapi_cmd2str(request->ccb[0]));
+    ata_printf(atp->controller, atp->unit, "queueing %s ", 
+	       atapi_cmd2str(request->ccb[0]));
     atapi_dump("ccb = ", &request->ccb[0], sizeof(request->ccb));
 #endif
     if (flags & ATPR_F_AT_HEAD)
@@ -221,8 +221,8 @@ atapi_queue_cmd(struct atapi_softc *atp, int8_t *ccb, caddr_t data,
     splx(s);
     error = request->error;
 #ifdef ATAPI_DEBUG
-    printf("%s: finished %s\n", 
-	   request->device->devname, atapi_cmd2str(request->ccb[0]));
+    ata_printf(atp->controller, atp->unit, "finished %s\n", 
+	       atapi_cmd2str(request->ccb[0]));
 #endif
     if (request->dmatab)
 	free(request->dmatab, M_DEVBUF);
@@ -262,8 +262,8 @@ atapi_transfer(struct atapi_request *request)
     u_int8_t reason;
 
 #ifdef ATAPI_DEBUG
-    printf("%s: starting %s ", 
-	   request->device->devname, atapi_cmd2str(request->ccb[0]));
+    ata_printf(atp->controller, atp->unit, "starting %s ", 
+	       atapi_cmd2str(request->ccb[0]));
     atapi_dump("ccb = ", &request->ccb[0], sizeof(request->ccb));
 #endif
     /* is this just a POLL DSC command ? */
@@ -312,7 +312,8 @@ atapi_transfer(struct atapi_request *request)
 		    request->bytecount, 0, 0, 0, 
 		    (request->flags & ATPR_F_DMA_USED) ? ATA_F_DMA : 0,
 		    ATA_IMMEDIATE))
-	printf("%s: failure to send ATAPI packet command\n", atp->devname);
+	ata_printf(atp->controller, atp->unit,
+		   "failure to send ATAPI packet command\n");
 
     if (request->flags & ATPR_F_DMA_USED)
 	ata_dmastart(atp->controller, atp->unit, 
@@ -334,7 +335,8 @@ atapi_transfer(struct atapi_request *request)
     }
     if (timout <= 0) {
 	request->result = ATA_INB(atp->controller->r_io, ATA_ERROR);
-	printf("%s: failure to execute ATAPI packet command\n", atp->devname);
+	ata_printf(atp->controller, atp->unit,
+		   "failure to execute ATAPI packet command\n");
 	return;
     }
 
@@ -358,7 +360,8 @@ atapi_interrupt(struct atapi_request *request)
     if (reason == ATAPI_P_CMDOUT) {
 	if (!(atp->controller->status & ATA_S_DRQ)) {
 	    request->result = ATA_INB(atp->controller->r_io, ATA_ERROR);
-	    printf("%s: command interrupt without DRQ\n", atp->devname);
+	    ata_printf(atp->controller, atp->unit,
+		       "command interrupt without DRQ\n");
 	    goto op_finished;
 	}
 	ATA_OUTSW(atp->controller->r_io, ATA_DATA, (int16_t *)request->ccb,
@@ -386,8 +389,9 @@ atapi_interrupt(struct atapi_request *request)
 	case ATAPI_P_WRITE:
 	    if (request->flags & ATPR_F_READ) {
 		request->result = ATA_INB(atp->controller->r_io, ATA_ERROR);
-		printf("%s: %s trying to write on read buffer\n",
-		       atp->devname, atapi_cmd2str(atp->cmd));
+		ata_printf(atp->controller, atp->unit,
+			   "%s trying to write on read buffer\n",
+			   atapi_cmd2str(atp->cmd));
 		break;
 	    }
 	    atapi_write(request, length);
@@ -396,15 +400,17 @@ atapi_interrupt(struct atapi_request *request)
 	case ATAPI_P_READ:
 	    if (!(request->flags & ATPR_F_READ)) {
 		request->result = ATA_INB(atp->controller->r_io, ATA_ERROR);
-		printf("%s: %s trying to read on write buffer\n",
-		       atp->devname, atapi_cmd2str(atp->cmd));
+		ata_printf(atp->controller, atp->unit,
+			   "%s trying to read on write buffer\n",
+			   atapi_cmd2str(atp->cmd));
 		break;
 	    }
 	    atapi_read(request, length);
 	    return ATA_OP_CONTINUES;
 
 	case ATAPI_P_DONEDRQ:
-	    printf("%s: %s DONEDRQ\n", atp->devname, atapi_cmd2str(atp->cmd));
+	    ata_printf(atp->controller, atp->unit, "%s DONEDRQ\n",
+		       atapi_cmd2str(atp->cmd));
 	    if (request->flags & ATPR_F_READ)
 		atapi_read(request, length);
 	    else
@@ -421,7 +427,8 @@ atapi_interrupt(struct atapi_request *request)
 	    break;
 
 	default:
-	    printf("%s: unknown transfer phase %d\n", atp->devname, reason);
+	    ata_printf(atp->controller, atp->unit,
+		       "unknown transfer phase %d\n", reason);
 	}
     }
 
@@ -442,9 +449,10 @@ op_finished:
     	if (request->result) {
 	    switch ((request->result & ATAPI_SK_MASK)) {
 	    case ATAPI_SK_RESERVED:
-		printf("%s: %s - timeout error = %02x\n", 
-		       atp->devname,
-		       atapi_cmd2str(atp->cmd), request->result & ATAPI_E_MASK);
+		ata_printf(atp->controller, atp->unit,
+			   "%s - timeout error=0x%02x\n", 
+			   atapi_cmd2str(atp->cmd), 
+			   request->result & ATAPI_E_MASK);
 		request->error = EIO;
 		break;
 
@@ -453,8 +461,9 @@ op_finished:
 		break;
 
 	    case ATAPI_SK_RECOVERED_ERROR:
-		printf("%s: %s - recovered error\n", 
-		       atp->devname, atapi_cmd2str(atp->cmd));
+		ata_printf(atp->controller, atp->unit,
+			   "%s - recovered error\n",
+			   atapi_cmd2str(atp->cmd));
 		request->error = 0;
 		break;
 
@@ -468,16 +477,17 @@ op_finished:
 		break;
 
 	    default: 
-		printf("%s: %s - %s asc=%02x ascq=%02x ",
-		       atp->devname, atapi_cmd2str(atp->cmd), 
-		       atapi_skey2str(request->sense.sense_key), 
-		       request->sense.asc, request->sense.ascq);
+		ata_printf(atp->controller, atp->unit,
+			   "%s - %s asc=0x%02x ascq=0x%02x ",
+			   atapi_cmd2str(atp->cmd), 
+			   atapi_skey2str(request->sense.sense_key), 
+			   request->sense.asc, request->sense.ascq);
 		if (request->sense.sksv)
-		    printf("sks=%02x %02x %02x ",
+		    printf("sks=0x%02x 0x%02x 0x%02x ",
 			   request->sense.sk_specific,
 			   request->sense.sk_specific1,
 			   request->sense.sk_specific2);
-		printf("error=%02x\n", request->result & ATAPI_E_MASK);
+		printf("error=0x%02x\n", request->result & ATAPI_E_MASK);
 		request->error = EIO;
 	    }
 	}
@@ -485,8 +495,8 @@ op_finished:
 	    request->error = 0;
 	if (request->callback) {
 #ifdef ATAPI_DEBUG
-	    printf("%s: finished %s (callback)\n", 
-		   request->device->devname, atapi_cmd2str(request->ccb[0]));
+	    ata_printf(atp->controller, atp->unit, "finished %s (callback)\n", 
+		       atapi_cmd2str(request->ccb[0]));
 #endif
 	    if (!((request->callback)(request))) {
 		if (request->dmatab)
@@ -548,10 +558,10 @@ atapi_dump(char *label, void *data, int len)
 {
     u_int8_t *p = data;
 
-    printf ("%s %02x", label, *p++);
+    printf("%s %02x", label, *p++);
     while (--len > 0) 
 	printf ("-%02x", *p++);
-    printf ("\n");
+    printf("\n");
 }
 
 static void
@@ -559,24 +569,24 @@ atapi_read(struct atapi_request *request, int length)
 {
     int8_t **buffer = (int8_t **)&request->data;
     int size = min(request->bytecount, length);
+    struct ata_softc *scp = request->device->controller;
     int resid;
 
     if (request->flags & ATPR_F_INTERNAL)
 	*buffer = (int8_t *)&request->sense;
 
-    if (request->device->controller->flags & ATA_USE_16BIT ||
-	(size % sizeof(int32_t)))
-	ATA_INSW(request->device->controller->r_io, ATA_DATA, 
-		 (void *)((uintptr_t)*buffer), size / sizeof(int16_t));
+    if (scp->flags & ATA_USE_16BIT || (size % sizeof(int32_t)))
+	ATA_INSW(scp->r_io, ATA_DATA, (void *)((uintptr_t)*buffer), 
+		 size / sizeof(int16_t));
     else
-	ATA_INSL(request->device->controller->r_io, ATA_DATA, 
-		 (void *)((uintptr_t)*buffer), size / sizeof(int32_t));
+	ATA_INSL(scp->r_io, ATA_DATA, (void *)((uintptr_t)*buffer),
+		 size / sizeof(int32_t));
 
     if (request->bytecount < length) {
-	printf("%s: read data overrun %d/%d\n",
-	       request->device->devname, length, request->bytecount);
+	ata_printf(scp, request->device->unit, "read data overrun %d/%d\n",
+		   length, request->bytecount);
 	for (resid=request->bytecount; resid<length; resid+=sizeof(int16_t))
-	     ATA_INW(request->device->controller->r_io, ATA_DATA);
+	     ATA_INW(scp->r_io, ATA_DATA);
     }
     *buffer += size;
     request->bytecount -= size;
@@ -588,24 +598,24 @@ atapi_write(struct atapi_request *request, int length)
 {
     int8_t **buffer = (int8_t **)&request->data;
     int size = min(request->bytecount, length);
+    struct ata_softc *scp = request->device->controller;
     int resid;
 
     if (request->flags & ATPR_F_INTERNAL)
 	*buffer = (int8_t *)&request->sense;
 
-    if (request->device->controller->flags & ATA_USE_16BIT ||
-	(size % sizeof(int32_t)))
-	ATA_OUTSW(request->device->controller->r_io, ATA_DATA, 
-		  (void *)((uintptr_t)*buffer), size / sizeof(int16_t));
+    if (scp->flags & ATA_USE_16BIT || (size % sizeof(int32_t)))
+	ATA_OUTSW(scp->r_io, ATA_DATA, (void *)((uintptr_t)*buffer),
+		  size / sizeof(int16_t));
     else
-	ATA_OUTSL(request->device->controller->r_io, ATA_DATA, 
-		  (void *)((uintptr_t)*buffer), size / sizeof(int32_t));
+	ATA_OUTSL(scp->r_io, ATA_DATA, (void *)((uintptr_t)*buffer),
+		  size / sizeof(int32_t));
 
     if (request->bytecount < length) {
-	printf("%s: write data underrun %d/%d\n",
-	       request->device->devname, length, request->bytecount);
+	ata_printf(scp, request->device->unit, "write data underrun %d/%d\n",
+		   length, request->bytecount);
 	for (resid=request->bytecount; resid<length; resid+=sizeof(int16_t))
-	    ATA_OUTW(request->device->controller->r_io, ATA_DATA, 0);
+	    ATA_OUTW(scp->r_io, ATA_DATA, 0);
     }
     *buffer += size;
     request->bytecount -= size;
@@ -619,15 +629,16 @@ atapi_timeout(struct atapi_request *request)
     int s = splbio();
 
     atp->controller->running = NULL;
-    printf("%s: %s command timeout - resetting\n", 
-	   atp->devname, atapi_cmd2str(request->ccb[0]));
+    ata_printf(atp->controller, atp->unit, "%s command timeout - resetting\n", 
+	       atapi_cmd2str(request->ccb[0]));
 
     if (request->flags & ATPR_F_DMA_USED) {
 	ata_dmadone(atp->controller);
 	if (request->retries == ATAPI_MAX_RETRIES) {
 	    ata_dmainit(atp->controller, atp->unit,
 		        (ata_pmode(ATP_PARAM)<0)?0:ata_pmode(ATP_PARAM),-1,-1);
-	    printf("%s: trying fallback to PIO mode\n", atp->devname);
+	    ata_printf(atp->controller, atp->unit, 
+		       "trying fallback to PIO mode\n");
 	    request->retries = 0;
 	}
     }
diff --git a/sys/dev/ata/atapi-all.h b/sys/dev/ata/atapi-all.h
index e08589d..10263e1 100644
--- a/sys/dev/ata/atapi-all.h
+++ b/sys/dev/ata/atapi-all.h
@@ -146,7 +146,6 @@ struct atapi_softc {
     struct ata_softc		*controller;	/* ptr to controller softc */
     int				unit;		/* ATA_MASTER or ATA_SLAVE */
     void			*driver;	/* ptr to subdriver softc */
-    char			*devname;	/* this devices name */
     u_int8_t			cmd;		/* last cmd executed */
     int				flags;		/* drive flags */
 #define		ATAPI_F_MEDIA_CHANGED	0x0001
diff --git a/sys/dev/ata/atapi-cd.c b/sys/dev/ata/atapi-cd.c
index 7f7e6e5..773d7b4 100644
--- a/sys/dev/ata/atapi-cd.c
+++ b/sys/dev/ata/atapi-cd.c
@@ -30,6 +30,7 @@
 
 #include <sys/param.h>
 #include <sys/systm.h>
+#include <sys/ata.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/bio.h>
@@ -107,6 +108,7 @@ acdattach(struct atapi_softc *atp)
     struct acd_softc *cdp;
     struct changer *chp;
     int count, error = 0;
+    char name[16];
     static int acd_cdev_done = 0;
 
     if (!acd_cdev_done) {
@@ -116,7 +118,7 @@ acdattach(struct atapi_softc *atp)
     }
 
     if ((cdp = acd_init_lun(atp, NULL)) == NULL) {
-	printf("acd: out of memory\n");
+	ata_printf(atp->controller, atp->unit, "acd: out of memory\n");
 	return -1;
     }
 
@@ -146,7 +148,7 @@ acdattach(struct atapi_softc *atp)
 
 	chp = malloc(sizeof(struct changer), M_ACD, M_NOWAIT | M_ZERO);
 	if (chp == NULL) {
-	    printf("acd: out of memory\n");
+	    ata_printf(atp->controller, atp->unit, "out of memory\n");
 	    free(cdp, M_ACD);
 	    return -1;
 	}
@@ -158,12 +160,11 @@ acdattach(struct atapi_softc *atp)
 	    struct acd_softc *tmpcdp = cdp;
 	    struct acd_softc **cdparr;
 	    int count;
-	    char string[16];
 
 	    chp->table_length = htons(chp->table_length);
 	    if (!(cdparr = malloc(sizeof(struct acd_softc) * chp->slots,
 				 M_ACD, M_NOWAIT))) {
-		printf("acd: out of memory\n");
+		ata_printf(atp->controller, atp->unit, "out of memory\n");
 		free(chp, M_ACD);
 		free(cdp, M_ACD);
 		return -1;
@@ -172,7 +173,7 @@ acdattach(struct atapi_softc *atp)
 		if (count > 0) {
 		    tmpcdp = acd_init_lun(atp, cdp->stats);
 		    if (!tmpcdp) {
-			printf("acd: out of memory\n");
+			ata_printf(atp->controller,atp->unit,"out of memory\n");
 			break;
 		    }
 		}
@@ -180,20 +181,14 @@ acdattach(struct atapi_softc *atp)
 		tmpcdp->driver = cdparr;
 		tmpcdp->slot = count;
 		tmpcdp->changer_info = chp;
-		if (bootverbose)
-		    printf("acd%d: changer slot %d %s\n", tmpcdp->lun, count,
-			   (chp->slot[count].present ? "CD present" : "empty"));
 	        acd_make_dev(tmpcdp);
 	    }
-	    sprintf(string, "acd%d-%d", cdp->lun, 
+	    sprintf(name, "acd%d-%d", cdp->lun, 
 		    cdp->lun + cdp->changer_info->slots - 1);
-	    devstat_add_entry(cdp->stats, string, tmpcdp->lun, DEV_BSIZE,
+	    devstat_add_entry(cdp->stats, name, tmpcdp->lun, DEV_BSIZE,
 			      DEVSTAT_NO_ORDERED_TAGS,
 			      DEVSTAT_TYPE_CDROM | DEVSTAT_TYPE_IF_IDE,
 			      DEVSTAT_PRIORITY_CD);
-    	    if ((cdp->atp->devname = malloc(8, M_ACD, M_NOWAIT)))
-       		sprintf(cdp->atp->devname, "acd%d-%d", cdp->lun, 
-			cdp->lun + cdp->changer_info->slots - 1);
 	}
     }
     else {
@@ -202,8 +197,8 @@ acdattach(struct atapi_softc *atp)
 			  DEVSTAT_NO_ORDERED_TAGS,
 			  DEVSTAT_TYPE_CDROM | DEVSTAT_TYPE_IF_IDE,
 			  DEVSTAT_PRIORITY_CD);
-    	if ((cdp->atp->devname = malloc(8, M_ACD, M_NOWAIT)))
-       	    sprintf(cdp->atp->devname, "acd%d", cdp->lun);
+       	sprintf(name, "acd%d", cdp->lun);
+	ata_set_name(atp->controller, atp->unit, name);
     }
     cdp->atp->driver = cdp;
     acd_describe(cdp);
@@ -230,7 +225,6 @@ acddetach(struct atapi_softc *atp)
 	    destroy_dev(cdp->dev2);
 	    devstat_remove_entry(cdp->stats);
 	    free(cdp->stats, M_ACD);
-	    free(cdp->atp->devname, M_ACD);
 	    ata_free_lun(&acd_lun_map, cdp->lun);
 	    free(cdp, M_ACD);
 	}
@@ -246,7 +240,7 @@ acddetach(struct atapi_softc *atp)
     destroy_dev(cdp->dev2);
     devstat_remove_entry(cdp->stats);
     free(cdp->stats, M_ACD);
-    free(cdp->atp->devname, M_ACD);
+    ata_free_name(atp->controller, atp->unit);
     ata_free_lun(&acd_lun_map, cdp->lun);
     free(cdp, M_ACD);
 }
@@ -322,20 +316,21 @@ acd_describe(struct acd_softc *cdp)
     char *mechanism;
 
     if (bootverbose) {
-	printf("acd%d: <%.40s/%.8s> %s drive at ata%d as %s\n",
-	       cdp->lun, ATA_PARAM(cdp->atp->controller, cdp->atp->unit)->model,
-	       ATA_PARAM(cdp->atp->controller, cdp->atp->unit)->revision,
-	       (cdp->cap.write_dvdr) ? "DVD-R" : 
-		(cdp->cap.write_dvdram) ? "DVD-RAM" : 
-		 (cdp->cap.write_cdrw) ? "CD-RW" :
-		  (cdp->cap.write_cdr) ? "CD-R" : 
-		   (cdp->cap.read_dvdrom) ? "DVD-ROM" : "CDROM",
-	       device_get_unit(cdp->atp->controller->dev),
-	       (cdp->atp->unit == ATA_MASTER) ? "master" : "slave");
-
-	printf("acd%d:", cdp->lun);
+	ata_printf(cdp->atp->controller, cdp->atp->unit,
+		   "<%.40s/%.8s> %s drive at ata%d as %s\n",
+		   ATA_PARAM(cdp->atp->controller, cdp->atp->unit)->model,
+		   ATA_PARAM(cdp->atp->controller, cdp->atp->unit)->revision,
+		   (cdp->cap.write_dvdr) ? "DVD-R" : 
+		    (cdp->cap.write_dvdram) ? "DVD-RAM" : 
+		     (cdp->cap.write_cdrw) ? "CD-RW" :
+		      (cdp->cap.write_cdr) ? "CD-R" : 
+		       (cdp->cap.read_dvdrom) ? "DVD-ROM" : "CDROM",
+		   device_get_unit(cdp->atp->controller->dev),
+		   (cdp->atp->unit == ATA_MASTER) ? "master" : "slave");
+
+	ata_printf(cdp->atp->controller, cdp->atp->unit, "");
 	if (cdp->cap.cur_read_speed) {
-	    printf(" read %dKB/s", cdp->cap.cur_read_speed * 1000 / 1024);
+	    printf("read %dKB/s", cdp->cap.cur_read_speed * 1000 / 1024);
 	    if (cdp->cap.max_read_speed) 
 		printf(" (%dKB/s)", cdp->cap.max_read_speed * 1000 / 1024);
 	    if ((cdp->cap.cur_write_speed) &&
@@ -355,7 +350,7 @@ acd_describe(struct acd_softc *cdp)
 	       comma ? "," : "", ata_mode2str(
 		cdp->atp->controller->mode[ATA_DEV(cdp->atp->unit)]));
 
-	printf("acd%d: Reads:", cdp->lun);
+	ata_printf(cdp->atp->controller, cdp->atp->unit, "Reads:");
 	comma = 0;
 	if (cdp->cap.read_cdr) {
 	    printf(" CD-R"); comma = 1;
@@ -382,9 +377,10 @@ acd_describe(struct acd_softc *cdp)
 	if (cdp->cap.read_packet)
 	    printf("%s packet", comma ? "," : "");
 
+	printf("\n");
+	ata_printf(cdp->atp->controller, cdp->atp->unit, "Writes:");
 	if (cdp->cap.write_cdr || cdp->cap.write_cdrw || 
 	    cdp->cap.write_dvdr || cdp->cap.write_dvdram) {
-	    printf("\nacd%d: Writes:", cdp->lun);
 	    comma = 0;
 	    if (cdp->cap.write_cdr) {
 		printf(" CD-R" ); comma = 1;
@@ -404,14 +400,16 @@ acd_describe(struct acd_softc *cdp)
 	    if (cdp->cap.burnproof)
 		printf("%s burnproof", comma ? "," : "");
 	}
+	printf("\n");
 	if (cdp->cap.audio_play) {
-	    printf("\nacd%d: Audio: ", cdp->lun);
+	    ata_printf(cdp->atp->controller, cdp->atp->unit, "Audio:");
 	    if (cdp->cap.audio_play)
 		printf("play");
 	    if (cdp->cap.max_vol_levels)
 		printf(", %d volume levels", cdp->cap.max_vol_levels);
 	}
-	printf("\nacd%d: Mechanism: ", cdp->lun);
+	printf("\n");
+	ata_printf(cdp->atp->controller, cdp->atp->unit, "Mechanism:");
 	switch (cdp->cap.mech) {
 	case MST_MECH_CADDY:
 	    mechanism = "caddy"; break;
@@ -432,7 +430,7 @@ acd_describe(struct acd_softc *cdp)
 	    printf("ejectable");
 
 	if (cdp->cap.mech != MST_MECH_CHANGER) {
-	    printf("\nacd%d: Medium: ", cdp->lun);
+	    ata_printf(cdp->atp->controller, cdp->atp->unit, "Medium:");
 	    switch (cdp->cap.medium_type & MST_TYPE_MASK_HIGH) {
 	    case MST_CDROM:
 		printf("CD-ROM "); break;
@@ -486,28 +484,24 @@ acd_describe(struct acd_softc *cdp)
 	printf("\n");
     }
     else {
-	char changer[32];
-	char devnum[8];
-
-	bzero(changer, sizeof(changer));
-	if (cdp->changer_info) {
-	    sprintf(devnum, "%d-%d",
-		    cdp->lun, cdp->lun + cdp->changer_info->slots - 1);
-	    sprintf(changer, " with %d CD changer", cdp->changer_info->slots);
-	}
-	else
-	    sprintf(devnum, "%d", cdp->lun);
-
-	printf("acd%s: %s%s <%.40s> at ata%d-%s %s\n",
-	       devnum, (cdp->cap.write_dvdr) ? "DVD-R" : 
-			(cdp->cap.write_dvdram) ? "DVD-RAM" : 
-			 (cdp->cap.write_cdrw) ? "CD-RW" :
-			  (cdp->cap.write_cdr) ? "CD-R" : 
-			   (cdp->cap.read_dvdrom) ? "DVD-ROM" : "CDROM",
-	       changer, ATA_PARAM(cdp->atp->controller, cdp->atp->unit)->model,
-	       device_get_unit(cdp->atp->controller->dev),
-	       (cdp->atp->unit == ATA_MASTER) ? "master" : "slave",
-	       ata_mode2str(cdp->atp->controller->mode[ATA_DEV(cdp->atp->unit)])
+	char chg[32];
+
+	bzero(chg, sizeof(chg));
+	if (cdp->changer_info)
+	    sprintf(chg, " with %d CD changer", cdp->changer_info->slots);
+
+	ata_printf(cdp->atp->controller, cdp->atp->unit,
+		   "%s%s <%.40s> at ata%d-%s %s\n",
+		   (cdp->cap.write_dvdr) ? "DVD-R" : 
+		    (cdp->cap.write_dvdram) ? "DVD-RAM" : 
+		     (cdp->cap.write_cdrw) ? "CD-RW" :
+		      (cdp->cap.write_cdr) ? "CD-R" : 
+		       (cdp->cap.read_dvdrom) ? "DVD-ROM" : "CDROM",
+		   chg, ATA_PARAM(cdp->atp->controller, cdp->atp->unit)->model,
+		   device_get_unit(cdp->atp->controller->dev),
+		   (cdp->atp->unit == ATA_MASTER) ? "master" : "slave",
+		   ata_mode2str(cdp->atp->controller->
+				mode[ATA_DEV(cdp->atp->unit)])
 	       );
     }
 }
@@ -1316,8 +1310,9 @@ acd_read_toc(struct acd_softc *cdp)
     bzero(&cdp->disklabel, sizeof(struct disklabel));
     strncpy(cdp->disklabel.d_typename, "               ", 
     	    sizeof(cdp->disklabel.d_typename));
-    strncpy(cdp->disklabel.d_typename, cdp->atp->devname, 
-    	    min(strlen(cdp->atp->devname),
+    strncpy(cdp->disklabel.d_typename,
+	    cdp->atp->controller->dev_name[ATA_DEV(cdp->atp->unit)], 
+    	    min(strlen(cdp->atp->controller->dev_name[ATA_DEV(cdp->atp->unit)]),
 		sizeof(cdp->disklabel.d_typename) - 1));
     strncpy(cdp->disklabel.d_packname, "unknown        ", 
     	    sizeof(cdp->disklabel.d_packname));
@@ -1340,15 +1335,15 @@ acd_read_toc(struct acd_softc *cdp)
 
 #ifdef ACD_DEBUG
     if (cdp->info.volsize && cdp->toc.hdr.ending_track) {
-	printf("acd%d: ", cdp->lun);
+	ata_printf(cdp->atp->controller, cdp->atp->unit,
+		   "(%d sectors (%d bytes)), %d tracks ", 
+		   cdp->info.volsize, cdp->info.blksize,
+		   cdp->toc.hdr.ending_track - cdp->toc.hdr.starting_track + 1);
 	if (cdp->toc.tab[0].control & 4)
-	    printf("%dMB ", cdp->info.volsize / 512);
+	    printf("%dMB\n", cdp->info.volsize / 512);
 	else
-	    printf("%d:%d audio ", cdp->info.volsize / 75 / 60,
+	    printf("%d:%d audio\n", cdp->info.volsize / 75 / 60,
 		cdp->info.volsize / 75 % 60);
-	printf("(%d sectors (%d bytes)), %d tracks\n", 
-	    cdp->info.volsize, cdp->info.blksize,
-	    cdp->toc.hdr.ending_track - cdp->toc.hdr.starting_track + 1);
     }
 #endif
 }
@@ -1895,8 +1890,9 @@ acd_mode_select(struct acd_softc *cdp, caddr_t pagebuf, int pagesize)
 		     pagesize>>8, pagesize, 0, 0, 0, 0, 0, 0, 0 };
 
 #ifdef ACD_DEBUG
-    printf("acd: modeselect pagesize=%d\n", pagesize);
-    atapi_dump("acd: mode select ", pagebuf, pagesize);
+    ata_printf(cdp->atp->controller, cdp->atp->unit,
+	       "modeselect pagesize=%d\n", pagesize);
+    atapi_dump("mode select ", pagebuf, pagesize);
 #endif
     return atapi_queue_cmd(cdp->atp, ccb, pagebuf, pagesize, 0, 30, NULL, NULL);
 }
diff --git a/sys/dev/ata/atapi-fd.c b/sys/dev/ata/atapi-fd.c
index bb3bf3d..9d19984 100644
--- a/sys/dev/ata/atapi-fd.c
+++ b/sys/dev/ata/atapi-fd.c
@@ -30,6 +30,7 @@
 
 #include <sys/param.h>
 #include <sys/systm.h>
+#include <sys/ata.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/bio.h>
@@ -83,10 +84,11 @@ afdattach(struct atapi_softc *atp)
 {
     struct afd_softc *fdp;
     dev_t dev;
+    char name[16];
 
     fdp = malloc(sizeof(struct afd_softc), M_AFD, M_NOWAIT | M_ZERO);
     if (!fdp) {
-	printf("afd: out of memory\n");
+	ata_printf(atp->controller, atp->unit, "out of memory\n");
 	return -1;
     }
     bioq_init(&fdp->queue);
@@ -112,8 +114,8 @@ afdattach(struct atapi_softc *atp)
     fdp->dev = dev;
     fdp->atp->flags |= ATAPI_F_MEDIA_CHANGED;
     fdp->atp->driver = fdp;
-    if ((fdp->atp->devname = malloc(8, M_AFD, M_NOWAIT)))
-        sprintf(fdp->atp->devname, "afd%d", fdp->lun);
+    sprintf(name, "afd%d", fdp->lun);
+    ata_set_name(atp->controller, atp->unit, name);
     afd_describe(fdp);
     return 0;
 }
@@ -132,7 +134,7 @@ afddetach(struct atapi_softc *atp)
     disk_invalidate(&fdp->disk);
     disk_destroy(fdp->dev);
     devstat_remove_entry(&fdp->stats);
-    free(fdp->atp->devname, M_AFD);
+    ata_free_name(atp->controller, atp->unit);
     ata_free_lun(&afd_lun_map, fdp->lun);
     free(fdp, M_AFD);
 }   
@@ -183,25 +185,27 @@ static void
 afd_describe(struct afd_softc *fdp)
 {
     if (bootverbose) {
-	printf("afd%d: <%.40s/%.8s> rewriteable drive at ata%d as %s\n",
-	       fdp->lun, ATA_PARAM(fdp->atp->controller, fdp->atp->unit)->model,
-	       ATA_PARAM(fdp->atp->controller, fdp->atp->unit)->revision,
-	       device_get_unit(fdp->atp->controller->dev),
-	       (fdp->atp->unit == ATA_MASTER) ? "master" : "slave");
-	printf("afd%d: %luMB (%u sectors), %u cyls, %u heads, %u S/T, %u B/S\n",
-	       fdp->lun, 
-	       (fdp->cap.cylinders * fdp->cap.heads * fdp->cap.sectors) / 
-	       ((1024L * 1024L) / fdp->cap.sector_size),
-	       fdp->cap.cylinders * fdp->cap.heads * fdp->cap.sectors,
-	       fdp->cap.cylinders, fdp->cap.heads, fdp->cap.sectors,
-	       fdp->cap.sector_size);
-	printf("afd%d: %dKB/s,", fdp->lun, fdp->cap.transfer_rate/8);
+	ata_printf(fdp->atp->controller, fdp->atp->unit,
+		   "<%.40s/%.8s> rewriteable drive at ata%d as %s\n",
+		   ATA_PARAM(fdp->atp->controller, fdp->atp->unit)->model,
+		   ATA_PARAM(fdp->atp->controller, fdp->atp->unit)->revision,
+		   device_get_unit(fdp->atp->controller->dev),
+		   (fdp->atp->unit == ATA_MASTER) ? "master" : "slave");
+	ata_printf(fdp->atp->controller, fdp->atp->unit,
+		   "%luMB (%u sectors), %u cyls, %u heads, %u S/T, %u B/S\n",
+		   (fdp->cap.cylinders * fdp->cap.heads * fdp->cap.sectors) / 
+		   ((1024L * 1024L) / fdp->cap.sector_size),
+		   fdp->cap.cylinders * fdp->cap.heads * fdp->cap.sectors,
+		   fdp->cap.cylinders, fdp->cap.heads, fdp->cap.sectors,
+		   fdp->cap.sector_size);
+	ata_printf(fdp->atp->controller, fdp->atp->unit, "%dKB/s,",
+		   fdp->lun, fdp->cap.transfer_rate/8);
 	if (fdp->transfersize)
 	    printf(" transfer limit %d blks,", fdp->transfersize);
 	printf(" %s\n", ata_mode2str(fdp->atp->controller->mode[
 				 ATA_DEV(fdp->atp->unit)]));
 	if (fdp->header.medium_type) {
-	    printf("afd%d: Medium: ", fdp->lun);
+	    ata_printf(fdp->atp->controller, fdp->atp->unit, "Medium: ");
 	    switch (fdp->header.medium_type) {
 	    case MFD_2DD:
 		printf("720KB DD disk"); break;
@@ -223,15 +227,16 @@ afd_describe(struct afd_softc *fdp)
 	printf("\n");
     }
     else {
-	printf("afd%d: %luMB <%.40s> [%d/%d/%d] at ata%d-%s %s\n",
-	       fdp->lun, (fdp->cap.cylinders*fdp->cap.heads*fdp->cap.sectors) /
-			 ((1024L * 1024L) / fdp->cap.sector_size),	
-	       ATA_PARAM(fdp->atp->controller, fdp->atp->unit)->model,
-	       fdp->cap.cylinders, fdp->cap.heads, fdp->cap.sectors,
-	       device_get_unit(fdp->atp->controller->dev),
-	       (fdp->atp->unit == ATA_MASTER) ? "master" : "slave",
-	       ata_mode2str(fdp->atp->controller->mode[ATA_DEV(fdp->atp->unit)])
-	       );
+	ata_printf(fdp->atp->controller, fdp->atp->unit,
+		   "%luMB <%.40s> [%d/%d/%d] at ata%d-%s %s\n",
+		   (fdp->cap.cylinders*fdp->cap.heads*fdp->cap.sectors) /
+		       ((1024L * 1024L) / fdp->cap.sector_size),	
+		   ATA_PARAM(fdp->atp->controller, fdp->atp->unit)->model,
+		   fdp->cap.cylinders, fdp->cap.heads, fdp->cap.sectors,
+		   device_get_unit(fdp->atp->controller->dev),
+		   (fdp->atp->unit == ATA_MASTER) ? "master" : "slave",
+		   ata_mode2str(fdp->atp->controller->
+				mode[ATA_DEV(fdp->atp->unit)]));
     }
 }
 
@@ -247,7 +252,8 @@ afdopen(dev_t dev, int flags, int fmt, struct proc *p)
 	afd_prevent_allow(fdp, 1);
 
     if (afd_sense(fdp))
-	printf("afd%d: sense media type failed\n", fdp->lun);
+	ata_printf(fdp->atp->controller, fdp->atp->unit,
+		   "sense media type failed\n");
 
     fdp->atp->flags &= ~ATAPI_F_MEDIA_CHANGED;
 
diff --git a/sys/dev/ata/atapi-tape.c b/sys/dev/ata/atapi-tape.c
index 7fa8fc5..d9a2843 100644
--- a/sys/dev/ata/atapi-tape.c
+++ b/sys/dev/ata/atapi-tape.c
@@ -30,6 +30,7 @@
 
 #include <sys/param.h>
 #include <sys/systm.h>
+#include <sys/ata.h>
 #include <sys/kernel.h>
 #include <sys/conf.h>
 #include <sys/malloc.h>
@@ -90,6 +91,7 @@ astattach(struct atapi_softc *atp)
     struct ast_softc *stp;
     struct ast_readposition position;
     dev_t dev;
+    char name[16];
     static int ast_cdev_done = 0;
 
     if (!ast_cdev_done) {
@@ -98,7 +100,7 @@ astattach(struct atapi_softc *atp)
     }
     stp = malloc(sizeof(struct ast_softc), M_AST, M_NOWAIT | M_ZERO);
     if (!stp) {
-	printf("ast: out of memory\n");
+	ata_printf(atp->controller, atp->unit, "out of memory\n");
 	return -1;
     }
     bioq_init(&stp->queue);
@@ -141,8 +143,8 @@ astattach(struct atapi_softc *atp)
     stp->dev2 = dev;
     stp->atp->flags |= ATAPI_F_MEDIA_CHANGED;
     stp->atp->driver = stp;
-    if ((stp->atp->devname = malloc(8, M_AST, M_NOWAIT)))
-        sprintf(stp->atp->devname, "ast%d", stp->lun);
+    sprintf(name, "ast%d", stp->lun);
+    ata_set_name(atp->controller, atp->unit, name);
     ast_describe(stp);
     return 0;
 }
@@ -161,7 +163,7 @@ astdetach(struct atapi_softc *atp)
     destroy_dev(stp->dev1);
     destroy_dev(stp->dev2);
     devstat_remove_entry(&stp->stats);
-    free(stp->atp->devname, M_AST);
+    ata_free_name(atp->controller, atp->unit);
     ata_free_lun(&ast_lun_map, stp->lun);
     free(stp, M_AST);
 }
@@ -198,19 +200,20 @@ static void
 ast_describe(struct ast_softc *stp)
 {
     if (bootverbose) {
-	printf("ast%d: <%.40s/%.8s> tape drive at ata%d as %s\n",
-               stp->lun, ATA_PARAM(stp->atp->controller, stp->atp->unit)->model,
-               ATA_PARAM(stp->atp->controller, stp->atp->unit)->revision,
-	       device_get_unit(stp->atp->controller->dev),
-	       (stp->atp->unit == ATA_MASTER) ? "master" : "slave");
-	printf("ast%d: ", stp->lun);
-	printf("%dKB/s, ", stp->cap.max_speed);
+	ata_printf(stp->atp->controller, stp->atp->unit,
+		   "<%.40s/%.8s> tape drive at ata%d as %s\n",
+		   ATA_PARAM(stp->atp->controller, stp->atp->unit)->model,
+		   ATA_PARAM(stp->atp->controller, stp->atp->unit)->revision,
+		   device_get_unit(stp->atp->controller->dev),
+		   (stp->atp->unit == ATA_MASTER) ? "master" : "slave");
+	ata_printf(stp->atp->controller, stp->atp->unit, "%dKB/s, ",
+		   stp->cap.max_speed);
 	printf("transfer limit %d blk%s, ",
 	       stp->cap.ctl, (stp->cap.ctl > 1) ? "s" : "");
 	printf("%dKB buffer, ", (stp->cap.buffer_size * DEV_BSIZE) / 1024);
 	printf("%s\n", ata_mode2str(stp->atp->controller->mode[
                                      ATA_DEV(stp->atp->unit)]));
-	printf("ast%d: ", stp->lun);
+	ata_printf(stp->atp->controller, stp->atp->unit, "");
 	switch (stp->cap.medium_type) {
 	    case 0x00:
 		printf("Drive empty"); break;
@@ -240,12 +243,13 @@ ast_describe(struct ast_softc *stp)
 	printf("\n");
     }
     else {
-	printf("ast%d: TAPE <%.40s> at ata%d-%s %s\n",
-               stp->lun, ATA_PARAM(stp->atp->controller, stp->atp->unit)->model,
-	       device_get_unit(stp->atp->controller->dev),
-	       (stp->atp->unit == ATA_MASTER) ? "master" : "slave",
-	       ata_mode2str(stp->atp->controller->mode[ATA_DEV(stp->atp->unit)])
-	       );
+	ata_printf(stp->atp->controller, stp->atp->unit,
+		   "TAPE <%.40s> at ata%d-%s %s\n",
+		   ATA_PARAM(stp->atp->controller, stp->atp->unit)->model,
+		   device_get_unit(stp->atp->controller->dev),
+		   (stp->atp->unit == ATA_MASTER) ? "master" : "slave",
+		   ata_mode2str(stp->atp->controller->
+				mode[ATA_DEV(stp->atp->unit)]));
     }
 }
 
@@ -266,7 +270,8 @@ astopen(dev_t dev, int flags, int fmt, struct proc *p)
 	ast_prevent_allow(stp, 1);
 
     if (ast_sense(stp))
-	printf("ast%d: sense media type failed\n", stp->lun);
+	ata_printf(stp->atp->controller, stp->atp->unit,
+		   "sense media type failed\n");
 
     stp->atp->flags &= ~ATAPI_F_MEDIA_CHANGED;
     stp->flags &= ~(F_DATA_WRITTEN | F_FM_WRITTEN);
@@ -297,7 +302,8 @@ astclose(dev_t dev, int flags, int fmt, struct proc *p)
 
     stp->flags &= F_CTL_WARN;
 #ifdef AST_DEBUG
-    printf("ast%d: %llu total bytes transferred\n", stp->lun, ast_total);
+    ata_printf(stp->atp->controller, stp->atp->unit,
+	       "%llu total bytes transferred\n", ast_total);
 #endif
     return 0;
 }
@@ -442,8 +448,8 @@ aststrategy(struct bio *bp)
 	
     /* check for != blocksize requests */
     if (bp->bio_bcount % stp->blksize) {
-	printf("ast%d: bad request, must be multiple of %d\n",
-	       stp->lun, stp->blksize);
+	ata_printf(stp->atp->controller, stp->atp->unit,
+		   "bad request, must be multiple of %d\n", stp->blksize);
 	bp->bio_error = EIO;
 	bp->bio_flags |= BIO_ERROR;
 	biodone(bp);
@@ -453,8 +459,9 @@ aststrategy(struct bio *bp)
     /* warn about transfers bigger than the device suggests */
     if (bp->bio_bcount > stp->blksize * stp->cap.ctl) {  
 	if ((stp->flags & F_CTL_WARN) == 0) {
-	    printf("ast%d: WARNING: CTL exceeded %ld>%d\n", 
-		    stp->lun, bp->bio_bcount, stp->blksize * stp->cap.ctl);
+	    ata_printf(stp->atp->controller, stp->atp->unit,
+		       "WARNING: CTL exceeded %ld>%d\n",
+		       bp->bio_bcount, stp->blksize * stp->cap.ctl);
 	    stp->flags |= F_CTL_WARN;
 	}
     }
@@ -541,8 +548,9 @@ ast_mode_select(struct ast_softc *stp, void *pagebuf, int pagesize)
 		       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
      
 #ifdef AST_DEBUG
-    printf("ast: modeselect pagesize=%d\n", pagesize);
-    atapi_dump("ast: mode select ", pagebuf, pagesize);
+    ata_printf(stp->atp->controller, stp->atp->unit, 
+	       "modeselect pagesize=%d\n", pagesize);
+    atapi_dump("mode select ", pagebuf, pagesize);
 #endif
     return atapi_queue_cmd(stp->atp, ccb, pagebuf, pagesize, 0, 10,
 			   NULL, NULL);