- bump __FreeBSD version to reflect added buf_ring, memory barriers,

  and ifnet functions

- add memory barriers to <machine/atomic.h>
- update drivers to only conditionally define their own

- add lockless producer / consumer ring buffer
- remove ring buffer implementation from cxgb and update its callers

- add if_transmit(struct ifnet *ifp, struct mbuf *m) to ifnet to
  allow drivers to efficiently manage multiple hardware queues
  (i.e. not serialize all packets through one ifq)
- expose if_qflush to allow drivers to flush any driver managed queues

This work was supported by Bitgravity Inc. and Chelsio Inc.

9 files changed, 49 insertions, 225 deletions

diff --git a/sys/dev/bce/if_bcereg.h b/sys/dev/bce/if_bcereg.h
index b05cbef..001d341 100644
--- a/sys/dev/bce/if_bcereg.h
+++ b/sys/dev/bce/if_bcereg.h
@@ -557,6 +557,8 @@
 
 #endif /* BCE_DEBUG */
 
+
+#if __FreeBSD_version < 800054
 #if defined(__i386__) || defined(__amd64__)
 #define mb()    __asm volatile("mfence" ::: "memory")
 #define wmb()   __asm volatile("sfence" ::: "memory")
@@ -566,6 +568,7 @@
 #define rmb()
 #define wmb()
 #endif
+#endif
 
 /****************************************************************************/
 /* Device identification definitions.                                       */
diff --git a/sys/dev/cxgb/cxgb_adapter.h b/sys/dev/cxgb/cxgb_adapter.h
index 2f274eb..1f37e3a 100644
--- a/sys/dev/cxgb/cxgb_adapter.h
+++ b/sys/dev/cxgb/cxgb_adapter.h
@@ -41,6 +41,7 @@ $FreeBSD$
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/condvar.h>
+#include <sys/buf_ring.h>
 
 #include <net/ethernet.h>
 #include <net/if.h>
@@ -258,7 +259,7 @@ struct sge_txq {
 	 * mbuf touches
 	 */
 	struct mbuf_head cleanq;	
-	struct buf_ring txq_mr;
+	struct buf_ring *txq_mr;
 	struct mbuf     *immpkt;
 	uint32_t        txq_drops;
 	uint32_t        txq_skipped;
diff --git a/sys/dev/cxgb/cxgb_multiq.c b/sys/dev/cxgb/cxgb_multiq.c
index 81c9ba2..bcae123 100644
--- a/sys/dev/cxgb/cxgb_multiq.c
+++ b/sys/dev/cxgb/cxgb_multiq.c
@@ -129,7 +129,7 @@ cxgb_pcpu_enqueue_packet_(struct sge_qset *qs, struct mbuf *m)
 		return (ENXIO);
 	}
 	txq = &qs->txq[TXQ_ETH];
-	err = buf_ring_enqueue(&txq->txq_mr, m);
+	err = buf_ring_enqueue(txq->txq_mr, m);
 	if (err) {
 		txq->txq_drops++;
 		m_freem(m);
@@ -194,14 +194,11 @@ cxgb_dequeue_packet(struct sge_txq *txq, struct mbuf **m_vec)
 	}
 	sc = qs->port->adapter;
 
-	m = buf_ring_dequeue(&txq->txq_mr);
+	m = buf_ring_dequeue_sc(txq->txq_mr);
 	if (m == NULL) 
 		return (0);
 
 	count = 1;
-	KASSERT(m->m_type == MT_DATA,
-	    ("m=%p is bad mbuf type %d from ring cons=%d prod=%d", m,
-		m->m_type, txq->txq_mr.br_cons, txq->txq_mr.br_prod));
 	m_vec[0] = m;
 	if (m->m_pkthdr.tso_segsz > 0 || m->m_pkthdr.len > TX_WR_SIZE_MAX ||
 	    m->m_next != NULL || (cxgb_pcpu_tx_coalesce == 0)) {
@@ -209,14 +206,14 @@ cxgb_dequeue_packet(struct sge_txq *txq, struct mbuf **m_vec)
 	}
 
 	size = m->m_pkthdr.len;
-	for (m = buf_ring_peek(&txq->txq_mr); m != NULL;
-	     m = buf_ring_peek(&txq->txq_mr)) {
+	for (m = buf_ring_peek(txq->txq_mr); m != NULL;
+	     m = buf_ring_peek(txq->txq_mr)) {
 
 		if (m->m_pkthdr.tso_segsz > 0 ||
 		    size + m->m_pkthdr.len > TX_WR_SIZE_MAX || m->m_next != NULL)
 			break;
 
-		buf_ring_dequeue(&txq->txq_mr);
+		buf_ring_dequeue_sc(txq->txq_mr);
 		size += m->m_pkthdr.len;
 		m_vec[count++] = m;
 
@@ -367,7 +364,7 @@ cxgb_pcpu_free(struct sge_qset *qs)
 	mtx_lock(&txq->lock);
 	while ((m = mbufq_dequeue(&txq->sendq)) != NULL) 
 		m_freem(m);
-	while ((m = buf_ring_dequeue(&txq->txq_mr)) != NULL) 
+	while ((m = buf_ring_dequeue_sc(txq->txq_mr)) != NULL) 
 		m_freem(m);
 
 	t3_free_tx_desc_all(txq);
@@ -429,7 +426,7 @@ cxgb_pcpu_start_(struct sge_qset *qs, struct mbuf *immpkt, int tx_flush)
 		initerr = ENXIO;
 	else if (immpkt) {
 
-		if (!buf_ring_empty(&txq->txq_mr)) 
+		if (!buf_ring_empty(txq->txq_mr)) 
 			initerr = cxgb_pcpu_enqueue_packet_(qs, immpkt);
 		else
 			txq->immpkt = immpkt;
@@ -460,7 +457,7 @@ cxgb_pcpu_start_(struct sge_qset *qs, struct mbuf *immpkt, int tx_flush)
 	}
 
 	stopped = isset(&qs->txq_stopped, TXQ_ETH);
-	flush = (((!buf_ring_empty(&txq->txq_mr) || (!IFQ_DRV_IS_EMPTY(&pi->ifp->if_snd))) && !stopped) || txq->immpkt); 
+	flush = (((!buf_ring_empty(txq->txq_mr) || (!IFQ_DRV_IS_EMPTY(&pi->ifp->if_snd))) && !stopped) || txq->immpkt); 
 	max_desc = tx_flush ? TX_ETH_Q_SIZE : TX_START_MAX_DESC;
 
 	if (cxgb_debug)
@@ -471,7 +468,7 @@ cxgb_pcpu_start_(struct sge_qset *qs, struct mbuf *immpkt, int tx_flush)
 
 
 	if ((tx_flush && flush && err == 0) &&
-	    (!buf_ring_empty(&txq->txq_mr)  ||
+	    (!buf_ring_empty(txq->txq_mr)  ||
 		!IFQ_DRV_IS_EMPTY(&pi->ifp->if_snd))) {
 		struct thread *td = curthread;
 
@@ -521,7 +518,7 @@ cxgb_pcpu_start(struct ifnet *ifp, struct mbuf *immpkt)
 	txq = &qs->txq[TXQ_ETH];
 
 	if (((sc->tunq_coalesce == 0) ||
-		(buf_ring_count(&txq->txq_mr) >= TX_WR_COUNT_MAX) ||
+		(buf_ring_count(txq->txq_mr) >= TX_WR_COUNT_MAX) ||
 		(cxgb_pcpu_tx_coalesce == 0)) && mtx_trylock(&txq->lock)) {
 		if (cxgb_debug)
 			printf("doing immediate transmit\n");
@@ -529,12 +526,12 @@ cxgb_pcpu_start(struct ifnet *ifp, struct mbuf *immpkt)
 		txq->flags |= TXQ_TRANSMITTING;
 		err = cxgb_pcpu_start_(qs, immpkt, FALSE);
 		txq->flags &= ~TXQ_TRANSMITTING;
-		resid = (buf_ring_count(&txq->txq_mr) > 64) || (desc_reclaimable(txq) > 64);
+		resid = (buf_ring_count(txq->txq_mr) > 64) || (desc_reclaimable(txq) > 64);
 		mtx_unlock(&txq->lock);
 	} else if (immpkt) {
 		if (cxgb_debug)
 			printf("deferred coalesce=%jx ring_count=%d mtx_owned=%d\n",
-			    sc->tunq_coalesce, buf_ring_count(&txq->txq_mr), mtx_owned(&txq->lock));
+			    sc->tunq_coalesce, buf_ring_count(txq->txq_mr), mtx_owned(&txq->lock));
 		err = cxgb_pcpu_enqueue_packet_(qs, immpkt);
 	}
 	
@@ -586,7 +583,7 @@ cxgb_pcpu_start_proc(void *arg)
 
 		if ((qs->port->ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
 			idleticks = hz;
-			if (!buf_ring_empty(&txq->txq_mr) ||
+			if (!buf_ring_empty(txq->txq_mr) ||
 			    !mbufq_empty(&txq->sendq))
 				cxgb_pcpu_free(qs);
 			goto done;
@@ -611,11 +608,13 @@ cxgb_pcpu_start_proc(void *arg)
 			mtx_unlock(&qs->rspq.lock);
 		}
 #endif		
-		if ((!buf_ring_empty(&txq->txq_mr)) && err == 0) {
+		if ((!buf_ring_empty(txq->txq_mr)) && err == 0) {
+#if 0
 			if (cxgb_debug)
 				printf("head=%p cons=%d prod=%d\n",
 				    txq->sendq.head, txq->txq_mr.br_cons,
 				    txq->txq_mr.br_prod);
+#endif			
 			continue;
 		}
 	done:	
diff --git a/sys/dev/cxgb/cxgb_osdep.h b/sys/dev/cxgb/cxgb_osdep.h
index ba37cb9..d0a7258 100644
--- a/sys/dev/cxgb/cxgb_osdep.h
+++ b/sys/dev/cxgb/cxgb_osdep.h
@@ -156,9 +156,6 @@ struct t3_mbuf_hdr {
 
 
 #if defined(__i386__) || defined(__amd64__)
-#define mb()    __asm volatile("mfence":::"memory")
-#define rmb()   __asm volatile("lfence":::"memory")
-#define wmb()   __asm volatile("sfence" ::: "memory")
 #define smp_mb() mb()
 
 #define L1_CACHE_BYTES 128
@@ -179,163 +176,11 @@ extern void kdb_backtrace(void);
 
 
 #else /* !i386 && !amd64 */
-#define mb()
-#define rmb()
-#define wmb()
 #define smp_mb()
 #define prefetch(x)
 #define L1_CACHE_BYTES 32
 #endif
 
-struct buf_ring {
-	caddr_t          *br_ring;
-	volatile uint32_t br_cons;
-	volatile uint32_t br_prod;
-	int               br_size;
-	struct mtx        br_lock;
-};
-
-struct buf_ring *buf_ring_alloc(int count, int flags);
-void buf_ring_free(struct buf_ring *);
-
-static __inline int
-buf_ring_count(struct buf_ring *mr)
-{
-	int size = mr->br_size;
-	uint32_t mask = size - 1;
-	
-	return ((size + mr->br_prod - mr->br_cons) & mask);
-}
-
-static __inline int
-buf_ring_empty(struct buf_ring *mr)
-{
-	return (mr->br_cons == mr->br_prod);
-}
-
-static __inline int
-buf_ring_full(struct buf_ring *mr)
-{
-	uint32_t mask;
-
-	mask = mr->br_size - 1;
-	return (mr->br_cons == ((mr->br_prod + 1) & mask));
-}
-
-/*
- * The producer and consumer are independently locked
- * this relies on the consumer providing his own serialization
- *
- */
-static __inline void *
-buf_ring_dequeue(struct buf_ring *mr)
-{
-	uint32_t prod, cons, mask;
-	caddr_t *ring, m;
-	
-	ring = (caddr_t *)mr->br_ring;
-	mask = mr->br_size - 1;
-	cons = mr->br_cons;
-	mb();
-	prod = mr->br_prod;
-	m = NULL;
-	if (cons != prod) {
-		m = ring[cons];
-		ring[cons] = NULL;
-		mr->br_cons = (cons + 1) & mask;
-		mb();
-	}
-	return (m);
-}
-
-#ifdef DEBUG_BUFRING
-static __inline void
-__buf_ring_scan(struct buf_ring *mr, void *m, char *file, int line)
-{
-	int i;
-
-	for (i = 0; i < mr->br_size; i++)
-		if (m == mr->br_ring[i])
-			panic("%s:%d m=%p present prod=%d cons=%d idx=%d", file,
-			    line, m, mr->br_prod, mr->br_cons, i);
-}
-
-static __inline void
-buf_ring_scan(struct buf_ring *mr, void *m, char *file, int line)
-{
-	mtx_lock(&mr->br_lock);
-	__buf_ring_scan(mr, m, file, line);
-	mtx_unlock(&mr->br_lock);
-}
-
-#else
-static __inline void
-__buf_ring_scan(struct buf_ring *mr, void *m, char *file, int line)
-{
-}
-
-static __inline void
-buf_ring_scan(struct buf_ring *mr, void *m, char *file, int line)
-{
-}
-#endif
-
-static __inline int
-__buf_ring_enqueue(struct buf_ring *mr, void *m, char *file, int line)
-{
-	
-	uint32_t prod, cons, mask;
-	int err;
-	
-	mask = mr->br_size - 1;
-	prod = mr->br_prod;
-	mb();
-	cons = mr->br_cons;
-	__buf_ring_scan(mr, m, file, line);
-	if (((prod + 1) & mask) != cons) {
-		KASSERT(mr->br_ring[prod] == NULL, ("overwriting entry"));
-		mr->br_ring[prod] = m;
-		mb();
-		mr->br_prod = (prod + 1) & mask;
-		err = 0;
-	} else
-		err = ENOBUFS;
-
-	return (err);
-}
-
-static __inline int
-buf_ring_enqueue_(struct buf_ring *mr, void *m, char *file, int line)
-{
-	int err;
-	
-	mtx_lock(&mr->br_lock);
-	err = __buf_ring_enqueue(mr, m, file, line);
-	mtx_unlock(&mr->br_lock);
-
-	return (err);
-}
-
-#define buf_ring_enqueue(mr, m) buf_ring_enqueue_((mr), (m), __FILE__, __LINE__)
-
-
-static __inline void *
-buf_ring_peek(struct buf_ring *mr)
-{
-	int prod, cons, mask;
-	caddr_t *ring, m;
-	
-	ring = (caddr_t *)mr->br_ring;
-	mask = mr->br_size - 1;
-	cons = mr->br_cons;
-	prod = mr->br_prod;
-	m = NULL;
-	if (cons != prod)
-		m = ring[cons];
-
-	return (m);
-}
-
 #define DBG_RX          (1 << 0)
 static const int debug_flags = DBG_RX;
 
diff --git a/sys/dev/cxgb/cxgb_sge.c b/sys/dev/cxgb/cxgb_sge.c
index 7781a55..0c49dd1 100644
--- a/sys/dev/cxgb/cxgb_sge.c
+++ b/sys/dev/cxgb/cxgb_sge.c
@@ -1719,10 +1719,8 @@ t3_free_qset(adapter_t *sc, struct sge_qset *q)
 	t3_free_tx_desc_all(&q->txq[TXQ_ETH]);
 	
 	for (i = 0; i < SGE_TXQ_PER_SET; i++) 
-		if (q->txq[i].txq_mr.br_ring != NULL) {
-			free(q->txq[i].txq_mr.br_ring, M_DEVBUF);
-			mtx_destroy(&q->txq[i].txq_mr.br_lock);
-		}
+		if (q->txq[i].txq_mr != NULL) 
+			buf_ring_free(q->txq[i].txq_mr, M_DEVBUF);
 	for (i = 0; i < SGE_RXQ_PER_SET; ++i) {
 		if (q->fl[i].desc) {
 			mtx_lock_spin(&sc->sge.reg_lock);
@@ -1885,7 +1883,6 @@ t3_free_tx_desc(struct sge_txq *q, int reclaimable)
 				txsd->flags &= ~TX_SW_DESC_MAPPED;
 			}
 			m_freem_iovec(&txsd->mi);	
-			buf_ring_scan(&q->txq_mr, txsd->mi.mi_base, __FILE__, __LINE__);
 			txsd->mi.mi_base = NULL;
 			/*
 			 * XXX check for cache hit rate here
@@ -2285,14 +2282,12 @@ t3_sge_alloc_qset(adapter_t *sc, u_int id, int nports, int irq_vec_idx,
 	int i, header_size, ret = 0;
 
 	for (i = 0; i < SGE_TXQ_PER_SET; i++) {
-		if ((q->txq[i].txq_mr.br_ring = malloc(cxgb_txq_buf_ring_size*sizeof(struct mbuf *),
-			    M_DEVBUF, M_WAITOK|M_ZERO)) == NULL) {
+		
+		if ((q->txq[i].txq_mr = buf_ring_alloc(cxgb_txq_buf_ring_size,
+			    M_DEVBUF, M_WAITOK, &q->txq[i].lock)) == NULL) {
 			device_printf(sc->dev, "failed to allocate mbuf ring\n");
 			goto err;
 		}
-		q->txq[i].txq_mr.br_prod = q->txq[i].txq_mr.br_cons = 0;
-		q->txq[i].txq_mr.br_size = cxgb_txq_buf_ring_size;
-		mtx_init(&q->txq[i].txq_mr.br_lock, "txq mbuf ring", NULL, MTX_DEF);
 	}
 
 	init_qset_cntxt(q, id);
@@ -3509,12 +3504,14 @@ t3_add_configured_sysctls(adapter_t *sc)
 			SYSCTL_ADD_INT(ctx, txqpoidlist, OID_AUTO, "sendqlen",
 			    CTLFLAG_RD, &qs->txq[TXQ_ETH].sendq.qlen,
 			    0, "#tunneled packets waiting to be sent");
+#if 0			
 			SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "queue_pidx",
 			    CTLFLAG_RD, (uint32_t *)(uintptr_t)&qs->txq[TXQ_ETH].txq_mr.br_prod,
 			    0, "#tunneled packets queue producer index");
 			SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "queue_cidx",
 			    CTLFLAG_RD, (uint32_t *)(uintptr_t)&qs->txq[TXQ_ETH].txq_mr.br_cons,
 			    0, "#tunneled packets queue consumer index");
+#endif			
 			SYSCTL_ADD_INT(ctx, txqpoidlist, OID_AUTO, "processed",
 			    CTLFLAG_RD, &qs->txq[TXQ_ETH].processed,
 			    0, "#tunneled packets processed by the card");
diff --git a/sys/dev/cxgb/sys/cxgb_support.c b/sys/dev/cxgb/sys/cxgb_support.c
index f0c5956..55cf0d5 100644
--- a/sys/dev/cxgb/sys/cxgb_support.c
+++ b/sys/dev/cxgb/sys/cxgb_support.c
@@ -303,33 +303,3 @@ free:
 		uma_zfree(zone, vec[i]);
 }
 	
-struct buf_ring *
-buf_ring_alloc(int count, int flags)
-{
-	struct buf_ring *br;
-
-	KASSERT(powerof2(count), ("buf ring must be size power of 2"));
-	
-	br = malloc(sizeof(struct buf_ring), M_DEVBUF, flags|M_ZERO);
-	if (br == NULL)
-		return (NULL);
-	
-	br->br_ring = malloc(sizeof(caddr_t)*count, M_DEVBUF, flags|M_ZERO);
-	if (br->br_ring == NULL) {
-		free(br, M_DEVBUF);
-		return (NULL);
-	}
-	
-	mtx_init(&br->br_lock, "buf ring", NULL, MTX_DUPOK|MTX_DEF);
-	br->br_size = count;
-	br->br_prod = br->br_cons = 0;
-
-	return (br);
-}
-
-void
-buf_ring_free(struct buf_ring *br)
-{
-	free(br->br_ring, M_DEVBUF);
-	free(br, M_DEVBUF);
-}
diff --git a/sys/dev/cxgb/ulp/iw_cxgb/iw_cxgb_resource.c b/sys/dev/cxgb/ulp/iw_cxgb/iw_cxgb_resource.c
index 1882bce..62ffef5 100644
--- a/sys/dev/cxgb/ulp/iw_cxgb/iw_cxgb_resource.c
+++ b/sys/dev/cxgb/ulp/iw_cxgb/iw_cxgb_resource.c
@@ -90,7 +90,7 @@ static int __cxio_init_resource_fifo(struct buf_ring **fifo,
 	u32 rarray[16];
 	mtx_init(fifo_lock, "cxio fifo", NULL, MTX_DEF|MTX_DUPOK);
 
-	*fifo = buf_ring_alloc(nr, M_NOWAIT);
+	*fifo = buf_ring_alloc(nr, M_DEVBUF, M_NOWAIT, fifo_lock);
 	if (*fifo == NULL)
 		return (-ENOMEM);
 #if 0
@@ -122,7 +122,7 @@ static int __cxio_init_resource_fifo(struct buf_ring **fifo,
 			buf_ring_enqueue(*fifo, (void *) (uintptr_t)i);
 #if 0
 	for (i = 0; i < skip_low + skip_high; i++)
-		buf_ring_dequeue(*fifo);
+		buf_ring_dequeue_sc(*fifo);
 #endif	
 	return 0;
 }
@@ -149,7 +149,8 @@ static int cxio_init_qpid_fifo(struct cxio_rdev *rdev_p)
 
 	mtx_init(&rdev_p->rscp->qpid_fifo_lock, "qpid fifo", NULL, MTX_DEF);
 
-	rdev_p->rscp->qpid_fifo = buf_ring_alloc(T3_MAX_NUM_QP, M_NOWAIT);
+	rdev_p->rscp->qpid_fifo = buf_ring_alloc(T3_MAX_NUM_QP, M_DEVBUF,
+	    M_NOWAIT, &rdev_p->rscp->qpid_fifo_lock);
 	if (rdev_p->rscp->qpid_fifo == NULL)
 		return (-ENOMEM);
 
@@ -168,7 +169,7 @@ int cxio_hal_init_rhdl_resource(u32 nr_rhdl)
 
 void cxio_hal_destroy_rhdl_resource(void)
 {
-	buf_ring_free(rhdl_fifo);
+	buf_ring_free(rhdl_fifo, M_DEVBUF);
 }
 #endif
 
@@ -202,11 +203,11 @@ int cxio_hal_init_resource(struct cxio_rdev *rdev_p,
 		goto pdid_err;
 	return 0;
 pdid_err:
-	buf_ring_free(rscp->cqid_fifo);
+	buf_ring_free(rscp->cqid_fifo, M_DEVBUF);
 cqid_err:
-	buf_ring_free(rscp->qpid_fifo);
+	buf_ring_free(rscp->qpid_fifo, M_DEVBUF);
 qpid_err:
-	buf_ring_free(rscp->tpt_fifo);
+	buf_ring_free(rscp->tpt_fifo, M_DEVBUF);
 tpt_err:
 	return (-ENOMEM);
 }
@@ -219,7 +220,7 @@ static u32 cxio_hal_get_resource(struct buf_ring *fifo, struct mtx *lock)
 	u32 entry;
 	
 	mtx_lock(lock);
-	entry = (u32)(uintptr_t)buf_ring_dequeue(fifo);
+	entry = (u32)(uintptr_t)buf_ring_dequeue_sc(fifo);
 	mtx_unlock(lock);
 	return entry;
 }
@@ -276,10 +277,10 @@ void cxio_hal_put_pdid(struct cxio_hal_resource *rscp, u32 pdid)
 
 void cxio_hal_destroy_resource(struct cxio_hal_resource *rscp)
 {
-	buf_ring_free(rscp->tpt_fifo);
-	buf_ring_free(rscp->cqid_fifo);
-	buf_ring_free(rscp->qpid_fifo);
-	buf_ring_free(rscp->pdid_fifo);
+	buf_ring_free(rscp->tpt_fifo, M_DEVBUF);
+	buf_ring_free(rscp->cqid_fifo, M_DEVBUF);
+	buf_ring_free(rscp->qpid_fifo, M_DEVBUF);
+	buf_ring_free(rscp->pdid_fifo, M_DEVBUF);
 	free(rscp, M_DEVBUF);
 }
 
diff --git a/sys/dev/mxge/if_mxge_var.h b/sys/dev/mxge/if_mxge_var.h
index 2112786..e57c637 100644
--- a/sys/dev/mxge/if_mxge_var.h
+++ b/sys/dev/mxge/if_mxge_var.h
@@ -279,6 +279,8 @@ struct mxge_media_type
 /* implement our own memory barriers, since bus_space_barrier
    cannot handle write-combining regions */
 
+#if __FreeBSD_version < 800053
+
 #if defined (__GNUC__)
   #if #cpu(i386) || defined __i386 || defined i386 || defined __i386__ || #cpu(x86_64) || defined __x86_64__
     #define mb()  __asm__ __volatile__ ("sfence;": : :"memory")
@@ -293,6 +295,8 @@ struct mxge_media_type
   #error "unknown compiler"
 #endif
 
+#endif
+
 static inline void
 mxge_pio_copy(volatile void *to_v, void *from_v, size_t size)
 {
diff --git a/sys/dev/nxge/xge-osdep.h b/sys/dev/nxge/xge-osdep.h
index 15adfe7..e8f4aba 100644
--- a/sys/dev/nxge/xge-osdep.h
+++ b/sys/dev/nxge/xge-osdep.h
@@ -242,8 +242,12 @@ typedef xge_pci_info_t             *pci_cfg_h;
 	mtx_unlock_flags(lockp, flags);                                        \
 }
 
+#if __FreeBSD_version > 800053
 /* Write memory barrier */
+#define xge_os_wmb()		wmb()	
+#else
 #define xge_os_wmb()
+#endif
 
 /* Delay (in micro seconds) */
 #define xge_os_udelay(us)            DELAY(us)