bxe: more cleanup.
[akaros.git] / kern / drivers / net / bxe / bxe.c
index d52c602..8e0e234 100644 (file)
@@ -216,7 +216,8 @@ static struct bxe_device_type bxe_devs[] = {
     }
 };
 
     }
 };
 
-#warning "MALLOC_DECLARE?"
+/* This is some sort of malloc zone for BSD.  The flag is passed later to
+ * various malloc invocations. */
 //MALLOC_DECLARE(M_BXE_ILT);
 //MALLOC_DEFINE(M_BXE_ILT, "bxe_ilt", "bxe ILT pointer");
 
 //MALLOC_DECLARE(M_BXE_ILT);
 //MALLOC_DEFINE(M_BXE_ILT, "bxe_ilt", "bxe ILT pointer");
 
@@ -249,7 +250,8 @@ static device_method_t bxe_methods[] = {
 };
 
 #endif
 };
 
 #endif
-//MTX_SYSINIT(bxe_prev_mtx, &bxe_prev_mtx, "bxe_prev_lock", MTX_DEF);
+qlock_t bxe_prev_mtx;
+
 struct bxe_prev_list_node {
     LIST_ENTRY(bxe_prev_list_node) node;
     uint8_t bus;
 struct bxe_prev_list_node {
     LIST_ENTRY(bxe_prev_list_node) node;
     uint8_t bus;
@@ -777,65 +779,6 @@ calc_crc32(uint8_t  *crc32_packet,
     return (crc32_result);
 }
 
     return (crc32_result);
 }
 
-int
-bxe_test_bit(int                    nr,
-             volatile unsigned long *addr)
-{
-    return ((atomic_load_acq_long(addr) & (1 << nr)) != 0);
-}
-
-void
-bxe_set_bit(unsigned int           nr,
-            volatile unsigned long *addr)
-{
-    atomic_set_acq_long(addr, (1 << nr));
-}
-
-void
-bxe_clear_bit(int                    nr,
-              volatile unsigned long *addr)
-{
-    atomic_clear_acq_long(addr, (1 << nr));
-}
-
-int
-bxe_test_and_set_bit(int                    nr,
-                       volatile unsigned long *addr)
-{
-    unsigned long x;
-    nr = (1 << nr);
-    do {
-        x = *addr;
-    } while (atomic_cmpset_acq_long(addr, x, x | nr) == 0);
-    // if (x & nr) bit_was_set; else bit_was_not_set;
-    return (x & nr);
-}
-
-int
-bxe_test_and_clear_bit(int                    nr,
-                       volatile unsigned long *addr)
-{
-    unsigned long x;
-    nr = (1 << nr);
-    do {
-        x = *addr;
-    } while (atomic_cmpset_acq_long(addr, x, x & ~nr) == 0);
-    // if (x & nr) bit_was_set; else bit_was_not_set;
-    return (x & nr);
-}
-
-int
-bxe_cmpxchg(volatile int *addr,
-            int          old,
-            int          new)
-{
-    int x;
-    do {
-        x = *addr;
-    } while (atomic_cmpset_acq_int(addr, old, new) == 0);
-    return (x);
-}
-
 /*
  * Get DMA memory from the OS.
  *
 /*
  * Get DMA memory from the OS.
  *
@@ -885,20 +828,22 @@ bxe_dma_alloc(struct bxe_adapter *sc,
               struct bxe_dma   *dma,
               const char       *msg)
 {
               struct bxe_dma   *dma,
               const char       *msg)
 {
-#if 0
-    int rc;
-
     if (dma->size > 0) {
         BLOGE(sc, "dma block '%s' already has size %lu\n", msg,
               (unsigned long)dma->size);
         return (1);
     }
 
     if (dma->size > 0) {
         BLOGE(sc, "dma block '%s' already has size %lu\n", msg,
               (unsigned long)dma->size);
         return (1);
     }
 
-    memset(dma, 0, sizeof(*dma)); /* sanity */
+    memset(dma, 0, sizeof(*dma)); /* sanity, except for size. */
     dma->sc   = sc;
     dma->size = size;
     snprintf(dma->msg, sizeof(dma->msg), "%s", msg);
 
     dma->sc   = sc;
     dma->size = size;
     snprintf(dma->msg, sizeof(dma->msg), "%s", msg);
 
+       /* Akaros style */
+       dma->vaddr = kzmalloc(size, KMALLOC_WAIT);
+       dma->paddr = PADDR(dma->vaddr);
+
+#if 0 /* the BSD way */
     rc = bus_dma_tag_create(sc->parent_dma_tag, /* parent tag */
                             BCM_PAGE_SIZE,      /* alignment */
                             0,                  /* boundary limit */
     rc = bus_dma_tag_create(sc->parent_dma_tag, /* parent tag */
                             BCM_PAGE_SIZE,      /* alignment */
                             0,                  /* boundary limit */
@@ -952,7 +897,6 @@ void
 bxe_dma_free(struct bxe_adapter *sc,
              struct bxe_dma   *dma)
 {
 bxe_dma_free(struct bxe_adapter *sc,
              struct bxe_dma   *dma)
 {
-#if 0
     if (dma->size > 0) {
 #if 0
         BLOGD(sc, DBG_LOAD,
     if (dma->size > 0) {
 #if 0
         BLOGD(sc, DBG_LOAD,
@@ -963,13 +907,15 @@ bxe_dma_free(struct bxe_adapter *sc,
 
         DBASSERT(sc, (dma->tag != NULL), ("dma tag is NULL"));
 
 
         DBASSERT(sc, (dma->tag != NULL), ("dma tag is NULL"));
 
+               kfree(dma->vaddr);
+               #if 0 /* the BSD way */
         bus_dmamap_sync(dma->tag, dma->map,
                         (BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE));
         bus_dmamap_unload(dma->tag, dma->map);
         bus_dmamem_free(dma->tag, dma->vaddr, dma->map);
         bus_dma_tag_destroy(dma->tag);
         bus_dmamap_sync(dma->tag, dma->map,
                         (BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE));
         bus_dmamap_unload(dma->tag, dma->map);
         bus_dmamem_free(dma->tag, dma->vaddr, dma->map);
         bus_dma_tag_destroy(dma->tag);
+               #endif
     }
     }
-#endif
     memset(dma, 0, sizeof(*dma));
 }
 
     memset(dma, 0, sizeof(*dma));
 }
 
@@ -1297,7 +1243,7 @@ bxe_nvram_read_dword(struct bxe_adapter *sc,
              * but ethtool sees it as an array of bytes
              * converting to big-endian will do the work
              */
              * but ethtool sees it as an array of bytes
              * converting to big-endian will do the work
              */
-            *ret_val = htobe32(val);
+            *ret_val = cpu_to_be32(val);
             rc = 0;
             break;
         }
             rc = 0;
             break;
         }
@@ -1456,7 +1402,7 @@ bxe_nvram_write1(struct bxe_adapter *sc,
         /* nvram data is returned as an array of bytes
          * convert it back to cpu order
          */
         /* nvram data is returned as an array of bytes
          * convert it back to cpu order
          */
-        val = be32toh(val);
+        val = be32_to_cpu(val);
 
         rc = bxe_nvram_write_dword(sc, align_offset, val, cmd_flags);
     }
 
         rc = bxe_nvram_write_dword(sc, align_offset, val, cmd_flags);
     }
@@ -2445,13 +2391,13 @@ bxe_sp_post(struct bxe_adapter *sc,
     BXE_SP_LOCK(sc);
 
     if (common) {
     BXE_SP_LOCK(sc);
 
     if (common) {
-        if (!atomic_load_acq_long(&sc->eq_spq_left)) {
+        if (!atomic_read(&sc->eq_spq_left)) {
             BLOGE(sc, "EQ ring is full!\n");
             BXE_SP_UNLOCK(sc);
             return (-1);
         }
     } else {
             BLOGE(sc, "EQ ring is full!\n");
             BXE_SP_UNLOCK(sc);
             return (-1);
         }
     } else {
-        if (!atomic_load_acq_long(&sc->cq_spq_left)) {
+        if (!atomic_read(&sc->cq_spq_left)) {
             BLOGE(sc, "SPQ ring is full!\n");
             BXE_SP_UNLOCK(sc);
             return (-1);
             BLOGE(sc, "SPQ ring is full!\n");
             BXE_SP_UNLOCK(sc);
             return (-1);
@@ -2462,7 +2408,7 @@ bxe_sp_post(struct bxe_adapter *sc,
 
     /* CID needs port number to be encoded int it */
     spe->hdr.conn_and_cmd_data =
 
     /* CID needs port number to be encoded int it */
     spe->hdr.conn_and_cmd_data =
-        htole32((command << SPE_HDR_CMD_ID_SHIFT) | HW_CID(sc, cid));
+        cpu_to_le32((command << SPE_HDR_CMD_ID_SHIFT) | HW_CID(sc, cid));
 
     type = (cmd_type << SPE_HDR_CONN_TYPE_SHIFT) & SPE_HDR_CONN_TYPE;
 
 
     type = (cmd_type << SPE_HDR_CONN_TYPE_SHIFT) & SPE_HDR_CONN_TYPE;
 
@@ -2470,10 +2416,10 @@ bxe_sp_post(struct bxe_adapter *sc,
     type |= ((SC_FUNC(sc) << SPE_HDR_FUNCTION_ID_SHIFT) &
              SPE_HDR_FUNCTION_ID);
 
     type |= ((SC_FUNC(sc) << SPE_HDR_FUNCTION_ID_SHIFT) &
              SPE_HDR_FUNCTION_ID);
 
-    spe->hdr.type = htole16(type);
+    spe->hdr.type = cpu_to_le16(type);
 
 
-    spe->data.update_data_addr.hi = htole32(data_hi);
-    spe->data.update_data_addr.lo = htole32(data_lo);
+    spe->data.update_data_addr.hi = cpu_to_le32(data_hi);
+    spe->data.update_data_addr.lo = cpu_to_le32(data_lo);
 
     /*
      * It's ok if the actual decrement is issued towards the memory
 
     /*
      * It's ok if the actual decrement is issued towards the memory
@@ -2481,9 +2427,9 @@ bxe_sp_post(struct bxe_adapter *sc,
      * memory barrier is needed.
      */
     if (common) {
      * memory barrier is needed.
      */
     if (common) {
-        atomic_subtract_acq_long(&sc->eq_spq_left, 1);
+        atomic_add(&sc->eq_spq_left, -1);
     } else {
     } else {
-        atomic_subtract_acq_long(&sc->cq_spq_left, 1);
+        atomic_add(&sc->cq_spq_left, -1);
     }
 
     BLOGD(sc, DBG_SP, "SPQE -> %#jx\n", (uintmax_t)sc->spq_dma.paddr);
     }
 
     BLOGD(sc, DBG_SP, "SPQE -> %#jx\n", (uintmax_t)sc->spq_dma.paddr);
@@ -2500,8 +2446,8 @@ bxe_sp_post(struct bxe_adapter *sc,
           data_hi,
           data_lo,
           type,
           data_hi,
           data_lo,
           type,
-          atomic_load_acq_long(&sc->cq_spq_left),
-          atomic_load_acq_long(&sc->eq_spq_left));
+          atomic_read(&sc->cq_spq_left),
+          atomic_read(&sc->eq_spq_left));
 
     bxe_sp_prod_update(sc);
 
 
     bxe_sp_prod_update(sc);
 
@@ -2580,7 +2526,7 @@ bxe_probe(device_t dev)
         if ((vid == t->bxe_vid) && (did == t->bxe_did) &&
             ((svid == t->bxe_svid) || (t->bxe_svid == PCI_ANY_ID)) &&
             ((sdid == t->bxe_sdid) || (t->bxe_sdid == PCI_ANY_ID))) {
         if ((vid == t->bxe_vid) && (did == t->bxe_did) &&
             ((svid == t->bxe_svid) || (t->bxe_svid == PCI_ANY_ID)) &&
             ((sdid == t->bxe_sdid) || (t->bxe_sdid == PCI_ANY_ID))) {
-            descbuf = malloc(BXE_DEVDESC_MAX, M_TEMP, M_NOWAIT);
+            descbuf = kmalloc(BXE_DEVDESC_MAX, 0); /* M_TEMP */
             if (descbuf == NULL)
                 return (ENOMEM);
 
             if (descbuf == NULL)
                 return (ENOMEM);
 
@@ -2593,7 +2539,7 @@ bxe_probe(device_t dev)
                      BXE_DRIVER_VERSION);
 
             device_set_desc_copy(dev, descbuf);
                      BXE_DRIVER_VERSION);
 
             device_set_desc_copy(dev, descbuf);
-            free(descbuf, M_TEMP);
+            kfree(descbuf); /* M_TEMP */
             return (BUS_PROBE_DEFAULT);
         }
         t++;
             return (BUS_PROBE_DEFAULT);
         }
         t++;
@@ -2735,7 +2681,7 @@ bxe_tx_queue_has_work(struct bxe_fastpath *fp)
     uint16_t hw_cons;
 
     mb(); /* status block fields can change */
     uint16_t hw_cons;
 
     mb(); /* status block fields can change */
-    hw_cons = le16toh(*fp->tx_cons_sb);
+    hw_cons = le16_to_cpu(*fp->tx_cons_sb);
     return (hw_cons != fp->tx_pkt_cons);
 }
 
     return (hw_cons != fp->tx_pkt_cons);
 }
 
@@ -2752,7 +2698,7 @@ bxe_has_rx_work(struct bxe_fastpath *fp)
     uint16_t rx_cq_cons_sb;
 
     mb(); /* status block fields can change */
     uint16_t rx_cq_cons_sb;
 
     mb(); /* status block fields can change */
-    rx_cq_cons_sb = le16toh(*fp->rx_cq_cons_sb);
+    rx_cq_cons_sb = le16_to_cpu(*fp->rx_cq_cons_sb);
     if ((rx_cq_cons_sb & RCQ_MAX) == RCQ_MAX)
         rx_cq_cons_sb++;
     return (fp->rx_cq_cons != rx_cq_cons_sb);
     if ((rx_cq_cons_sb & RCQ_MAX) == RCQ_MAX)
         rx_cq_cons_sb++;
     return (fp->rx_cq_cons != rx_cq_cons_sb);
@@ -2838,10 +2784,10 @@ bxe_sp_event(struct bxe_adapter    *sc,
     bxe_iov_sp_event(sc, cid, TRUE);
 #endif
 
     bxe_iov_sp_event(sc, cid, TRUE);
 #endif
 
-    atomic_add_acq_long(&sc->cq_spq_left, 1);
+    atomic_add(&sc->cq_spq_left, 1);
 
     BLOGD(sc, DBG_SP, "sc->cq_spq_left 0x%lx\n",
 
     BLOGD(sc, DBG_SP, "sc->cq_spq_left 0x%lx\n",
-          atomic_load_acq_long(&sc->cq_spq_left));
+          atomic_read(&sc->cq_spq_left));
 
 #if 0
     if ((drv_cmd == ECORE_Q_CMD_UPDATE) && (IS_FCOE_FP(fp)) &&
 
 #if 0
     if ((drv_cmd == ECORE_Q_CMD_UPDATE) && (IS_FCOE_FP(fp)) &&
@@ -2912,9 +2858,9 @@ bxe_tpa_start(struct bxe_adapter            *sc,
     /* change the TPA queue to the start state */
     tpa_info->state            = BXE_TPA_STATE_START;
     tpa_info->placement_offset = cqe->placement_offset;
     /* change the TPA queue to the start state */
     tpa_info->state            = BXE_TPA_STATE_START;
     tpa_info->placement_offset = cqe->placement_offset;
-    tpa_info->parsing_flags    = le16toh(cqe->pars_flags.flags);
-    tpa_info->vlan_tag         = le16toh(cqe->vlan_tag);
-    tpa_info->len_on_bd        = le16toh(cqe->len_on_bd);
+    tpa_info->parsing_flags    = le16_to_cpu(cqe->pars_flags.flags);
+    tpa_info->vlan_tag         = le16_to_cpu(cqe->vlan_tag);
+    tpa_info->len_on_bd        = le16_to_cpu(cqe->len_on_bd);
 
     fp->rx_tpa_queue_used |= (1 << queue);
 
 
     fp->rx_tpa_queue_used |= (1 << queue);
 
@@ -2952,8 +2898,8 @@ bxe_tpa_start(struct bxe_adapter            *sc,
 
     /* update the Rx BD with the empty mbuf phys address from the TPA pool */
     rx_bd = &fp->rx_chain[index];
 
     /* update the Rx BD with the empty mbuf phys address from the TPA pool */
     rx_bd = &fp->rx_chain[index];
-    rx_bd->addr_hi = htole32(U64_HI(tpa_info->seg.ds_addr));
-    rx_bd->addr_lo = htole32(U64_LO(tpa_info->seg.ds_addr));
+    rx_bd->addr_hi = cpu_to_le32(U64_HI(tpa_info->seg.ds_addr));
+    rx_bd->addr_lo = cpu_to_le32(U64_LO(tpa_info->seg.ds_addr));
 #endif
 }
 #if 0
 #endif
 }
 #if 0
@@ -2978,7 +2924,7 @@ bxe_fill_frag_mbuf(struct bxe_adapter          *sc,
     int rc = 0;
     int j;
 
     int rc = 0;
     int j;
 
-    frag_size = le16toh(cqe->pkt_len) - tpa_info->len_on_bd;
+    frag_size = le16_to_cpu(cqe->pkt_len) - tpa_info->len_on_bd;
 
     BLOGD(sc, DBG_LRO,
           "fp[%02d].tpa[%02d] TPA fill len_on_bd=%d frag_size=%d pages=%d\n",
 
     BLOGD(sc, DBG_LRO,
           "fp[%02d].tpa[%02d] TPA fill len_on_bd=%d frag_size=%d pages=%d\n",
@@ -2988,7 +2934,7 @@ bxe_fill_frag_mbuf(struct bxe_adapter          *sc,
     if (pages > 8 * PAGES_PER_SGE) {
         BLOGE(sc, "fp[%02d].sge[0x%04x] has too many pages (%d)! "
                   "pkt_len=%d len_on_bd=%d frag_size=%d\n",
     if (pages > 8 * PAGES_PER_SGE) {
         BLOGE(sc, "fp[%02d].sge[0x%04x] has too many pages (%d)! "
                   "pkt_len=%d len_on_bd=%d frag_size=%d\n",
-              fp->index, cqe_idx, pages, le16toh(cqe->pkt_len),
+              fp->index, cqe_idx, pages, le16_to_cpu(cqe->pkt_len),
               tpa_info->len_on_bd, frag_size);
         bxe_panic(sc, ("sge page count error\n"));
         return (EINVAL);
               tpa_info->len_on_bd, frag_size);
         bxe_panic(sc, ("sge page count error\n"));
         return (EINVAL);
@@ -2999,13 +2945,13 @@ bxe_fill_frag_mbuf(struct bxe_adapter          *sc,
      * single mbuf for the host stack.
      */
     for (i = 0, j = 0; i < pages; i += PAGES_PER_SGE, j++) {
      * single mbuf for the host stack.
      */
     for (i = 0, j = 0; i < pages; i += PAGES_PER_SGE, j++) {
-        sge_idx = RX_SGE(le16toh(cqe->sgl_or_raw_data.sgl[j]));
+        sge_idx = RX_SGE(le16_to_cpu(cqe->sgl_or_raw_data.sgl[j]));
 
         /*
          * Firmware gives the indices of the SGE as if the ring is an array
          * (meaning that the "next" element will consume 2 indices).
          */
 
         /*
          * Firmware gives the indices of the SGE as if the ring is an array
          * (meaning that the "next" element will consume 2 indices).
          */
-        frag_len = min(frag_size, (uint32_t)(SGE_PAGES));
+        frag_len = MIN(frag_size, (uint32_t)(SGE_PAGES));
 
         BLOGD(sc, DBG_LRO, "fp[%02d].tpa[%02d] TPA fill i=%d j=%d "
                            "sge_idx=%d frag_size=%d frag_len=%d\n",
 
         BLOGD(sc, DBG_LRO, "fp[%02d].tpa[%02d] TPA fill i=%d j=%d "
                            "sge_idx=%d frag_size=%d frag_len=%d\n",
@@ -3096,17 +3042,17 @@ bxe_update_sge_prod(struct bxe_adapter          *sc,
     /* first mark all used pages */
     for (i = 0; i < sge_len; i++) {
         BIT_VEC64_CLEAR_BIT(fp->sge_mask,
     /* first mark all used pages */
     for (i = 0; i < sge_len; i++) {
         BIT_VEC64_CLEAR_BIT(fp->sge_mask,
-                            RX_SGE(le16toh(cqe->sgl_or_raw_data.sgl[i])));
+                            RX_SGE(le16_to_cpu(cqe->sgl_or_raw_data.sgl[i])));
     }
 
     BLOGD(sc, DBG_LRO,
           "fp[%02d] fp_cqe->sgl[%d] = %d\n",
           fp->index, sge_len - 1,
     }
 
     BLOGD(sc, DBG_LRO,
           "fp[%02d] fp_cqe->sgl[%d] = %d\n",
           fp->index, sge_len - 1,
-          le16toh(cqe->sgl_or_raw_data.sgl[sge_len - 1]));
+          le16_to_cpu(cqe->sgl_or_raw_data.sgl[sge_len - 1]));
 
     /* assume that the last SGE index is the biggest */
     bxe_update_last_max_sge(fp,
 
     /* assume that the last SGE index is the biggest */
     bxe_update_last_max_sge(fp,
-                            le16toh(cqe->sgl_or_raw_data.sgl[sge_len - 1]));
+                            le16_to_cpu(cqe->sgl_or_raw_data.sgl[sge_len - 1]));
 
     last_max = RX_SGE(fp->last_max_sge);
     last_elem = last_max >> BIT_VEC64_ELEM_SHIFT;
 
     last_max = RX_SGE(fp->last_max_sge);
     last_elem = last_max >> BIT_VEC64_ELEM_SHIFT;
@@ -3119,7 +3065,7 @@ bxe_update_sge_prod(struct bxe_adapter          *sc,
 
     /* now update the prod */
     for (i = first_elem; i != last_elem; i = RX_SGE_NEXT_MASK_ELEM(i)) {
 
     /* now update the prod */
     for (i = first_elem; i != last_elem; i = RX_SGE_NEXT_MASK_ELEM(i)) {
-        if (__predict_true(fp->sge_mask[i])) {
+        if (fp->sge_mask[i]) {
             break;
         }
 
             break;
         }
 
@@ -3160,7 +3106,7 @@ bxe_tpa_stop(struct bxe_adapter          *sc,
     BLOGD(sc, DBG_LRO,
           "fp[%02d].tpa[%02d] pad=%d pkt_len=%d pages=%d vlan=%d\n",
           fp->index, queue, tpa_info->placement_offset,
     BLOGD(sc, DBG_LRO,
           "fp[%02d].tpa[%02d] pad=%d pkt_len=%d pages=%d vlan=%d\n",
           fp->index, queue, tpa_info->placement_offset,
-          le16toh(cqe->pkt_len), pages, tpa_info->vlan_tag);
+          le16_to_cpu(cqe->pkt_len), pages, tpa_info->vlan_tag);
 
     m = tpa_info->bd.m;
 
 
     m = tpa_info->bd.m;
 
@@ -3227,6 +3173,7 @@ static uint8_t
 bxe_rxeof(struct bxe_adapter    *sc,
           struct bxe_fastpath *fp)
 {
 bxe_rxeof(struct bxe_adapter    *sc,
           struct bxe_fastpath *fp)
 {
+       return 0xaa;
 #if 0
     if_t ifp = sc->ifp;
     uint16_t bd_cons, bd_prod, bd_prod_fw, comp_ring_cons;
 #if 0
     if_t ifp = sc->ifp;
     uint16_t bd_cons, bd_prod, bd_prod_fw, comp_ring_cons;
@@ -3237,7 +3184,7 @@ bxe_rxeof(struct bxe_adapter    *sc,
     BXE_FP_RX_LOCK(fp);
 
     /* CQ "next element" is of the size of the regular element */
     BXE_FP_RX_LOCK(fp);
 
     /* CQ "next element" is of the size of the regular element */
-    hw_cq_cons = le16toh(*fp->rx_cq_cons_sb);
+    hw_cq_cons = le16_to_cpu(*fp->rx_cq_cons_sb);
     if ((hw_cq_cons & RCQ_USABLE_PER_PAGE) == RCQ_USABLE_PER_PAGE) {
         hw_cq_cons++;
     }
     if ((hw_cq_cons & RCQ_USABLE_PER_PAGE) == RCQ_USABLE_PER_PAGE) {
         hw_cq_cons++;
     }
@@ -3288,9 +3235,9 @@ bxe_rxeof(struct bxe_adapter    *sc,
               CQE_TYPE(cqe_fp_flags),
               cqe_fp_flags,
               cqe_fp->status_flags,
               CQE_TYPE(cqe_fp_flags),
               cqe_fp_flags,
               cqe_fp->status_flags,
-              le32toh(cqe_fp->rss_hash_result),
-              le16toh(cqe_fp->vlan_tag),
-              le16toh(cqe_fp->pkt_len_or_gro_seg_len));
+              le32_to_cpu(cqe_fp->rss_hash_result),
+              le16_to_cpu(cqe_fp->vlan_tag),
+              le16_to_cpu(cqe_fp->pkt_len_or_gro_seg_len));
 
         /* is this a slowpath msg? */
         if (__predict_false(CQE_TYPE_SLOW(cqe_fp_type))) {
 
         /* is this a slowpath msg? */
         if (__predict_false(CQE_TYPE_SLOW(cqe_fp_type))) {
@@ -3330,7 +3277,7 @@ bxe_rxeof(struct bxe_adapter    *sc,
             BLOGD(sc, DBG_LRO, "fp[%02d].tpa[%02d] TPA STOP\n",
                   fp->index, queue);
 
             BLOGD(sc, DBG_LRO, "fp[%02d].tpa[%02d] TPA STOP\n",
                   fp->index, queue);
 
-            frag_size = (le16toh(cqe->end_agg_cqe.pkt_len) -
+            frag_size = (le16_to_cpu(cqe->end_agg_cqe.pkt_len) -
                          tpa_info->len_on_bd);
             pages = SGE_PAGE_ALIGN(frag_size) >> SGE_PAGE_SHIFT;
 
                          tpa_info->len_on_bd);
             pages = SGE_PAGE_ALIGN(frag_size) >> SGE_PAGE_SHIFT;
 
@@ -3352,7 +3299,7 @@ bxe_rxeof(struct bxe_adapter    *sc,
             goto next_rx;
         }
 
             goto next_rx;
         }
 
-        len = le16toh(cqe_fp->pkt_len_or_gro_seg_len);
+        len = le16_to_cpu(cqe_fp->pkt_len_or_gro_seg_len);
         pad = cqe_fp->placement_offset;
 
         m = rx_buf->m;
         pad = cqe_fp->placement_offset;
 
         m = rx_buf->m;
@@ -3450,7 +3397,7 @@ next_rx:
         bd_prod_fw = RX_BD_NEXT(bd_prod_fw);
 
         /* pass the frame to the stack */
         bd_prod_fw = RX_BD_NEXT(bd_prod_fw);
 
         /* pass the frame to the stack */
-        if (__predict_true(m != NULL)) {
+        if (m != NULL) {
             if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
             rx_pkts++;
             if_input(ifp, m);
             if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
             rx_pkts++;
             if_input(ifp, m);
@@ -3490,6 +3437,7 @@ bxe_free_tx_pkt(struct bxe_adapter    *sc,
                 struct bxe_fastpath *fp,
                 uint16_t            idx)
 {
                 struct bxe_fastpath *fp,
                 uint16_t            idx)
 {
+       return 0xaa;
 #if 0
     struct bxe_sw_tx_bd *tx_buf = &fp->tx_mbuf_chain[idx];
     struct eth_tx_start_bd *tx_start_bd;
 #if 0
     struct bxe_sw_tx_bd *tx_buf = &fp->tx_mbuf_chain[idx];
     struct eth_tx_start_bd *tx_start_bd;
@@ -3501,7 +3449,7 @@ bxe_free_tx_pkt(struct bxe_adapter    *sc,
     bus_dmamap_unload(fp->tx_mbuf_tag, tx_buf->m_map);
 
     tx_start_bd = &fp->tx_chain[bd_idx].start_bd;
     bus_dmamap_unload(fp->tx_mbuf_tag, tx_buf->m_map);
 
     tx_start_bd = &fp->tx_chain[bd_idx].start_bd;
-    nbd = le16toh(tx_start_bd->nbd) - 1;
+    nbd = le16_to_cpu(tx_start_bd->nbd) - 1;
     // this #if 0 was already here in fbsd
 #if 0
     if ((nbd - 1) > (MAX_MBUF_FRAGS + 2)) {
     // this #if 0 was already here in fbsd
 #if 0
     if ((nbd - 1) > (MAX_MBUF_FRAGS + 2)) {
@@ -3542,7 +3490,7 @@ bxe_free_tx_pkt(struct bxe_adapter    *sc,
 #endif
 
     /* free the mbuf */
 #endif
 
     /* free the mbuf */
-    if (__predict_true(tx_buf->m != NULL)) {
+    if (tx_buf->m != NULL) {
         m_freem(tx_buf->m);
         fp->eth_q_stats.mbuf_alloc_tx--;
     } else {
         m_freem(tx_buf->m);
         fp->eth_q_stats.mbuf_alloc_tx--;
     } else {
@@ -3561,7 +3509,6 @@ static int
 bxe_watchdog(struct bxe_adapter    *sc,
              struct bxe_fastpath *fp)
 {
 bxe_watchdog(struct bxe_adapter    *sc,
              struct bxe_fastpath *fp)
 {
-#if 0
     BXE_FP_TX_LOCK(fp);
 
     if ((fp->watchdog_timer == 0) || (--fp->watchdog_timer)) {
     BXE_FP_TX_LOCK(fp);
 
     if ((fp->watchdog_timer == 0) || (--fp->watchdog_timer)) {
@@ -3573,9 +3520,8 @@ bxe_watchdog(struct bxe_adapter    *sc,
 
     BXE_FP_TX_UNLOCK(fp);
 
 
     BXE_FP_TX_UNLOCK(fp);
 
-    atomic_store_rel_long(&sc->chip_tq_flags, CHIP_TQ_REINIT);
+    atomic_set(&sc->chip_tq_flags, CHIP_TQ_REINIT);
     taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task);
     taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task);
-#endif
     return (-1);
 }
 
     return (-1);
 }
 
@@ -3584,6 +3530,7 @@ static uint8_t
 bxe_txeof(struct bxe_adapter    *sc,
           struct bxe_fastpath *fp)
 {
 bxe_txeof(struct bxe_adapter    *sc,
           struct bxe_fastpath *fp)
 {
+       return 0xaa;
 #if 0
     if_t ifp = sc->ifp;
     uint16_t bd_cons, hw_cons, sw_cons, pkt_cons;
 #if 0
     if_t ifp = sc->ifp;
     uint16_t bd_cons, hw_cons, sw_cons, pkt_cons;
@@ -3592,7 +3539,7 @@ bxe_txeof(struct bxe_adapter    *sc,
     BXE_FP_TX_LOCK_ASSERT(fp);
 
     bd_cons = fp->tx_bd_cons;
     BXE_FP_TX_LOCK_ASSERT(fp);
 
     bd_cons = fp->tx_bd_cons;
-    hw_cons = le16toh(*fp->tx_cons_sb);
+    hw_cons = le16_to_cpu(*fp->tx_cons_sb);
     sw_cons = fp->tx_pkt_cons;
 
     while (sw_cons != hw_cons) {
     sw_cons = fp->tx_pkt_cons;
 
     while (sw_cons != hw_cons) {
@@ -3668,7 +3615,6 @@ bxe_drain_tx_queues(struct bxe_adapter *sc)
         }
     }
 #endif
         }
     }
 #endif
-    return;
 }
 
 static int
 }
 
 static int
@@ -3825,6 +3771,7 @@ bxe_set_q_rx_mode(struct bxe_adapter *sc,
 static int
 bxe_set_storm_rx_mode(struct bxe_adapter *sc)
 {
 static int
 bxe_set_storm_rx_mode(struct bxe_adapter *sc)
 {
+       return 0xaa;
 #if 0
     unsigned long rx_mode_flags = 0, ramrod_flags = 0;
     unsigned long rx_accept_flags = 0, tx_accept_flags = 0;
 #if 0
     unsigned long rx_mode_flags = 0, ramrod_flags = 0;
     unsigned long rx_accept_flags = 0, tx_accept_flags = 0;
@@ -3850,6 +3797,7 @@ bxe_set_storm_rx_mode(struct bxe_adapter *sc)
 static int
 bxe_nic_load_no_mcp(struct bxe_adapter *sc)
 {
 static int
 bxe_nic_load_no_mcp(struct bxe_adapter *sc)
 {
+       return 0xaa;
 #if 0
     int path = SC_PATH(sc);
     int port = SC_PORT(sc);
 #if 0
     int path = SC_PATH(sc);
     int port = SC_PORT(sc);
@@ -3876,6 +3824,7 @@ bxe_nic_load_no_mcp(struct bxe_adapter *sc)
 static int
 bxe_nic_unload_no_mcp(struct bxe_adapter *sc)
 {
 static int
 bxe_nic_unload_no_mcp(struct bxe_adapter *sc)
 {
+       return 0xaa;
 #if 0
     int port = SC_PORT(sc);
     int path = SC_PATH(sc);
 #if 0
     int port = SC_PORT(sc);
     int path = SC_PATH(sc);
@@ -4084,7 +4033,7 @@ bxe_wait_sp_comp(struct bxe_adapter *sc,
 
     while (tout--) {
         mb();
 
     while (tout--) {
         mb();
-        if (!(atomic_load_acq_long(&sc->sp_state) & mask)) {
+        if (!(ACCESS_ONCE(sc->sp_state) & mask)) {
             return (TRUE);
         }
 
             return (TRUE);
         }
 
@@ -4093,7 +4042,7 @@ bxe_wait_sp_comp(struct bxe_adapter *sc,
 
     mb();
 
 
     mb();
 
-    tmp = atomic_load_acq_long(&sc->sp_state);
+    tmp = ACCESS_ONCE(sc->sp_state);
     if (tmp & mask) {
         BLOGE(sc, "Filtering completion timed out: "
                   "sp_state 0x%lx, mask 0x%lx\n",
     if (tmp & mask) {
         BLOGE(sc, "Filtering completion timed out: "
                   "sp_state 0x%lx, mask 0x%lx\n",
@@ -4617,8 +4566,7 @@ bxe_ioctl_nvram(struct bxe_adapter *sc,
 
     if (len > sizeof(struct bxe_nvram_data)) {
         if ((nvdata = (struct bxe_nvram_data *)
 
     if (len > sizeof(struct bxe_nvram_data)) {
         if ((nvdata = (struct bxe_nvram_data *)
-                 malloc(len, M_DEVBUF,
-                        (M_NOWAIT | M_ZERO))) == NULL) {
+                 kzmalloc(len, /*M_DEVBUF,*/ 0)) == NULL) {
             BLOGE(sc, "BXE_IOC_RD_NVRAM malloc failed\n");
             return (1);
         }
             BLOGE(sc, "BXE_IOC_RD_NVRAM malloc failed\n");
             return (1);
         }
@@ -4646,7 +4594,7 @@ bxe_ioctl_nvram(struct bxe_adapter *sc,
     }
 
     if (len > sizeof(struct bxe_nvram_data)) {
     }
 
     if (len > sizeof(struct bxe_nvram_data)) {
-        free(nvdata, M_DEVBUF);
+        kfree(nvdata); /* M_DEVBUF */
     }
 
     return (error);
     }
 
     return (error);
@@ -4659,6 +4607,7 @@ bxe_ioctl_stats_show(struct bxe_adapter *sc,
                      uint32_t         priv_op,
                      struct ifreq     *ifr)
 {
                      uint32_t         priv_op,
                      struct ifreq     *ifr)
 {
+       return 0xaa;
 #if 0
     const size_t str_size   = (BXE_NUM_ETH_STATS * STAT_NAME_LEN);
     const size_t stats_size = (BXE_NUM_ETH_STATS * sizeof(uint64_t));
 #if 0
     const size_t str_size   = (BXE_NUM_ETH_STATS * STAT_NAME_LEN);
     const size_t stats_size = (BXE_NUM_ETH_STATS * sizeof(uint64_t));
@@ -4717,7 +4666,7 @@ bxe_handle_chip_tq(void *context,
 {
 #if 0
     struct bxe_adapter *sc = (struct bxe_adapter *)context;
 {
 #if 0
     struct bxe_adapter *sc = (struct bxe_adapter *)context;
-    long work = atomic_load_acq_long(&sc->chip_tq_flags);
+    long work = atomic_read(&sc->chip_tq_flags);
 
     switch (work)
     {
 
     switch (work)
     {
@@ -4803,10 +4752,10 @@ bxe_ioctl(if_t ifp,
             break;
         }
 
             break;
         }
 
-        atomic_store_rel_int((volatile unsigned int *)&sc->mtu,
+        atomic_set(volatile unsigned int *)&sc->mtu,
                              (unsigned long)ifr->ifr_mtu);
        /* 
                              (unsigned long)ifr->ifr_mtu);
        /* 
-        atomic_store_rel_long((volatile unsigned long *)&if_getmtu(ifp),
+        atomic_set((volatile unsigned long *)&if_getmtu(ifp),
                               (unsigned long)ifr->ifr_mtu);
        XXX - Not sure why it needs to be atomic
        */
                               (unsigned long)ifr->ifr_mtu);
        XXX - Not sure why it needs to be atomic
        */
@@ -4824,12 +4773,12 @@ bxe_ioctl(if_t ifp,
                 /* set the receive mode flags */
                 bxe_set_rx_mode(sc);
             } else {
                 /* set the receive mode flags */
                 bxe_set_rx_mode(sc);
             } else {
-                atomic_store_rel_long(&sc->chip_tq_flags, CHIP_TQ_START);
+                atomic_set(&sc->chip_tq_flags, CHIP_TQ_START);
                 taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task);
             }
         } else {
             if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
                 taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task);
             }
         } else {
             if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
-                atomic_store_rel_long(&sc->chip_tq_flags, CHIP_TQ_STOP);
+                atomic_set(&sc->chip_tq_flags, CHIP_TQ_STOP);
                 taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task);
             }
         }
                 taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task);
             }
         }
@@ -5003,7 +4952,7 @@ bxe_ioctl(if_t ifp,
     if (reinit && (if_getdrvflags(sc->ifp) & IFF_DRV_RUNNING)) {
         BLOGD(sc, DBG_LOAD | DBG_IOCTL,
               "Re-initializing hardware from IOCTL change\n");
     if (reinit && (if_getdrvflags(sc->ifp) & IFF_DRV_RUNNING)) {
         BLOGD(sc, DBG_LOAD | DBG_IOCTL,
               "Re-initializing hardware from IOCTL change\n");
-        atomic_store_rel_long(&sc->chip_tq_flags, CHIP_TQ_REINIT);
+        atomic_set(&sc->chip_tq_flags, CHIP_TQ_REINIT);
         taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task);
     }
 
         taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task);
     }
 
@@ -5095,7 +5044,7 @@ bxe_chktso_window(struct bxe_adapter  *sc,
     wnd_sum = 0;
     wnd_size = 10;
     num_wnds = nsegs - wnd_size;
     wnd_sum = 0;
     wnd_size = 10;
     num_wnds = nsegs - wnd_size;
-    lso_mss = htole16(m->m_pkthdr.tso_segsz);
+    lso_mss = cpu_to_le16(m->m_pkthdr.tso_segsz);
 
     /*
      * Total header lengths Eth+IP+TCP in first FreeBSD mbuf so calculate the
 
     /*
      * Total header lengths Eth+IP+TCP in first FreeBSD mbuf so calculate the
@@ -5103,7 +5052,7 @@ bxe_chktso_window(struct bxe_adapter  *sc,
      * header in FreeBSD.
      */
     for (frag_idx = 1; (frag_idx <= wnd_size); frag_idx++) {
      * header in FreeBSD.
      */
     for (frag_idx = 1; (frag_idx <= wnd_size); frag_idx++) {
-        wnd_sum += htole16(segs[frag_idx].ds_len);
+        wnd_sum += cpu_to_le16(segs[frag_idx].ds_len);
     }
 
     /* check the first 10 bd window size */
     }
 
     /* check the first 10 bd window size */
@@ -5114,9 +5063,9 @@ bxe_chktso_window(struct bxe_adapter  *sc,
     /* run through the windows */
     for (wnd_idx = 0; wnd_idx < num_wnds; wnd_idx++, frag_idx++) {
         /* subtract the first mbuf->m_len of the last wndw(-header) */
     /* run through the windows */
     for (wnd_idx = 0; wnd_idx < num_wnds; wnd_idx++, frag_idx++) {
         /* subtract the first mbuf->m_len of the last wndw(-header) */
-        wnd_sum -= htole16(segs[wnd_idx+1].ds_len);
+        wnd_sum -= cpu_to_le16(segs[wnd_idx+1].ds_len);
         /* add the next mbuf len to the len of our new window */
         /* add the next mbuf len to the len of our new window */
-        wnd_sum += htole16(segs[frag_idx].ds_len);
+        wnd_sum += cpu_to_le16(segs[frag_idx].ds_len);
         if (wnd_sum < lso_mss) {
             return (1);
         }
         if (wnd_sum < lso_mss) {
             return (1);
         }
@@ -5266,9 +5215,9 @@ bxe_set_pbd_csum(struct bxe_fastpath        *fp,
     /* note that rest of global_data is indirectly zeroed here */
     if (m->m_flags & M_VLANTAG) {
         pbd->global_data =
     /* note that rest of global_data is indirectly zeroed here */
     if (m->m_flags & M_VLANTAG) {
         pbd->global_data =
-            htole16(hlen | (1 << ETH_TX_PARSE_BD_E1X_LLC_SNAP_EN_SHIFT));
+            cpu_to_le16(hlen | (1 << ETH_TX_PARSE_BD_E1X_LLC_SNAP_EN_SHIFT));
     } else {
     } else {
-        pbd->global_data = htole16(hlen);
+        pbd->global_data = cpu_to_le16(hlen);
     }
 
     pbd->ip_hlen_w = ip_hlen;
     }
 
     pbd->ip_hlen_w = ip_hlen;
@@ -5292,7 +5241,7 @@ bxe_set_pbd_csum(struct bxe_fastpath        *fp,
         return (0);
     }
 
         return (0);
     }
 
-    pbd->total_hlen_w = htole16(hlen);
+    pbd->total_hlen_w = cpu_to_le16(hlen);
 
     if (m->m_pkthdr.csum_flags & (CSUM_TCP |
                                   CSUM_TSO |
 
     if (m->m_pkthdr.csum_flags & (CSUM_TCP |
                                   CSUM_TSO |
@@ -5370,7 +5319,7 @@ bxe_set_pbd_lso(struct mbuf                *m,
     ip = (struct ip *)(m->m_data + e_hlen);
     th = (struct tcphdr *)((caddr_t)ip + (ip->ip_hl << 2));
 
     ip = (struct ip *)(m->m_data + e_hlen);
     th = (struct tcphdr *)((caddr_t)ip + (ip->ip_hl << 2));
 
-    pbd->lso_mss = htole16(m->m_pkthdr.tso_segsz);
+    pbd->lso_mss = cpu_to_le16(m->m_pkthdr.tso_segsz);
     pbd->tcp_send_seq = ntohl(th->th_seq);
     pbd->tcp_flags = ((ntohl(((uint32_t *)th)[3]) >> 16) & 0xff);
 
     pbd->tcp_send_seq = ntohl(th->th_seq);
     pbd->tcp_flags = ((ntohl(((uint32_t *)th)[3]) >> 16) & 0xff);
 
@@ -5390,7 +5339,7 @@ bxe_set_pbd_lso(struct mbuf                *m,
 #endif
 
     pbd->global_data |=
 #endif
 
     pbd->global_data |=
-        htole16(ETH_TX_PARSE_BD_E1X_PSEUDO_CS_WITHOUT_LEN);
+        cpu_to_le16(ETH_TX_PARSE_BD_E1X_PSEUDO_CS_WITHOUT_LEN);
 }
 
 /*
 }
 
 /*
@@ -5582,9 +5531,9 @@ bxe_tx_encap_continue:
           "sending pkt_prod=%u tx_buf=%p next_idx=%u bd=%u tx_start_bd=%p\n",
           pkt_prod, tx_buf, fp->tx_pkt_prod, bd_prod, tx_start_bd);
 
           "sending pkt_prod=%u tx_buf=%p next_idx=%u bd=%u tx_start_bd=%p\n",
           pkt_prod, tx_buf, fp->tx_pkt_prod, bd_prod, tx_start_bd);
 
-    tx_start_bd->addr_lo = htole32(U64_LO(segs[0].ds_addr));
-    tx_start_bd->addr_hi = htole32(U64_HI(segs[0].ds_addr));
-    tx_start_bd->nbytes  = htole16(segs[0].ds_len);
+    tx_start_bd->addr_lo = cpu_to_le32(U64_LO(segs[0].ds_addr));
+    tx_start_bd->addr_hi = cpu_to_le32(U64_HI(segs[0].ds_addr));
+    tx_start_bd->nbytes  = cpu_to_le16(segs[0].ds_len);
     total_pkt_size += tx_start_bd->nbytes;
     tx_start_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_START_BD;
 
     total_pkt_size += tx_start_bd->nbytes;
     tx_start_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_START_BD;
 
@@ -5592,10 +5541,10 @@ bxe_tx_encap_continue:
 
     /* all frames have at least Start BD + Parsing BD */
     nbds = nsegs + 1;
 
     /* all frames have at least Start BD + Parsing BD */
     nbds = nsegs + 1;
-    tx_start_bd->nbd = htole16(nbds);
+    tx_start_bd->nbd = cpu_to_le16(nbds);
 
     if (m0->m_flags & M_VLANTAG) {
 
     if (m0->m_flags & M_VLANTAG) {
-        tx_start_bd->vlan_or_ethertype = htole16(m0->m_pkthdr.ether_vtag);
+        tx_start_bd->vlan_or_ethertype = cpu_to_le16(m0->m_pkthdr.ether_vtag);
         tx_start_bd->bd_flags.as_bitfield |=
             (X_ETH_OUTBAND_VLAN << ETH_TX_BD_FLAGS_VLAN_MODE_SHIFT);
     } else {
         tx_start_bd->bd_flags.as_bitfield |=
             (X_ETH_OUTBAND_VLAN << ETH_TX_BD_FLAGS_VLAN_MODE_SHIFT);
     } else {
@@ -5606,7 +5555,7 @@ bxe_tx_encap_continue:
             tx_start_bd->vlan_or_ethertype = eh->evl_encap_proto;
         } else {
             /* used by FW for packet accounting */
             tx_start_bd->vlan_or_ethertype = eh->evl_encap_proto;
         } else {
             /* used by FW for packet accounting */
-            tx_start_bd->vlan_or_ethertype = htole16(fp->tx_pkt_prod);
+            tx_start_bd->vlan_or_ethertype = cpu_to_le16(fp->tx_pkt_prod);
 #if 0
             /*
              * If NPAR-SD is active then FW should do the tagging regardless
 #if 0
             /*
              * If NPAR-SD is active then FW should do the tagging regardless
@@ -5690,7 +5639,7 @@ bxe_tx_encap_continue:
 
         SET_FLAG(global_data,
                  ETH_TX_PARSE_BD_E1X_ETH_ADDR_TYPE, mac_type);
 
         SET_FLAG(global_data,
                  ETH_TX_PARSE_BD_E1X_ETH_ADDR_TYPE, mac_type);
-        pbd_e1x->global_data |= htole16(global_data);
+        pbd_e1x->global_data |= cpu_to_le16(global_data);
     }
 
     /* setup the parsing BD with TSO specific info */
     }
 
     /* setup the parsing BD with TSO specific info */
@@ -5703,25 +5652,25 @@ bxe_tx_encap_continue:
 
             /* split the first BD into header/data making the fw job easy */
             nbds++;
 
             /* split the first BD into header/data making the fw job easy */
             nbds++;
-            tx_start_bd->nbd = htole16(nbds);
-            tx_start_bd->nbytes = htole16(hlen);
+            tx_start_bd->nbd = cpu_to_le16(nbds);
+            tx_start_bd->nbytes = cpu_to_le16(hlen);
 
             bd_prod = TX_BD_NEXT(bd_prod);
 
             /* new transmit BD after the tx_parse_bd */
             tx_data_bd = &fp->tx_chain[TX_BD(bd_prod)].reg_bd;
 
             bd_prod = TX_BD_NEXT(bd_prod);
 
             /* new transmit BD after the tx_parse_bd */
             tx_data_bd = &fp->tx_chain[TX_BD(bd_prod)].reg_bd;
-            tx_data_bd->addr_hi = htole32(U64_HI(segs[0].ds_addr + hlen));
-            tx_data_bd->addr_lo = htole32(U64_LO(segs[0].ds_addr + hlen));
-            tx_data_bd->nbytes  = htole16(segs[0].ds_len - hlen);
+            tx_data_bd->addr_hi = cpu_to_le32(U64_HI(segs[0].ds_addr + hlen));
+            tx_data_bd->addr_lo = cpu_to_le32(U64_LO(segs[0].ds_addr + hlen));
+            tx_data_bd->nbytes  = cpu_to_le16(segs[0].ds_len - hlen);
             if (tx_total_pkt_size_bd == NULL) {
                 tx_total_pkt_size_bd = tx_data_bd;
             }
 
             BLOGD(sc, DBG_TX,
                   "TSO split header size is %d (%x:%x) nbds %d\n",
             if (tx_total_pkt_size_bd == NULL) {
                 tx_total_pkt_size_bd = tx_data_bd;
             }
 
             BLOGD(sc, DBG_TX,
                   "TSO split header size is %d (%x:%x) nbds %d\n",
-                  le16toh(tx_start_bd->nbytes),
-                  le32toh(tx_start_bd->addr_hi),
-                  le32toh(tx_start_bd->addr_lo),
+                  le16_to_cpu(tx_start_bd->nbytes),
+                  le32_to_cpu(tx_start_bd->addr_hi),
+                  le32_to_cpu(tx_start_bd->addr_lo),
                   nbds);
         }
 
                   nbds);
         }
 
@@ -5733,16 +5682,16 @@ bxe_tx_encap_continue:
     }
 
     if (pbd_e2_parsing_data) {
     }
 
     if (pbd_e2_parsing_data) {
-        pbd_e2->parsing_data = htole32(pbd_e2_parsing_data);
+        pbd_e2->parsing_data = cpu_to_le32(pbd_e2_parsing_data);
     }
 
     /* prepare remaining BDs, start tx bd contains first seg/frag */
     for (i = 1; i < nsegs ; i++) {
         bd_prod = TX_BD_NEXT(bd_prod);
         tx_data_bd = &fp->tx_chain[TX_BD(bd_prod)].reg_bd;
     }
 
     /* prepare remaining BDs, start tx bd contains first seg/frag */
     for (i = 1; i < nsegs ; i++) {
         bd_prod = TX_BD_NEXT(bd_prod);
         tx_data_bd = &fp->tx_chain[TX_BD(bd_prod)].reg_bd;
-        tx_data_bd->addr_lo = htole32(U64_LO(segs[i].ds_addr));
-        tx_data_bd->addr_hi = htole32(U64_HI(segs[i].ds_addr));
-        tx_data_bd->nbytes  = htole16(segs[i].ds_len);
+        tx_data_bd->addr_lo = cpu_to_le32(U64_LO(segs[i].ds_addr));
+        tx_data_bd->addr_hi = cpu_to_le32(U64_HI(segs[i].ds_addr));
+        tx_data_bd->nbytes  = cpu_to_le16(segs[i].ds_len);
         if (tx_total_pkt_size_bd == NULL) {
             tx_total_pkt_size_bd = tx_data_bd;
         }
         if (tx_total_pkt_size_bd == NULL) {
             tx_total_pkt_size_bd = tx_data_bd;
         }
@@ -5765,8 +5714,8 @@ bxe_tx_encap_continue:
                       "bd_flags=0x%x hdr_nbds=%d\n",
                       tx_start_bd,
                       tmp_bd,
                       "bd_flags=0x%x hdr_nbds=%d\n",
                       tx_start_bd,
                       tmp_bd,
-                      le16toh(tx_start_bd->nbd),
-                      le16toh(tx_start_bd->vlan_or_ethertype),
+                      le16_to_cpu(tx_start_bd->nbd),
+                      le16_to_cpu(tx_start_bd->vlan_or_ethertype),
                       tx_start_bd->bd_flags.as_bitfield,
                       (tx_start_bd->general_data & ETH_TX_START_BD_HDR_NBDS));
             } else if (i == 1) {
                       tx_start_bd->bd_flags.as_bitfield,
                       (tx_start_bd->general_data & ETH_TX_START_BD_HDR_NBDS));
             } else if (i == 1) {
@@ -5784,7 +5733,7 @@ bxe_tx_encap_continue:
                           pbd_e1x->tcp_flags,
                           pbd_e1x->tcp_pseudo_csum,
                           pbd_e1x->tcp_send_seq,
                           pbd_e1x->tcp_flags,
                           pbd_e1x->tcp_pseudo_csum,
                           pbd_e1x->tcp_send_seq,
-                          le16toh(pbd_e1x->total_hlen_w));
+                          le16_to_cpu(pbd_e1x->total_hlen_w));
                 } else { /* if (pbd_e2) */
                     BLOGD(sc, DBG_TX,
                           "-> Parse: %p bd=%d dst=%02x:%02x:%02x "
                 } else { /* if (pbd_e2) */
                     BLOGD(sc, DBG_TX,
                           "-> Parse: %p bd=%d dst=%02x:%02x:%02x "
@@ -5807,9 +5756,9 @@ bxe_tx_encap_continue:
                       "-> Frag: %p bd=%d nbytes=%d hi=0x%x lo: 0x%x\n",
                       tx_data_bd,
                       tmp_bd,
                       "-> Frag: %p bd=%d nbytes=%d hi=0x%x lo: 0x%x\n",
                       tx_data_bd,
                       tmp_bd,
-                      le16toh(tx_data_bd->nbytes),
-                      le32toh(tx_data_bd->addr_hi),
-                      le32toh(tx_data_bd->addr_lo));
+                      le16_to_cpu(tx_data_bd->nbytes),
+                      le32_to_cpu(tx_data_bd->addr_hi),
+                      le32_to_cpu(tx_data_bd->addr_lo));
             }
 
             tmp_bd = TX_BD_NEXT(tmp_bd);
             }
 
             tmp_bd = TX_BD_NEXT(tmp_bd);
@@ -6174,7 +6123,7 @@ bxe_ilt_set_info(struct bxe_adapter *sc)
           ilt_client->start, ilt_client->end,
           ilt_client->page_size,
           ilt_client->flags,
           ilt_client->start, ilt_client->end,
           ilt_client->page_size,
           ilt_client->flags,
-          ilog2(ilt_client->page_size >> 12));
+          LOG2_UP(ilt_client->page_size >> 12));
 
     /* QM */
     if (QM_INIT(sc->qm_cid_count)) {
 
     /* QM */
     if (QM_INIT(sc->qm_cid_count)) {
@@ -6195,7 +6144,7 @@ bxe_ilt_set_info(struct bxe_adapter *sc)
               "psz 0x%x, flags 0x%x, hw psz %d\n",
               ilt_client->start, ilt_client->end,
               ilt_client->page_size, ilt_client->flags,
               "psz 0x%x, flags 0x%x, hw psz %d\n",
               ilt_client->start, ilt_client->end,
               ilt_client->page_size, ilt_client->flags,
-              ilog2(ilt_client->page_size >> 12));
+              LOG2_UP(ilt_client->page_size >> 12));
     }
 
     if (CNIC_SUPPORT(sc)) {
     }
 
     if (CNIC_SUPPORT(sc)) {
@@ -6213,7 +6162,7 @@ bxe_ilt_set_info(struct bxe_adapter *sc)
               "psz 0x%x, flags 0x%x, hw psz %d\n",
               ilt_client->start, ilt_client->end,
               ilt_client->page_size, ilt_client->flags,
               "psz 0x%x, flags 0x%x, hw psz %d\n",
               ilt_client->start, ilt_client->end,
               ilt_client->page_size, ilt_client->flags,
-              ilog2(ilt_client->page_size >> 12));
+              LOG2_UP(ilt_client->page_size >> 12));
 
         /* TM */
         ilt_client = &ilt->clients[ILT_CLIENT_TM];
 
         /* TM */
         ilt_client = &ilt->clients[ILT_CLIENT_TM];
@@ -6229,7 +6178,7 @@ bxe_ilt_set_info(struct bxe_adapter *sc)
               "psz 0x%x, flags 0x%x, hw psz %d\n",
               ilt_client->start, ilt_client->end,
               ilt_client->page_size, ilt_client->flags,
               "psz 0x%x, flags 0x%x, hw psz %d\n",
               ilt_client->start, ilt_client->end,
               ilt_client->page_size, ilt_client->flags,
-              ilog2(ilt_client->page_size >> 12));
+              LOG2_UP(ilt_client->page_size >> 12));
     }
 
     //assert((line <= ILT_MAX_LINES), ("Invalid number of ILT lines!"));
     }
 
     //assert((line <= ILT_MAX_LINES), ("Invalid number of ILT lines!"));
@@ -6272,14 +6221,11 @@ static int
 bxe_alloc_ilt_mem(struct bxe_adapter *sc)
 {
     int rc = 0;
 bxe_alloc_ilt_mem(struct bxe_adapter *sc)
 {
     int rc = 0;
-    /*
     if ((sc->ilt =
     if ((sc->ilt =
-         (struct ecore_ilt *)malloc(sizeof(struct ecore_ilt),
-                                    M_BXE_ILT,
-                                    (M_NOWAIT | M_ZERO))) == NULL) {
+         (struct ecore_ilt *)kzmalloc(sizeof(struct ecore_ilt),
+                                     /*M_BXE_ILT,*/ 0)) == NULL) {
         rc = 1;
     }
         rc = 1;
     }
-    */
     return (rc);
 }
 
     return (rc);
 }
 
@@ -6287,14 +6233,11 @@ static int
 bxe_alloc_ilt_lines_mem(struct bxe_adapter *sc)
 {
     int rc = 0;
 bxe_alloc_ilt_lines_mem(struct bxe_adapter *sc)
 {
     int rc = 0;
-    /*
     if ((sc->ilt->lines =
     if ((sc->ilt->lines =
-         (struct ilt_line *)malloc((sizeof(struct ilt_line) * ILT_MAX_LINES),
-                                    M_BXE_ILT,
-                                    (M_NOWAIT | M_ZERO))) == NULL) {
+         (struct ilt_line *)kzmalloc((sizeof(struct ilt_line) * ILT_MAX_LINES),
+                                     /*M_BXE_ILT,*/ 0)) == NULL) {
         rc = 1;
     }
         rc = 1;
     }
-    */
     return (rc);
 }
 
     return (rc);
 }
 
@@ -6321,17 +6264,15 @@ bxe_free_mem(struct bxe_adapter *sc)
 {
     int i;
 
 {
     int i;
 
-#if 0
     if (!CONFIGURE_NIC_MODE(sc)) {
         /* free searcher T2 table */
     if (!CONFIGURE_NIC_MODE(sc)) {
         /* free searcher T2 table */
-        bxe_dma_free(sc, &sc->t2);
+        bxe_dma_free(sc, sc->t2);
     }
     }
-#endif
 
     for (i = 0; i < L2_ILT_LINES(sc); i++) {
 
     for (i = 0; i < L2_ILT_LINES(sc); i++) {
-      //bxe_dma_free(sc, &sc->context[i].vcxt_dma);
-      //sc->context[i].vcxt = NULL;
-      //sc->context[i].size = 0;
+        bxe_dma_free(sc, &sc->context[i].vcxt_dma);
+        sc->context[i].vcxt = NULL;
+        sc->context[i].size = 0;
     }
 
     ecore_ilt_mem_op(sc, ILT_MEMOP_FREE);
     }
 
     ecore_ilt_mem_op(sc, ILT_MEMOP_FREE);
@@ -6350,15 +6291,13 @@ bxe_alloc_mem(struct bxe_adapter *sc)
     int allocated;
     int i;
 
     int allocated;
     int i;
 
-#if 0
     if (!CONFIGURE_NIC_MODE(sc)) {
         /* allocate searcher T2 table */
         if (bxe_dma_alloc(sc, SRC_T2_SZ,
     if (!CONFIGURE_NIC_MODE(sc)) {
         /* allocate searcher T2 table */
         if (bxe_dma_alloc(sc, SRC_T2_SZ,
-                          &sc->t2, "searcher t2 table") != 0) {
+                          sc->t2, "searcher t2 table") != 0) {
             return (-1);
         }
     }
             return (-1);
         }
     }
-#endif
 
     /*
      * Allocate memory for CDU context:
 
     /*
      * Allocate memory for CDU context:
@@ -6377,7 +6316,7 @@ bxe_alloc_mem(struct bxe_adapter *sc)
     context_size = (sizeof(union cdu_context) * BXE_L2_CID_COUNT(sc));
     for (i = 0, allocated = 0; allocated < context_size; i++) {
       /*
     context_size = (sizeof(union cdu_context) * BXE_L2_CID_COUNT(sc));
     for (i = 0, allocated = 0; allocated < context_size; i++) {
       /*
-        sc->context[i].size = min(CDU_ILT_PAGE_SZ,
+        sc->context[i].size = MIN(CDU_ILT_PAGE_SZ,
                                   (context_size - allocated));
 
         if (bxe_dma_alloc(sc, sc->context[i].size,
                                   (context_size - allocated));
 
         if (bxe_dma_alloc(sc, sc->context[i].size,
@@ -6661,8 +6600,8 @@ bxe_alloc_rx_bd_mbuf(struct bxe_fastpath *fp,
     rx_buf->m = m;
 
     rx_bd = &fp->rx_chain[index];
     rx_buf->m = m;
 
     rx_bd = &fp->rx_chain[index];
-    rx_bd->addr_hi = htole32(U64_HI(segs[0].ds_addr));
-    rx_bd->addr_lo = htole32(U64_LO(segs[0].ds_addr));
+    rx_bd->addr_hi = cpu_to_le32(U64_HI(segs[0].ds_addr));
+    rx_bd->addr_lo = cpu_to_le32(U64_LO(segs[0].ds_addr));
 
     return (rc);
 #endif
 
     return (rc);
 #endif
@@ -6790,8 +6729,8 @@ bxe_alloc_rx_sge_mbuf(struct bxe_fastpath *fp,
     sge_buf->m = m;
 
     sge = &fp->rx_sge_chain[index];
     sge_buf->m = m;
 
     sge = &fp->rx_sge_chain[index];
-    sge->addr_hi = htole32(U64_HI(segs[0].ds_addr));
-    sge->addr_lo = htole32(U64_LO(segs[0].ds_addr));
+    sge->addr_hi = cpu_to_le32(U64_HI(segs[0].ds_addr));
+    sge->addr_lo = cpu_to_le32(U64_LO(segs[0].ds_addr));
 
     return (rc);
 #endif
 
     return (rc);
 #endif
@@ -8656,8 +8595,8 @@ static void
 bxe_attn_int(struct bxe_adapter *sc)
 {
     /* read local copy of bits */
 bxe_attn_int(struct bxe_adapter *sc)
 {
     /* read local copy of bits */
-    uint32_t attn_bits = le32toh(sc->def_sb->atten_status_block.attn_bits);
-    uint32_t attn_ack = le32toh(sc->def_sb->atten_status_block.attn_bits_ack);
+    uint32_t attn_bits = le32_to_cpu(sc->def_sb->atten_status_block.attn_bits);
+    uint32_t attn_ack = le32_to_cpu(sc->def_sb->atten_status_block.attn_bits_ack);
     uint32_t attn_state = sc->attn_state;
 
     /* look for changed bits */
     uint32_t attn_state = sc->attn_state;
 
     /* look for changed bits */
@@ -8705,8 +8644,6 @@ bxe_update_dsb_idx(struct bxe_adapter *sc)
     return (rc);
 }
 
     return (rc);
 }
 
-#warning "fix"
-#if 0
 static inline struct ecore_queue_sp_obj *
 bxe_cid_to_q_obj(struct bxe_adapter *sc,
                  uint32_t         cid)
 static inline struct ecore_queue_sp_obj *
 bxe_cid_to_q_obj(struct bxe_adapter *sc,
                  uint32_t         cid)
@@ -8714,7 +8651,6 @@ bxe_cid_to_q_obj(struct bxe_adapter *sc,
     BLOGD(sc, DBG_SP, "retrieving fp from cid %d\n", cid);
     return (&sc->sp_objs[CID_TO_FP(cid, sc)].q_obj);
 }
     BLOGD(sc, DBG_SP, "retrieving fp from cid %d\n", cid);
     return (&sc->sp_objs[CID_TO_FP(cid, sc)].q_obj);
 }
-#endif
 
 static void
 bxe_handle_mcast_eqe(struct bxe_adapter *sc)
 
 static void
 bxe_handle_mcast_eqe(struct bxe_adapter *sc)
@@ -8754,9 +8690,9 @@ bxe_handle_classification_eqe(struct bxe_adapter      *sc,
     struct ecore_vlan_mac_obj *vlan_mac_obj;
 
     /* always push next commands out, don't wait here */
     struct ecore_vlan_mac_obj *vlan_mac_obj;
 
     /* always push next commands out, don't wait here */
-    bit_set(&ramrod_flags, RAMROD_CONT);
+    __set_bit(RAMROD_CONT, &ramrod_flags);
 
 
-    switch (le32toh(elem->message.data.eth_event.echo) >> BXE_SWCID_SHIFT) {
+    switch (le32_to_cpu(elem->message.data.eth_event.echo) >> BXE_SWCID_SHIFT) {
     case ECORE_FILTER_MAC_PENDING:
         BLOGD(sc, DBG_SP, "Got SETUP_MAC completions\n");
         vlan_mac_obj = &sc->sp_objs[cid].mac_obj;
     case ECORE_FILTER_MAC_PENDING:
         BLOGD(sc, DBG_SP, "Got SETUP_MAC completions\n");
         vlan_mac_obj = &sc->sp_objs[cid].mac_obj;
@@ -8830,7 +8766,7 @@ bxe_eq_int(struct bxe_adapter *sc)
     struct ecore_func_sp_obj *f_obj = &sc->func_obj;
     struct ecore_raw_obj *rss_raw = &sc->rss_conf_obj.raw;
 
     struct ecore_func_sp_obj *f_obj = &sc->func_obj;
     struct ecore_raw_obj *rss_raw = &sc->rss_conf_obj.raw;
 
-    hw_cons = le16toh(*sc->eq_cons_sb);
+    hw_cons = le16_to_cpu(*sc->eq_cons_sb);
 
     /*
      * The hw_cons range is 1-255, 257 - the sw_cons range is 0-254, 256.
 
     /*
      * The hw_cons range is 1-255, 257 - the sw_cons range is 0-254, 256.
@@ -8850,7 +8786,7 @@ bxe_eq_int(struct bxe_adapter *sc)
     sw_prod = sc->eq_prod;
 
     BLOGD(sc, DBG_SP,"EQ: hw_cons=%u sw_cons=%u eq_spq_left=0x%lx\n",
     sw_prod = sc->eq_prod;
 
     BLOGD(sc, DBG_SP,"EQ: hw_cons=%u sw_cons=%u eq_spq_left=0x%lx\n",
-          hw_cons, sw_cons, atomic_load_acq_long(&sc->eq_spq_left));
+          hw_cons, sw_cons, atomic_read(&sc->eq_spq_left));
 
     for (;
          sw_cons != hw_cons;
 
     for (;
          sw_cons != hw_cons;
@@ -9009,7 +8945,7 @@ next_spqe:
     } /* for */
 
     mb();
     } /* for */
 
     mb();
-    atomic_add_acq_long(&sc->eq_spq_left, spqe_cnt);
+    atomic_add(&sc->eq_spq_left, spqe_cnt);
 
     sc->eq_cons = sw_cons;
     sc->eq_prod = sw_prod;
 
     sc->eq_cons = sw_cons;
     sc->eq_prod = sw_prod;
@@ -9048,7 +8984,7 @@ bxe_handle_sp_tq(void *context,
         BLOGD(sc, DBG_SP, "---> EQ INTR <---\n");
         bxe_eq_int(sc);
         bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID,
         BLOGD(sc, DBG_SP, "---> EQ INTR <---\n");
         bxe_eq_int(sc);
         bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID,
-                   le16toh(sc->def_idx), IGU_INT_NOP, 1);
+                   le16_to_cpu(sc->def_idx), IGU_INT_NOP, 1);
         status &= ~BXE_DEF_SB_IDX;
     }
 
         status &= ~BXE_DEF_SB_IDX;
     }
 
@@ -9059,7 +8995,7 @@ bxe_handle_sp_tq(void *context,
 
     /* ack status block only if something was actually handled */
     bxe_ack_sb(sc, sc->igu_dsb_id, ATTENTION_ID,
 
     /* ack status block only if something was actually handled */
     bxe_ack_sb(sc, sc->igu_dsb_id, ATTENTION_ID,
-               le16toh(sc->def_att_idx), IGU_INT_ENABLE, 1);
+               le16_to_cpu(sc->def_att_idx), IGU_INT_ENABLE, 1);
 
     /*
      * Must be called after the EQ processing (since eq leads to sriov
 
     /*
      * Must be called after the EQ processing (since eq leads to sriov
@@ -9119,13 +9055,12 @@ bxe_handle_fp_tq(void *context,
 
     if (more_rx /*|| more_tx*/) {
         /* still more work to do */
 
     if (more_rx /*|| more_tx*/) {
         /* still more work to do */
-#warning "task queue"
-      //taskqueue_enqueue_fast(fp->tq, &fp->tq_task);
+        taskqueue_enqueue_fast(fp->tq, &fp->tq_task);
         return;
     }
 
     bxe_ack_sb(sc, fp->igu_sb_id, USTORM_ID,
         return;
     }
 
     bxe_ack_sb(sc, fp->igu_sb_id, USTORM_ID,
-               le16toh(fp->fp_hc_idx), IGU_INT_ENABLE, 1);
+               le16_to_cpu(fp->fp_hc_idx), IGU_INT_ENABLE, 1);
 }
 
 static void
 }
 
 static void
@@ -9154,7 +9089,7 @@ bxe_task_fp(struct bxe_fastpath *fp)
 
     if (more_rx /*|| more_tx*/) {
         /* still more work to do, bail out if this ISR and process later */
 
     if (more_rx /*|| more_tx*/) {
         /* still more work to do, bail out if this ISR and process later */
-      //taskqueue_enqueue_fast(fp->tq, &fp->tq_task);
+        taskqueue_enqueue_fast(fp->tq, &fp->tq_task);
         return;
     }
 
         return;
     }
 
@@ -9166,7 +9101,7 @@ bxe_task_fp(struct bxe_fastpath *fp)
      * not do any work in.
      */
     bxe_ack_sb(sc, fp->igu_sb_id, USTORM_ID,
      * not do any work in.
      */
     bxe_ack_sb(sc, fp->igu_sb_id, USTORM_ID,
-               le16toh(fp->fp_hc_idx), IGU_INT_ENABLE, 1);
+               le16_to_cpu(fp->fp_hc_idx), IGU_INT_ENABLE, 1);
 }
 
 /*
 }
 
 /*
@@ -9238,7 +9173,7 @@ bxe_intr_legacy(void *xsc)
         bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
 
         /* schedule slowpath handler */
         bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
 
         /* schedule slowpath handler */
-        //taskqueue_enqueue_fast(sc->sp_tq, &sc->sp_tq_task);
+        taskqueue_enqueue_fast(sc->sp_tq, &sc->sp_tq_task);
 
         status &= ~0x1;
     }
 
         status &= ~0x1;
     }
@@ -9260,7 +9195,7 @@ bxe_intr_sp(void *xsc)
     bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
 
     /* schedule slowpath handler */
     bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
 
     /* schedule slowpath handler */
-    //taskqueue_enqueue_fast(sc->sp_tq, &sc->sp_tq_task);
+    taskqueue_enqueue_fast(sc->sp_tq, &sc->sp_tq_task);
 }
 
 /* fastpath interrupt entry point */
 }
 
 /* fastpath interrupt entry point */
@@ -9391,7 +9326,7 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
         }
 
         /* ask for the necessary number of MSI-X vectors */
         }
 
         /* ask for the necessary number of MSI-X vectors */
-        num_requested = min((sc->num_queues + 1), msix_count);
+        num_requested = MIN((sc->num_queues + 1), msix_count);
 
         BLOGD(sc, DBG_LOAD, "Requesting %d MSI-X vectors\n", num_requested);
 
 
         BLOGD(sc, DBG_LOAD, "Requesting %d MSI-X vectors\n", num_requested);
 
@@ -9553,7 +9488,6 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
 static void
 bxe_interrupt_detach(struct bxe_adapter *sc)
 {
 static void
 bxe_interrupt_detach(struct bxe_adapter *sc)
 {
-#if 0
     struct bxe_fastpath *fp;
     int i;
 
     struct bxe_fastpath *fp;
     int i;
 
@@ -9585,7 +9519,6 @@ bxe_interrupt_detach(struct bxe_adapter *sc)
         taskqueue_free(sc->sp_tq);
         sc->sp_tq = NULL;
     }
         taskqueue_free(sc->sp_tq);
         sc->sp_tq = NULL;
     }
-#endif
 }
 
 /*
 }
 
 /*
@@ -9600,7 +9533,6 @@ bxe_interrupt_detach(struct bxe_adapter *sc)
 static int
 bxe_interrupt_attach(struct bxe_adapter *sc)
 {
 static int
 bxe_interrupt_attach(struct bxe_adapter *sc)
 {
-#if 0
     struct bxe_fastpath *fp;
     int rc = 0;
     int i;
     struct bxe_fastpath *fp;
     int rc = 0;
     int i;
@@ -9644,7 +9576,7 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
          * to the interrupt handler for the slowpath.
          */
         if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
          * to the interrupt handler for the slowpath.
          */
         if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
-                                 (INTR_TYPE_NET | INTR_MPSAFE),
+                                 0, //(INTR_TYPE_NET | INTR_MPSAFE),
                                  NULL, bxe_intr_sp, sc,
                                  &sc->intr[0].tag)) != 0) {
             BLOGE(sc, "Failed to allocate MSI-X[0] vector (%d)\n", rc);
                                  NULL, bxe_intr_sp, sc,
                                  &sc->intr[0].tag)) != 0) {
             BLOGE(sc, "Failed to allocate MSI-X[0] vector (%d)\n", rc);
@@ -9667,7 +9599,7 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
              * case.
              */
             if ((rc = bus_setup_intr(sc->pcidev, sc->intr[i + 1].resource,
              * case.
              */
             if ((rc = bus_setup_intr(sc->pcidev, sc->intr[i + 1].resource,
-                                     (INTR_TYPE_NET | INTR_MPSAFE),
+                                     0, //(INTR_TYPE_NET | INTR_MPSAFE),
                                      NULL, bxe_intr_fp, fp,
                                      &sc->intr[i + 1].tag)) != 0) {
                 BLOGE(sc, "Failed to allocate MSI-X[%d] vector (%d)\n",
                                      NULL, bxe_intr_fp, fp,
                                      &sc->intr[i + 1].tag)) != 0) {
                 BLOGE(sc, "Failed to allocate MSI-X[%d] vector (%d)\n",
@@ -9694,7 +9626,7 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
          * will handle both the slowpath and fastpath.
          */
         if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
          * will handle both the slowpath and fastpath.
          */
         if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
-                                 (INTR_TYPE_NET | INTR_MPSAFE),
+                                 0, //(INTR_TYPE_NET | INTR_MPSAFE),
                                  NULL, bxe_intr_legacy, sc,
                                  &sc->intr[0].tag)) != 0) {
             BLOGE(sc, "Failed to allocate MSI[0] vector (%d)\n", rc);
                                  NULL, bxe_intr_legacy, sc,
                                  &sc->intr[0].tag)) != 0) {
             BLOGE(sc, "Failed to allocate MSI[0] vector (%d)\n", rc);
@@ -9710,7 +9642,7 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
          * will handle both the slowpath and fastpath.
          */
         if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
          * will handle both the slowpath and fastpath.
          */
         if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
-                                 (INTR_TYPE_NET | INTR_MPSAFE),
+                                 0, //(INTR_TYPE_NET | INTR_MPSAFE),
                                  NULL, bxe_intr_legacy, sc,
                                  &sc->intr[0].tag)) != 0) {
             BLOGE(sc, "Failed to allocate INTx interrupt (%d)\n", rc);
                                  NULL, bxe_intr_legacy, sc,
                                  &sc->intr[0].tag)) != 0) {
             BLOGE(sc, "Failed to allocate INTx interrupt (%d)\n", rc);
@@ -9721,8 +9653,6 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
 bxe_interrupt_attach_exit:
 
     return (rc);
 bxe_interrupt_attach_exit:
 
     return (rc);
-#endif
-    return -1;
 }
 
 static int  bxe_init_hw_common_chip(struct bxe_adapter *sc);
 }
 
 static int  bxe_init_hw_common_chip(struct bxe_adapter *sc);
@@ -9777,7 +9707,7 @@ bxe_init_hw(struct bxe_adapter *sc,
     int rc;
 
     /* prepare the parameters for function state transitions */
     int rc;
 
     /* prepare the parameters for function state transitions */
-    bit_set(&func_params.ramrod_flags, RAMROD_COMP_WAIT);
+    __set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
 
     func_params.f_obj = &sc->func_obj;
     func_params.cmd = ECORE_F_CMD_HW_INIT;
 
     func_params.f_obj = &sc->func_obj;
     func_params.cmd = ECORE_F_CMD_HW_INIT;
@@ -10103,8 +10033,8 @@ bxe_init_eth_fp(struct bxe_adapter *sc,
     bxe_update_fp_sb_idx(fp);
 
     /* Configure Queue State object */
     bxe_update_fp_sb_idx(fp);
 
     /* Configure Queue State object */
-    bit_set(&q_type, ECORE_Q_TYPE_HAS_RX);
-    bit_set(&q_type, ECORE_Q_TYPE_HAS_TX);
+    __set_bit(ECORE_Q_TYPE_HAS_RX, &q_type);
+    __set_bit(ECORE_Q_TYPE_HAS_TX, &q_type);
 
     ecore_init_queue_obj(sc,
                          &sc->sp_objs[idx].q_obj,
 
     ecore_init_queue_obj(sc,
                          &sc->sp_objs[idx].q_obj,
@@ -10331,7 +10261,7 @@ bxe_init_def_sb(struct bxe_adapter *sc)
 static void
 bxe_init_sp_ring(struct bxe_adapter *sc)
 {
 static void
 bxe_init_sp_ring(struct bxe_adapter *sc)
 {
-    atomic_store_rel_long(&sc->cq_spq_left, MAX_SPQ_PENDING);
+    atomic_set(&sc->cq_spq_left, MAX_SPQ_PENDING);
     sc->spq_prod_idx = 0;
     sc->dsb_sp_prod = &sc->def_sb->sp_sb.index_values[HC_SP_INDEX_ETH_DEF_CONS];
     sc->spq_prod_bd = sc->spq;
     sc->spq_prod_idx = 0;
     sc->dsb_sp_prod = &sc->def_sb->sp_sb.index_values[HC_SP_INDEX_ETH_DEF_CONS];
     sc->spq_prod_bd = sc->spq;
@@ -10347,10 +10277,10 @@ bxe_init_eq_ring(struct bxe_adapter *sc)
     for (i = 1; i <= NUM_EQ_PAGES; i++) {
         elem = &sc->eq[EQ_DESC_CNT_PAGE * i - 1];
 
     for (i = 1; i <= NUM_EQ_PAGES; i++) {
         elem = &sc->eq[EQ_DESC_CNT_PAGE * i - 1];
 
-        elem->next_page.addr.hi = htole32(U64_HI(sc->eq_dma.paddr +
+        elem->next_page.addr.hi = cpu_to_le32(U64_HI(sc->eq_dma.paddr +
                                                  BCM_PAGE_SIZE *
                                                  (i % NUM_EQ_PAGES)));
                                                  BCM_PAGE_SIZE *
                                                  (i % NUM_EQ_PAGES)));
-        elem->next_page.addr.lo = htole32(U64_LO(sc->eq_dma.paddr +
+        elem->next_page.addr.lo = cpu_to_le32(U64_LO(sc->eq_dma.paddr +
                                                  BCM_PAGE_SIZE *
                                                  (i % NUM_EQ_PAGES)));
     }
                                                  BCM_PAGE_SIZE *
                                                  (i % NUM_EQ_PAGES)));
     }
@@ -10359,8 +10289,8 @@ bxe_init_eq_ring(struct bxe_adapter *sc)
     sc->eq_prod    = NUM_EQ_DESC;
     sc->eq_cons_sb = &sc->def_sb->sp_sb.index_values[HC_SP_INDEX_EQ_CONS];
 
     sc->eq_prod    = NUM_EQ_DESC;
     sc->eq_cons_sb = &sc->def_sb->sp_sb.index_values[HC_SP_INDEX_EQ_CONS];
 
-    atomic_store_rel_long(&sc->eq_spq_left,
-                          (min((MAX_SP_DESC_CNT - MAX_SPQ_PENDING),
+    atomic_set(&sc->eq_spq_left,
+                          (MIN((MAX_SP_DESC_CNT - MAX_SPQ_PENDING),
                                NUM_EQ_DESC) - 1));
 }
 
                                NUM_EQ_DESC) - 1));
 }
 
@@ -10670,7 +10600,7 @@ bxe_pf_init(struct bxe_adapter *sc)
      * This flag is relevant for E1x only.
      * E2 doesn't have a TPA configuration in a function level.
      */
      * This flag is relevant for E1x only.
      * E2 doesn't have a TPA configuration in a function level.
      */
-#warning "no getcapenable
+#warning "no getcapenable"
 //    flags |= (if_getcapenable(sc->ifp) & IFCAP_LRO) ? FUNC_FLG_TPA : 0;
 
     func_init.func_flgs = flags;
 //    flags |= (if_getcapenable(sc->ifp) & IFCAP_LRO) ? FUNC_FLG_TPA : 0;
 
     func_init.func_flgs = flags;
@@ -11028,12 +10958,13 @@ bxe_init_objs(struct bxe_adapter *sc)
 static inline int
 bxe_func_start(struct bxe_adapter *sc)
 {
 static inline int
 bxe_func_start(struct bxe_adapter *sc)
 {
+       return 0xaa;
 #if 0
     struct ecore_func_state_params func_params = { NULL };
     struct ecore_func_start_params *start_params = &func_params.params.start;
 
     /* Prepare parameters for function state transitions */
 #if 0
     struct ecore_func_state_params func_params = { NULL };
     struct ecore_func_start_params *start_params = &func_params.params.start;
 
     /* Prepare parameters for function state transitions */
-    bit_set(&func_params.ramrod_flags, RAMROD_COMP_WAIT);
+    __set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
 
     func_params.f_obj = &sc->func_obj;
     func_params.cmd = ECORE_F_CMD_START;
 
     func_params.f_obj = &sc->func_obj;
     func_params.cmd = ECORE_F_CMD_START;
@@ -11813,7 +11744,7 @@ bxe_pf_rx_q_prep(struct bxe_adapter              *sc,
         max_sge = SGE_PAGE_ALIGN(sc->mtu) >> SGE_PAGE_SHIFT;
         max_sge = ((max_sge + PAGES_PER_SGE - 1) &
                    (~(PAGES_PER_SGE - 1))) >> PAGES_PER_SGE_SHIFT;
         max_sge = SGE_PAGE_ALIGN(sc->mtu) >> SGE_PAGE_SHIFT;
         max_sge = ((max_sge + PAGES_PER_SGE - 1) &
                    (~(PAGES_PER_SGE - 1))) >> PAGES_PER_SGE_SHIFT;
-        sge_sz = (uint16_t)min(SGE_PAGES, 0xffff);
+        sge_sz = (uint16_t)MIN(SGE_PAGES, 0xffff);
     }
 
     /* pause - not for e1 */
     }
 
     /* pause - not for e1 */
@@ -12045,10 +11976,7 @@ bxe_config_rss_pf(struct bxe_adapter            *sc,
 
     if (config_hash) {
         /* RSS keys */
 
     if (config_hash) {
         /* RSS keys */
-        for (i = 0; i < sizeof(params.rss_key) / 4; i++) {
-            params.rss_key[i] = arc4random();
-        }
-
+               randomread(params.rss_key, sizeof(params.rss_key));
         bxe_set_bit(ECORE_RSS_SET_SRCH, &params.rss_flags);
     }
 
         bxe_set_bit(ECORE_RSS_SET_SRCH, &params.rss_flags);
     }
 
@@ -12553,7 +12481,9 @@ bxe_initial_phy_init(struct bxe_adapter *sc,
     return (rc);
 }
 
     return (rc);
 }
 
-/* must be called under IF_ADDR_LOCK */
+/* must be called with sc locked. We don't need finer grained locking,
+ * I think, because adding addresses is not that frequent.
+ */
 static int
 bxe_init_mcast_macs_list(struct bxe_adapter                 *sc,
                          struct ecore_mcast_ramrod_params *p)
 static int
 bxe_init_mcast_macs_list(struct bxe_adapter                 *sc,
                          struct ecore_mcast_ramrod_params *p)
@@ -12573,8 +12503,8 @@ bxe_init_mcast_macs_list(struct bxe_adapter                 *sc,
         return (0);
     }
 
         return (0);
     }
 
-    mta = malloc(sizeof(unsigned char) * ETH_ADDR_LEN *
-                mc_count, 0); //M_DEVBUF, M_NOWAIT);
+    mta = kmalloc(sizeof(unsigned char) * ETH_ADDR_LEN * mc_count,
+                     0); //M_DEVBUF, M_NOWAIT);
     mta = NULL;
 
     if(mta == NULL) {
     mta = NULL;
 
     if(mta == NULL) {
@@ -12582,10 +12512,9 @@ bxe_init_mcast_macs_list(struct bxe_adapter                 *sc,
         return (-1);
     }
     
         return (-1);
     }
     
-    mc_mac = kmalloc(sizeof(*mc_mac) * mc_count, 0); //M_DEVBUF,
-    //(M_NOWAIT | M_ZERO));
+    mc_mac = kzmalloc(sizeof(*mc_mac) * mc_count, 0); //M_DEVBUF,
     if (!mc_mac) {
     if (!mc_mac) {
-      free(mta); //, M_DEVBUF);
+        kfree(mta); //, M_DEVBUF);
         BLOGE(sc, "Failed to allocate temp mcast list\n");
         return (-1);
     }
         BLOGE(sc, "Failed to allocate temp mcast list\n");
         return (-1);
     }
@@ -12667,6 +12596,7 @@ bxe_set_mc_list(struct bxe_adapter *sc)
 static int
 bxe_set_uc_list(struct bxe_adapter *sc)
 {
 static int
 bxe_set_uc_list(struct bxe_adapter *sc)
 {
+       return 0xaa;
 #if 0
     if_t ifp = sc->ifp;
     struct ecore_vlan_mac_obj *mac_obj = &sc->sp_objs->mac_obj;
 #if 0
     if_t ifp = sc->ifp;
     struct ecore_vlan_mac_obj *mac_obj = &sc->sp_objs->mac_obj;
@@ -12674,21 +12604,13 @@ bxe_set_uc_list(struct bxe_adapter *sc)
     unsigned long ramrod_flags = 0;
     int rc;
 
     unsigned long ramrod_flags = 0;
     int rc;
 
-#if __FreeBSD_version < 800000
-    IF_ADDR_LOCK(ifp);
-#else
-    if_addr_rlock(ifp);
-#endif
-
+       they used to lock the ifp. We could do that.
+       just lock the sc here. I see no reason to get finer grained for this one.
     /* first schedule a cleanup up of old configuration */
     rc = bxe_del_all_macs(sc, mac_obj, ECORE_UC_LIST_MAC, FALSE);
     if (rc < 0) {
     /* first schedule a cleanup up of old configuration */
     rc = bxe_del_all_macs(sc, mac_obj, ECORE_UC_LIST_MAC, FALSE);
     if (rc < 0) {
+unlock ehre.
         BLOGE(sc, "Failed to schedule delete of all ETH MACs (%d)\n", rc);
         BLOGE(sc, "Failed to schedule delete of all ETH MACs (%d)\n", rc);
-#if __FreeBSD_version < 800000
-        IF_ADDR_UNLOCK(ifp);
-#else
-        if_addr_runlock(ifp);
-#endif
         return (rc);
     }
 
         return (rc);
     }
 
@@ -12707,25 +12629,17 @@ bxe_set_uc_list(struct bxe_adapter *sc)
             rc = 0;
         } else if (rc < 0) {
             BLOGE(sc, "Failed to schedule ADD operations (%d)\n", rc);
             rc = 0;
         } else if (rc < 0) {
             BLOGE(sc, "Failed to schedule ADD operations (%d)\n", rc);
-#if __FreeBSD_version < 800000
-            IF_ADDR_UNLOCK(ifp);
-#else
-            if_addr_runlock(ifp);
-#endif
+unlock ehre.
             return (rc);
         }
 
         ifa = TAILQ_NEXT(ifa, ifa_link);
     }
 
             return (rc);
         }
 
         ifa = TAILQ_NEXT(ifa, ifa_link);
     }
 
-#if __FreeBSD_version < 800000
-    IF_ADDR_UNLOCK(ifp);
-#else
-    if_addr_runlock(ifp);
-#endif
+unlock here.
 
     /* Execute the pending commands */
 
     /* Execute the pending commands */
-    bit_set(&ramrod_flags, RAMROD_CONT);
+    __set_bit(RAMROD_CONT, &ramrod_flags);
     return (bxe_set_mac_one(sc, NULL, mac_obj, FALSE /* don't care */,
                             ECORE_UC_LIST_MAC, &ramrod_flags));
 #endif
     return (bxe_set_mac_one(sc, NULL, mac_obj, FALSE /* don't care */,
                             ECORE_UC_LIST_MAC, &ramrod_flags));
 #endif
@@ -12748,7 +12662,6 @@ bxe_handle_rx_mode_tq(void *context,
     }
 
     BLOGD(sc, DBG_SP, "if_flags(ifp)=0x%x\n", if_getflags(sc->ifp));
     }
 
     BLOGD(sc, DBG_SP, "if_flags(ifp)=0x%x\n", if_getflags(sc->ifp));
-#warning "FIX ALL FLAGS"
 #if 0
     if (if_getflags(ifp) & IFF_PROMISC) {
         rx_mode = BXE_RX_MODE_PROMISC;
 #if 0
     if (if_getflags(ifp) & IFF_PROMISC) {
         rx_mode = BXE_RX_MODE_PROMISC;
@@ -12852,7 +12765,7 @@ bxe_periodic_callout_func(void *xsc)
         /* just bail and try again next time */
 
         if ((sc->state == BXE_STATE_OPEN) &&
         /* just bail and try again next time */
 
         if ((sc->state == BXE_STATE_OPEN) &&
-            (atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_GO)) {
+            (atomic_read(&sc->periodic_flags) == PERIODIC_GO)) {
             /* schedule the next periodic callout */
                //callout_reset(&sc->periodic_callout, hz,
                //        bxe_periodic_callout_func, sc);
             /* schedule the next periodic callout */
                //callout_reset(&sc->periodic_callout, hz,
                //        bxe_periodic_callout_func, sc);
@@ -12862,7 +12775,7 @@ bxe_periodic_callout_func(void *xsc)
     }
 
     if ((sc->state != BXE_STATE_OPEN) ||
     }
 
     if ((sc->state != BXE_STATE_OPEN) ||
-        (atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_STOP)) {
+        (atomic_read(&sc->periodic_flags) == PERIODIC_STOP)) {
         BLOGW(sc, "periodic callout exit (state=0x%x)\n", sc->state);
         BXE_CORE_UNLOCK(sc);
         return;
         BLOGW(sc, "periodic callout exit (state=0x%x)\n", sc->state);
         BXE_CORE_UNLOCK(sc);
         return;
@@ -12929,7 +12842,7 @@ bxe_periodic_callout_func(void *xsc)
     BXE_CORE_UNLOCK(sc);
 
     if ((sc->state == BXE_STATE_OPEN) &&
     BXE_CORE_UNLOCK(sc);
 
     if ((sc->state == BXE_STATE_OPEN) &&
-        (atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_GO)) {
+        (atomic_read(&sc->periodic_flags) == PERIODIC_GO)) {
         /* schedule the next periodic callout */
 //        callout_reset(&sc->periodic_callout, hz,
 //                      bxe_periodic_callout_func, sc);
         /* schedule the next periodic callout */
 //        callout_reset(&sc->periodic_callout, hz,
 //                      bxe_periodic_callout_func, sc);
@@ -12939,14 +12852,14 @@ bxe_periodic_callout_func(void *xsc)
 static void
 bxe_periodic_start(struct bxe_adapter *sc)
 {
 static void
 bxe_periodic_start(struct bxe_adapter *sc)
 {
-       //atomic_store_rel_long(&sc->periodic_flags, PERIODIC_GO);
+       //atomic_set(&sc->periodic_flags, PERIODIC_GO);
     //  callout_reset(&sc->periodic_callout, hz, bxe_periodic_callout_func, sc);
 }
 
 static void
 bxe_periodic_stop(struct bxe_adapter *sc)
 {
     //  callout_reset(&sc->periodic_callout, hz, bxe_periodic_callout_func, sc);
 }
 
 static void
 bxe_periodic_stop(struct bxe_adapter *sc)
 {
-//    atomic_store_rel_long(&sc->periodic_flags, PERIODIC_STOP);
+//    atomic_set(&sc->periodic_flags, PERIODIC_STOP);
 //    callout_drain(&sc->periodic_callout);
 }
 
 //    callout_drain(&sc->periodic_callout);
 }
 
@@ -13587,6 +13500,7 @@ bxe_pcie_capability_read(struct bxe_adapter *sc,
 static uint8_t
 bxe_is_pcie_pending(struct bxe_adapter *sc)
 {
 static uint8_t
 bxe_is_pcie_pending(struct bxe_adapter *sc)
 {
+       return 0xaa;
 #if 0
     return (bxe_pcie_capability_read(sc, PCIR_EXPRESS_DEVICE_STA, 2) &
             PCIM_EXP_STA_TRANSACTION_PND);
 #if 0
     return (bxe_pcie_capability_read(sc, PCIR_EXPRESS_DEVICE_STA, 2) &
             PCIM_EXP_STA_TRANSACTION_PND);
@@ -14235,7 +14149,7 @@ bxe_get_tunable_params(struct bxe_adapter *sc)
         sc->num_queues = 1;
     } else { /* INTR_MODE_MSI or INTR_MODE_MSIX */
         sc->num_queues =
         sc->num_queues = 1;
     } else { /* INTR_MODE_MSI or INTR_MODE_MSIX */
         sc->num_queues =
-               min((bxe_queue_count ? bxe_queue_count : 8) //mp_ncpus),
+               MIN((bxe_queue_count ? bxe_queue_count : 8) //mp_ncpus),
                 MAX_RSS_CHAINS);
         if (sc->num_queues > mp_ncpus) {
             sc->num_queues = mp_ncpus;
                 MAX_RSS_CHAINS);
         if (sc->num_queues > mp_ncpus) {
             sc->num_queues = mp_ncpus;
@@ -14311,7 +14225,7 @@ bxe_media_detect(struct bxe_adapter *sc)
         break;
     }
 #endif
         break;
     }
 #endif
-    asset(0);
+    assert(0);
 }
 
 #define GET_FIELD(value, fname)                     \
 }
 
 #define GET_FIELD(value, fname)                     \
@@ -14370,7 +14284,7 @@ bxe_get_igu_cam_info(struct bxe_adapter *sc)
      * PCI. Driver should use the minimal value of both as the actual status
      * block count
      */
      * PCI. Driver should use the minimal value of both as the actual status
      * block count
      */
-    sc->igu_sb_cnt = min(sc->igu_sb_cnt, igu_sb_cnt);
+    sc->igu_sb_cnt = MIN(sc->igu_sb_cnt, igu_sb_cnt);
 
     if (igu_sb_cnt == 0) {
         BLOGE(sc, "CAM configuration error\n");
 
     if (igu_sb_cnt == 0) {
         BLOGE(sc, "CAM configuration error\n");
@@ -15150,7 +15064,7 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
     sc->gz_buf = (void *)sc->gz_buf_dma.vaddr;
 
     if ((sc->gz_strm =
     sc->gz_buf = (void *)sc->gz_buf_dma.vaddr;
 
     if ((sc->gz_strm =
-         malloc(sizeof(*sc->gz_strm), M_DEVBUF, M_NOWAIT)) == NULL) {
+         kmalloc(sizeof(*sc->gz_strm), /*M_DEVBUF,*/ M_NOWAIT)) == NULL) {
         /* XXX */
         bxe_dma_free(sc, &sc->gz_buf_dma);
         sc->gz_buf = NULL;
         /* XXX */
         bxe_dma_free(sc, &sc->gz_buf_dma);
         sc->gz_buf = NULL;
@@ -15218,8 +15132,8 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
             /* point to the next page and wrap from last page */
             busaddr = (fp->tx_dma.paddr +
                        (BCM_PAGE_SIZE * (j % TX_BD_NUM_PAGES)));
             /* point to the next page and wrap from last page */
             busaddr = (fp->tx_dma.paddr +
                        (BCM_PAGE_SIZE * (j % TX_BD_NUM_PAGES)));
-            tx_next_bd->addr_hi = htole32(U64_HI(busaddr));
-            tx_next_bd->addr_lo = htole32(U64_LO(busaddr));
+            tx_next_bd->addr_hi = cpu_to_le32(U64_HI(busaddr));
+            tx_next_bd->addr_lo = cpu_to_le32(U64_LO(busaddr));
         }
 
         /******************/
         }
 
         /******************/
@@ -15244,8 +15158,8 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
             /* point to the next page and wrap from last page */
             busaddr = (fp->rx_dma.paddr +
                        (BCM_PAGE_SIZE * (j % RX_BD_NUM_PAGES)));
             /* point to the next page and wrap from last page */
             busaddr = (fp->rx_dma.paddr +
                        (BCM_PAGE_SIZE * (j % RX_BD_NUM_PAGES)));
-            rx_bd->addr_hi = htole32(U64_HI(busaddr));
-            rx_bd->addr_lo = htole32(U64_LO(busaddr));
+            rx_bd->addr_hi = cpu_to_le32(U64_HI(busaddr));
+            rx_bd->addr_lo = cpu_to_le32(U64_LO(busaddr));
         }
 
         /*******************/
         }
 
         /*******************/
@@ -15271,8 +15185,8 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
             /* point to the next page and wrap from last page */
             busaddr = (fp->rcq_dma.paddr +
                        (BCM_PAGE_SIZE * (j % RCQ_NUM_PAGES)));
             /* point to the next page and wrap from last page */
             busaddr = (fp->rcq_dma.paddr +
                        (BCM_PAGE_SIZE * (j % RCQ_NUM_PAGES)));
-            rx_cqe_next->addr_hi = htole32(U64_HI(busaddr));
-            rx_cqe_next->addr_lo = htole32(U64_LO(busaddr));
+            rx_cqe_next->addr_hi = cpu_to_le32(U64_HI(busaddr));
+            rx_cqe_next->addr_lo = cpu_to_le32(U64_LO(busaddr));
         }
 
         /*******************/
         }
 
         /*******************/
@@ -15297,8 +15211,8 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
             /* point to the next page and wrap from last page */
             busaddr = (fp->rx_sge_dma.paddr +
                        (BCM_PAGE_SIZE * (j % RX_SGE_NUM_PAGES)));
             /* point to the next page and wrap from last page */
             busaddr = (fp->rx_sge_dma.paddr +
                        (BCM_PAGE_SIZE * (j % RX_SGE_NUM_PAGES)));
-            rx_sge->addr_hi = htole32(U64_HI(busaddr));
-            rx_sge->addr_lo = htole32(U64_LO(busaddr));
+            rx_sge->addr_hi = cpu_to_le32(U64_HI(busaddr));
+            rx_sge->addr_lo = cpu_to_le32(U64_LO(busaddr));
         }
 
         /***********************/
         }
 
         /***********************/
@@ -15734,8 +15648,7 @@ bxe_prev_is_path_marked(struct bxe_adapter *sc)
 {
     struct bxe_prev_list_node *tmp;
     int rc = FALSE;
 {
     struct bxe_prev_list_node *tmp;
     int rc = FALSE;
-#warning "TODO: figure out bxe_prev_mtx"
-    //    mtx_lock(&bxe_prev_mtx);
+    qlock(&bxe_prev_mtx);
 
     tmp = bxe_prev_path_get_entry(sc);
     if (tmp) {
 
     tmp = bxe_prev_path_get_entry(sc);
     if (tmp) {
@@ -15751,7 +15664,7 @@ bxe_prev_is_path_marked(struct bxe_adapter *sc)
         }
     }
 
         }
     }
 
-    //    mtx_unlock(&bxe_prev_mtx);
+    qunlock(&bxe_prev_mtx);
 
     return (rc);
 }
 
     return (rc);
 }
@@ -15762,7 +15675,7 @@ bxe_prev_mark_path(struct bxe_adapter *sc,
 {
     struct bxe_prev_list_node *tmp;
 
 {
     struct bxe_prev_list_node *tmp;
 
-    //    mtx_lock(&bxe_prev_mtx);
+    qlock(&bxe_prev_mtx);
 
     /* Check whether the entry for this path already exists */
     tmp = bxe_prev_path_get_entry(sc);
 
     /* Check whether the entry for this path already exists */
     tmp = bxe_prev_path_get_entry(sc);
@@ -15778,14 +15691,14 @@ bxe_prev_mark_path(struct bxe_adapter *sc,
             tmp->aer = 0;
         }
 
             tmp->aer = 0;
         }
 
-       //        mtx_unlock(&bxe_prev_mtx);
+               qunlock(&bxe_prev_mtx);
         return (0);
     }
 
         return (0);
     }
 
-    //    mtx_unlock(&bxe_prev_mtx);
+    qunlock(&bxe_prev_mtx);
 
     /* Create an entry for this path and add it */
 
     /* Create an entry for this path and add it */
-    tmp = kmalloc(sizeof(struct bxe_prev_list_node), 0); //M_DEVBUF,
+    tmp = kzmalloc(sizeof(struct bxe_prev_list_node), 0); //M_DEVBUF,
 //                 (M_NOWAIT | M_ZERO));
     if (!tmp) {
         BLOGE(sc, "Failed to allocate 'bxe_prev_list_node'\n");
 //                 (M_NOWAIT | M_ZERO));
     if (!tmp) {
         BLOGE(sc, "Failed to allocate 'bxe_prev_list_node'\n");
@@ -15798,14 +15711,14 @@ bxe_prev_mark_path(struct bxe_adapter *sc,
     tmp->aer  = 0;
     tmp->undi = after_undi ? (1 << SC_PORT(sc)) : 0;
 
     tmp->aer  = 0;
     tmp->undi = after_undi ? (1 << SC_PORT(sc)) : 0;
 
-    //    mtx_lock(&bxe_prev_mtx);
+    qlock(&bxe_prev_mtx);
 
     BLOGD(sc, DBG_LOAD,
           "Marked path %d/%d/%d - finished previous unload\n",
           sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
     //    LIST_INSERT_HEAD(&bxe_prev_list, tmp, node);
 
 
     BLOGD(sc, DBG_LOAD,
           "Marked path %d/%d/%d - finished previous unload\n",
           sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
     //    LIST_INSERT_HEAD(&bxe_prev_list, tmp, node);
 
-    //    mtx_unlock(&bxe_prev_mtx);
+    qunlock(&bxe_prev_mtx);
 
     return (0);
 }
 
     return (0);
 }
@@ -16215,7 +16128,7 @@ bxe_set_qm_cid_count(struct bxe_adapter *sc)
         cid_count += CNIC_CID_MAX;
     }
 
         cid_count += CNIC_CID_MAX;
     }
 
-    return (roundup(cid_count, QM_CID_ROUND));
+    return (ROUNDUP(cid_count, QM_CID_ROUND));
 }
 
 static void
 }
 
 static void
@@ -16628,7 +16541,7 @@ bxe_detach(device_t dev)
     bxe_periodic_stop(sc);
 
     /* stop the chip taskqueue */
     bxe_periodic_stop(sc);
 
     /* stop the chip taskqueue */
-    atomic_store_rel_long(&sc->chip_tq_flags, CHIP_TQ_NONE);
+    atomic_set(&sc->chip_tq_flags, CHIP_TQ_NONE);
     if (sc->chip_tq) {
         taskqueue_drain(sc->chip_tq, &sc->chip_tq_task);
         taskqueue_free(sc->chip_tq);
     if (sc->chip_tq) {
         taskqueue_drain(sc->chip_tq, &sc->chip_tq_task);
         taskqueue_free(sc->chip_tq);
@@ -16715,6 +16628,7 @@ bxe_igu_ack_sb(struct bxe_adapter *sc,
     bxe_igu_ack_sb_gen(sc, igu_sb_id, segment, index, op, update, igu_addr);
 }
 
     bxe_igu_ack_sb_gen(sc, igu_sb_id, segment, index, op, update, igu_addr);
 }
 
+#endif
 static void
 bxe_igu_clear_sb_gen(struct bxe_adapter *sc,
                      uint8_t          func,
 static void
 bxe_igu_clear_sb_gen(struct bxe_adapter *sc,
                      uint8_t          func,
@@ -16780,7 +16694,6 @@ bxe_igu_clear_sb(struct bxe_adapter *sc,
 }
 
 
 }
 
 
-#endif
 
 
 
 
 
 
@@ -16950,7 +16863,7 @@ bxe_iov_init_dq(struct bxe_adapter *sc)
 
     /* Set the DQ such that the CID reflect the abs_vfid */
     REG_WR(sc, DORQ_REG_VF_NORM_VF_BASE, 0);
 
     /* Set the DQ such that the CID reflect the abs_vfid */
     REG_WR(sc, DORQ_REG_VF_NORM_VF_BASE, 0);
-    REG_WR(sc, DORQ_REG_MAX_RVFID_SIZE, ilog2(BNX2X_MAX_NUM_OF_VFS));
+    REG_WR(sc, DORQ_REG_MAX_RVFID_SIZE, LOG2_UP(BNX2X_MAX_NUM_OF_VFS));
 
     /*
      * Set VFs starting CID. If its > 0 the preceding CIDs are belong to
 
     /*
      * Set VFs starting CID. If its > 0 the preceding CIDs are belong to
@@ -18944,4 +18857,3 @@ ecore_storm_memset_struct(struct bxe_adapter *sc,
         REG_WR(sc, addr + (i * 4), data[i]);
     }
 }
         REG_WR(sc, addr + (i * 4), data[i]);
     }
 }
-