svn commit: r220229 - head/sys/dev/bxe

David Christensen davidch at FreeBSD.org
Thu Mar 31 22:40:44 UTC 2011


Author: davidch
Date: Thu Mar 31 22:40:44 2011
New Revision: 220229
URL: http://svn.freebsd.org/changeset/base/220229

Log:
  - Freshened debug support code.
  - Renamed several RX variable for more consistent usage.
  - Fixed a potential problem when masking RX CQ producer value.
  
  MFC after:	One week.

Modified:
  head/sys/dev/bxe/if_bxe.c
  head/sys/dev/bxe/if_bxe.h

Modified: head/sys/dev/bxe/if_bxe.c
==============================================================================
--- head/sys/dev/bxe/if_bxe.c	Thu Mar 31 22:04:00 2011	(r220228)
+++ head/sys/dev/bxe/if_bxe.c	Thu Mar 31 22:40:44 2011	(r220229)
@@ -68,7 +68,8 @@ __FBSDID("$FreeBSD$");
 
 /* BXE Debug Options */
 #ifdef BXE_DEBUG
-	uint32_t bxe_debug = BXE_INFO;
+uint32_t bxe_debug = BXE_INFO;
+
 
 /*          0 = Never              */
 /*          1 = 1 in 2,147,483,648 */
@@ -345,8 +346,8 @@ int  bxe_set_gpio_int(struct bxe_softc *
 static int bxe_sysctl_driver_state(SYSCTL_HANDLER_ARGS);
 static int bxe_sysctl_hw_state(SYSCTL_HANDLER_ARGS);
 static int bxe_sysctl_dump_fw(SYSCTL_HANDLER_ARGS);
-static int bxe_sysctl_dump_cqe_chain(SYSCTL_HANDLER_ARGS);
-static int bxe_sysctl_dump_rx_chain(SYSCTL_HANDLER_ARGS);
+static int bxe_sysctl_dump_rx_cq_chain(SYSCTL_HANDLER_ARGS);
+static int bxe_sysctl_dump_rx_bd_chain(SYSCTL_HANDLER_ARGS);
 static int bxe_sysctl_dump_tx_chain(SYSCTL_HANDLER_ARGS);
 static int bxe_sysctl_reg_read(SYSCTL_HANDLER_ARGS);
 static int bxe_sysctl_breakpoint(SYSCTL_HANDLER_ARGS);
@@ -357,16 +358,16 @@ static void bxe_dump_enet(struct bxe_sof
 static void bxe_dump_mbuf (struct bxe_softc *, struct mbuf *);
 static void bxe_dump_tx_mbuf_chain(struct bxe_softc *, int, int);
 static void bxe_dump_rx_mbuf_chain(struct bxe_softc *, int, int);
-static void bxe_dump_pbd_locked(struct bxe_softc *,int,
+static void bxe_dump_tx_parsing_bd(struct bxe_fastpath *,int,
 	    struct eth_tx_parse_bd *);
-static void bxe_dump_txbd_locked(struct bxe_fastpath *, int,
-	    struct eth_tx_bd *);
-static void bxe_dump_rxbd_locked(struct bxe_fastpath *, int,
+static void bxe_dump_txbd(struct bxe_fastpath *, int,
+	    union eth_tx_bd_types *);
+static void bxe_dump_rxbd(struct bxe_fastpath *, int,
 	    struct eth_rx_bd *);
-static void bxe_dump_cqe_locked(struct bxe_fastpath *, int, union eth_rx_cqe *);
+static void bxe_dump_cqe(struct bxe_fastpath *, int, union eth_rx_cqe *);
 static void bxe_dump_tx_chain(struct bxe_fastpath *, int, int);
-static void bxe_dump_cqe_chain(struct bxe_fastpath *, int, int);
-static void bxe_dump_rx_chain(struct bxe_fastpath *, int, int);
+static void bxe_dump_rx_cq_chain(struct bxe_fastpath *, int, int);
+static void bxe_dump_rx_bd_chain(struct bxe_fastpath *, int, int);
 static void bxe_dump_status_block(struct bxe_softc *);
 static void bxe_dump_stats_block(struct bxe_softc *);
 static void bxe_dump_fp_state(struct bxe_fastpath *);
@@ -404,6 +405,7 @@ static device_method_t bxe_methods[] = {
 	KOBJMETHOD_END
 };
 
+
 static driver_t bxe_driver = {
 	"bxe",
 	bxe_methods,
@@ -1725,11 +1727,11 @@ bxe_attach(device_t dev)
 	 * processor memory.
 	 */
 	rid = PCIR_BAR(0);
-	sc->bxe_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
-		&rid, RF_ACTIVE);
+	sc->bxe_res = bus_alloc_resource_any(dev,
+	    SYS_RES_MEMORY, &rid, RF_ACTIVE);
 	if (sc->bxe_res == NULL) {
 		BXE_PRINTF("%s(%d):PCI BAR0 memory allocation failed\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		rc = ENXIO;
 		goto bxe_attach_fail;
 	}
@@ -1744,11 +1746,11 @@ bxe_attach(device_t dev)
 	 * Doorbell (DB) memory.
 	 */
 	rid = PCIR_BAR(2);
-	sc->bxe_db_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
-		&rid, RF_ACTIVE);
+	sc->bxe_db_res = bus_alloc_resource_any(dev,
+	    SYS_RES_MEMORY, &rid, RF_ACTIVE);
 	if (sc->bxe_db_res == NULL) {
 		BXE_PRINTF("%s(%d): PCI BAR2 memory allocation failed\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		rc = ENXIO;
 		goto bxe_attach_fail;
 	}
@@ -1834,7 +1836,6 @@ bxe_attach(device_t dev)
 
 
 #ifdef BXE_DEBUG
-
 	/* Allocate a memory buffer for grcdump output.*/
 	sc->grcdump_buffer = malloc(BXE_GRCDUMP_BUF_SIZE, M_TEMP, M_NOWAIT);
 	if (sc->grcdump_buffer == NULL) {
@@ -3738,8 +3739,8 @@ bxe_init_locked(struct bxe_softc *sc, in
 	callout_reset(&sc->bxe_tick_callout, hz, bxe_tick, sc);
 	/* Everything went OK, go ahead and exit. */
 	goto bxe_init_locked_exit;
+
 	/* Try and gracefully shutdown the device because of a failure. */
-/* Try and gracefully shutdown the device because of a failure. */
 bxe_init_locked_failed4:
 
 	for (i = 1; i < sc->num_queues; i++)
@@ -4413,6 +4414,7 @@ bxe_write_dmae(struct bxe_softc *sc, bus
 
 	DELAY(50);
 
+	/* Wait up to 200ms. */
 	timeout = 4000;
 	while (*wb_comp != BXE_WB_COMP_VAL) {
 		if (!timeout) {
@@ -4433,18 +4435,18 @@ bxe_write_dmae_exit:
 
 
 /*
-* Perform a DMAE read from to device memory.
-*
+ * Perform a DMAE read from to device memory.
+ *
  * Some of the registers on the 577XX controller are 128bits wide.  It is
  * required that when accessing those registers that they be read
  * atomically and that no intervening bus acceses to the device occur.
  * This could be handled by a lock held across all driver instances for
  * the device or it can be handled by performing a DMA operation when
  * reading from the device.  This code implements the latter.
-*
-* Returns:
-*   None.
-*/
+ *
+ * Returns:
+ *   None.
+ */
 void
 bxe_read_dmae(struct bxe_softc *sc, uint32_t src_addr,
     uint32_t len32)
@@ -7244,7 +7246,8 @@ bxe_stats_init(struct bxe_softc *sc)
 		    sizeof(struct ustorm_per_client_stats));
 		memset(&fp->old_xclient, 0,
 		    sizeof(struct xstorm_per_client_stats));
-		memset(&fp->eth_q_stats, 0, sizeof(struct bxe_q_stats));
+		memset(&fp->eth_q_stats, 0,
+		    sizeof(struct bxe_q_stats));
 	}
 
 	sc->stats_state = STATS_STATE_DISABLED;
@@ -8539,6 +8542,7 @@ bxe_chktso_window(struct bxe_softc* sc, 
 	return (defrag);
 }
 
+
 /*
  * Encapsultes an mbuf cluster into the tx_bd chain structure and
  * makes the memory visible to the controller.
@@ -8557,7 +8561,7 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 	bus_dma_segment_t segs[32];
 	bus_dmamap_t map;
 	struct mbuf *m0;
-	struct eth_tx_parse_bd *pbd;
+	struct eth_tx_parse_bd *tx_parse_bd;
 	struct eth_tx_bd *tx_data_bd;
 	struct eth_tx_bd *tx_total_pkt_size_bd;
 	struct eth_tx_start_bd *tx_start_bd;
@@ -8580,7 +8584,7 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 	tx_total_pkt_size_bd = NULL;
 	tx_start_bd = NULL;
 	tx_data_bd = NULL;
-	pbd = NULL;
+	tx_parse_bd = NULL;
 
 	pkt_prod = fp->tx_pkt_prod;
 	bd_prod = TX_BD(fp->tx_bd_prod);
@@ -8693,6 +8697,7 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 				}
 				break;
 			}
+
 			/* Last try */
 			if (m0->m_pkthdr.csum_flags & CSUM_TSO){
 				if (bxe_chktso_window(sc,nsegs,segs,m0))
@@ -8765,11 +8770,11 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 	 * however, it is only used for tso & chksum.
 	 */
 	bd_prod = TX_BD(NEXT_TX_BD(bd_prod));
-	pbd = (struct eth_tx_parse_bd *)
+	tx_parse_bd = (struct eth_tx_parse_bd *)
 		   &fp->tx_bd_chain[TX_PAGE(bd_prod)][TX_IDX(bd_prod)].parse_bd;
-	memset(pbd, 0, sizeof(struct eth_tx_parse_bd));
+	memset(tx_parse_bd, 0, sizeof(struct eth_tx_parse_bd));
 
-	/* Gather all info about the packet and add to pbd */
+	/* Gather all info about the packet and add to tx_parse_bd */
 	if (m0->m_pkthdr.csum_flags) {
 		struct ether_vlan_header *eh;
 		struct ip *ip = NULL;
@@ -8790,8 +8795,9 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 		}
 
 		/* Set the Ethernet header length in 16 bit words. */
-		pbd->global_data = (e_hlen + ovlan) >> 1;
-		pbd->global_data |= ((m0->m_flags & M_VLANTAG) << ETH_TX_PARSE_BD_LLC_SNAP_EN_SHIFT);
+		tx_parse_bd->global_data = (e_hlen + ovlan) >> 1;
+		tx_parse_bd->global_data |= ((m0->m_flags & M_VLANTAG) <<
+		    ETH_TX_PARSE_BD_LLC_SNAP_EN_SHIFT);
 
 		switch (etype) {
 		case ETHERTYPE_IP:{
@@ -8802,10 +8808,10 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 				ip = (struct ip *)(m0->m_data + e_hlen);
 
 			/* Calculate IP header length (16 bit words). */
-			pbd->ip_hlen = (ip->ip_hl << 1);
+			tx_parse_bd->ip_hlen = (ip->ip_hl << 1);
 
 			/* Calculate enet + IP header length (16 bit words). */
-			pbd->total_hlen = pbd->ip_hlen + (e_hlen >> 1);
+			tx_parse_bd->total_hlen = tx_parse_bd->ip_hlen + (e_hlen >> 1);
 
 			if (m0->m_pkthdr.csum_flags & CSUM_IP) {
 				DBPRINT(sc, BXE_EXTREME_SEND, "%s(): IP checksum "
@@ -8816,7 +8822,7 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 
 			/* Handle any checksums requested by the stack. */
 			if ((m0->m_pkthdr.csum_flags & CSUM_TCP)||
-				(m0->m_pkthdr.csum_flags & CSUM_TSO)){
+			    (m0->m_pkthdr.csum_flags & CSUM_TSO)){
 
 				/* Perform TCP checksum offload. */
 				DBPRINT(sc, BXE_EXTREME_SEND, "%s(): TCP checksum "
@@ -8830,10 +8836,10 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 				DBRUN(sc->debug_tcp_csum_offload_frames++);
 
 				/* Update the enet + IP + TCP header length. */
-				pbd->total_hlen += (uint16_t)(th->th_off << 1);
+				tx_parse_bd->total_hlen += (uint16_t)(th->th_off << 1);
 
 				/* Get the pseudo header checksum. */
-				pbd->tcp_pseudo_csum = ntohs(th->th_sum);
+				tx_parse_bd->tcp_pseudo_csum = ntohs(th->th_sum);
 			} else if (m0->m_pkthdr.csum_flags & CSUM_UDP) {
 				/*
 				 * The hardware doesn't actually support UDP checksum
@@ -8861,7 +8867,7 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 				/* Add the TCP checksum offload flag for UDP frames too. */
 				flags |= ETH_TX_BD_FLAGS_L4_CSUM;
 				DBRUN(sc->debug_udp_csum_offload_frames++);
-				pbd->global_data |= ETH_TX_PARSE_BD_UDP_CS_FLG;
+				tx_parse_bd->global_data |= ETH_TX_PARSE_BD_UDP_CS_FLG;
 
 				/* Get a pointer to the UDP header. */
 				uh = (struct udphdr *)((caddr_t)ip + (ip->ip_hl << 2));
@@ -8878,8 +8884,8 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 					ntohl((*(tmp_uh + 2)) & 0x0000FFFF));
 
 				/* Update the enet + IP + UDP header length. */
-				pbd->total_hlen += (sizeof(struct udphdr) >> 1);
-				pbd->tcp_pseudo_csum = ~in_addword(uh->uh_sum, ~tmp_csum);
+				tx_parse_bd->total_hlen += (sizeof(struct udphdr) >> 1);
+				tx_parse_bd->tcp_pseudo_csum = ~in_addword(uh->uh_sum, ~tmp_csum);
 			}
 
 			/* Update the flags settings for VLAN/Offload. */
@@ -8900,9 +8906,10 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 		/* Setup the Parsing BD with TSO specific info */
 		if (m0->m_pkthdr.csum_flags & CSUM_TSO) {
 
-			uint16_t hdr_len = pbd->total_hlen << 1;
+			uint16_t hdr_len = tx_parse_bd->total_hlen << 1;
 
-			DBPRINT(sc, BXE_EXTREME_SEND, "%s(): TSO is enabled.\n",__FUNCTION__);
+			DBPRINT(sc, BXE_EXTREME_SEND, "%s(): TSO is enabled.\n",
+			    __FUNCTION__);
 
 			tx_start_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_SW_LSO;
 
@@ -8918,9 +8925,9 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 					__FUNCTION__, tx_start_bd->nbytes, tx_start_bd->addr_hi,
 					tx_start_bd->addr_lo, nbds);
 
-	bd_prod = TX_BD(NEXT_TX_BD(bd_prod));
+				bd_prod = TX_BD(NEXT_TX_BD(bd_prod));
 
-				/* Get a new transmit BD (after the pbd) and fill it. */
+				/* Get a new transmit BD (after the tx_parse_bd) and fill it. */
 				tx_data_bd = &fp->tx_bd_chain[TX_PAGE(bd_prod)][TX_IDX(bd_prod)].reg_bd;
 				tx_data_bd->addr_hi = htole32(U64_HI(segs[0].ds_addr + hdr_len));
 				tx_data_bd->addr_lo = htole32(U64_LO(segs[0].ds_addr + hdr_len));
@@ -8934,23 +8941,26 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 				 */
 
 				DBPRINT(sc, BXE_EXTREME_SEND, "%s(): TSO split data "
-					"size is %d (%x:%x)\n", __FUNCTION__,
-					tx_data_bd->nbytes, tx_data_bd->addr_hi, tx_data_bd->addr_lo);
+				    "size is %d (%x:%x)\n", __FUNCTION__,
+				    tx_data_bd->nbytes, tx_data_bd->addr_hi,
+				    tx_data_bd->addr_lo);
 			}
 
 			/*
 			 * For TSO the controller needs the following info:
 			 * MSS, tcp_send_seq, ip_id, and tcp_pseudo_csum.
 			 */
-			pbd->lso_mss = htole16(m0->m_pkthdr.tso_segsz);
-			pbd->tcp_send_seq = ntohl(th->th_seq);
-			pbd->tcp_flags = th->th_flags;
-			pbd->ip_id = ntohs(ip->ip_id);
+			tx_parse_bd->lso_mss = htole16(m0->m_pkthdr.tso_segsz);
+			tx_parse_bd->tcp_send_seq = ntohl(th->th_seq);
+			tx_parse_bd->tcp_flags = th->th_flags;
+			tx_parse_bd->ip_id = ntohs(ip->ip_id);
+
+			tx_parse_bd->tcp_pseudo_csum =
+			    ntohs(in_pseudo(ip->ip_src.s_addr,
+			    ip->ip_dst.s_addr, htons(IPPROTO_TCP)));
 
-			pbd->tcp_pseudo_csum = ntohs(in_pseudo(ip->ip_src.s_addr,
-								   ip->ip_dst.s_addr, htons(IPPROTO_TCP)));
-
-			pbd->global_data |= ETH_TX_PARSE_BD_PSEUDO_CS_WITHOUT_LEN;
+			tx_parse_bd->global_data |=
+			    ETH_TX_PARSE_BD_PSEUDO_CS_WITHOUT_LEN;
 		}
 	}
 
@@ -8971,17 +8981,6 @@ bxe_tx_encap(struct bxe_fastpath *fp, st
 
 	/* Update bd producer index value for next tx */
 	bd_prod = TX_BD(NEXT_TX_BD(bd_prod));
-/*
-BXE_PRINTF("tx_start_bd: addrlo:0x%x, addrhi:0x%x, nbytes:0x%x, bitfield:0x%x, gendata:0x%x, nbd:0x%x\n",
-tx_start_bd->addr_lo,
-tx_start_bd->addr_hi,
-tx_start_bd->nbytes,
-tx_start_bd->bd_flags.as_bitfield,
-tx_start_bd->general_data,
-tx_start_bd->nbd );
-
-bxe_dump_mbuf(sc, m0);
-*/
 	DBRUNMSG(BXE_EXTREME_SEND, bxe_dump_tx_chain(fp, debug_prod, nbds));
 
 	/*
@@ -9391,12 +9390,12 @@ bxe_ioctl(struct ifnet *ifp, u_long comm
  * 	 The adjusted value of *fp->rx_cons_sb.
  */
 static __inline uint16_t
-bxe_rx_comp_cons(struct bxe_fastpath *fp)
+bxe_rx_cq_cons(struct bxe_fastpath *fp)
 {
 	volatile uint16_t rx_cons_sb = 0;
 
 	rmb();
-	rx_cons_sb = (volatile uint16_t)le16toh(*fp->rx_cons_sb);
+	rx_cons_sb = (volatile uint16_t) le16toh(*fp->rx_cons_sb);
 
 	/*
 	 * It is valid for the hardware's copy of the completion
@@ -9405,8 +9404,8 @@ bxe_rx_comp_cons(struct bxe_fastpath *fp
 	 * that it is pointing at the next available CQE so we
 	 * need to adjust the value accordingly.
 	 */
-	if ((rx_cons_sb & TOTAL_RCQ_ENTRIES_PER_PAGE) ==
-		TOTAL_RCQ_ENTRIES_PER_PAGE)
+	if ((rx_cons_sb & USABLE_RCQ_ENTRIES_PER_PAGE) ==
+		USABLE_RCQ_ENTRIES_PER_PAGE)
 		rx_cons_sb++;
 
 	return (rx_cons_sb);
@@ -9434,7 +9433,7 @@ bxe_has_rx_work(struct bxe_fastpath *fp)
 {
 
 	rmb();
-	return (bxe_rx_comp_cons(fp) != fp->rx_comp_cons);
+	return (bxe_rx_cq_cons(fp) != fp->rx_cq_cons);
 }
 
 /*
@@ -10306,7 +10305,7 @@ bxe_init_rx_chains(struct bxe_softc *sc)
 	struct eth_rx_bd *rx_bd;
 	struct eth_rx_cqe_next_page *nextpg;
 	uint16_t ring_prod, cqe_ring_prod;
-	int func, i, j, max_agg_queues;
+	int func, i, j, rcq_idx, rx_idx, rx_sge_idx, max_agg_queues;
 
 	DBENTER(BXE_VERBOSE_LOAD | BXE_VERBOSE_RESET);
 
@@ -10374,16 +10373,19 @@ bxe_init_rx_chains(struct bxe_softc *sc)
 
 			/* Link the SGE Ring Pages to form SGE chain */
 			for (j = 0; j < NUM_RX_SGE_PAGES; j++) {
-				DBPRINT(sc,
-				    (BXE_INSANE_LOAD | BXE_INSANE_RESET),
-				    "%s(): Linking fp[%d] SGE ring[%d].\n",
-				    __FUNCTION__, i, j);
-
+				rx_sge_idx = ((j + 1) % NUM_RX_SGE_PAGES);
 				sge = &fp->rx_sge_chain[j][MAX_RX_SGE_CNT];
+
+				DBPRINT(sc, (BXE_EXTREME_LOAD | BXE_EXTREME_RESET),
+				    "%s(): fp[%02d].rx_sge_chain[%02d][0x%04X]=0x%jX\n",
+				     __FUNCTION__, i, j,
+				    (uint16_t) MAX_RX_SGE_CNT,
+				    (uintmax_t) fp->rx_sge_chain_paddr[rx_sge_idx]);
+
 				sge->addr_hi =
-				    htole32(U64_HI(fp->rx_sge_chain_paddr[(j + 1) %	NUM_RX_SGE_PAGES]));
+				    htole32(U64_HI(fp->rx_sge_chain_paddr[rx_sge_idx]));
 				sge->addr_lo =
-				    htole32(U64_LO(fp->rx_sge_chain_paddr[(j + 1) %	NUM_RX_SGE_PAGES]));
+				    htole32(U64_LO(fp->rx_sge_chain_paddr[rx_sge_idx]));
 			}
 
 			bxe_init_sge_ring_bit_mask(fp);
@@ -10394,16 +10396,19 @@ bxe_init_rx_chains(struct bxe_softc *sc)
 
 		/* Link the pages to form the RX BD Chain. */
 		for (j = 0; j < NUM_RX_PAGES; j++) {
+			rx_idx = ((j + 1) % NUM_RX_PAGES);
 			rx_bd = &fp->rx_bd_chain[j][USABLE_RX_BD_PER_PAGE];
 
-			DBPRINT(sc, (BXE_INSANE_LOAD | BXE_INSANE_RESET),
-			    "%s(): Linking fp[%d] RX BD chain page[%d].\n",
-			    __FUNCTION__, i, j);
+			DBPRINT(sc, (BXE_INFO_LOAD),
+			    "%s(): fp[%02d].rx_bd_chain[%02d][0x%04X]=0x%jX\n",
+			     __FUNCTION__, i, j,
+			    (uint16_t) USABLE_RX_BD_PER_PAGE,
+			    (uintmax_t) fp->rx_bd_chain_paddr[rx_idx]);
 
 			rx_bd->addr_hi =
-			    htole32(U64_HI(fp->rx_bd_chain_paddr[(j + 1) % NUM_RX_PAGES]));
+			    htole32(U64_HI(fp->rx_bd_chain_paddr[rx_idx]));
 			rx_bd->addr_lo =
-			    htole32(U64_LO(fp->rx_bd_chain_paddr[(j + 1) % NUM_RX_PAGES]));
+			    htole32(U64_LO(fp->rx_bd_chain_paddr[rx_idx]));
 		}
 
 		DBPRINT(sc, (BXE_INSANE_LOAD | BXE_INSANE_RESET),
@@ -10412,17 +10417,20 @@ bxe_init_rx_chains(struct bxe_softc *sc)
 
 		/* Link the pages to form the RX Completion Queue.*/
 		for (j = 0; j < NUM_RCQ_PAGES; j++) {
+			rcq_idx = ((j + 1) % NUM_RCQ_PAGES);
 			nextpg = (struct eth_rx_cqe_next_page *)
-			    &fp->rx_comp_chain[j][USABLE_RCQ_ENTRIES_PER_PAGE];
+			    &fp->rx_cq_chain[j][USABLE_RCQ_ENTRIES_PER_PAGE];
 
-			DBPRINT(sc, (BXE_INSANE_LOAD | BXE_INSANE_RESET),
-	"%s(): Linking fp[%d] RX completion chain page[%d].\n",
-			     __FUNCTION__, i, j);
+			DBPRINT(sc, (BXE_INFO_LOAD),
+			    "%s(): fp[%02d].rx_cq_chain[%02d][0x%04X]=0x%jX\n",
+			     __FUNCTION__, i, j,
+			    (uint16_t) USABLE_RCQ_ENTRIES_PER_PAGE,
+			    (uintmax_t) fp->rx_cq_chain_paddr[rcq_idx]);
 
 			nextpg->addr_hi =
-			    htole32(U64_HI(fp->rx_comp_chain_paddr[(j + 1) % NUM_RCQ_PAGES]));
+			    htole32(U64_HI(fp->rx_cq_chain_paddr[rcq_idx]));
 			nextpg->addr_lo =
-			    htole32(U64_LO(fp->rx_comp_chain_paddr[(j + 1) % NUM_RCQ_PAGES]));
+			    htole32(U64_LO(fp->rx_cq_chain_paddr[rcq_idx]));
 		}
 
 		if (TPA_ENABLED(sc)) {
@@ -10432,7 +10440,8 @@ bxe_init_rx_chains(struct bxe_softc *sc)
 			while (ring_prod < sc->rx_ring_size) {
 				if (bxe_alloc_rx_sge(sc, fp, ring_prod) != 0) {
 					BXE_PRINTF(
-	"%s(%d): Memory allocation failure! Disabling TPA for fp[%d].\n",
+					    "%s(%d): Memory allocation failure! "
+					    "Disabling TPA for fp[%d].\n",
 					    __FILE__, __LINE__, i);
 
 					/* Cleanup already allocated elements */
@@ -10452,7 +10461,7 @@ bxe_init_rx_chains(struct bxe_softc *sc)
 		 * Allocate buffers for all the RX BDs in RX BD Chain.
 		 * Add completion queue entries at the same time.
 		 */
-		fp->rx_comp_cons = ring_prod = cqe_ring_prod = 0;
+		fp->rx_cq_cons = ring_prod = cqe_ring_prod = 0;
 		DBRUN(fp->free_rx_bd = USABLE_RX_BD);
 
 		while (ring_prod < sc->rx_ring_size) {
@@ -10469,9 +10478,9 @@ bxe_init_rx_chains(struct bxe_softc *sc)
 		/* Update the driver's copy of the producer indices. */
 		fp->rx_bd_prod = ring_prod;
 
-		fp->rx_comp_prod = cqe_ring_prod;
+		fp->rx_cq_prod = cqe_ring_prod;
 		/*
-		 * fp->rx_comp_prod =
+		 * fp->rx_cq_prod =
 		 *     (uint16_t)min(NUM_RCQ_PAGES*TOTAL_RCQ_ENTRIES_PER_PAGE,
 		 *     cqe_ring_prod);
 		 */
@@ -10485,8 +10494,8 @@ bxe_init_rx_chains(struct bxe_softc *sc)
 			    BUS_DMASYNC_PREWRITE);
 
 		for (j = 0; j < NUM_RCQ_PAGES; j++)
-			bus_dmamap_sync(fp->rx_comp_chain_tag,
-			    fp->rx_comp_chain_map[j], BUS_DMASYNC_PREREAD |
+			bus_dmamap_sync(fp->rx_cq_chain_tag,
+			    fp->rx_cq_chain_map[j], BUS_DMASYNC_PREREAD |
 			    BUS_DMASYNC_PREWRITE);
 
 		/*
@@ -10494,7 +10503,7 @@ bxe_init_rx_chains(struct bxe_softc *sc)
 		 * Warning! this will generate an interrupt (to the TSTORM).
 		 * This must only be done when the controller is initialized.
 		 */
-		bxe_update_rx_prod(sc, fp, ring_prod, fp->rx_comp_prod,
+		bxe_update_rx_prod(sc, fp, ring_prod, fp->rx_cq_prod,
 		    fp->rx_sge_prod);
 
 		if (i != 0)
@@ -10502,10 +10511,10 @@ bxe_init_rx_chains(struct bxe_softc *sc)
 
 		REG_WR(sc, BAR_USTORM_INTMEM +
 		    USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(func),
-		    U64_LO(fp->rx_comp_chain_paddr[0]));
+		    U64_LO(fp->rx_cq_chain_paddr[0]));
 		REG_WR(sc, BAR_USTORM_INTMEM +
 		    USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(func) + 4,
-		    U64_HI(fp->rx_comp_chain_paddr[0]));
+		    U64_HI(fp->rx_cq_chain_paddr[0]));
 	}
 
 	DBEXIT(BXE_VERBOSE_LOAD | BXE_VERBOSE_RESET);
@@ -10521,7 +10530,7 @@ static void
 bxe_init_tx_chains(struct bxe_softc *sc)
 {
 	struct bxe_fastpath *fp;
-	struct eth_tx_next_bd *tx_bd;
+	struct eth_tx_next_bd *tx_n_bd;
 	int i, j;
 
 	DBENTER(BXE_VERBOSE_LOAD | BXE_VERBOSE_RESET);
@@ -10532,17 +10541,17 @@ bxe_init_tx_chains(struct bxe_softc *sc)
 		    "%s(): Linking fp[%d] TX chain pages.\n", __FUNCTION__, i);
 
 		for (j = 0; j < NUM_TX_PAGES; j++) {
-			tx_bd =
+			tx_n_bd =
 			    &fp->tx_bd_chain[j][USABLE_TX_BD_PER_PAGE].next_bd;
 
 			DBPRINT(sc, (BXE_INSANE_LOAD | BXE_INSANE_RESET),
 			    "%s(): Linking fp[%d] TX BD chain page[%d].\n",
 			    __FUNCTION__, i, j);
 
-			tx_bd->addr_hi =
+			tx_n_bd->addr_hi =
 			    htole32(U64_HI(fp->tx_bd_chain_paddr[(j + 1) %
 			    NUM_TX_PAGES]));
-			tx_bd->addr_lo =
+			tx_n_bd->addr_lo =
 			    htole32(U64_LO(fp->tx_bd_chain_paddr[(j + 1) %
 			    NUM_TX_PAGES]));
 		}
@@ -10609,8 +10618,8 @@ bxe_free_rx_chains(struct bxe_softc *sc)
 
 			/* Clear each RX completion queue page. */
 			for (j = 0; j < NUM_RCQ_PAGES; j++) {
-				if (fp->rx_comp_chain[j] != NULL)
-					bzero((char *)fp->rx_comp_chain[j],
+				if (fp->rx_cq_chain[j] != NULL)
+					bzero((char *)fp->rx_cq_chain[j],
 					    BXE_RX_CHAIN_PAGE_SZ);
 			}
 
@@ -11190,14 +11199,14 @@ bxe_init_internal_func(struct bxe_softc 
 	for (i = 0; i < sc->num_queues; i++) {
 		fp = &sc->fp[i];
 		nextpg = (struct eth_rx_cqe_next_page *)
-		    &fp->rx_comp_chain[i][USABLE_RCQ_ENTRIES_PER_PAGE];
+		    &fp->rx_cq_chain[i][USABLE_RCQ_ENTRIES_PER_PAGE];
 		/* Program the completion queue address. */
 		REG_WR(sc, BAR_USTORM_INTMEM +
 		    USTORM_CQE_PAGE_BASE_OFFSET(port, fp->cl_id),
-		    U64_LO(fp->rx_comp_chain_paddr[0]));
+		    U64_LO(fp->rx_cq_chain_paddr[0]));
 		REG_WR(sc, BAR_USTORM_INTMEM +
 		    USTORM_CQE_PAGE_BASE_OFFSET(port, fp->cl_id) + 4,
-		    U64_HI(fp->rx_comp_chain_paddr[0]));
+		    U64_HI(fp->rx_cq_chain_paddr[0]));
 
 		/* Next page */
 		REG_WR(sc, BAR_USTORM_INTMEM + USTORM_CQE_PAGE_NEXT_OFFSET(port,
@@ -12806,22 +12815,22 @@ bxe_dma_free(struct bxe_softc *sc)
 				 * Free, unmap and destroy all RX CQ
 				 * chain pages.
 				 */
-				if (fp->rx_comp_chain_tag != NULL) {
+				if (fp->rx_cq_chain_tag != NULL) {
 					for (j = 0; j < NUM_RCQ_PAGES; j++ ) {
-						if (fp->rx_comp_chain_map[j] != NULL) {
-							if (fp->rx_comp_chain[j] != NULL)
-								bus_dmamem_free(fp->rx_comp_chain_tag,
-									fp->rx_comp_chain[j],
-									fp->rx_comp_chain_map[j]);
-
-							bus_dmamap_unload(fp->rx_comp_chain_tag,
-								fp->rx_comp_chain_map[j]);
-							bus_dmamap_destroy(fp->rx_comp_chain_tag,
-								fp->rx_comp_chain_map[j]);
+						if (fp->rx_cq_chain_map[j] != NULL) {
+							if (fp->rx_cq_chain[j] != NULL)
+								bus_dmamem_free(fp->rx_cq_chain_tag,
+									fp->rx_cq_chain[j],
+									fp->rx_cq_chain_map[j]);
+
+							bus_dmamap_unload(fp->rx_cq_chain_tag,
+								fp->rx_cq_chain_map[j]);
+							bus_dmamap_destroy(fp->rx_cq_chain_tag,
+								fp->rx_cq_chain_map[j]);
 						}
 					}
 
-					bus_dma_tag_destroy(fp->rx_comp_chain_tag);
+					bus_dma_tag_destroy(fp->rx_cq_chain_tag);
 				}
 
 				/* Unload and destroy the TX mbuf maps. */
@@ -13093,7 +13102,7 @@ bxe_dma_alloc(device_t dev)
 	    NULL,			/* filter f() */
 	    NULL,			/* filter f() arg */
 	    MAXBSIZE,			/* max map for this tag */
-	    BUS_SPACE_UNRESTRICTED,	/* #of discontinuities */
+	    BUS_SPACE_UNRESTRICTED,	/* # of discontinuities */
 	    BUS_SPACE_MAXSIZE_32BIT,	/* max seg size */
 	    0,				/* flags */
 	    NULL,			/* lock f() */
@@ -13115,9 +13124,9 @@ bxe_dma_alloc(device_t dev)
 		    (long unsigned int)sizeof(struct bxe_fastpath));
 
 		/*
-		 * Create a DMA tag for the status block, allocate and clear the
-		 * memory, map the memory into DMA space, and fetch the physical
-		 * address of the block.
+		 * Create a DMA tag for the status block, allocate and
+		 * clear the memory, map the memory into DMA space, and
+		 * fetch the physical address of the block.
 		 */
 
 		if (bus_dma_tag_create(sc->parent_tag,
@@ -13266,10 +13275,11 @@ bxe_dma_alloc(device_t dev)
 
 		/* Create DMA maps for each the TX mbuf cluster(ext buf). */
 		for (j = 0; j < TOTAL_TX_BD; j++) {
-			if (bus_dmamap_create(fp->tx_mbuf_tag, BUS_DMA_NOWAIT,
+			if (bus_dmamap_create(fp->tx_mbuf_tag,
+			    BUS_DMA_NOWAIT,
 			    &(fp->tx_mbuf_map[j]))) {
-				BXE_PRINTF(
-		"%s(%d): Unable to create fp[%d] TX mbuf DMA map!\n",
+				BXE_PRINTF("%s(%d): Unable to create fp[%d] "
+				    "TX mbuf DMA map!\n",
 				    __FILE__, __LINE__, i);
 				rc = ENOMEM;
 				goto bxe_dma_alloc_exit;
@@ -13363,8 +13373,8 @@ bxe_dma_alloc(device_t dev)
 
 		/* Create DMA maps for the RX mbuf clusters. */
 		for (j = 0; j < TOTAL_RX_BD; j++) {
-			if (bus_dmamap_create(fp->rx_mbuf_tag, BUS_DMA_NOWAIT,
-			    &(fp->rx_mbuf_map[j]))) {
+			if (bus_dmamap_create(fp->rx_mbuf_tag,
+			    BUS_DMA_NOWAIT, &(fp->rx_mbuf_map[j]))) {
 				BXE_PRINTF(
 		"%s(%d): Unable to create fp[%d] RX mbuf DMA map!\n",
 				    __FILE__, __LINE__, i);
@@ -13392,7 +13402,7 @@ bxe_dma_alloc(device_t dev)
 		    0,			/* flags */
 		    NULL,		/* lock f() */
 		    NULL,		/* lock f() arg */
-		    &fp->rx_comp_chain_tag)) {
+		    &fp->rx_cq_chain_tag)) {
 			BXE_PRINTF(
 	"%s(%d): Could not allocate fp[%d] RX Completion Queue DMA tag!\n",
 			    __FILE__, __LINE__, i);
@@ -13401,9 +13411,9 @@ bxe_dma_alloc(device_t dev)
 		}
 
 		for (j = 0; j < NUM_RCQ_PAGES; j++) {
-			if (bus_dmamem_alloc(fp->rx_comp_chain_tag,
-			    (void **)&fp->rx_comp_chain[j], BUS_DMA_NOWAIT,
-			    &fp->rx_comp_chain_map[j])) {
+			if (bus_dmamem_alloc(fp->rx_cq_chain_tag,
+			    (void **)&fp->rx_cq_chain[j], BUS_DMA_NOWAIT,
+			    &fp->rx_cq_chain_map[j])) {
 				BXE_PRINTF(
 	"%s(%d): Could not allocate fp[%d] RX Completion Queue DMA memory!\n",
 				    __FILE__, __LINE__, i);
@@ -13411,11 +13421,11 @@ bxe_dma_alloc(device_t dev)
 				goto bxe_dma_alloc_exit;
 			}
 
-			bzero((char *)fp->rx_comp_chain[j],
+			bzero((char *)fp->rx_cq_chain[j],
 			    BXE_RX_CHAIN_PAGE_SZ);
 
-			error = bus_dmamap_load(fp->rx_comp_chain_tag,
-			    fp->rx_comp_chain_map[j], fp->rx_comp_chain[j],
+			error = bus_dmamap_load(fp->rx_cq_chain_tag,
+			    fp->rx_cq_chain_map[j], fp->rx_cq_chain[j],
 			    BXE_RX_CHAIN_PAGE_SZ, bxe_dma_map_addr, &busaddr,
 			    BUS_DMA_NOWAIT);
 
@@ -13431,17 +13441,17 @@ bxe_dma_alloc(device_t dev)
 			 * Physical address of each page in the RX
 			 * Completion Chain.
 			 */
-			fp->rx_comp_chain_paddr[j] = busaddr;
+			fp->rx_cq_chain_paddr[j] = busaddr;
 
 			DBPRINT(sc, (BXE_EXTREME_LOAD | BXE_EXTREME_RESET),
-			    "%s(): fp[%d]->rx_comp_chain_paddr[%d] = 0x%jX\n",
+			    "%s(): fp[%d]->rx_cq_chain_paddr[%d] = 0x%jX\n",
 			    __FUNCTION__, i, j, (uintmax_t)busaddr);
 		}
 
 		if (TPA_ENABLED(sc)) {
 			int tpa_pool_max = CHIP_IS_E1H(sc) ?
-				ETH_MAX_AGGREGATION_QUEUES_E1H :
-				ETH_MAX_AGGREGATION_QUEUES_E1;
+			    ETH_MAX_AGGREGATION_QUEUES_E1H :
+			    ETH_MAX_AGGREGATION_QUEUES_E1;
 
 			/*
 			 * Create a DMA tag for the RX SGE Ring,
@@ -14213,6 +14223,7 @@ bxe_ifmedia_upd(struct ifnet *ifp)
 
 	ifm = &sc->bxe_ifmedia;
 	rc = 0;
+
 	/* This is an Ethernet controller. */
 	if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) {
 		rc = EINVAL;
@@ -14672,27 +14683,27 @@ bxe_tpa_stop_exit:
  */
 static __inline void
 bxe_update_rx_prod(struct bxe_softc *sc, struct bxe_fastpath *fp,
-    uint16_t bd_prod, uint16_t rx_comp_prod, uint16_t rx_sge_prod)
+    uint16_t bd_prod, uint16_t rx_cq_prod, uint16_t sge_prod)
 {
 	volatile struct ustorm_eth_rx_producers rx_prods = {0};
 	int i;
 
 	/* Update producers. */
-	rx_prods.bd_prod =  bd_prod;/* htole16(bd_prod);*/
-	rx_prods.cqe_prod = rx_comp_prod;/*htole16(rx_comp_prod);*/
-	rx_prods.sge_prod = rx_sge_prod;/*htole16(rx_sge_prod);*/
+	rx_prods.bd_prod =  bd_prod;
+	rx_prods.cqe_prod = rx_cq_prod;
+	rx_prods.sge_prod = sge_prod;
 
 	wmb();
 
 	for (i = 0; i < sizeof(struct ustorm_eth_rx_producers) / 4; i++){
 		REG_WR(sc, BAR_USTORM_INTMEM +
 		    USTORM_RX_PRODS_OFFSET(BP_PORT(sc), fp->cl_id) + i * 4,
-		    ((volatile uint32_t *)&rx_prods)[i]);
+		    ((volatile uint32_t *) &rx_prods)[i]);
 	}
 
-	DBPRINT(sc, BXE_EXTREME_RECV, "%s(): Wrote fp[%d] bd_prod = 0x%04X, "
-	    "cqe_prod = 0x%04X, sge_prod = 0x%04X\n", __FUNCTION__, fp->index,
-	    bd_prod, rx_comp_prod, rx_sge_prod);
+	DBPRINT(sc, BXE_EXTREME_RECV, "%s(%d): Wrote fp[%02d] bd_prod = 0x%04X, "
+	    "rx_cq_prod = 0x%04X, sge_prod = 0x%04X\n", __FUNCTION__, curcpu,
+	    fp->index, bd_prod, rx_cq_prod, sge_prod);
 }
 
 /*
@@ -14706,32 +14717,38 @@ bxe_rxeof(struct bxe_fastpath *fp)
 {
 	struct bxe_softc *sc;
 	struct ifnet *ifp;
-	uint16_t bd_cons, bd_prod, bd_prod_fw;
-	uint16_t hw_comp_cons_idx, sw_comp_cons_idx, sw_comp_prod;
-	uint16_t comp_ring_cons;
+	uint16_t rx_bd_cons, rx_bd_cons_idx;
+	uint16_t rx_bd_prod, rx_bd_prod_idx;
+	uint16_t rx_cq_cons, rx_cq_cons_idx;
+	uint16_t rx_cq_prod, rx_cq_cons_sb;
 
 #ifdef BXE_DEBUG
 	unsigned long rx_pkts = 0;
 #endif
+
 	sc = fp->sc;
 	ifp = sc->bxe_ifp;
 
 	DBENTER(BXE_EXTREME_RECV);
-	/* Get the sb's view of the RX completion consumer index. */
-	hw_comp_cons_idx = le16toh(*fp->rx_cons_sb);
-	if ((hw_comp_cons_idx & USABLE_RCQ_ENTRIES_PER_PAGE) ==
-	    USABLE_RCQ_ENTRIES_PER_PAGE)
-		hw_comp_cons_idx++;
-	/* Get working copies of the driver's view of the RX indices. */
-	bd_cons = fp->rx_bd_cons;
-	bd_prod = bd_prod_fw = fp->rx_bd_prod;
-	sw_comp_cons_idx = fp->rx_comp_cons;
-	sw_comp_prod = fp->rx_comp_prod;
+
+	/* Get the status block's view of the RX completion consumer index. */
+	rx_cq_cons_sb = bxe_rx_cq_cons(fp);
+
+	/*
+	 * Get working copies of the driver's view of the
+	 * RX indices. These are 16 bit values that are
+	 * expected to increment from from 0 to	65535
+	 * and then wrap-around to 0 again.
+	 */
+	rx_bd_cons = fp->rx_bd_cons;
+	rx_bd_prod = fp->rx_bd_prod;
+	rx_cq_cons = fp->rx_cq_cons;
+	rx_cq_prod = fp->rx_cq_prod;
 
 	DBPRINT(sc, (BXE_EXTREME_RECV),
-	    "%s(): fp[%d], bd_cons = 0x%04X, bd_prod = 0x%04X, "
-	    "sw_comp_cons = 0x%04X, sw_comp_prod = 0x%04X\n", __FUNCTION__,
-	    fp->index, bd_cons, bd_prod, sw_comp_cons_idx, sw_comp_prod);
+	    "%s(%d): BEFORE: fp[%d], rx_bd_cons = 0x%04X, rx_bd_prod = 0x%04X, "
+	    "rx_cq_cons_sw = 0x%04X, rx_cq_prod_sw = 0x%04X\n", __FUNCTION__,
+	    curcpu, fp->index, rx_bd_cons, rx_bd_prod, rx_cq_cons, rx_cq_prod);
 
 	/*
 	 * Memory barrier to prevent speculative reads of the RX buffer
@@ -14743,20 +14760,25 @@ bxe_rxeof(struct bxe_fastpath *fp)
 	 * Scan through the receive chain as long
 	 * as there is work to do.
 	 */
-	while (sw_comp_cons_idx != hw_comp_cons_idx) {
+	while (rx_cq_cons != rx_cq_cons_sb) {
 		struct mbuf *m;
 		union eth_rx_cqe *cqe;
 		uint8_t cqe_fp_flags;
 		uint16_t len, pad;
 
-		/* Convert the indices to an actual rx_bd index. */
-		comp_ring_cons = RCQ_ENTRY(sw_comp_cons_idx);
-		bd_prod = RX_BD(bd_prod);
-		bd_cons = RX_BD(bd_cons);
+		/*
+		 * Convert the 16 bit indices used by hardware
+		 * into values that map to the arrays used by
+		 * the driver (i.e. an index).
+		 */
+		rx_cq_cons_idx   = RCQ_ENTRY(rx_cq_cons);
+		rx_bd_prod_idx = RX_BD(rx_bd_prod);
+		rx_bd_cons_idx = RX_BD(rx_bd_cons);
 		wmb();
+
 		/* Fetch the cookie. */
-		cqe = (union eth_rx_cqe*)
-		    &fp->rx_comp_chain[RCQ_PAGE(comp_ring_cons)][RCQ_IDX(comp_ring_cons)];
+		cqe = (union eth_rx_cqe *)
+		    &fp->rx_cq_chain[RCQ_PAGE(rx_cq_cons_idx)][RCQ_IDX(rx_cq_cons_idx)];
 		cqe_fp_flags = cqe->fast_path_cqe.type_error_flags;
 
 #ifdef BXE_DEBUG
@@ -14769,9 +14791,10 @@ bxe_rxeof(struct bxe_fastpath *fp)
 		}
 #endif
 
-		DBRUNIF((cqe_fp_flags == 0), BXE_PRINTF(
-		    "%s(): CQE received with null type/error flags!\n",
-		    __FUNCTION__));
+		DBRUNIF((cqe_fp_flags == 0),
+		    BXE_PRINTF("%s(): CQE received with null "
+		    "type/error flags!\n", __FUNCTION__);
+		    bxe_dump_cqe(fp, rx_cq_cons_idx, cqe));
 
 		/* Check the CQE type for slowpath or fastpath completion. */
 		if (__predict_false(CQE_TYPE(cqe_fp_flags) ==
@@ -14803,8 +14826,8 @@ bxe_rxeof(struct bxe_fastpath *fp)
 				 * Check if a TPA aggregation has been started.
 				 */
 				if (TPA_TYPE(cqe_fp_flags) == TPA_TYPE_START) {
-					bxe_tpa_start(fp, queue, bd_cons,
-					    bd_prod);
+					bxe_tpa_start(fp, queue,
+					    rx_bd_cons_idx, rx_bd_prod_idx);
 					goto bxe_rxeof_next_rx;
 				}
 
@@ -14826,7 +14849,7 @@ bxe_rxeof(struct bxe_fastpath *fp)
 					 * the frame up.
 					 */
 					bxe_tpa_stop(sc, fp, queue, pad, len,
-					    cqe, comp_ring_cons);
+					    cqe, rx_cq_cons_idx);
 					bxe_update_sge_prod(fp,
 					    &cqe->fast_path_cqe);
 					goto bxe_rxeof_next_cqe;
@@ -14834,8 +14857,8 @@ bxe_rxeof(struct bxe_fastpath *fp)
 			}
 
 			/* Remove the mbuf from the RX chain. */
-			m = fp->rx_mbuf_ptr[bd_cons];
-			fp->rx_mbuf_ptr[bd_cons] = NULL;
+			m = fp->rx_mbuf_ptr[rx_bd_cons_idx];
+			fp->rx_mbuf_ptr[rx_bd_cons_idx] = NULL;
 
 			DBRUN(fp->free_rx_bd++);
 			DBRUNIF((fp->free_rx_bd > USABLE_RX_BD),
@@ -14845,9 +14868,10 @@ bxe_rxeof(struct bxe_fastpath *fp)
 
 			/* Unmap the mbuf from DMA space. */
 			bus_dmamap_sync(fp->rx_mbuf_tag,
-			    fp->rx_mbuf_map[bd_cons], BUS_DMASYNC_POSTREAD);
+			    fp->rx_mbuf_map[rx_bd_cons_idx],
+			    BUS_DMASYNC_POSTREAD);
 			bus_dmamap_unload(fp->rx_mbuf_tag,
-			    fp->rx_mbuf_map[bd_cons]);
+			    fp->rx_mbuf_map[rx_bd_cons_idx]);
 
 			/* Check if the received frame has any errors. */
 			if (__predict_false(cqe_fp_flags &
@@ -14860,11 +14884,13 @@ bxe_rxeof(struct bxe_fastpath *fp)
 				fp->soft_rx_errors++;
 
 				/* Reuse the mbuf for a new frame. */
-				if (bxe_get_buf(fp, m, bd_prod)) {
+				if (bxe_get_buf(fp, m, rx_bd_prod_idx)) {
 					DBPRINT(sc, BXE_FATAL,
 					    "%s(): Can't reuse RX mbuf!\n",
 					    __FUNCTION__);
 					DBRUN(bxe_breakpoint(sc));
+
+					/* ToDo: Find alterntive to panic(). */
 					panic("bxe%d: Can't reuse RX mbuf!\n",
 					    sc->bxe_unit);
 				}
@@ -14885,7 +14911,8 @@ bxe_rxeof(struct bxe_fastpath *fp)
 			 */
 
 			/* Allocate a new mbuf for the receive chain. */
-			if (__predict_false(bxe_get_buf(fp, NULL, bd_prod))) {
+			if (__predict_false(bxe_get_buf(fp,
+			    NULL, rx_bd_prod_idx))) {
 				/*
 				 * Drop the current frame if we can't get
 				 * a new mbuf.
@@ -14897,12 +14924,11 @@ bxe_rxeof(struct bxe_fastpath *fp)
 				 * receive chain.
 				 */
 				if (__predict_false(bxe_get_buf(fp, m,
-				    bd_prod))) {
+				    rx_bd_prod_idx))) {
 					/* This is really bad! */
 					DBPRINT(sc, BXE_FATAL,
 					    "%s(): Can't reuse RX mbuf!\n",
 					    __FUNCTION__);
-
 					DBRUN(bxe_breakpoint(sc));
 
 					/* ToDo: Find alterntive to panic(). */
@@ -14980,12 +15006,12 @@ bxe_rxeof(struct bxe_fastpath *fp)
 			}
 
 			/* Last chance to check for problems. */
-			DBRUN(bxe_validate_rx_packet(fp, comp_ring_cons, cqe,
-			    m));
+			DBRUN(bxe_validate_rx_packet(fp, rx_cq_cons, cqe, m));
 
 			/* Pass the mbuf off to the upper layers. */
 			ifp->if_ipackets++;
 
+			/* ToDo: Any potential locking issues here? */
 			/* Pass the frame to the stack. */
 			(*ifp->if_input)(ifp, m);
 
@@ -14993,14 +15019,13 @@ bxe_rxeof(struct bxe_fastpath *fp)
 		}
 
 bxe_rxeof_next_rx:
-		bd_prod = NEXT_RX_BD(bd_prod);
-		bd_prod_fw = NEXT_RX_BD(bd_prod_fw);
-		bd_cons = NEXT_RX_BD(bd_cons);
+		rx_bd_prod = NEXT_RX_BD(rx_bd_prod);
+		rx_bd_cons = NEXT_RX_BD(rx_bd_cons);
 		DBRUN(rx_pkts++);
 
 bxe_rxeof_next_cqe:
-		sw_comp_prod = NEXT_RCQ_IDX(sw_comp_prod);
-		sw_comp_cons_idx = NEXT_RCQ_IDX(sw_comp_cons_idx);
+		rx_cq_prod = NEXT_RCQ_IDX(rx_cq_prod);
+		rx_cq_cons = NEXT_RCQ_IDX(rx_cq_cons);
 
 		/*
 		 * Memory barrier to prevent speculative reads of the RX buffer
@@ -15010,18 +15035,19 @@ bxe_rxeof_next_cqe:
 	}
 
 	/* Update the driver copy of the fastpath indices. */
-	fp->rx_bd_cons = bd_cons;
-	fp->rx_bd_prod = bd_prod_fw;
-	fp->rx_comp_cons = sw_comp_cons_idx;

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***


More information about the svn-src-all mailing list