 @@ -1,14 +1,14 @@
-/*	$NetBSD: ips.c,v 1.4 2021/08/07 16:19:14 thorpej Exp $	*/
+/*	$NetBSD: ips.c,v 1.5 2022/02/12 02:40:39 riastradh Exp $	*/
 /*	$OpenBSD: ips.c,v 1.113 2016/08/14 04:08:03 dlg Exp $	*/
 /*-
  * Copyright (c) 2017 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -38,27 +38,27 @@
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 /*
  * IBM (Adaptec) ServeRAID controllers driver.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ips.c,v 1.4 2021/08/07 16:19:14 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ips.c,v 1.5 2022/02/12 02:40:39 riastradh Exp $");
 #include "bio.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/queue.h>
 #include <sys/buf.h>
 #include <sys/endian.h>
 #include <sys/conf.h>
 #include <sys/malloc.h>
 #include <sys/ioctl.h>
 @@ -409,27 +409,27 @@ struct ips_ccb {
 SLIST_HEAD(ips_ccbq, ips_ccb);
 /* DMA-able chunk of memory */
 struct dmamem {
 	bus_dma_tag_t		dm_tag;
 	bus_dmamap_t		dm_map;
 	bus_dma_segment_t	dm_seg;
 	bus_size_t		dm_size;
 	void *			dm_vaddr;
 #define dm_paddr dm_seg.ds_addr
 };
 struct ips_softc {
-	struct device		sc_dev;
+	device_t		sc_dev;
 	/* SCSI mid-layer connection. */
 	struct scsipi_adapter   sc_adapt;
 	struct ips_pt {
 		struct scsipi_channel	pt_chan;
 		int			pt_nchan;
 		struct ips_softc *	pt_sc;
 		int			pt_proctgt;
 		char			pt_procdev[16];
 	}			sc_pt[IPS_MAXCHANS];
 @@ -624,26 +624,27 @@ ips_attach(struct device *parent, struct
 	struct ips_ccb ccb0;
 	struct ips_adapterinfo *ai;
 	struct ips_driveinfo *di;
 	struct ips_pg5 *pg5;
 	pcireg_t maptype;
 	bus_size_t iosize;
 	pci_intr_handle_t ih;
 	const char *intrstr;
 	int type, i;
 	struct scsipi_adapter *adapt;
 	struct scsipi_channel *chan;
 	char intrbuf[PCI_INTRSTR_LEN];
 	sc->sc_dev = self;
 	sc->sc_dmat = pa->pa_dmat;
 	/* Identify chipset */
 	if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_IBM_SERVERAID)
 		sc->sc_chip = &ips_chips[IPS_CHIP_COPPERHEAD];
 	else
 		sc->sc_chip = &ips_chips[IPS_CHIP_MORPHEUS];
 	/* Map registers */
 	// XXX check IPS_IOSIZE as old code used to do?
 	maptype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, sc->sc_chip->ic_bar);
 	if (pci_mapreg_map(pa, sc->sc_chip->ic_bar, maptype, 0, &sc->sc_iot,
 	    &sc->sc_ioh, NULL, &iosize)) {
 @@ -728,37 +729,37 @@ ips_attach(struct device *parent, struct
+	}
 	SLIST_INIT(&sc->sc_ccbq_free);
 	for (i = 0; i < sc->sc_nccbs; i++)
 		SLIST_INSERT_HEAD(&sc->sc_ccbq_free,
 		    &sc->sc_ccb[i], c_link);
 	/* Install interrupt handler */
 	if (pci_intr_map(pa, &ih)) {
 		printf(": can't map interrupt\n");
 		goto fail5;
+	}
 	intrstr = pci_intr_string(pa->pa_pc, ih, intrbuf, sizeof(intrbuf));
 	if (pci_intr_establish_xname(pa->pa_pc, ih, IPL_BIO, ips_intr, sc,
-	    sc->sc_dev.dv_xname) == NULL) {
+		device_xname(sc->sc_dev)) == NULL) {
 		printf(": can't establish interrupt");
 		if (intrstr != NULL)
 			printf(" at %s", intrstr);
 		printf("\n");
 		goto fail5;
+	}
 	printf(": %s\n", intrstr);
 	/* Display adapter info */
-	printf("%s: ServeRAID", sc->sc_dev.dv_xname);
+	device_printf(sc->sc_dev, "ServeRAID");
 	type = htole16(pg5->type);
 	if (type < sizeof(ips_names) / sizeof(ips_names[0]) && ips_names[type])
 		printf(" %s", ips_names[type]);
 	printf(", FW %c%c%c%c%c%c%c", ai->firmware[0], ai->firmware[1],
 	    ai->firmware[2], ai->firmware[3], ai->firmware[4], ai->firmware[5],
 	    ai->firmware[6]);
 	printf(", BIOS %c%c%c%c%c%c%c", ai->bios[0], ai->bios[1], ai->bios[2],
 	    ai->bios[3], ai->bios[4], ai->bios[5], ai->bios[6]);
 	printf(", %d cmds, %d LD%s", sc->sc_nccbs, sc->sc_nunits,
 	    (sc->sc_nunits == 1 ? "" : "s"));
 	printf("\n");
 	/*
 @@ -812,27 +813,27 @@ ips_attach(struct device *parent, struct
 		chan->chan_ntargets = IPS_MAXTARGETS;
 		chan->chan_nluns = lastarget + 1;
 		chan->chan_id = i;
 		chan->chan_flags = SCSIPI_CHAN_NOSETTLE;
 		config_found(self, chan, scsiprint, CFARGS_NONE);
+	}
 	/* Enable interrupts */
 	ips_intren(sc);
 #if NBIO > 0
 	/* Install ioctl handler */
 	if (bio_register(&sc->sc_dev, ips_ioctl))
-		printf("%s: no ioctl support\n", sc->sc_dev.dv_xname);
+		device_printf(sc->sc_dev, "no ioctl support\n");
 #endif
 	return;
 fail5:
 	ips_ccb_free(sc, sc->sc_ccb, sc->sc_nccbs);
 fail4:
 	if (sc->sc_chip->ic_id == IPS_CHIP_COPPERHEAD)
 		ips_dmamem_free(&sc->sc_sqm);
 fail3:
 	ips_dmamem_free(&sc->sc_infom);
 fail2:
 	ips_dmamem_free(&sc->sc_cmdbm);
 fail1:
 @@ -844,32 +845,32 @@ ips_scsi_cmd(struct ips_ccb *ccb)
+{
 	struct scsipi_xfer *xs = ccb->c_xfer;
 	struct scsipi_periph *periph = xs->xs_periph;
 	struct scsipi_channel *chan = periph->periph_channel;
 	struct ips_softc *sc = device_private(chan->chan_adapter->adapt_dev);
 	struct ips_driveinfo *di = &sc->sc_info->drive;
 	struct ips_drive *drive;
 	struct ips_cmd *cmd;
 	int target = periph->periph_target;
 	u_int32_t blkno, blkcnt;
 	int code;
 	DPRINTF(IPS_D_XFER, ("%s: ips_scsi_cmd: xs %p, target %d, "
-	    "opcode 0x%02x, flags 0x%x\n", sc->sc_dev.dv_xname, xs, target,
+	    "opcode 0x%02x, flags 0x%x\n", device_xname(sc->sc_dev), xs, target,
 	    xs->cmd->opcode, xs->xs_control));
 	if (target >= sc->sc_nunits || periph->periph_lun != 0) {
 		DPRINTF(IPS_D_INFO, ("%s: ips_scsi_cmd: invalid params "
-		    "target %d, lun %d\n", sc->sc_dev.dv_xname,
+		    "target %d, lun %d\n", device_xname(sc->sc_dev),
 		    target, periph->periph_lun));
 		xs->error = XS_DRIVER_STUFFUP;
 		ips_ccb_put(sc, ccb);
 		scsipi_done(xs);
 		return;
+	}
 	drive = &di->drive[target];
 	xs->error = XS_NOERROR;
 	/* Fake SCSI commands */
 	switch (xs->cmd->opcode) {
 	case READ_10:
 @@ -883,46 +884,46 @@ ips_scsi_cmd(struct ips_ccb *ccb)
 			rw = (void *)xs->cmd;
 			blkno = _3btol(rw->addr) &
 			    (SRW_TOPADDR << 16 | 0xffff);
 			blkcnt = rw->length ? rw->length : 0x100;
 		} else {
 			rwb = (void *)xs->cmd;
 			blkno = _4btol(rwb->addr);
 			blkcnt = _2btol(rwb->length);
+		}
 		if (blkno >= htole32(drive->seccnt) || blkno + blkcnt >
 		    htole32(drive->seccnt)) {
 			DPRINTF(IPS_D_ERR, ("%s: ips_scsi_cmd: invalid params "
-			    "blkno %u, blkcnt %u\n", sc->sc_dev.dv_xname,
+			    "blkno %u, blkcnt %u\n", device_xname(sc->sc_dev),
 			    blkno, blkcnt));
 			xs->error = XS_DRIVER_STUFFUP;
 			break;
+		}
 		if (xs->xs_control & XS_CTL_DATA_IN)
 			code = IPS_CMD_READ;
 		else
 			code = IPS_CMD_WRITE;
 		cmd = ccb->c_cmdbva;
 		cmd->code = code;
 		cmd->drive = target;
 		cmd->lba = htole32(blkno);
 		cmd->seccnt = htole16(blkcnt);
 		if (ips_load_xs(sc, ccb, xs)) {
 			DPRINTF(IPS_D_ERR, ("%s: ips_scsi_cmd: ips_load_xs "
-			    "failed\n", sc->sc_dev.dv_xname));
+			    "failed\n", device_xname(sc->sc_dev)));
 			xs->error = XS_DRIVER_STUFFUP;
 			ips_ccb_put(sc, ccb);
 			scsipi_done(xs);
 			return;
+		}
 		if (cmd->sgcnt > 0)
 			cmd->code |= IPS_CMD_SG;
 		ccb->c_done = ips_done_xs;
 		ips_start_xs(sc, ccb, xs);
 		return;
+	}
 @@ -963,27 +964,27 @@ ips_scsi_cmd(struct ips_ccb *ccb)
 	case SCSI_SYNCHRONIZE_CACHE_10:
 		cmd = ccb->c_cmdbva;
 		cmd->code = IPS_CMD_FLUSH;
 		ccb->c_done = ips_done_xs;
 		ips_start_xs(sc, ccb, xs);
 		return;
 	case SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL:
 	case START_STOP:
 	case SCSI_TEST_UNIT_READY:
 		break;
 	default:
 		DPRINTF(IPS_D_INFO, ("%s: unsupported scsi command 0x%02x\n",
-		    sc->sc_dev.dv_xname, xs->cmd->opcode));
+		    device_xname(sc->sc_dev), xs->cmd->opcode));
 		xs->error = XS_DRIVER_STUFFUP;
+	}
 	ips_ccb_put(sc, ccb);
 	scsipi_done(xs);
+}
 /*
  * Start a SCSI command.
  */
 static void
 ips_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
 		   void *arg)
 @@ -1034,49 +1035,49 @@ ips_scsi_ioctl(struct scsipi_channel *ch
 	return (ips_ioctl(chan->chan_adapter->adapt_dev, cmd, data));
 #else
 	return (ENOTTY);
 #endif
+}
 #if NBIO > 0
 int
 ips_ioctl(device_t dev, u_long cmd, void *data)
+{
 	struct ips_softc *sc = (struct ips_softc *)dev;
 	DPRINTF(IPS_D_INFO, ("%s: ips_ioctl: cmd %lu\n",
-	    sc->sc_dev.dv_xname, cmd));
+	    device_xname(sc->sc_dev), cmd));
 	switch (cmd) {
 	case BIOCINQ:
 		return (ips_ioctl_inq(sc, (struct bioc_inq *)data));
 	case BIOCVOL:
 		return (ips_ioctl_vol(sc, (struct bioc_vol *)data));
 	case BIOCDISK:
 		return (ips_ioctl_disk(sc, (struct bioc_disk *)data));
 	case BIOCSETSTATE:
 		return (ips_ioctl_setstate(sc, (struct bioc_setstate *)data));
 	default:
 		return (ENOTTY);
+	}
+}
 int
 ips_ioctl_inq(struct ips_softc *sc, struct bioc_inq *bi)
+{
 	struct ips_conf *conf = &sc->sc_info->conf;
 	int i;
-	strlcpy(bi->bi_dev, sc->sc_dev.dv_xname, sizeof(bi->bi_dev));
+	strlcpy(bi->bi_dev, device_xname(sc->sc_dev), sizeof(bi->bi_dev));
 	bi->bi_novol = sc->sc_nunits;
 	for (i = 0, bi->bi_nodisk = 0; i < sc->sc_nunits; i++)
 		bi->bi_nodisk += conf->ld[i].chunkcnt;
 	DPRINTF(IPS_D_INFO, ("%s: ips_ioctl_inq: novol %d, nodisk %d\n",
 	    bi->bi_dev, bi->bi_novol, bi->bi_nodisk));
 	return (0);
+}
 int
 ips_ioctl_vol(struct ips_softc *sc, struct bioc_vol *bv)
+{
 @@ -1129,32 +1130,32 @@ ips_ioctl_vol(struct ips_softc *sc, stru
 		int chan, target;
 		for (chan = 0; chan < IPS_MAXCHANS; chan++)
 			for (target = 0; target < IPS_MAXTARGETS; target++) {
 				dev = &conf->dev[chan][target];
 				if (dev->state && !(dev->state &
 				    IPS_DVS_MEMBER) &&
 				    (dev->params & SID_TYPE) == T_DIRECT)
 					bv->bv_nodisk++;
+			}
+	}
 	dv = &sc->sc_dev;
-	strlcpy(bv->bv_dev, dv->dv_xname, sizeof(bv->bv_dev));
+	strlcpy(bv->bv_dev, device_xname(dv), sizeof(bv->bv_dev));
 	strlcpy(bv->bv_vendor, "IBM", sizeof(bv->bv_vendor));
 	DPRINTF(IPS_D_INFO, ("%s: ips_ioctl_vol: vid %d, state 0x%02x, "
 	    "total %u, done %u, size %llu, level %d, nodisk %d, dev %s\n",
-	    sc->sc_dev.dv_xname, vid, ld->state, total, done, bv->bv_size,
+	    device_xname(sc->sc_dev), vid, ld->state, total, done, bv->bv_size,
 	    bv->bv_level, bv->bv_nodisk, bv->bv_dev));
 	return (0);
+}
 int
 ips_ioctl_disk(struct ips_softc *sc, struct bioc_disk *bd)
+{
 	struct ips_conf *conf = &sc->sc_info->conf;
 	struct ips_ld *ld;
 	struct ips_chunk *chunk;
 	struct ips_dev *dev;
 	int vid = bd->bd_volid, did = bd->bd_diskid;
 @@ -1206,27 +1207,27 @@ out:
 	if (dev->state & IPS_DVS_READY) {
 		bd->bd_status = BIOC_SDUNUSED;
 		if (dev->state & IPS_DVS_MEMBER)
 			bd->bd_status = BIOC_SDONLINE;
 		if (dev->state & IPS_DVS_SPARE)
 			bd->bd_status = BIOC_SDHOTSPARE;
 		if (dev->state & IPS_DVS_REBUILD)
 			bd->bd_status = BIOC_SDREBUILD;
 	} else {
 		bd->bd_status = BIOC_SDOFFLINE;
+	}
 	DPRINTF(IPS_D_INFO, ("%s: ips_ioctl_disk: vid %d, did %d, channel %d, "
-	    "target %d, size %llu, state 0x%02x\n", sc->sc_dev.dv_xname,
+	    "target %d, size %llu, state 0x%02x\n", device_xname(sc->sc_dev),
 	    vid, did, bd->bd_channel, bd->bd_target, bd->bd_size, dev->state));
 	return (0);
+}
 int
 ips_ioctl_setstate(struct ips_softc *sc, struct bioc_setstate *bs)
+{
 	struct ips_conf *conf = &sc->sc_info->conf;
 	struct ips_dev *dev;
 	int state, error;
 	if (bs->bs_channel >= IPS_MAXCHANS || bs->bs_target >= IPS_MAXTARGETS)
 @@ -1318,92 +1319,93 @@ ips_start_xs(struct ips_softc *sc, struc
 	 * errors.
 	 */
 	ips_cmd(sc, ccb);
+}
 int
 ips_cmd(struct ips_softc *sc, struct ips_ccb *ccb)
+{
 	struct ips_cmd *cmd = ccb->c_cmdbva;
 	int s, error = 0;
 	DPRINTF(IPS_D_XFER, ("%s: ips_cmd: id 0x%02x, flags 0x%x, xs %p, "
 	    "code 0x%02x, drive %d, sgcnt %d, lba %d, sgaddr 0x%08x, "
-	    "seccnt %d\n", sc->sc_dev.dv_xname, ccb->c_id, ccb->c_flags,
+	    "seccnt %d\n", device_xname(sc->sc_dev), ccb->c_id, ccb->c_flags,
 	    ccb->c_xfer, cmd->code, cmd->drive, cmd->sgcnt, htole32(cmd->lba),
 	    htole32(cmd->sgaddr), htole16(cmd->seccnt)));
 	cmd->id = ccb->c_id;
 	/* Post command to controller and optionally wait for completion */
 	s = splbio();
 	ips_exec(sc, ccb);
 	ccb->c_state = IPS_CCB_QUEUED;
 	if (ccb->c_flags & XS_CTL_POLL)
 		error = ips_poll(sc, ccb);
 	splx(s);
 	return (error);
+}
 int
 ips_poll(struct ips_softc *sc, struct ips_ccb *ccb)
+{
 	struct timeval tv;
 	int error, timo;
 	if (ccb->c_flags & XS_CTL_NOSLEEP) {
 		/* busy-wait */
 		DPRINTF(IPS_D_XFER, ("%s: ips_poll: busy-wait\n",
-		    sc->sc_dev.dv_xname));
+		    device_xname(sc->sc_dev)));
 		for (timo = 10000; timo > 0; timo--) {
 			delay(100);
 			ips_intr(sc);
 			if (ccb->c_state == IPS_CCB_DONE)
 				break;
+		}
 	} else {
 		/* sleep */
 		timo = ccb->c_xfer ? ccb->c_xfer->timeout : IPS_TIMEOUT;
 		tv.tv_sec = timo / 1000;
 		tv.tv_usec = (timo % 1000) * 1000;
 		timo = tvtohz(&tv);
 		DPRINTF(IPS_D_XFER, ("%s: ips_poll: sleep %d hz\n",
-		    sc->sc_dev.dv_xname, timo));
+		    device_xname(sc->sc_dev), timo));
 		tsleep(ccb, PRIBIO + 1, "ipscmd", timo);
+	}
-	DPRINTF(IPS_D_XFER, ("%s: ips_poll: state %d\n", sc->sc_dev.dv_xname,
+	DPRINTF(IPS_D_XFER, ("%s: ips_poll: state %d\n",
 	    device_xname(sc->sc_dev),
 	    ccb->c_state));
 	if (ccb->c_state != IPS_CCB_DONE)
 		/*
 		 * Command never completed. Fake hardware status byte
 		 * to indicate timeout.
 		 */
 		ccb->c_stat = IPS_STAT_TIMO;
 	ips_done(sc, ccb);
 	error = ccb->c_error;
 	return (error);
+}
 void
 ips_done(struct ips_softc *sc, struct ips_ccb *ccb)
+{
 	DPRINTF(IPS_D_XFER, ("%s: ips_done: id 0x%02x, flags 0x%x, xs %p\n",
-	    sc->sc_dev.dv_xname, ccb->c_id, ccb->c_flags, ccb->c_xfer));
+	    device_xname(sc->sc_dev), ccb->c_id, ccb->c_flags, ccb->c_xfer));
 	ccb->c_error = ips_error(sc, ccb);
 	ccb->c_done(sc, ccb);
+}
 void
 ips_done_xs(struct ips_softc *sc, struct ips_ccb *ccb)
+{
 	struct scsipi_xfer *xs = ccb->c_xfer;
 	if (!(xs->xs_control & XS_CTL_POLL))
 		callout_stop(&xs->xs_callout);
 @@ -1478,27 +1480,27 @@ int
 ips_error(struct ips_softc *sc, struct ips_ccb *ccb)
+{
 	struct ips_cmdb *cmdb = ccb->c_cmdbva;
 	struct ips_cmd *cmd = &cmdb->cmd;
 	struct ips_dcdb *dcdb = &cmdb->dcdb;
 	struct scsipi_xfer *xs = ccb->c_xfer;
 	u_int8_t gsc = IPS_STAT_GSC(ccb->c_stat);
 	if (gsc == IPS_STAT_OK)
 		return (0);
 	DPRINTF(IPS_D_ERR, ("%s: ips_error: stat 0x%02x, estat 0x%02x, "
 	    "cmd code 0x%02x, drive %d, sgcnt %d, lba %u, seccnt %d",
-	    sc->sc_dev.dv_xname, ccb->c_stat, ccb->c_estat, cmd->code,
+	    device_xname(sc->sc_dev), ccb->c_stat, ccb->c_estat, cmd->code,
 	    cmd->drive, cmd->sgcnt, htole32(cmd->lba), htole16(cmd->seccnt)));
 	if (cmd->code == IPS_CMD_DCDB || cmd->code == IPS_CMD_DCDB_SG) {
 		int i;
 		DPRINTF(IPS_D_ERR, (", dcdb device 0x%02x, attr 0x%02x, "
 		    "datalen %d, sgcnt %d, status 0x%02x",
 		    dcdb->device, dcdb->attr, htole16(dcdb->datalen),
 		    dcdb->sgcnt, dcdb->status));
 		DPRINTF(IPS_D_ERR, (", cdb"));
 		for (i = 0; i < dcdb->cdblen; i++)
 			DPRINTF(IPS_D_ERR, (" %x", dcdb->cdb[i]));
 		if (ccb->c_estat == IPS_ESTAT_CKCOND) {
 @@ -1576,50 +1578,50 @@ ips_error_xs(struct ips_softc *sc, struc
+	}
 	return (XS_DRIVER_STUFFUP);
+}
 int
 ips_intr(void *arg)
+{
 	struct ips_softc *sc = arg;
 	struct ips_ccb *ccb;
 	u_int32_t status;
 	int id;
-	DPRINTF(IPS_D_XFER, ("%s: ips_intr", sc->sc_dev.dv_xname));
+	DPRINTF(IPS_D_XFER, ("%s: ips_intr", device_xname(sc->sc_dev)));
 	if (!ips_isintr(sc)) {
 		DPRINTF(IPS_D_XFER, (": not ours\n"));
 		return (0);
+	}
 	DPRINTF(IPS_D_XFER, ("\n"));
 	/* Process completed commands */
 	while ((status = ips_status(sc)) != 0xffffffff) {
 		DPRINTF(IPS_D_XFER, ("%s: ips_intr: status 0x%08x\n",
-		    sc->sc_dev.dv_xname, status));
+		    device_xname(sc->sc_dev), status));
 		id = IPS_STAT_ID(status);
 		if (id >= sc->sc_nccbs) {
 			DPRINTF(IPS_D_ERR, ("%s: ips_intr: invalid id %d\n",
-			    sc->sc_dev.dv_xname, id));
+			    device_xname(sc->sc_dev), id));
 			continue;
+		}
 		ccb = &sc->sc_ccb[id];
 		if (ccb->c_state != IPS_CCB_QUEUED) {
 			DPRINTF(IPS_D_ERR, ("%s: ips_intr: cmd 0x%02x not "
 			    "queued, state %d, status 0x%08x\n",
-			    sc->sc_dev.dv_xname, ccb->c_id, ccb->c_state,
+			    device_xname(sc->sc_dev), ccb->c_id, ccb->c_state,
 			    status));
 			continue;
+		}
 		ccb->c_state = IPS_CCB_DONE;
 		ccb->c_stat = IPS_STAT_BASIC(status);
 		ccb->c_estat = IPS_STAT_EXT(status);
 		if (ccb->c_flags & XS_CTL_POLL) {
 			wakeup(ccb);
 		} else {
 			ips_done(sc, ccb);
+		}
 @@ -1630,27 +1632,27 @@ ips_intr(void *arg)
 void
 ips_timeout(void *arg)
+{
 	struct ips_ccb *ccb = arg;
 	struct ips_softc *sc = ccb->c_sc;
 	struct scsipi_xfer *xs = ccb->c_xfer;
 	int s;
 	s = splbio();
 	if (xs)
 		scsi_print_addr(xs->xs_periph);
 	else
-		printf("%s: ", sc->sc_dev.dv_xname);
+		printf("%s: ", device_xname(sc->sc_dev));
 	printf("timeout\n");
 	/*
 	 * Command never completed. Fake hardware status byte
 	 * to indicate timeout.
 	 * XXX: need to remove command from controller.
 	 */
 	ccb->c_stat = IPS_STAT_TIMO;
 	ips_done(sc, ccb);
 	splx(s);
+}
 int
 @@ -1808,27 +1810,27 @@ ips_rebuild(struct ips_softc *sc, int ch
 void
 ips_copperhead_exec(struct ips_softc *sc, struct ips_ccb *ccb)
+{
 	u_int32_t reg;
 	int timeout;
 	for (timeout = 100; timeout-- > 0; delay(100)) {
 		reg = bus_space_read_4(sc->sc_iot, sc->sc_ioh, IPS_REG_CCC);
 		if ((reg & IPS_REG_CCC_SEM) == 0)
 			break;
+	}
 	if (timeout < 0) {
-		printf("%s: semaphore timeout\n", sc->sc_dev.dv_xname);
+		device_printf(sc->sc_dev, "semaphore timeout\n");
 		return;
+	}
 	bus_space_write_4(sc->sc_iot, sc->sc_ioh, IPS_REG_CCSA, ccb->c_cmdbpa);
 	bus_space_write_2(sc->sc_iot, sc->sc_ioh, IPS_REG_CCC,
 	    IPS_REG_CCC_START);
+}
 void
 ips_copperhead_intren(struct ips_softc *sc)
+{
 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, IPS_REG_HIS, IPS_REG_HIS_EN);
+}
 @@ -1843,27 +1845,27 @@ ips_copperhead_isintr(struct ips_softc *
 	if (reg != 0xff && (reg & IPS_REG_HIS_SCE))
 		return (1);
 	return (0);
+}
 u_int32_t
 ips_copperhead_status(struct ips_softc *sc)
+{
 	u_int32_t sqhead, sqtail, status;
 	sqhead = bus_space_read_4(sc->sc_iot, sc->sc_ioh, IPS_REG_SQH);
 	DPRINTF(IPS_D_XFER, ("%s: sqhead 0x%08x, sqtail 0x%08x\n",
-	    sc->sc_dev.dv_xname, sqhead, sc->sc_sqtail));
+	    device_xname(sc->sc_dev), sqhead, sc->sc_sqtail));
 	sqtail = sc->sc_sqtail + sizeof(u_int32_t);
 	if (sqtail == sc->sc_sqm.dm_paddr + IPS_SQSZ)
 		sqtail = sc->sc_sqm.dm_paddr;
 	if (sqtail == sqhead)
 		return (0xffffffff);
 	sc->sc_sqtail = sqtail;
 	if (++sc->sc_sqidx == IPS_MAXCMDS)
 		sc->sc_sqidx = 0;
 	status = htole32(sc->sc_sqbuf[sc->sc_sqidx]);
 	bus_space_write_4(sc->sc_iot, sc->sc_ioh, IPS_REG_SQT, sqtail);
 @@ -1889,27 +1891,28 @@ ips_morpheus_intren(struct ips_softc *sc
 int
 ips_morpheus_isintr(struct ips_softc *sc)
+{
 	return (bus_space_read_4(sc->sc_iot, sc->sc_ioh, IPS_REG_OIS) &
 	    IPS_REG_OIS_PEND);
+}
 u_int32_t
 ips_morpheus_status(struct ips_softc *sc)
+{
 	u_int32_t reg;
 	reg = bus_space_read_4(sc->sc_iot, sc->sc_ioh, IPS_REG_OQP);
-	DPRINTF(IPS_D_XFER, ("%s: status 0x%08x\n", sc->sc_dev.dv_xname, reg));
+	DPRINTF(IPS_D_XFER, ("%s: status 0x%08x\n", device_xname(sc->sc_dev),
 	    reg));
 	return (reg);
+}
 struct ips_ccb *
 ips_ccb_alloc(struct ips_softc *sc, int n)
+{
 	struct ips_ccb *ccb;
 	int i;
 	ccb = malloc(n * sizeof(*ccb), M_DEVBUF, M_WAITOK | M_ZERO);
 	for (i = 0; i < n; i++) {
 		ccb[i].c_sc = sc;