 @@ -1,1365 +1,809 @@
-/*	$NetBSD: fw_port.h,v 1.32 2009/04/20 09:56:07 mschuett Exp $	*/
+/*	$NetBSD: fw_port.h,v 1.33 2009/08/07 00:10:53 dyoung Exp $	*/
 /*
  * Copyright (c) 2004 KIYOHARA Takashi
  * 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
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
+ *
  */
 #ifndef _FW_PORT_H
 #define _FW_PORT_H
 #ifdef _KERNEL
 #if defined(__FreeBSD__)
 #ifdef __DragonFly__
 #define OS_STR			"DragonFly"
 #define OS_VER			__DragonFly_cc_version
 #define OS_VER_STR		"DragonFly-1"
 #define PROJECT_STR		"DragonFly Project"
 #else
 #define OS_STR			"FreeBSD"
 #define OS_VER			__FreeBSD_version
 #define OS_VER_STR		"FreeBSD-5"
 #define PROJECT_STR		"FreeBSD Project"
 #endif
 #if defined(__DragonFly__) || __FreeBSD_version < 500000
 #define fw_dev_t dev_t
 #else
 #define fw_dev_t struct cdev *
 #endif
 #if defined(__DragonFly__) || __FreeBSD_version < 500000
 #define fw_dev2unit(x)	((minor(x) & 0xff) | (minor(x) >> 8))
 #define fw_unit2minor(x) (((x) & 0xff) | (((x) << 8) & ~0xffff))
 #else
 #define fw_dev2unit(x)	dev2unit(x)
 #define fw_unit2minor(x) unit2minor(x)
 #endif
 #define fw_timevalcmp(tv1, tv2, op)	timevalcmp((tv1), (tv2), op)
 #define fw_timevalsub(tv1, tv2)		timevalsub((tv1), (tv2))
 #define fw_get_nameunit(dev)		device_get_nameunit((dev))
 #define fw_get_unit(dev)		device_get_unit((dev))
 #define fw_printf(dev, ...)		device_printf((dev), __VA_ARGS__)
 /* atomic macros */
 #define fw_atomic_set_int(P, V)		atomic_set_int((P), (V))
 #define fw_atomic_readandclear_int(p)	atomic_readandclear_int((p))
 /* mutex macros */
 #include <sys/mutex.h>
 typedef struct mtx fw_mtx_t;
 #define fw_mtx_init(mutex, name, type, opts) \
 				mtx_init(mutex, name, type, opts)
 #define fw_mtx_lock(mutex)	mtx_lock(mutex)
 #define fw_mtx_unlock(mutex)	mtx_unlock(mutex)
 #define fw_mtx_destroy(mutex)	mtx_destroy(mutex)
 #define fw_mtx_assert(mutex, what) \
 				mtx_assert(mutex, what)
 #define fw_msleep(ident, mtx, priority, wmesg, timo) \
 	msleep(ident, mtx, priority, wmesg, timo);
 /* taskqueue macros */
 #include <sys/taskqueue.h>
 typedef struct task fw_task_t;
 #define FW_TASK_INIT(task, priority, func, context) \
 				TASK_INIT((task), (priority), (func), (context))
 #define fw_taskqueue_enqueue(queue, task) \
 				taskqueue_enqueue((queue), (task))
 #define fw_taskqueue_create_fast(name, mflags, enqueue, taskqueue) \
 	taskqueue_create_fast((name), (mflags), (enqueue), (taskqueue))
 #define fw_taskqueue_start_threads(taskqueue, n, x, fmt, ...) \
 	taskqueue_start_threads((taskqueue), (n), (x), (fmt), ...)
 /* kthread macros */
 #ifdef __DragonFly__
 typedef d_thread_t fw_thread_t;
 typedef d_thread_t fw_proc_t;
 #define fw_kthread_create(func, arg, newpp, fmt, ...) \
 	kthread_create(func, arg, newpp, fmt, __VA_ARGS__)
 #define fw_kthread_exit(x)	kthread_exit()
 #elif __FreeBSD_version >= 500000
 typedef struct thread fw_thread_t;
 typedef struct thread fw_proc_t;
 #define fw_kthread_create(func, arg, newpp, fmt, ...) \
 	kthread_create(func, arg, newpp, 0, 0, fmt, __VA_ARGS__)
 #define fw_kthread_exit(ecode)	kthread_exit((ecode))
 #else
 typedef struct proc fw_thread_t;
 typedef struct proc fw_proc_t;
 #define fw_kthread_create(func, arg, newpp, fmt, ...) \
 	kproc_create(func, arg, newpp, fmt, __VA_ARGS__)
 #define fw_kthread_exit(ecode)	kproc_exit((ecode))
 #endif
 /* callout macros */
 #if defined(__DragonFly__) || __FreeBSD_version < 500000
 #define fw_callout_init(c)	callout_init((c), 0)
 #else
 #define fw_callout_init(c)	callout_init(c, 1 /* mpsafe */)
 #endif
 #define fw_callout_reset(c, ticks, func, arg) \
 				callout_reset((c), (ticks), (func), (arg))
 #define fw_callout_stop(c)	callout_stop((c))
 /* bus_dma macros */
 typedef bus_dma_tag_t fw_bus_dma_tag_t;
 #if defined(__FreeBSD__) && __FreeBSD_version >= 501102
 #define fw_bus_dma_tag_create(t,					     \
 	    a, b, laddr, haddr, ffunc, farg, s, ns, mxss, f, lfunc, larg, tp)\
 	bus_dma_tag_create((t), (a), (b), (laddr), (haddr),		     \
 	    (ffunc), (farg), (s), (ns), (mxss), (f), (lfunc), (larg), (tp))
 #else
 #define fw_bus_dma_tag_create(t, a, b,					\
 	    laddr, haddr, ffunc, farg, s, ns, mxss, f, lfunc, larg, tp)	\
 	bus_dma_tag_create((t), (a), (b), (laddr), (haddr),		\
 	    (ffunc), (farg), (s), (ns), (mxss), (f), (tp))
 #endif
 #define fw_bus_dma_tag_destroy(t) \
 	bus_dma_tag_destroy((t))
 #define fw_bus_dmamap_create(t, f, mp) \
 	bus_dmamap_create((t), 0, (mp))
 #define fw_bus_dmamap_destroy((t), (m)) \
 	bus_dmamap_destroy((t), (m))
 #define fw_bus_dmamap_load(t, m, b, l, func, a, f) \
 	bus_dmamap_load((t), (m), (b), (l), (func), (a), 0)
 #define fw_bus_dmamap_load_mbuf(t, m, b, func, a, f) \
 	bus_dmamap_load((t), (m), (b), (func), (a), 0)
 #define fw_bus_dmamap_unload(t, m) \
 	bus_dmamap_unload((t), (m))
 #if __FreeBSD_version < 500000
 #define fw_bus_dmamap_sync(t, m, op)					\
 	do {								\
 		switch ((op)) {						\
 		(BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE):		\
 			bus_dmamap_sync((t), (m), BUS_DMASYNC_PREWRITE);\
 			bus_dmamap_sync((t), (m), BUS_DMASYNC_PREREAD);	\
 			break;						\
 		(BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE):		\
 			/* BUS_DMASYNC_POSTWRITE is probably a no-op. */\
 			bus_dmamap_sync((t), (m), BUS_DMASYNC_POSTREAD);\
 			break;						\
 		default:						\
 			bus_dmamap_sync((t), (m), (op));		\
 		}							\
 	} while (/*CONSTCOND*/0)
 #else
 #define fw_bus_dmamap_sync(t, m, op) \
 	bus_dmamap_sync((t), (m), (op))
 #endif
 #define fw_bus_dmamem_alloc(t, vp, f, mp) \
 	bus_dmamem_alloc((t), (vp), (f), (mp))
 #define fw_bus_dmamem_free(t, v, m) \
         bus_dmamem_free((t), (v), (m))
 #define fw_config_pending_incr()
 #define fw_config_pending_decr()
 #define splfw()		splimp()
 #define splfwnet()	splimp()
 #define splfwsbp()	splcam()
 #ifdef __DragonFly__
 #include <sys/select.h>
 #elif __FreeBSD_version >= 500000
 #include <sys/selinfo.h>
 #else
 #include <sys/select.h>
 #endif
 #define FW_KASSERT(expression, str) \
 				KASSERT(expression, str)
 #ifdef __DragonFly__
 #define M_DONTWAIT MB_DONTWAIT
 #endif
 /*
  * fw attach macro for FreeBSD
  */
 #define FW_ATTACH(dname) 	\
 	static int		\
 	__CONCAT(dname,_attach)(device_t dev)
 #define FW_ATTACH_START(dname, sc, fwa)					\
 	struct __CONCAT(dname,_softc) *sc =				\
 	    ((struct __CONCAT(dname,_softc) *)device_get_softc(dev));	\
 	__unused struct fw_attach_args *fwa =		\
 	    device_get_ivars(dev)
 #define FW_ATTACH_RETURN(r)	return (r)
 /*
  * fw detach macro for FreeBSD
  */
 #define FW_DETACH(dname)	\
 	static int		\
 	__CONCAT(dname,_detach)(device_t dev)
 #define FW_DETACH_START(dname, sc)					\
 	struct __CONCAT(dname,_softc) *sc =				\
 	    ((struct __CONCAT(dname,_softc) *)device_get_softc(dev))
 /*
  * fw open macro for FreeBSD
  */
 #define FW_OPEN(dname)	\
 	int		\
 	__CONCAT(dname,_open)(fw_dev_t dev, int flags, int fmt, fw_proc_t td)
 #define FW_OPEN_START			\
 	int unit = DEV2UNIT(dev);	\
 	__unused struct firewire_softc *sc = \
 	    devclass_get_softc(firewire_devclass, unit)
 /*
  * fw close macro for FreeBSD
  */
 #define FW_CLOSE(dname)		\
 	int			\
 	__CONCAT(dname,_close)(fw_dev_t dev, int flags, \
 	int fmt, fw_proc_t td)
 #define FW_CLOSE_START
 /*
  * fw read macro for FreeBSD
  */
 #define FW_READ(dname)	\
 	int		\
 	__CONCAT(dname,_read)(fw_dev_t dev, struct uio *uio, int ioflag)
 #define FW_READ_START
 /*
  * fw write macro for FreeBSD
  */
 #define FW_WRITE(dname)	\
 	int		\
 	__CONCAT(dname,_write)(fw_dev_t dev, struct uio *uio, int ioflag)
 #define FW_WRITE_START
 /*
  * fw ioctl macro for FreeBSD
  */
 #define FW_IOCTL(dname)					\
 	int						\
 	__CONCAT(dname,_ioctl)				\
 	    (fw_dev_t dev, u_long cmd, void *data, int flag, fw_proc_t td)
 #define FW_IOCTL_START			\
 	int unit = DEV2UNIT(dev);       \
 	__unused struct firewire_softc *sc = \
 	    devclass_get_softc(firewire_devclass, unit)
 /*
  * fw poll macro for FreeBSD
  */
 #define FW_POLL(dname)	\
 	int		\
 	__CONCAT(dname,_poll)(fw_dev_t dev, int events, fw_proc_t td)
 #define FW_POLL_START
 /*
  * fw mmap macro for FreeBSD
  */
 #if defined(__DragonFly__) || __FreeBSD_version < 500102
 #define FW_MMAP(dname)	\
 	int		\
 	__CONCAT(dname,_mmap)(fw_dev_t dev, vm_offset_t offset, int nproto)
 #else
 #define FW_MMAP(dname)		\
 	int			\
 	__CONCAT(dname,_mmap)	\
 	   (fw_dev_t dev, vm_offset_t offset, vm_paddr_t *paddr, int nproto)
 #endif
 #define FW_MMAP_START
 /*
  * fw strategy macro for FreeBSD
  */
 #define FW_STRATEGY_START		\
 	fw_dev_t dev = bp->bio_dev;	\
 	int unit = DEV2UNIT(dev);	\
 	__unused struct firewire_softc *sc = \
 	    devclass_get_softc(firewire_devclass, unit)
 /*
  * if macro for FreeBSD
  */
 #define IF_DETACH_START(dname, sc)		\
 	struct __CONCAT(dname,_softc) *sc =	\
 	    (struct __CONCAT(dname,_softc) *)device_get_softc(dev)
 #define IF_IOCTL_START(dname, sc)		\
 	struct __CONCAT(dname,_softc) *sc =	\
 	    ((struct fwip_eth_softc *)ifp->if_softc)->fwip
 #define IF_INIT(dname)	\
 	static void	\
 	__CONCAT(dname,_init)(void *arg)
 #define IF_INIT_START(dname, sc, ifp)			\
 	struct __CONCAT(dname,_softc) *sc =		\
 	    ((struct fwip_eth_softc *)arg)->fwip;	\
 	struct ifnet *ifp = (sc)->fw_softc.fwip_ifp
 #define IF_INIT_RETURN(r)	return
 #define IF_STOP(dname)	\
 	static void	\
 	__CONCAT(dname,_stop)(struct __CONCAT(dname,_softc) *fwip)
 #define IF_STOP_START(dname, ifp, sc) \
 	struct ifnet *ifp = (sc)->fw_softc.fwip_ifp;
 /*
  * fwohci macro for FreeBSD
  */
 #define FWOHCI_DETACH()	\
 	int		\
 	fwohci_detach(struct fwohci_softc *sc, device_t dev)
 #define FWOHCI_DETACH_START
 #define FWOHCI_DETACH_END
 #define FWOHCI_INIT_END
 /*
  * firewire macro for FreeBSD
  */
 #define FIREWIRE_ATTACH_START		 	\
 	device_t pa = device_get_parent(dev);	\
 	struct firewire_comm *fc = (struct firewire_comm *)device_get_softc(pa)
 #define FWDEV_DESTROYDEV(sc)					\
 	do {							\
 		int err;					\
 		if ((err = fwdev_destroydev((sc))) != 0)	\
 			return err;				\
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_GENERIC_ATTACH					\
 	do {							\
 		/* Locate our children */			\
 		bus_generic_probe(dev);				\
 		/* launch attachement of the added children */	\
 		bus_generic_attach(dev);			\
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_GENERIC_DETACH					\
 	do {							\
 		int err;					\
 		if ((err = bus_generic_detach(dev)) != 0)	\
 			return err;				\
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_SBP_ATTACH						\
 	do {								\
 		fwa.fwdev = fwdev;					\
 		fwdev->sbp = device_add_child(fc->bdev, fwa.name, -1);	\
 		if (fwdev->sbp) {					\
 			device_set_ivars(fwdev->sbp, &fwa);		\
 			device_probe_and_attach(fwdev->sbp);		\
 		}							\
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_SBP_DETACH				\
 	do {						\
 		if (device_detach(fwdev->sbp) != 0)	\
 			return;				\
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_CHILDREN_FOREACH_FUNC(func, fdc)			      \
 	do {								      \
 		device_t *devlistp;					      \
 		int i, devcnt;						      \
 		if (device_get_children(fc->bdev, &devlistp, &devcnt) == 0) { \
 			for( i = 0 ; i < devcnt ; i++)			      \
 				if (device_get_state(devlistp[i]) >=	      \
 				    DS_ATTACHED)  {			      \
 					(fdc) = device_get_softc(devlistp[i]);\
 					if ((fdc)->func != NULL)	      \
 						(fdc)->func((fdc));	      \
 				}					      \
 			free(devlistp, M_TEMP);				      \
 		}							      \
 	} while (/*CONSTCOND*/0)
 /*
  * sbp macro for FreeBSD
  */
 #define SBP_ATTACH_START          		\
         struct cam_devq *devq;			\
         memset(sbp, 0, sizeof(struct sbp_softc));	\
 	sbp->fd.dev = dev
 #define SBP_SCSIBUS_ATTACH						    \
 	do {								    \
 		sbp->sim = cam_sim_alloc(sbp_action, sbp_poll, "sbp", sbp,  \
 				 device_get_unit(dev),			    \
 				 &sbp->mtx,				    \
 				 /*untagged*/ 1,			    \
 				 /*tagged*/ SBP_QUEUE_LEN - 1,		    \
 				 devq);					    \
 		if (sbp->sim == NULL) {					    \
 			cam_simq_free(devq);				    \
 			return ENXIO;					    \
 		}							    \
 		SBP_LOCK(sbp);						    \
 		if (xpt_bus_register(sbp->sim, /*bus*/0) != CAM_SUCCESS)    \
 			goto fail;					    \
 		if (xpt_create_path(					    \
 		    &sbp->path, xpt_periph, cam_sim_path(sbp->sim),	    \
 		    CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {\
 			xpt_bus_deregister(cam_sim_path(sbp->sim));	    \
 			goto fail;					    \
 		}							    \
 		xpt_async(AC_BUS_RESET, sbp->path, /*arg*/ NULL);	    \
 		SBP_UNLOCK(sbp);					    \
 	} while (/*CONSTCOND*/0)
 #define SBP_DEVICE(d)		((d)->path)
 #define SBP_DEVICE_FREEZE(d, x)	xpt_freeze_devq((d)->path, (x))
 #define SBP_DEVICE_THAW(d, x)	xpt_release_devq((d)->path, (x), TRUE)
 #define SBP_BUS_FREEZE(b)					\
 	do {							\
 		if (((b)->sim->flags & SIMQ_FREEZED) == 0) {	\
 			xpt_freeze_simq((b)->sim, /*count*/1);	\
 			(b)->sim->flags |= SIMQ_FREEZED;	\
 		}						\
 	} while (/*CONSTCOND*/0)
 #define SBP_BUS_THAW(b)						\
 	do {							\
 		xpt_release_simq((b)->sim, /*run queue*/TRUE);	\
 		(b)->sim->flags &= ~SIMQ_FREEZED;		\
 	} while (/*CONSTCOND*/0)
 #define SBP_DEVICE_PREATTACH()
 /*
  * fwip macro for FreeBSD
  */
 #define FWIP_ATTACH_START		\
 	int unit = device_get_unit(dev);\
 	struct fw_hwaddr *hwaddr;
 #define FWIP_ATTACH_SETUP						\
 	do {								\
 		fwip->fw_softc.fwip_ifp = if_alloc(IFT_IEEE1394);	\
 		hwaddr = &IFP2FWC(fwip->fw_softc.fwip_ifp)->fc_hwaddr;	\
 	} while (/*CONSTCOND*/0)
 #define FWDEV_MAKEDEV(sc)	fwdev_makedev(sc)
 #define FIREWIRE_IFATTACH(ifp, ha) \
 				firewire_ifattach((ifp), (ha))
 #define FIREWIRE_IFDETACH(ifp)		\
 	do {				\
 		firewire_ifdetach(ifp);	\
 		if_free(ifp);		\
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_BUSRESET(ifp)	firewire_busreset((ifp))
 #define FIREWIRE_INPUT(ifp, m, src) \
 				firewire_input((ifp), (m), (src))
 #define	FWIP_INIT(sc)		fwip_init(&(sc)->fw_softc)
 #define	FWIP_STOP(sc)		fwip_stop((sc))
 #define FIREWIRE_IOCTL(ifp, cmd, data) \
 				firewire_ioctl((ifp), (cmd), (data))
 #define IF_INITNAME(ifp, dev, unit)	\
 	if_initname((ifp), device_get_name((dev)), (unit));
 #define SET_IFFUNC(ifp, start, ioctl, init, stop)	\
 	do {						\
 		(ifp)->if_start = (start);		\
 		(ifp)->if_ioctl = (ioctl);		\
 		(ifp)->if_init = (init);		\
 	} while (/*CONSTCOND*/0)
 /*
  * fwdev macro for FreeBSD
  */
 #define FWDEV_OPEN_START	\
 	if (DEV_FWMEM(dev))	\
 		return fwmem_open(dev, flags, fmt, td)
 #define FWDEV_CLOSE_START	\
         if (DEV_FWMEM(dev))	\
 		return fwmem_close(dev, flags, fmt, td)
 #define FWDEV_READ_START	\
         if (DEV_FWMEM(dev))	\
 		return (physio(dev, uio, ioflag))
 #define FWDEV_WRITE_START	\
         if (DEV_FWMEM(dev))	\
 		return (physio(dev, uio, ioflag))
 #define FWDEV_IOCTL_START	\
 	if (DEV_FWMEM(dev))	\
 		return fwmem_ioctl(dev, cmd, data, flag, td)
 #define FWDEV_IOCTL_REDIRECT	fc->ioctl(dev, cmd, data, flag, td)
 #define FWDEV_POLL_START	\
 	if (DEV_FWMEM(dev))	\
 		return fwmem_poll(dev, events, td)
 #if defined(__DragonFly__) || __FreeBSD_version < 500102
 #define FWDEV_MMAP_START	\
         if (DEV_FWMEM(dev)) 	\
 		return fwmem_mmap(dev, offset, nproto)
 #else
 #define FWDEV_MMAP_START	\
         if (DEV_FWMEM(dev)) 	\
 		return fwmem_mmap(dev, offset, paddr, nproto)
 #endif
 #define FWDEV_STRATEGY_START		\
 	if (DEV_FWMEM(dev)) {		\
 		fwmem_strategy(bp);	\
 		return;			\
 #define XS_REQ_INVALID		CAM_REQ_INVALID
 #define XS_SCSI_BUS_RESET	CAM_SCSI_BUS_RESET
 #define XS_BDR_SENT		CAM_BDR_SENT
 #define XS_DEV_NOT_THERE	CAM_DEV_NOT_THERE
 #define XS_CMD_TIMEOUT		CAM_CMD_TIMEOUT
 #define XS_REQUEUE_REQ		CAM_REQUEUE_REQ
 #define XS_REQ_CMP		CAM_REQ_CMP
 #define XS_REQ_CMP_ERR		CAM_REQ_CMP_ERR
 #define XS_UA_ABORT		CAM_UA_ABORT
 #define XS_SENSE		(CAM_SCSI_STATUS_ERROR | CAM_AUTOSNS_VALID)
 typedef union ccb sbp_scsi_xfer;
 typedef struct scsi_inquiry_data sbp_scsi_inquiry_data;
 #define SCSI_XFER_TARGET(x)	((x)->ccb_h.target_id)
 #define SCSI_XFER_LUN(x)	((x)->ccb_h.target_lun)
 #define SCSI_XFER_ERROR(x)	((x)->ccb_h.status)
 #define SCSI_XFER_DIR(x)	((x)->ccb_h.flags & CAM_DIR_MASK)
 #define     SCSI_XFER_DATA_IN	CAM_DIR_IN
 #define SCSI_XFER_CALLOUT(x)	((x)->ccb_h.timeout_ch)
 #define SCSI_XFER_TIMEOUT(x)	((x)->ccb_h.timeout)
 #define SCSI_XFER_OPECODE(x)	((x)->csio.cdb_io.cdb_bytes[0])
 #define SCSI_XFER_STATUS(x)	((x)->csio.scsi_status)
 #define SCSI_XFER_EVPD(x)	((x)->csio.cdb_io.cdb_bytes[1] & SI_EVPD)
 #define SCSI_XFER_CMDLEN(x)	((x)->csio.cdb_len)
 #define SCSI_XFER_CMD(x)			\
 	(((x)->csio.ccb_h.flags & CAM_CDB_POINTER) ?\
 	    (void *)(x)->csio.cdb_io.cdb_ptr : \
 	    (void *)&(x)->csio.cdb_io.cdb_bytes)
 #define SCSI_XFER_DATALEN(x)	((x)->csio.dxfer_len)
 #define SCSI_XFER_DATA(x)	((x)->csio.data_ptr)
 #define SCSI_XFER_SENSELEN(x)	((x)->csio.sense_len)
 #define SCSI_SENSE_DATA(x)	(&(x)->csio.sense_data)
 #define SCSI_INQUIRY_DATA(x)	((x)->csio.data_ptr)
 #define SCSI_XFER_FUNCCODE(x)	((x)->ccb_h.func_code)
 #define SCSI_XFER_10BCMD_DUMP(x) \
 	((x)->csio.cdb_io.cdb_bytes[0]),	\
 	((x)->csio.cdb_io.cdb_bytes[1]),	\
 	((x)->csio.cdb_io.cdb_bytes[2]),	\
 	((x)->csio.cdb_io.cdb_bytes[3]),	\
 	((x)->csio.cdb_io.cdb_bytes[4]),	\
 	((x)->csio.cdb_io.cdb_bytes[5]),	\
 	((x)->csio.cdb_io.cdb_bytes[6]),	\
 	((x)->csio.cdb_io.cdb_bytes[7]),	\
 	((x)->csio.cdb_io.cdb_bytes[8]), 	\
 	((x)->csio.cdb_io.cdb_bytes[9])
 #define SCSI_XFER_REQUEST_COMPLETE(x)
 #define SCSI_TRANSFER_DONE(x)	xpt_done((x))
 #ifdef SID_TYPE
 #undef SID_TYPE
 #define SID_TYPE 0x1f
 #endif
 #define NOT_LUN_WILDCARD(l)	((l) != CAM_LUN_WILDCARD)
 #define CAM_XFER_FLAGS(x)	((x)->csio.ccb_h.flags)
 #define mstohz(ms) \
 	(__predict_false((ms) >= 0x20000) ? \
 	    (((ms) + 0u) / 1000u) * hz : \
 	    (((ms) + 0u) * hz) / 1000u)
 #elif defined(__NetBSD__)
 #define OS_STR			"NetBSD"
 #define OS_VER			__NetBSD_Version__
 #define OS_VER_STR		"NetBSD-2"
 #define PROJECT_STR		"NetBSD Project"
 #define fw_dev_t dev_t
 struct fwbus_attach_args {
 	const char *name;
 };
 struct fw_hwaddr {
 	uint32_t		sender_unique_ID_hi;
 	uint32_t		sender_unique_ID_lo;
 	uint8_t			sender_max_rec;
 	uint8_t			sspd;
 	uint16_t		sender_unicast_FIFO_hi;
 	uint32_t		sender_unicast_FIFO_lo;
 };
 #define fw_dev2unit(x)		minor(x)
 #define fw_unit2minor(x)	(((x) & 0xff) | (((x) << 12) & ~0xfffff))
 #define fw_timevalcmp(tv1, tv2, op)	timercmp((tv1), (tv2), op)
 #define fw_timevalsub(tv1, tv2)		timersub((tv1), (tv2), (tv1))
 #define fw_get_nameunit(dev)		device_xname(dev)
 #define fw_get_unit(dev)		device_unit((dev))
 #define fw_printf(dev, ...)		aprint_normal_dev((dev), __VA_ARGS__)
 /* atomic macros */
 /* XXXX: unsafe... */
 #define fw_atomic_set_int(P, V)	(*(u_int *)(P) |= (V))
 static __inline int
 fw_atomic_readandclear_int(int *p)
+{
 	int _p = *p;
 	*p = 0;
 	return _p;
+}
 /* mutex macros */
 /* XXXX: unsafe... */
 typedef void *fw_mtx_t;
 #define fw_mtx_init(mutex, name, type, opts)
 #define fw_mtx_lock(mutex)	(void)(mutex)	/* XXXX */
 #define fw_mtx_unlock(mutex)	(void)(mutex)	/* XXXX */
 #define fw_mtx_destroy(mutex)
 #define fw_mtx_assert(mutex, what)
 #define fw_msleep(ident, mtx, priority, wmesg, timo) \
 				tsleep((ident), (priority), (wmesg), (timo))
 /* taskqueue macros */
 /* XXXX: unsafe... */
 typedef void (*task_fn_t)(void *context, int pending);
 typedef struct {
 	STAILQ_ENTRY(task) ta_link;	/* link for queue */
 	u_short ta_pending;		/* count times queued */
 	u_short ta_priority;		/* priority of task in queue */
 	task_fn_t ta_func;		/* task handler */
 	void *ta_context;		/* argument for handler */
 } fw_task_t;
 #define fw_taskqueue_enqueue(queue, task) \
 	(task)->ta_func((task)->ta_context, 0)
 #define FW_TASK_INIT(task, priority, func, context)	\
 	do {						\
 		(task)->ta_priority = (priority);	\
 		(task)->ta_func = (func);		\
 		(task)->ta_context = (context);		\
 	} while (/*CONSTCOND*/0)
 #define fw_taskqueue_create_fast(name, mflags, enqueue, taskqueue) \
 	NULL
 #define fw_taskqueue_start_threads(taskqueue, n, x, fmt, ...)
 /* kthread macros */
 typedef struct proc fw_thread_t;
 typedef struct lwp *fw_proc_t;
 #define fw_kthread_create(func, arg, newpp, fmt, ...)	\
 	kthread_create(PRI_NONE, 0, NULL,		\
 	    (func), (arg), (newpp), (fmt), __VA_ARGS__)
 #define fw_kthread_exit(ecode)	kthread_exit((ecode))
 /* callout macros */
 #define fw_callout_init(c)	callout_init((c), 0)
 #define fw_callout_reset(c, ticks, func, arg) \
 				callout_reset((c), (ticks), (func), (arg))
 #define fw_callout_stop(c)	callout_stop((c))
 /* bus_dma macros */
 #include <sys/malloc.h>
 #include <sys/bus.h>
 struct fw_bus_dma_tag {
 	bus_dma_tag_t tag;
 	bus_size_t alignment;
 	bus_size_t boundary;
 	bus_size_t size;
 	int nsegments;
 	bus_size_t maxsegsz;
 	int flags;
 };
 typedef struct fw_bus_dma_tag *fw_bus_dma_tag_t;
 typedef int bus_dmasync_op_t;
 typedef void bus_dmamap_callback_t(void *, bus_dma_segment_t *, int, int);
 typedef void
     bus_dmamap_callback2_t(void *, bus_dma_segment_t *, int, bus_size_t, int);
 #define fw_bus_dma_tag_create(				\
     p, a, b, la, ha, ffunc, farg, maxsz,		\
     nseg, maxsegsz, f, lfunc, larg, dmat)		\
+							\
     _fw_bus_dma_tag_create((p), (a), (b), (la), (ha),	\
 	(ffunc), (farg), (maxsz), (nseg), (maxsegsz), (f), (dmat))
 static __inline int
 _fw_bus_dma_tag_create(bus_dma_tag_t parent,
     bus_size_t alignment, bus_size_t boundary,
     bus_addr_t lowaddr, bus_addr_t highaddr,
     void *filtfunc, void *filtfuncarg,
     bus_size_t maxsize, int nsegments, bus_size_t maxsegsz,
     int flags, fw_bus_dma_tag_t *fwdmat)
+{
 	fw_bus_dma_tag_t tag;
 	tag = malloc(sizeof(struct fw_bus_dma_tag), M_DEVBUF, M_NOWAIT);
 	if (tag == NULL)
 		return ENOMEM;
 /* XXXX */
 #define BUS_SPACE_MAXADDR_32BIT 0
 #define BUS_SPACE_MAXADDR 0
 	tag->tag = parent;
 	tag->alignment = alignment;
 	tag->boundary = boundary;
 	tag->size = maxsize;
 	tag->nsegments = nsegments;
 	tag->maxsegsz = maxsegsz;
 	tag->flags = flags;
 	*fwdmat = tag;
 	return 0;
+}
 #define fw_bus_dma_tag_destroy(ft) \
 	free(ft, M_DEVBUF)
 #define fw_bus_dmamap_create(ft, f, mp)		\
 	bus_dmamap_create((ft)->tag, (ft)->size,\
 	    (ft)->nsegments, (ft)->maxsegsz, (ft)->boundary, (f), (mp))
 #define fw_bus_dmamap_destroy(ft, m) \
 	bus_dmamap_destroy((ft)->tag, (m))
 static __inline int
 fw_bus_dmamap_load(fw_bus_dma_tag_t ft, bus_dmamap_t m,
     void *b, bus_size_t l, bus_dmamap_callback_t *func, void *a, int f)
+{
 	int lf = f & (BUS_DMA_WAITOK | BUS_DMA_NOWAIT | BUS_DMA_STREAMING |
 	    BUS_DMA_READ | BUS_DMA_WRITE |
 	    BUS_DMA_BUS1 | BUS_DMA_BUS2 | BUS_DMA_BUS3 | BUS_DMA_BUS4);
 	int err = bus_dmamap_load(ft->tag, m, b, l, NULL, lf);
 	(func)(a, m->dm_segs, m->dm_nsegs, err);
 	return err;
+}
 static __inline int
 fw_bus_dmamap_load_mbuf(fw_bus_dma_tag_t ft, bus_dmamap_t m,
     struct mbuf *b, bus_dmamap_callback2_t *func, void *a, int f)
+{
 	int lf = f & (BUS_DMA_WAITOK | BUS_DMA_NOWAIT | BUS_DMA_STREAMING |
 	    BUS_DMA_READ | BUS_DMA_WRITE |
 	    BUS_DMA_BUS1 | BUS_DMA_BUS2 | BUS_DMA_BUS3 | BUS_DMA_BUS4);
 	int err = bus_dmamap_load_mbuf(ft->tag, m, b, lf);
 	(func)(a, m->dm_segs, m->dm_nsegs, m->dm_mapsize, err);
 	return err;
+}
 #define fw_bus_dmamap_unload(ft, m) \
 	bus_dmamap_unload((ft)->tag, (m))
 #define fw_bus_dmamap_sync(ft, m, op) \
 	bus_dmamap_sync((ft)->tag, (m), 0, (m)->dm_mapsize, (op))
 static __inline int
 fw_bus_dmamem_alloc(fw_bus_dma_tag_t ft, void **vp, int f, bus_dmamap_t *mp)
+{
         bus_dma_segment_t segs;
 	int nsegs, err;
 	int af, mf, cf;
 	af = f & (BUS_DMA_WAITOK | BUS_DMA_NOWAIT | BUS_DMA_STREAMING |
 	    BUS_DMA_BUS1 | BUS_DMA_BUS2 | BUS_DMA_BUS3 | BUS_DMA_BUS4);
 	err = bus_dmamem_alloc(ft->tag, ft->size,
 	    ft->alignment, ft->boundary, &segs, ft->nsegments, &nsegs, af);
 	if (err) {
 		printf("fw_bus_dmamem_alloc: failed(1)\n");
 		return err;
+	}
 	mf = f & (BUS_DMA_WAITOK | BUS_DMA_NOWAIT |
 	    BUS_DMA_BUS1 | BUS_DMA_BUS2 | BUS_DMA_BUS3 | BUS_DMA_BUS4 |
 	    BUS_DMA_COHERENT | BUS_DMA_NOCACHE);
 	err = bus_dmamem_map(ft->tag,
 	    &segs, nsegs, ft->size, (void **)vp, mf);
 	if (err) {
 		printf("fw_bus_dmamem_alloc: failed(2)\n");
 		bus_dmamem_free(ft->tag, &segs, nsegs);
 		return err;
+	}
 	if (*mp != NULL)
 		return err;
 	cf = f & (BUS_DMA_WAITOK | BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW |
 	    BUS_DMA_BUS1 | BUS_DMA_BUS2 | BUS_DMA_BUS3 | BUS_DMA_BUS4);
 	err = bus_dmamap_create(ft->tag,
 	    ft->size, nsegs, ft->maxsegsz, ft->boundary, cf, mp);
 	if (err) {
 		printf("fw_bus_dmamem_alloc: failed(3)\n");
 		bus_dmamem_unmap(ft->tag, (void *)*vp, ft->size);
 		bus_dmamem_free(ft->tag, &segs, nsegs);\
+	}
 	return err;
+}
 #define fw_bus_dmamem_free(ft, v, m)					\
 	do {								\
 		bus_dmamem_unmap((ft)->tag, (v), (ft)->size);		\
 		bus_dmamem_free((ft)->tag, (m)->dm_segs, (m)->dm_nsegs);\
 		bus_dmamap_destroy((ft)->tag, (m));			\
 	} while (/*CONSTCOND*/0)
 #define fw_config_pending_incr()	config_pending_incr()
 #define fw_config_pending_decr()	config_pending_decr()
 #define splfw()		splvm()
 #define splfwnet()	splnet()
 #define splfwsbp()	splbio()
 #define splsoftvm()	splbio()
 #include <sys/select.h>
 #define FW_KASSERT(expression, str) \
 				KASSERT(expression)
 /*
  * fw attach macro for NetBSD
  */
 #define FW_ATTACH(dname) 	\
 	void			\
 	__CONCAT(dname,attach)	\
 	    (device_t parent, device_t self, void *aux)
 #define FW_ATTACH_START(dname, sc, fwa)					\
 	struct __CONCAT(dname,_softc) *sc = device_private(self);	\
 	__unused struct fw_attach_args *fwa = (struct fw_attach_args *)aux
 #define FW_ATTACH_RETURN(r)	return
 /*
  * fw detach macro for NetBSD
  */
 #define FW_DETACH(dname)	\
 	int			\
 	__CONCAT(dname,detach)(device_t self, int flags)
 #define FW_DETACH_START(dname, sc)	\
 	struct __CONCAT(dname,_softc) *sc = device_private(self)
 /*
  * fw open macro for NetBSD
  */
 #define FW_OPEN(dname)	\
 	int		\
 	__CONCAT(dname,_open)(dev_t _dev, int flags, int fmt,  fw_proc_t td)
 #define FW_OPEN_START							 \
 	struct firewire_softc *sc, *dev;				 \
+									 \
 	sc = dev = device_lookup_private(&ieee1394if_cd, DEV2UNIT(_dev));\
 	if (dev == NULL)						 \
 		return ENXIO
 /*
  * fw close macro for NetBSD
  */
 #define FW_CLOSE(dname)		\
 	int			\
 	__CONCAT(dname,_close)(dev_t _dev, int flags, int fmt, fw_proc_t td)
 #define FW_CLOSE_START						\
 	int unit = DEV2UNIT(_dev);				\
 	struct firewire_softc *dev;				\
+								\
 	dev = device_lookup_private(&ieee1394if_cd, unit);	\
 	if (dev == NULL)					\
 		return ENXIO
 /*
  * fw read macro for NetBSD
  */
 #define FW_READ(dname)	\
 	int		\
 	__CONCAT(dname,_read)(dev_t _dev, struct uio *uio, int ioflag)
 #define FW_READ_START						\
 	int unit = DEV2UNIT(_dev);				\
 	struct firewire_softc *dev;				\
+								\
 	dev = device_lookup_private(&ieee1394if_cd, unit);	\
 	if (dev == NULL)					\
 		return ENXIO
 /*
  * fw write macro for NetBSD
  */
 #define FW_WRITE(dname)	\
 	int		\
 	__CONCAT(dname,_write)(dev_t _dev, struct uio *uio, int ioflag)
 #define FW_WRITE_START						\
 	int unit = DEV2UNIT(_dev);				\
 	struct firewire_softc *dev;				\
+								\
 	dev = device_lookup_private(&ieee1394if_cd, unit);	\
 	if (dev == NULL)					\
 		return ENXIO
 /*
  * fw ioctl macro for NetBSD
  */
 #define FW_IOCTL(dname)		\
 	int			\
 	__CONCAT(dname,_ioctl)	\
 	    (dev_t _dev, u_long cmd, void *data, int flag, fw_proc_t td)
 #define FW_IOCTL_START						\
 	int unit = DEV2UNIT(_dev);				\
 	struct firewire_softc *sc, *dev;			\
+								\
 	sc = dev = device_lookup_private(&ieee1394if_cd, unit);	\
 	if (dev == NULL)					\
 		return ENXIO
 /*
  * fw poll macro for NetBSD
  */
 #define FW_POLL(dname)	\
 	int		\
 	__CONCAT(dname,_poll)(dev_t _dev, int events, fw_proc_t td)
 #define FW_POLL_START						\
 	int unit = DEV2UNIT(_dev);				\
 	struct firewire_softc *dev;				\
+								\
 	dev = device_lookup_private(&ieee1394if_cd, unit);	\
 	if (dev == NULL)					\
 		return ENXIO
 /*
  * fw mmap macro for NetBSD
  */
 #define FW_MMAP(dname)	\
 	paddr_t		\
 	__CONCAT(dname,_mmap)(dev_t _dev, off_t offset, int nproto)
 #define FW_MMAP_START						\
 	int unit = DEV2UNIT(_dev);				\
 	struct firewire_softc *dev;				\
+								\
 	dev = device_lookup_private(&ieee1394if_cd, unit);	\
 	if (dev == NULL)					\
 		return ENXIO
 /*
  * fw strategy macro for NetBSD
  */
 #define FW_STRATEGY_START					\
 	dev_t _dev = bp->bio_dev;				\
 	int unit = DEV2UNIT(_dev);				\
 	struct firewire_softc *sc, *dev;			\
+								\
 	sc = dev = device_lookup_private(&ieee1394if_cd, unit);	\
 	if (dev == NULL)					\
 		return
 /*
  * if macro for NetBSD
  */
 #define IF_DETACH_START(dname, sc)		\
 	struct __CONCAT(dname,_softc) *sc = device_private(self)
 #define IF_IOCTL_START(dname, sc)		\
 	struct __CONCAT(dname,_softc) *sc =	\
 	    ((struct fwip_eth_softc *)ifp->if_softc)->fwip
 #define IF_INIT(dname)	\
 	int		\
 	__CONCAT(dname,_init)(struct ifnet *ifp)
 #define IF_INIT_START(dname, sc, ifp)	\
 	struct __CONCAT(dname,_softc) *sc =	\
 	    ((struct fwip_eth_softc *)(ifp)->if_softc)->fwip
 #define IF_INIT_RETURN(r)	return (r)
 #define IF_STOP(dname)	\
 	void		\
 	__CONCAT(dname,_stop)(struct ifnet *ifp, int disable)
 #define IF_STOP_START(dname, ifp, sc)		\
 	struct __CONCAT(dname,_softc) *sc =	\
 	    ((struct fwip_eth_softc *)(ifp)->if_softc)->fwip
 /*
  * fwohci macro for NetBSD
  */
 #define FWOHCI_DETACH()	\
 	int		\
 	fwohci_detach(struct fwohci_softc *sc, int flags)
 #define FWOHCI_DETACH_START		\
 	if (sc->fc.bdev != NULL)	\
 		config_detach(sc->fc.bdev, flags)
 #define FWOHCI_DETACH_END
 #define FWOHCI_INIT_END							      \
 	do {								      \
 		struct fwbus_attach_args faa;				      \
 		faa.name = "ieee1394if";				      \
 		sc->fc.bdev = config_found(sc->fc.dev, &faa, fwohci_print);   \
 	} while (/*CONSTCOND*/0)
 /*
  * firewire macro for NetBSD
  */
 #define FIREWIRE_ATTACH_START						\
 	struct firewire_comm *fc = device_private(parent);		\
+									\
 	aprint_normal(": IEEE1394 bus\n");				\
+									\
 	fc->bdev = sc->dev = self;					\
 	SLIST_INIT(&sc->devlist)
 #define FWDEV_DESTROYDEV(sc)
 #define FIREWIRE_GENERIC_ATTACH						    \
 	do {								    \
 		struct fw_attach_args faa;				    \
 		struct firewire_dev_list *devlist, *elm;		    \
+									    \
 		devlist = malloc(					    \
 		    sizeof(struct firewire_dev_list), M_DEVBUF, M_NOWAIT);  \
 		if (devlist == NULL)					    \
 			break;						    \
+									    \
 		faa.name = "fwip";					    \
 		faa.fc = fc;						    \
 		faa.fwdev = NULL;					    \
 		devlist->dev = config_found(sc->dev, &faa, firewire_print); \
 		if (devlist->dev == NULL) {				    \
 			free(devlist, M_DEVBUF);			    \
 			break;						    \
 		}							    \
+									    \
 		if (SLIST_EMPTY(&sc->devlist))				    \
 			SLIST_INSERT_HEAD(&sc->devlist, devlist, link);	    \
 		else {							    \
 			for (elm = SLIST_FIRST(&sc->devlist);		    \
 			    SLIST_NEXT(elm, link) != NULL;		    \
 			    elm = SLIST_NEXT(elm, link));		    \
 			SLIST_INSERT_AFTER(elm, devlist, link);		    \
 		}							    \
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_GENERIC_DETACH						      \
 	do {								      \
 		struct firewire_dev_list *devlist;			      \
 		int err;						      \
+									      \
 		while ((devlist = SLIST_FIRST(&sc->devlist)) != NULL) {	      \
 			if ((err = config_detach(devlist->dev, flags)) != 0)  \
 				return err;				      \
 			SLIST_REMOVE(					      \
 			    &sc->devlist, devlist, firewire_dev_list, link);  \
 			free(devlist, M_DEVBUF);			      \
 		}							      \
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_SBP_ATTACH						      \
 	do {								      \
 		struct firewire_softc *sc = device_private(fc->bdev);	      \
 		struct firewire_dev_list *devlist, *elm;		      \
 		int locs[IEEE1394IFCF_NLOCS];				      \
+									      \
 		devlist = malloc(					      \
 		    sizeof(struct firewire_dev_list), M_DEVBUF, M_NOWAIT);    \
 		if (devlist == NULL) {					      \
 			printf("memory allocation failed\n");		      \
 			break;						      \
 		}							      \
+									      \
 		locs[IEEE1394IFCF_EUIHI] = fwdev->eui.hi;		      \
 		locs[IEEE1394IFCF_EUILO] = fwdev->eui.lo;		      \
+									      \
 		fwa.fwdev = fwdev;					      \
 		fwdev->sbp = config_found_sm_loc(sc->dev, "ieee1394if",	      \
 		    locs, &fwa, firewire_print, config_stdsubmatch);	      \
 		if (fwdev->sbp == NULL) {				      \
 			free(devlist, M_DEVBUF);			      \
 			break;						      \
 		}							      \
+									      \
 		devlist->fwdev = fwdev;					      \
 		devlist->dev = fwdev->sbp;				      \
+									      \
 		if (SLIST_EMPTY(&sc->devlist))				      \
 			SLIST_INSERT_HEAD(&sc->devlist, devlist, link);	      \
 		else {							      \
 			for (elm = SLIST_FIRST(&sc->devlist);		      \
 			    SLIST_NEXT(elm, link) != NULL;		      \
 			    elm = SLIST_NEXT(elm, link));		      \
 			SLIST_INSERT_AFTER(elm, devlist, link);		      \
 		}							      \
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_SBP_DETACH						      \
 	do {								      \
 		struct firewire_softc *sc = device_private(fc->bdev);	      \
 		struct firewire_dev_list *devlist;			      \
+									      \
 		SLIST_FOREACH(devlist, &sc->devlist, link) {		      \
 			if (devlist->fwdev != fwdev)			      \
 				continue;				      \
 			SLIST_REMOVE(					      \
 			    &sc->devlist, devlist, firewire_dev_list, link);  \
 			free(devlist, M_DEVBUF);			      \
+									      \
 			if (config_detach(fwdev->sbp, DETACH_FORCE) != 0)     \
 				return;					      \
 		}							      \
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_CHILDREN_FOREACH_FUNC(func, fdc)			      \
 	do {								      \
 		struct firewire_dev_list *devlist;			      \
 		struct firewire_softc *sc = device_private(fc->bdev);	      \
+									      \
 		if (!SLIST_EMPTY(&sc->devlist)) {			      \
 			SLIST_FOREACH(devlist, &sc->devlist, link) {	      \
 				(fdc) =	device_private(devlist->dev);	      \
 				if ((fdc)->func != NULL)		      \
 					(fdc)->func((fdc));		      \
 			}						      \
 		}							      \
 	} while (/*CONSTCOND*/0)
 /*
  * sbp macro for NetBSD
  */
 #define SBP_ATTACH_START					\
 	do {							\
 		aprint_normal(": SBP-2/SCSI over IEEE1394\n");	\
+								\
 		sbp->fd.dev = self;				\
 	} while (/*CONSTCOND*/0)
 #define SBP_SCSIBUS_ATTACH						    \
 	do {								    \
 		struct scsipi_adapter *sc_adapter = &sbp->sc_adapter;	    \
 		struct scsipi_channel *sc_channel = &sbp->sc_channel;	    \
 		struct sbp_target *target = &sbp->target;		    \
+									    \
 		sc_adapter->adapt_dev = sbp->fd.dev;			    \
 		sc_adapter->adapt_nchannels = 1;			    \
 		sc_adapter->adapt_max_periph = 1;			    \
 		sc_adapter->adapt_request = sbp_scsipi_request;		    \
 		sc_adapter->adapt_minphys = sbp_minphys;		    \
 		sc_adapter->adapt_openings = 8;				    \
 					/*Start with some. Grow as needed.*/\
+									    \
 		sc_channel->chan_adapter = sc_adapter;			    \
 		sc_channel->chan_bustype = &scsi_bustype;		    \
 		sc_channel->chan_defquirks = PQUIRK_ONLYBIG;		    \
 		sc_channel->chan_channel = 0;				    \
 		sc_channel->chan_flags =				    \
 		    SCSIPI_CHAN_CANGROW | SCSIPI_CHAN_NOSETTLE;		    \
+									    \
 		/* We set nluns 0 now */				    \
 		sc_channel->chan_ntargets = 1;				    \
 		sc_channel->chan_nluns = target->num_lun;		    \
 		sc_channel->chan_id = 1;				    \
+									    \
 		if ((sbp->sc_bus =					    \
 		    config_found(sbp->fd.dev, sc_channel, scsiprint)) ==    \
 		    NULL) {						    \
 			fw_printf(sbp->fd.dev, "attach failed\n");	    \
 			return;						    \
 		}							    \
 	} while (/*CONSTCOND*/0)
 #define SBP_DEVICE(d)		((d)->periph)
 #define SBP_DEVICE_FREEZE(d, x)	scsipi_periph_freeze((d)->periph, (x));
 #define SBP_DEVICE_THAW(d, x)						\
 	do {								\
 		if ((d)->periph)					\
 			scsipi_periph_thaw((d)->periph, (x));		\
 		/* XXXX */						\
 		scsipi_channel_thaw(&(d)->target->sbp->sc_channel, 0);	\
 	} while (/*CONSTCOND*/0)
 #define SBP_BUS_FREEZE(b)	scsipi_channel_freeze(&(b)->sc_channel, 1)
 #define SBP_BUS_THAW(b)		scsipi_channel_thaw(&(b)->sc_channel, 1)
 #define SBP_DEVICE_PREATTACH()						\
 	do {								\
 		if (!sbp->lwp) {					\
 			/* create thread */				\
 			if (kthread_create(PRI_NONE, 0, NULL,		\
 			    sbp_scsipi_scan_target, &sbp->target,	\
 			    &sbp->lwp, "sbp%d_attach",			\
 			    device_unit(sbp->fd.dev))) {		\
 				fw_printf(sbp->fd.dev,			\
 				    "unable to create thread");		\
 				panic("fw_kthread_create");		\
 			}						\
 		}							\
 	} while (/*CONSTCOND*/0)
 /*
  * fwip macro for NetBSD
  */
 #define FWIP_ATTACH_START						\
 	device_t dev = self;						\
 	struct fw_hwaddr *hwaddr;
 #define FWIP_ATTACH_SETUP						      \
 	do {								      \
 		aprint_normal(": IP over IEEE1394\n");			      \
 		fwip->fd.dev = self;					      \
 		fwip->fw_softc.fwip_ifp = &fwip->fw_softc.fwcom.fc_if;	      \
 		hwaddr = (struct fw_hwaddr *)&fwip->fw_softc.fwcom.ic_hwaddr; \
 	} while (/*CONSTCOND*/0)
 #define FWDEV_MAKEDEV(sc)
 #define FIREWIRE_IFATTACH(ifp, ha)					       \
 	do {								       \
 		if_attach((ifp));					       \
 		ieee1394_ifattach((ifp), (const struct ieee1394_hwaddr *)(ha));\
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_IFDETACH(ifp)			\
 	do {					\
 		ieee1394_ifdetach(ifp);		\
 		if_detach(ifp);			\
 	} while (/*CONSTCOND*/0)
 #define FIREWIRE_BUSRESET(ifp)	ieee1394_drain((ifp))
 #define FIREWIRE_INPUT(ifp, m, src) \
 				ieee1394_input((ifp), (m), (src))
 #define	FWIP_INIT(sc)		fwip_init((sc)->fw_softc.fwip_ifp)
 #define	FWIP_STOP(sc)		fwip_stop((sc)->fw_softc.fwip_ifp, 1)
 #define FIREWIRE_IOCTL(ifp, cmd, data) \
 				ieee1394_ioctl((ifp), (cmd), (data))
 #define IF_INITNAME(ifp, dev, unit)	\
 	strlcpy((ifp)->if_xname, device_xname(dev), IFNAMSIZ);
 #define SET_IFFUNC(ifp, start, ioctl, init, stop)	\
 	do {						\
 		(ifp)->if_start = (start);		\
 		(ifp)->if_ioctl = (ioctl);		\
 		(ifp)->if_init = (init);		\
 		(ifp)->if_stop = (stop);		\
 	} while (/*CONSTCOND*/0)
 /*
  * fwdev macro for NetBSD
  */
 #define FWDEV_OPEN_START	\
 	if (DEV_FWMEM(_dev))	\
 		return fwmem_open(_dev, flags, fmt, td)
 #define FWDEV_CLOSE_START	\
         if (DEV_FWMEM(_dev))	\
 		return fwmem_close(_dev, flags, fmt, td)
 #define FWDEV_READ_START	\
         if (DEV_FWMEM(_dev))	\
 		return physio(fw_strategy, NULL, _dev, ioflag, minphys, uio)
 #define FWDEV_WRITE_START	\
         if (DEV_FWMEM(_dev))	\
 		return physio(fw_strategy, NULL, _dev, ioflag, minphys, uio)
 #define FWDEV_IOCTL_START	\
 	if (DEV_FWMEM(_dev))	\
 		return fwmem_ioctl(_dev, cmd, data, flag, td)
 #define FWDEV_IOCTL_REDIRECT	fc->ioctl(_dev, cmd, data, flag, td)
 #define FWDEV_POLL_START	\
 	if (DEV_FWMEM(_dev))	\
 		return fwmem_poll(_dev, events, td)
 #define FWDEV_MMAP_START	\
         if (DEV_FWMEM(_dev)) 	\
 		return fwmem_mmap(_dev, offset, nproto)
 #define FWDEV_STRATEGY_START		\
 	if (DEV_FWMEM(_dev)) {		\
 		fwmem_strategy(bp);	\
 		return;			\
+	}
 #define XS_REQ_INVALID		XS_DRIVER_STUFFUP
 #define XS_SCSI_BUS_RESET	XS_RESET
 #define XS_BDR_SENT		XS_RESET
 #define XS_DEV_NOT_THERE	XS_DRIVER_STUFFUP
 #define XS_CMD_TIMEOUT		XS_TIMEOUT
 #define XS_REQUEUE_REQ		XS_REQUEUE
 #define XS_REQ_CMP		XS_NOERROR
 #define XS_REQ_CMP_ERR		XS_DRIVER_STUFFUP
 #define XS_UA_ABORT		XS_DRIVER_STUFFUP
 typedef struct scsipi_xfer sbp_scsi_xfer;
 typedef struct scsipi_inquiry_data sbp_scsi_inquiry_data;
 #define SCSI_XFER_TARGET(x)	((x)->xs_periph->periph_target)
 #define SCSI_XFER_LUN(x)	((x)->xs_periph->periph_lun)
 #define SCSI_XFER_ERROR(x)	((x)->error)
 #define SCSI_XFER_DIR(x) \
 	((x)->xs_control & (XS_CTL_DATA_IN | XS_CTL_DATA_OUT))
 #define     SCSI_XFER_DATA_IN	XS_CTL_DATA_IN
 #define SCSI_XFER_CALLOUT(x)	((x)->xs_callout)
 #define SCSI_XFER_TIMEOUT(x)	((x)->timeout)
 #define SCSI_XFER_OPECODE(x)	((x)->cmd->opcode)
 #define SCSI_XFER_STATUS(x)	((x)->xs_status)
 #define SCSI_XFER_EVPD(x)	((x)->cmd->bytes[0] & SI_EVPD)
 #define     SI_EVPD		0x01
 #define SCSI_XFER_CMDLEN(x)	((x)->cmdlen)
 #define SCSI_XFER_CMD(x)	((x)->cmd)
 #define SCSI_XFER_DATALEN(x)	((x)->datalen)
 #define SCSI_XFER_DATA(x)	((x)->data)
 #define SCSI_XFER_SENSELEN(x)	(0 /* XXXXX */)
 #define SCSI_SENSE_DATA(x)	(&(x)->sense.scsi_sense)
 #define SCSI_INQUIRY_DATA(x)	((x)->data)
 #define SCSI_XFER_FUNCCODE(x)	XPT_SCSI_IO
 #define SCSI_XFER_10BCMD_DUMP(x)\
 	((x)->cmd->opcode),	\
 	((x)->cmd->bytes[0]),	\
 	((x)->cmd->bytes[1]),	\
 	((x)->cmd->bytes[2]),	\
 	((x)->cmd->bytes[3]),	\
 	((x)->cmd->bytes[4]),	\
 	((x)->cmd->bytes[5]),	\
 	((x)->cmd->bytes[6]),	\
 	((x)->cmd->bytes[7]),	\
 	((x)->cmd->bytes[8])
 #define SCSI_XFER_REQUEST_COMPLETE(x) \
 	((x)->resid = 0)
 #define SCSI_TRANSFER_DONE(x)	scsipi_done((x))
 #define NOT_LUN_WILDCARD(l)	(1)
 #define CAM_XFER_FLAGS(x)	(0)	/* XXX */
 #define CAM_SCATTER_VALID	(0)	/* XXX */
 #define CAM_DATA_PHYS		(0)	/* XXX */
 #define XPT_SCSI_IO		(1)	/* XXX */
 #ifndef rounddown
 #define rounddown(x, y) ((x) / (y) * (y))
 #endif
 /*
  * additional mbuf macros for NetBSD
  */
 #include <sys/mbuf.h>
 #define	M_TRYWAIT	M_WAITOK
 #define MTAG_FIREWIRE			1394
 #define MTAG_FIREWIRE_HWADDR		0
 #define MTAG_FIREWIRE_SENDER_EUID	1
 #define m_tag_alloc(cookie, type, len, wait) \
 				m_tag_get((type), (len), (wait))
 #define m_tag_locate(m, cookie, type, t) \
 				m_tag_find((m), (type), (t))
 /* additional bpf macros */
 #define bpf_peers_present(if_bpf)	(if_bpf)
 #define CTR0(m, format)
 #define CTR1(m, format, p1)
 #define OHCI_CSR_WRITE(sc, reg, val) \
 	bus_space_write_4((sc)->bst, (sc)->bsh, reg, val)
 #define FILTER_STRAY		0
 #define FILTER_HANDLED		1
 #define SSD_CURRENT_ERROR	0x70
 #define SSD_DEFERRED_ERROR	0x71
 #define T_RBC				T_SIMPLE_DIRECT
 #define SCSI_STATUS_CHECK_COND		SCSI_CHECK
 #define SCSI_STATUS_BUSY		SCSI_BUSY
 #define SCSI_STATUS_CMD_TERMINATED	SCSI_TERMINATED
 #define BUS_SPACE_MAXSIZE_32BIT		0xFFFFFFFF
 #define DFLTPHYS			(64 * 1024)	/* fake */
 #define kdb_backtrace()
 #define kdb_active		0
 #endif
 #endif
 #if defined(__NetBSD__)
 #define vm_offset_t void *
 #endif
 #endif