bxe: properly get the maddr from the netif.
[akaros.git] / kern / drivers / net / bxe / bxe.c
index 6f5fecc..c7290e3 100644 (file)
@@ -24,7 +24,6 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
 //__FBSDID("$FreeBSD: head/sys/dev/bxe/bxe.c 275358 2014-12-01 11:45:24Z hselasky $");
 
 #define BXE_DRIVER_VERSION "1.78.78"
 #define CSUM_UDP_IPV6 0
 #endif
 
-/*
- * pci_find_cap was added in r219865. Re-define this at pci_find_extcap
- * for older kernels that don't include this changeset.
- */
-#if __FreeBSD_version < 900035
-#define pci_find_cap pci_find_extcap
-#endif
-
 #define BXE_DEF_SB_ATT_IDX 0x0001
 #define BXE_DEF_SB_IDX     0x0002
 
@@ -225,9 +216,12 @@ static struct bxe_device_type bxe_devs[] = {
     }
 };
 
-MALLOC_DECLARE(M_BXE_ILT);
-MALLOC_DEFINE(M_BXE_ILT, "bxe_ilt", "bxe ILT pointer");
+/* 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");
 
+#if 0
 /*
  * FreeBSD device entry points.
  */
@@ -255,30 +249,9 @@ static device_method_t bxe_methods[] = {
     KOBJMETHOD_END
 };
 
-/*
- * FreeBSD KLD Module data declaration
- */
-static driver_t bxe_driver = {
-    "bxe",                   /* module name */
-    bxe_methods,             /* event handler */
-    sizeof(struct bxe_adapter) /* extra data */
-};
-
-/*
- * FreeBSD dev class is needed to manage dev instances and
- * to associate with a bus type
- */
-static devclass_t bxe_devclass;
-
-MODULE_DEPEND(bxe, pci, 1, 1, 1);
-MODULE_DEPEND(bxe, ether, 1, 1, 1);
-DRIVER_MODULE(bxe, pci, bxe_driver, bxe_devclass, 0, 0);
-
-/* resources needed for unloading a previously loaded device */
+#endif
+qlock_t bxe_prev_mtx;
 
-#define BXE_PREV_WAIT_NEEDED 1
-struct mtx bxe_prev_mtx;
-MTX_SYSINIT(bxe_prev_mtx, &bxe_prev_mtx, "bxe_prev_lock", MTX_DEF);
 struct bxe_prev_list_node {
     LIST_ENTRY(bxe_prev_list_node) node;
     uint8_t bus;
@@ -287,69 +260,68 @@ struct bxe_prev_list_node {
     uint8_t aer; /* XXX automatic error recovery */
     uint8_t undi;
 };
-static LIST_HEAD(, bxe_prev_list_node) bxe_prev_list = LIST_HEAD_INITIALIZER(bxe_prev_list);
-
-static int load_count[2][3] = { {0} }; /* per-path: 0-common, 1-port0, 2-port1 */
+//static LIST_HEAD(, bxe_prev_list_node) bxe_prev_list = LIST_HEAD_INITIALIZER(bxe_prev_list);
 
 /* Tunable device values... */
 
-SYSCTL_NODE(_hw, OID_AUTO, bxe, CTLFLAG_RD, 0, "bxe driver parameters");
+//SYSCTL_NODE(_hw, OID_AUTO, bxe, CTLFLAG_RD, 0, "bxe driver parameters");
 
 /* Debug */
 unsigned long bxe_debug = 0;
-SYSCTL_ULONG(_hw_bxe, OID_AUTO, debug, CTLFLAG_RDTUN,
-             &bxe_debug, 0, "Debug logging mode");
+//SYSCTL_ULONG(_hw_bxe, OID_AUTO, debug, CTLFLAG_RDTUN,
+//             &bxe_debug, 0, "Debug logging mode");
 
 /* Interrupt Mode: 0 (IRQ), 1 (MSI/IRQ), and 2 (MSI-X/MSI/IRQ) */
 static int bxe_interrupt_mode = INTR_MODE_MSIX;
-SYSCTL_INT(_hw_bxe, OID_AUTO, interrupt_mode, CTLFLAG_RDTUN,
-           &bxe_interrupt_mode, 0, "Interrupt (MSI-X/MSI/INTx) mode");
+//SYSCTL_INT(_hw_bxe, OID_AUTO, interrupt_mode, CTLFLAG_RDTUN,
+//           &bxe_interrupt_mode, 0, "Interrupt (MSI-X/MSI/INTx) mode");
 
 /* Number of Queues: 0 (Auto) or 1 to 16 (fixed queue number) */
 static int bxe_queue_count = 4;
-SYSCTL_INT(_hw_bxe, OID_AUTO, queue_count, CTLFLAG_RDTUN,
-           &bxe_queue_count, 0, "Multi-Queue queue count");
+//SYSCTL_INT(_hw_bxe, OID_AUTO, queue_count, CTLFLAG_RDTUN,
+//           &bxe_queue_count, 0, "Multi-Queue queue count");
 
 /* max number of buffers per queue (default RX_BD_USABLE) */
 static int bxe_max_rx_bufs = 0;
-SYSCTL_INT(_hw_bxe, OID_AUTO, max_rx_bufs, CTLFLAG_RDTUN,
-           &bxe_max_rx_bufs, 0, "Maximum Number of Rx Buffers Per Queue");
+//SYSCTL_INT(_hw_bxe, OID_AUTO, max_rx_bufs, CTLFLAG_RDTUN,
+//           &bxe_max_rx_bufs, 0, "Maximum Number of Rx Buffers Per Queue");
 
 /* Host interrupt coalescing RX tick timer (usecs) */
 static int bxe_hc_rx_ticks = 25;
-SYSCTL_INT(_hw_bxe, OID_AUTO, hc_rx_ticks, CTLFLAG_RDTUN,
-           &bxe_hc_rx_ticks, 0, "Host Coalescing Rx ticks");
+//SYSCTL_INT(_hw_bxe, OID_AUTO, hc_rx_ticks, CTLFLAG_RDTUN,
+//           &bxe_hc_rx_ticks, 0, "Host Coalescing Rx ticks");
 
 /* Host interrupt coalescing TX tick timer (usecs) */
 static int bxe_hc_tx_ticks = 50;
-SYSCTL_INT(_hw_bxe, OID_AUTO, hc_tx_ticks, CTLFLAG_RDTUN,
-           &bxe_hc_tx_ticks, 0, "Host Coalescing Tx ticks");
+//SYSCTL_INT(_hw_bxe, OID_AUTO, hc_tx_ticks, CTLFLAG_RDTUN,
+//           &bxe_hc_tx_ticks, 0, "Host Coalescing Tx ticks");
 
 /* Maximum number of Rx packets to process at a time */
 static int bxe_rx_budget = 0xffffffff;
-SYSCTL_INT(_hw_bxe, OID_AUTO, rx_budget, CTLFLAG_TUN,
-           &bxe_rx_budget, 0, "Rx processing budget");
+//SYSCTL_INT(_hw_bxe, OID_AUTO, rx_budget, CTLFLAG_TUN,
+//           &bxe_rx_budget, 0, "Rx processing budget");
 
 /* Maximum LRO aggregation size */
 static int bxe_max_aggregation_size = 0;
-SYSCTL_INT(_hw_bxe, OID_AUTO, max_aggregation_size, CTLFLAG_TUN,
-           &bxe_max_aggregation_size, 0, "max aggregation size");
+//SYSCTL_INT(_hw_bxe, OID_AUTO, max_aggregation_size, CTLFLAG_TUN,
+//           &bxe_max_aggregation_size, 0, "max aggregation size");
 
 /* PCI MRRS: -1 (Auto), 0 (128B), 1 (256B), 2 (512B), 3 (1KB) */
 static int bxe_mrrs = -1;
-SYSCTL_INT(_hw_bxe, OID_AUTO, mrrs, CTLFLAG_RDTUN,
-           &bxe_mrrs, 0, "PCIe maximum read request size");
+//SYSCTL_INT(_hw_bxe, OID_AUTO, mrrs, CTLFLAG_RDTUN,
+//           &bxe_mrrs, 0, "PCIe maximum read request size");
 
 /* AutoGrEEEn: 0 (hardware default), 1 (force on), 2 (force off) */
 static int bxe_autogreeen = 0;
-SYSCTL_INT(_hw_bxe, OID_AUTO, autogreeen, CTLFLAG_RDTUN,
-           &bxe_autogreeen, 0, "AutoGrEEEn support");
+//SYSCTL_INT(_hw_bxe, OID_AUTO, autogreeen, CTLFLAG_RDTUN,
+//           &bxe_autogreeen, 0, "AutoGrEEEn support");
 
 /* 4-tuple RSS support for UDP: 0 (disabled), 1 (enabled) */
 static int bxe_udp_rss = 0;
-SYSCTL_INT(_hw_bxe, OID_AUTO, udp_rss, CTLFLAG_RDTUN,
-           &bxe_udp_rss, 0, "UDP RSS support");
+//SYSCTL_INT(_hw_bxe, OID_AUTO, udp_rss, CTLFLAG_RDTUN,
+//           &bxe_udp_rss, 0, "UDP RSS support");
 
+static int bxe_periodic_alarm = 60;
 
 #define STAT_NAME_LEN 32 /* no stat names below can be longer than this */
 
@@ -690,7 +662,9 @@ static inline void bxe_update_rx_prod(struct bxe_adapter    *sc,
 static void    bxe_link_report_locked(struct bxe_adapter *sc);
 static void    bxe_link_report(struct bxe_adapter *sc);
 static void    bxe_link_status_update(struct bxe_adapter *sc);
-static void    bxe_periodic_callout_func(void *xsc);
+static void    bxe__alarm_handler(struct alarm_waiter *waiter,
+                                 struct hw_trapframe *hw_tf);
+
 static void    bxe_periodic_start(struct bxe_adapter *sc);
 static void    bxe_periodic_stop(struct bxe_adapter *sc);
 static int     bxe_alloc_rx_bd_mbuf(struct bxe_fastpath *fp,
@@ -703,9 +677,9 @@ static int     bxe_alloc_rx_sge_mbuf(struct bxe_fastpath *fp,
 static uint8_t bxe_txeof(struct bxe_adapter *sc,
                          struct bxe_fastpath *fp);
 static void    bxe_task_fp(struct bxe_fastpath *fp);
-static __noinline void bxe_dump_mbuf(struct bxe_adapter *sc,
-                                     struct mbuf      *m,
-                                     uint8_t          contents);
+//static __noinline void bxe_dump_mbuf(struct bxe_adapter *sc,
+//                                     struct mbuf      *m,
+//                                     uint8_t          contents);
 static int     bxe_alloc_mem(struct bxe_adapter *sc);
 static void    bxe_free_mem(struct bxe_adapter *sc);
 static int     bxe_alloc_fw_stats_mem(struct bxe_adapter *sc);
@@ -809,65 +783,6 @@ calc_crc32(uint8_t  *crc32_packet,
     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.
  *
@@ -883,6 +798,7 @@ bxe_cmpxchg(volatile int *addr,
 static void
 bxe_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 {
+#if 0
     struct bxe_dma *dma = arg;
 
     if (error) {
@@ -899,6 +815,7 @@ bxe_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error)
               dma->nseg, dma->size);
 #endif
     }
+#endif
 }
 
 /*
@@ -915,19 +832,22 @@ bxe_dma_alloc(struct bxe_adapter *sc,
               struct bxe_dma   *dma,
               const char       *msg)
 {
-    int rc;
-
     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);
 
+       /* 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 */
@@ -973,7 +893,7 @@ bxe_dma_alloc(struct bxe_adapter *sc,
         memset(dma, 0, sizeof(*dma));
         return (1);
     }
-
+#endif
     return (0);
 }
 
@@ -991,13 +911,15 @@ bxe_dma_free(struct bxe_adapter *sc,
 
         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);
+               #endif
     }
-
     memset(dma, 0, sizeof(*dma));
 }
 
@@ -1011,9 +933,9 @@ bxe_reg_wr_ind(struct bxe_adapter *sc,
                uint32_t         addr,
                uint32_t         val)
 {
-    pci_write_config(sc->dev, PCICFG_GRC_ADDRESS, addr, 4);
-    pci_write_config(sc->dev, PCICFG_GRC_DATA, val, 4);
-    pci_write_config(sc->dev, PCICFG_GRC_ADDRESS, 0, 4);
+    pcidev_write32(sc->pcidev, PCICFG_GRC_ADDRESS, addr);
+    pcidev_write32(sc->pcidev, PCICFG_GRC_DATA, val);
+    pcidev_write32(sc->pcidev, PCICFG_GRC_ADDRESS, 0);
 }
 
 uint32_t
@@ -1022,9 +944,9 @@ bxe_reg_rd_ind(struct bxe_adapter *sc,
 {
     uint32_t val;
 
-    pci_write_config(sc->dev, PCICFG_GRC_ADDRESS, addr, 4);
-    val = pci_read_config(sc->dev, PCICFG_GRC_DATA, 4);
-    pci_write_config(sc->dev, PCICFG_GRC_ADDRESS, 0, 4);
+    pcidev_write32(sc->pcidev, PCICFG_GRC_ADDRESS, addr);
+    val = pcidev_read32(sc->pcidev, PCICFG_GRC_DATA);
+    pcidev_write32(sc->pcidev, PCICFG_GRC_ADDRESS, 0);
 
     return (val);
 }
@@ -1130,7 +1052,7 @@ bxe_acquire_hw_lock(struct bxe_adapter *sc,
         if (lock_status & resource_bit) {
             return (0);
         }
-        DELAY(5000);
+        udelay(5000);
     }
 
     BLOGE(sc, "Resource lock timeout!\n");
@@ -1211,7 +1133,7 @@ bxe_acquire_nvram_lock(struct bxe_adapter *sc)
             break;
         }
 
-        DELAY(5);
+        udelay(5);
     }
 
     if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))) {
@@ -1245,7 +1167,7 @@ bxe_release_nvram_lock(struct bxe_adapter *sc)
             break;
         }
 
-        DELAY(5);
+        udelay(5);
     }
 
     if (val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port)) {
@@ -1316,7 +1238,7 @@ bxe_nvram_read_dword(struct bxe_adapter *sc,
     *ret_val = 0;
     rc = -1;
     for (i = 0; i < count; i++) {
-        DELAY(5);
+        udelay(5);
         val = REG_RD(sc, MCP_REG_MCPR_NVM_COMMAND);
 
         if (val & MCPR_NVM_COMMAND_DONE) {
@@ -1325,7 +1247,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
              */
-            *ret_val = htobe32(val);
+            *ret_val = cpu_to_be32(val);
             rc = 0;
             break;
         }
@@ -1429,7 +1351,7 @@ bxe_nvram_write_dword(struct bxe_adapter *sc,
     /* wait for completion */
     rc = -1;
     for (i = 0; i < count; i++) {
-        DELAY(5);
+        udelay(5);
         val = REG_RD(sc, MCP_REG_MCPR_NVM_COMMAND);
         if (val & MCPR_NVM_COMMAND_DONE) {
             rc = 0;
@@ -1484,7 +1406,7 @@ bxe_nvram_write1(struct bxe_adapter *sc,
         /* 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);
     }
@@ -1666,7 +1588,7 @@ bxe_issue_dmae_with_comp(struct bxe_adapter    *sc,
     bxe_post_dmae(sc, dmae, INIT_DMAE_C(sc));
 
     /* wait for completion */
-    DELAY(5);
+    udelay(5);
 
     while ((*wb_comp & ~DMAE_PCI_ERR_FLAG) != DMAE_COMP_VAL) {
         if (!timeout ||
@@ -1678,7 +1600,7 @@ bxe_issue_dmae_with_comp(struct bxe_adapter    *sc,
         }
 
         timeout--;
-        DELAY(50);
+        udelay(50);
     }
 
     if (*wb_comp & DMAE_PCI_ERR_FLAG) {
@@ -1869,7 +1791,7 @@ void
 elink_cb_udelay(struct bxe_adapter *sc,
                 uint32_t         usecs)
 {
-    DELAY(usecs);
+    udelay(usecs);
 }
 
 uint32_t
@@ -2227,7 +2149,7 @@ elink_cb_fw_command(struct bxe_adapter *sc,
 
     /* Let the FW do it's magic. GIve it up to 5 seconds... */
     do {
-        DELAY(delay * 1000);
+        udelay(delay * 1000);
         rc = SHMEM_RD(sc, func_mb[mb_idx].fw_mb_header);
     } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 500));
 
@@ -2415,8 +2337,8 @@ void bxe_sp_prod_update(struct bxe_adapter *sc)
     REG_WR16(sc, (BAR_XSTRORM_INTMEM + XSTORM_SPQ_PROD_OFFSET(func)),
              sc->spq_prod_idx);
 
-    bus_space_barrier(sc->bar[BAR0].tag, sc->bar[BAR0].handle, 0, 0,
-                      BUS_SPACE_BARRIER_WRITE);
+    //    bus_space_barrier(sc->bar[BAR0].tag, sc->bar[BAR0].handle, 0, 0,
+    //                      BUS_SPACE_BARRIER_WRITE);
 }
 
 /**
@@ -2473,13 +2395,13 @@ bxe_sp_post(struct bxe_adapter *sc,
     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 {
-        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);
@@ -2490,7 +2412,7 @@ bxe_sp_post(struct bxe_adapter *sc,
 
     /* 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;
 
@@ -2498,10 +2420,10 @@ bxe_sp_post(struct bxe_adapter *sc,
     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
@@ -2509,9 +2431,9 @@ bxe_sp_post(struct bxe_adapter *sc,
      * memory barrier is needed.
      */
     if (common) {
-        atomic_subtract_acq_long(&sc->eq_spq_left, 1);
+        atomic_add(&sc->eq_spq_left, -1);
     } 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);
@@ -2528,8 +2450,8 @@ bxe_sp_post(struct bxe_adapter *sc,
           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);
 
@@ -2577,9 +2499,12 @@ bxe_debug_print_ind_table(struct bxe_adapter               *sc,
  * Returns:
  *   BUS_PROBE_DEFAULT on success, positive value on failure.
  */
+#warning "no probe function"
+
 static int
 bxe_probe(device_t dev)
 {
+#if 0
     struct bxe_adapter *sc;
     struct bxe_device_type *t;
     char *descbuf;
@@ -2587,7 +2512,7 @@ bxe_probe(device_t dev)
 
     /* Find our device structure */
     sc = device_get_softc(dev);
-    sc->dev = dev;
+    sc->pcidev= dev;
     t = bxe_devs;
 
     /* Get the data for the device to be probed. */
@@ -2605,31 +2530,32 @@ 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))) {
-            descbuf = malloc(BXE_DEVDESC_MAX, M_TEMP, M_NOWAIT);
+            descbuf = kmalloc(BXE_DEVDESC_MAX, 0); /* M_TEMP */
             if (descbuf == NULL)
                 return (ENOMEM);
 
             /* Print out the device identity. */
             snprintf(descbuf, BXE_DEVDESC_MAX,
                      "%s (%c%d) BXE v:%s\n", t->bxe_name,
-                     (((pci_read_config(dev, PCIR_REVID, 4) &
+                     (((pcidev_read32(dev, PCIR_REVID) &
                         0xf0) >> 4) + 'A'),
-                     (pci_read_config(dev, PCIR_REVID, 4) & 0xf),
+                     (pcidev_read32(dev, PCIR_REVID) & 0xf),
                      BXE_DRIVER_VERSION);
 
             device_set_desc_copy(dev, descbuf);
-            free(descbuf, M_TEMP);
+            kfree(descbuf); /* M_TEMP */
             return (BUS_PROBE_DEFAULT);
         }
         t++;
     }
-
+#endif
     return (ENXIO);
 }
 
 static void
 bxe_init_mutexes(struct bxe_adapter *sc)
 {
+#if 0
 #ifdef BXE_CORE_LOCK_SX
     snprintf(sc->core_sx_name, sizeof(sc->core_sx_name),
              "bxe%d_core_lock", sc->unit);
@@ -2638,7 +2564,6 @@ bxe_init_mutexes(struct bxe_adapter *sc)
     snprintf(sc->core_mtx_name, sizeof(sc->core_mtx_name),
              "bxe%d_core_lock", sc->unit);
     mtx_init(&sc->core_mtx, sc->core_mtx_name, NULL, MTX_DEF);
-#endif
 
     snprintf(sc->sp_mtx_name, sizeof(sc->sp_mtx_name),
              "bxe%d_sp_lock", sc->unit);
@@ -2667,11 +2592,14 @@ bxe_init_mutexes(struct bxe_adapter *sc)
     snprintf(sc->mcast_mtx_name, sizeof(sc->mcast_mtx_name),
              "bxe%d_mcast_lock", sc->unit);
     mtx_init(&(sc->mcast_mtx), sc->mcast_mtx_name, NULL, MTX_DEF);
+#endif
+#endif
 }
 
 static void
 bxe_release_mutexes(struct bxe_adapter *sc)
 {
+#if 0
 #ifdef BXE_CORE_LOCK_SX
     sx_destroy(&sc->core_sx);
 #else
@@ -2707,6 +2635,7 @@ bxe_release_mutexes(struct bxe_adapter *sc)
     if (mtx_initialized(&sc->mcast_mtx)) {
         mtx_destroy(&sc->mcast_mtx);
     }
+#endif
 }
 
 static void
@@ -2756,7 +2685,7 @@ bxe_tx_queue_has_work(struct bxe_fastpath *fp)
     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);
 }
 
@@ -2773,7 +2702,7 @@ bxe_has_rx_work(struct bxe_fastpath *fp)
     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);
@@ -2784,6 +2713,7 @@ bxe_sp_event(struct bxe_adapter    *sc,
              struct bxe_fastpath *fp,
              union eth_rx_cqe    *rr_cqe)
 {
+#if 0
     int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
     int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
     enum ecore_queue_cmd drv_cmd = ECORE_Q_CMD_MAX;
@@ -2858,10 +2788,10 @@ bxe_sp_event(struct bxe_adapter    *sc,
     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",
-          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)) &&
@@ -2881,6 +2811,7 @@ bxe_sp_event(struct bxe_adapter    *sc,
         bxe_schedule_sp_task(sc);
     }
 #endif
+#endif
 }
 
 /*
@@ -2896,6 +2827,7 @@ bxe_tpa_start(struct bxe_adapter            *sc,
               uint16_t                    prod,
               struct eth_fast_path_rx_cqe *cqe)
 {
+#if 0
     struct bxe_sw_rx_bd tmp_bd;
     struct bxe_sw_rx_bd *rx_buf;
     struct eth_rx_bd *rx_bd;
@@ -2930,9 +2862,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;
-    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);
 
@@ -2970,10 +2902,11 @@ 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];
-    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
 /*
  * When a TPA aggregation is completed, loop through the individual mbufs
  * of the aggregation, combining them into a single mbuf which will be sent
@@ -2995,7 +2928,7 @@ bxe_fill_frag_mbuf(struct bxe_adapter          *sc,
     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",
@@ -3005,7 +2938,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",
-              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);
@@ -3016,13 +2949,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++) {
-        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).
          */
-        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",
@@ -3055,7 +2988,7 @@ bxe_fill_frag_mbuf(struct bxe_adapter          *sc,
 
     return (rc);
 }
-
+#endif
 static inline void
 bxe_clear_sge_mask_next_elems(struct bxe_fastpath *fp)
 {
@@ -3113,17 +3046,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,
-                            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,
-          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,
-                            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;
@@ -3136,7 +3069,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)) {
-        if (__predict_true(fp->sge_mask[i])) {
+        if (fp->sge_mask[i]) {
             break;
         }
 
@@ -3169,6 +3102,7 @@ bxe_tpa_stop(struct bxe_adapter          *sc,
                         struct eth_end_agg_rx_cqe *cqe,
              uint16_t                  cqe_idx)
 {
+#if 0
     if_t ifp = sc->ifp;
     struct mbuf *m;
     int rc = 0;
@@ -3176,7 +3110,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,
-          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;
 
@@ -3236,12 +3170,15 @@ bxe_tpa_stop_exit:
 
     fp->rx_tpa_info[queue].state = BXE_TPA_STATE_STOP;
     fp->rx_tpa_queue_used &= ~(1 << queue);
+#endif
 }
 
 static uint8_t
 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;
     uint16_t hw_cq_cons, sw_cq_cons, sw_cq_prod;
@@ -3251,7 +3188,7 @@ bxe_rxeof(struct bxe_adapter    *sc,
     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++;
     }
@@ -3302,9 +3239,9 @@ bxe_rxeof(struct bxe_adapter    *sc,
               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))) {
@@ -3344,7 +3281,7 @@ bxe_rxeof(struct bxe_adapter    *sc,
             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;
 
@@ -3366,7 +3303,7 @@ bxe_rxeof(struct bxe_adapter    *sc,
             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;
@@ -3464,7 +3401,7 @@ next_rx:
         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);
@@ -3496,6 +3433,7 @@ next_cqe:
     BXE_FP_RX_UNLOCK(fp);
 
     return (sw_cq_cons != hw_cq_cons);
+#endif
 }
 
 static uint16_t
@@ -3503,6 +3441,8 @@ bxe_free_tx_pkt(struct bxe_adapter    *sc,
                 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;
     uint16_t bd_idx = TX_BD(tx_buf->first_bd);
@@ -3513,8 +3453,8 @@ 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;
-    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)) {
         bxe_panic(sc, ("BAD nbd!\n"));
@@ -3522,7 +3462,7 @@ bxe_free_tx_pkt(struct bxe_adapter    *sc,
 #endif
 
     new_cons = (tx_buf->first_bd + nbd);
-
+    // this #if 0 was already here in fbsd
 #if 0
     struct eth_tx_bd *tx_data_bd;
 
@@ -3554,7 +3494,7 @@ bxe_free_tx_pkt(struct bxe_adapter    *sc,
 #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 {
@@ -3565,6 +3505,7 @@ bxe_free_tx_pkt(struct bxe_adapter    *sc,
     tx_buf->first_bd = 0;
 
     return (new_cons);
+#endif
 }
 
 /* transmit timeout watchdog */
@@ -3583,9 +3524,8 @@ bxe_watchdog(struct bxe_adapter    *sc,
 
     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);
-
     return (-1);
 }
 
@@ -3594,6 +3534,8 @@ static uint8_t
 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;
     uint16_t tx_bd_avail;
@@ -3601,7 +3543,7 @@ bxe_txeof(struct bxe_adapter    *sc,
     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) {
@@ -3642,11 +3584,13 @@ bxe_txeof(struct bxe_adapter    *sc,
         fp->watchdog_timer = 0;
         return (FALSE);
     }
+#endif
 }
 
 static void
 bxe_drain_tx_queues(struct bxe_adapter *sc)
 {
+#if 0
     struct bxe_fastpath *fp;
     int i, count;
 
@@ -3670,12 +3614,11 @@ bxe_drain_tx_queues(struct bxe_adapter *sc)
             }
 
             count--;
-            DELAY(1000);
+            udelay(1000);
             rmb();
         }
     }
-
-    return;
+#endif
 }
 
 static int
@@ -3684,6 +3627,7 @@ bxe_del_all_macs(struct bxe_adapter          *sc,
                  int                       mac_type,
                  uint8_t                   wait_for_comp)
 {
+#if 0
     unsigned long ramrod_flags = 0, vlan_mac_flags = 0;
     int rc;
 
@@ -3701,6 +3645,8 @@ bxe_del_all_macs(struct bxe_adapter          *sc,
     }
 
     return (rc);
+#endif
+    return -1;
 }
 
 static int
@@ -3709,6 +3655,7 @@ bxe_fill_accept_flags(struct bxe_adapter *sc,
                       unsigned long    *rx_accept_flags,
                       unsigned long    *tx_accept_flags)
 {
+#if 0
     /* Clear the flags first */
     *rx_accept_flags = 0;
     *tx_accept_flags = 0;
@@ -3778,7 +3725,7 @@ bxe_fill_accept_flags(struct bxe_adapter *sc,
         bxe_set_bit(ECORE_ACCEPT_ANY_VLAN, rx_accept_flags);
         bxe_set_bit(ECORE_ACCEPT_ANY_VLAN, tx_accept_flags);
     }
-
+#endif
     return (0);
 }
 
@@ -3790,6 +3737,7 @@ bxe_set_q_rx_mode(struct bxe_adapter *sc,
                   unsigned long    tx_accept_flags,
                   unsigned long    ramrod_flags)
 {
+#if 0
     struct ecore_rx_mode_ramrod_params ramrod_param;
     int rc;
 
@@ -3820,13 +3768,15 @@ bxe_set_q_rx_mode(struct bxe_adapter *sc,
         BLOGE(sc, "Set rx_mode %d failed\n", sc->rx_mode);
         return (rc);
     }
-
+#endif
     return (0);
 }
 
 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;
     int rc;
@@ -3844,12 +3794,15 @@ bxe_set_storm_rx_mode(struct bxe_adapter *sc)
     return (bxe_set_q_rx_mode(sc, sc->fp[0].cl_id, rx_mode_flags,
                               rx_accept_flags, tx_accept_flags,
                               ramrod_flags));
+#endif
 }
 
 /* returns the "mcp load_code" according to global load_count array */
 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);
 
@@ -3868,12 +3821,15 @@ bxe_nic_load_no_mcp(struct bxe_adapter *sc)
     } else {
         return (FW_MSG_CODE_DRV_LOAD_FUNCTION);
     }
+#endif
 }
 
 /* returns the "mcp load_code" according to global load_count array */
 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);
 
@@ -3892,6 +3848,7 @@ bxe_nic_unload_no_mcp(struct bxe_adapter *sc)
     } else {
         return (FW_MSG_CODE_DRV_UNLOAD_FUNCTION);
     }
+#endif
 }
 
 /* request unload mode from the MCP: COMMON, PORT or FUNCTION */
@@ -3899,22 +3856,20 @@ static uint32_t
 bxe_send_unload_req(struct bxe_adapter *sc,
                     int              unload_mode)
 {
-    uint32_t reset_code = 0;
 #if 0
+    uint32_t reset_code = 0;
     int port = SC_PORT(sc);
     int path = SC_PATH(sc);
-#endif
 
     /* Select the UNLOAD request mode */
     if (unload_mode == UNLOAD_NORMAL) {
         reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
     }
-#if 0
     else if (sc->flags & BXE_NO_WOL_FLAG) {
         reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP;
     } else if (sc->wol) {
         uint32_t emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
-        uint8_t *mac_addr = sc->dev->dev_addr;
+        uint8_t *mac_addr = sc->pcidev->dev_addr;
         uint32_t val;
         uint16_t pmc;
 
@@ -3932,19 +3887,15 @@ bxe_send_unload_req(struct bxe_adapter *sc,
         EMAC_WR(sc, EMAC_REG_EMAC_MAC_MATCH + entry + 4, val);
 
         /* Enable the PME and clear the status */
-        pmc = pci_read_config(sc->dev,
+        pmc = pcidev_read16(sc->pcidev,
                               (sc->devinfo.pcie_pm_cap_reg +
-                               PCIR_POWER_STATUS),
-                              2);
+                               PCIR_POWER_STATUS));
         pmc |= PCIM_PSTAT_PMEENABLE | PCIM_PSTAT_PME;
-        pci_write_config(sc->dev,
-                         (sc->devinfo.pcie_pm_cap_reg +
-                          PCIR_POWER_STATUS),
-                         pmc, 4);
+        pcidev_write32(sc->pcidev,
+                      (sc->devinfo.pcie_pm_cap_reg + PCIR_POWER_STATUS), pmc);
 
         reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_EN;
     }
-#endif
     else {
         reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
     }
@@ -3957,6 +3908,8 @@ bxe_send_unload_req(struct bxe_adapter *sc,
     }
 
     return (reset_code);
+#endif
+    return 0;
 }
 
 /* send UNLOAD_DONE command to the MCP */
@@ -3976,6 +3929,7 @@ bxe_send_unload_done(struct bxe_adapter *sc,
 static int
 bxe_func_wait_started(struct bxe_adapter *sc)
 {
+#if 0
     int tout = 50;
 
     if (!sc->port.pmf) {
@@ -4003,7 +3957,7 @@ bxe_func_wait_started(struct bxe_adapter *sc)
 
     while (ecore_func_get_state(sc, &sc->func_obj) !=
            ECORE_F_STATE_STARTED && tout--) {
-        DELAY(20000);
+        udelay(20000);
     }
 
     if (ecore_func_get_state(sc, &sc->func_obj) != ECORE_F_STATE_STARTED) {
@@ -4027,7 +3981,7 @@ bxe_func_wait_started(struct bxe_adapter *sc)
         func_params.cmd = ECORE_F_CMD_TX_START;
         return (ecore_func_state_change(sc, &func_params));
     }
-
+#endif
     return (0);
 }
 
@@ -4035,6 +3989,7 @@ static int
 bxe_stop_queue(struct bxe_adapter *sc,
                int              index)
 {
+#if 0
     struct bxe_fastpath *fp = &sc->fp[index];
     struct ecore_queue_state_params q_params = { NULL };
     int rc;
@@ -4068,6 +4023,8 @@ bxe_stop_queue(struct bxe_adapter *sc,
     memset(&q_params.params.cfc_del, 0, sizeof(q_params.params.cfc_del));
     q_params.params.cfc_del.cid_index = FIRST_TX_COS_INDEX;
     return (ecore_queue_state_change(sc, &q_params));
+#endif
+    return -1;
 }
 
 /* wait for the outstanding SP commands */
@@ -4080,16 +4037,16 @@ bxe_wait_sp_comp(struct bxe_adapter *sc,
 
     while (tout--) {
         mb();
-        if (!(atomic_load_acq_long(&sc->sp_state) & mask)) {
+        if (!(ACCESS_ONCE(sc->sp_state) & mask)) {
             return (TRUE);
         }
 
-        DELAY(1000);
+        udelay(1000);
     }
 
     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",
@@ -4103,6 +4060,7 @@ bxe_wait_sp_comp(struct bxe_adapter *sc,
 static int
 bxe_func_stop(struct bxe_adapter *sc)
 {
+#if 0
     struct ecore_func_state_params func_params = { NULL };
     int rc;
 
@@ -4124,7 +4082,7 @@ bxe_func_stop(struct bxe_adapter *sc)
         bxe_set_bit(RAMROD_DRV_CLR_ONLY, &func_params.ramrod_flags);
         return (ecore_func_state_change(sc, &func_params));
     }
-
+#endif
     return (0);
 }
 
@@ -4132,6 +4090,7 @@ static int
 bxe_reset_hw(struct bxe_adapter *sc,
              uint32_t         load_code)
 {
+#if 0
     struct ecore_func_state_params func_params = { NULL };
 
     /* Prepare parameters for function state transitions */
@@ -4143,6 +4102,8 @@ bxe_reset_hw(struct bxe_adapter *sc,
     func_params.params.hw_init.load_phase = load_code;
 
     return (ecore_func_state_change(sc, &func_params));
+#endif
+    return 0;
 }
 
 static void
@@ -4166,6 +4127,7 @@ bxe_chip_cleanup(struct bxe_adapter *sc,
                  uint32_t         unload_mode,
                  uint8_t          keep_link)
 {
+#if 0
     int port = SC_PORT(sc);
     struct ecore_mcast_ramrod_params rparam = { NULL };
     uint32_t reset_code;
@@ -4174,7 +4136,7 @@ bxe_chip_cleanup(struct bxe_adapter *sc,
     bxe_drain_tx_queues(sc);
 
     /* give HW time to discard old tx messages */
-    DELAY(1000);
+    udelay(1000);
 
     /* Clean all ETH MACs */
     rc = bxe_del_all_macs(sc, &sc->sp_objs[0].mac_obj, ECORE_ETH_MAC, FALSE);
@@ -4273,11 +4235,13 @@ unload_error:
 
     /* Report UNLOAD_DONE to MCP */
     bxe_send_unload_done(sc, keep_link);
+#endif
 }
 
 static void
 bxe_disable_close_the_gate(struct bxe_adapter *sc)
 {
+#if 0
     uint32_t val;
     int port = SC_PORT(sc);
 
@@ -4296,6 +4260,7 @@ bxe_disable_close_the_gate(struct bxe_adapter *sc)
                  MISC_AEU_GENERAL_MASK_REG_AEU_NIG_CLOSE_MASK);
         REG_WR(sc, MISC_REG_AEU_GENERAL_MASK, val);
     }
+#endif
 }
 
 /*
@@ -4305,6 +4270,7 @@ bxe_disable_close_the_gate(struct bxe_adapter *sc)
 static void
 bxe_squeeze_objects(struct bxe_adapter *sc)
 {
+#if 0
     unsigned long ramrod_flags = 0, vlan_mac_flags = 0;
     struct ecore_mcast_ramrod_params rparam = { NULL };
     struct ecore_vlan_mac_obj *mac_obj = &sc->sp_objs->mac_obj;
@@ -4356,6 +4322,7 @@ bxe_squeeze_objects(struct bxe_adapter *sc)
 
         rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_CONT);
     }
+#endif
 }
 
 /* stop the controller */
@@ -4364,6 +4331,7 @@ bxe_nic_unload(struct bxe_adapter *sc,
                uint32_t         unload_mode,
                uint8_t          keep_link)
 {
+#if 0
     uint8_t global = FALSE;
     uint32_t val;
 
@@ -4508,7 +4476,7 @@ bxe_nic_unload(struct bxe_adapter *sc,
     }
 
     BLOGD(sc, DBG_LOAD, "Ended NIC unload\n");
-
+#endif
     return (0);
 }
 
@@ -4519,6 +4487,7 @@ bxe_nic_unload(struct bxe_adapter *sc,
 static int
 bxe_ifmedia_update(struct ifnet  *ifp)
 {
+#if 0
     struct bxe_adapter *sc = (struct bxe_adapter *)if_getsoftc(ifp);
     struct ifmedia *ifm;
 
@@ -4542,7 +4511,7 @@ bxe_ifmedia_update(struct ifnet  *ifp)
               IFM_SUBTYPE(ifm->ifm_media));
         return (EINVAL);
     }
-
+#endif
     return (0);
 }
 
@@ -4552,6 +4521,7 @@ bxe_ifmedia_update(struct ifnet  *ifp)
 static void
 bxe_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr)
 {
+#if 0
     struct bxe_adapter *sc = if_getsoftc(ifp);
 
     /* Report link down if the driver isn't running. */
@@ -4578,6 +4548,7 @@ bxe_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr)
     } else {
         ifmr->ifm_active |= IFM_HDX;
     }
+#endif
 }
 
 static int
@@ -4585,6 +4556,7 @@ bxe_ioctl_nvram(struct bxe_adapter *sc,
                 uint32_t         priv_op,
                 struct ifreq     *ifr)
 {
+#if 0
     struct bxe_nvram_data nvdata_base;
     struct bxe_nvram_data *nvdata;
     int len;
@@ -4598,8 +4570,7 @@ bxe_ioctl_nvram(struct bxe_adapter *sc,
 
     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);
         }
@@ -4627,10 +4598,12 @@ bxe_ioctl_nvram(struct bxe_adapter *sc,
     }
 
     if (len > sizeof(struct bxe_nvram_data)) {
-        free(nvdata, M_DEVBUF);
+        kfree(nvdata); /* M_DEVBUF */
     }
 
     return (error);
+#endif
+    return -1;
 }
 
 static int
@@ -4638,6 +4611,8 @@ bxe_ioctl_stats_show(struct bxe_adapter *sc,
                      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));
     caddr_t p_tmp;
@@ -4686,14 +4661,16 @@ bxe_ioctl_stats_show(struct bxe_adapter *sc,
     default:
         return (-1);
     }
+#endif
 }
 
 static void
 bxe_handle_chip_tq(void *context,
                    int  pending)
 {
+#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)
     {
@@ -4735,6 +4712,7 @@ bxe_handle_chip_tq(void *context,
     default:
         break;
     }
+#endif
 }
 
 /*
@@ -4745,9 +4723,10 @@ bxe_handle_chip_tq(void *context,
  */
 static int
 bxe_ioctl(if_t ifp,
-          u_long       command,
-          caddr_t      data)
+          unsigned long       command,
+          void *      data)
 {
+#if 0
     struct bxe_adapter *sc = if_getsoftc(ifp);
     struct ifreq *ifr = (struct ifreq *)data;
     struct bxe_nvram_data *nvdata;
@@ -4777,10 +4756,10 @@ bxe_ioctl(if_t ifp,
             break;
         }
 
-        atomic_store_rel_int((volatile unsigned int *)&sc->mtu,
+        atomic_set(volatile unsigned int *)&sc->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
        */
@@ -4798,12 +4777,12 @@ bxe_ioctl(if_t ifp,
                 /* 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) {
-                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);
             }
         }
@@ -4977,11 +4956,13 @@ 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");
-        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);
     }
 
     return (error);
+#endif
+    return -1;
 }
 
 static __noinline void
@@ -4989,6 +4970,7 @@ bxe_dump_mbuf(struct bxe_adapter *sc,
               struct mbuf      *m,
               uint8_t          contents)
 {
+#if 0
     char * type;
     int i = 0;
 
@@ -5041,8 +5023,9 @@ bxe_dump_mbuf(struct bxe_adapter *sc,
         m = m->m_next;
         i++;
     }
+#endif
 }
-
+#if 0
 /*
  * Checks to ensure the 13 bd sliding window is >= MSS for TSO.
  * Check that (13 total bds - 3 bds) = 10 bd window >= MSS.
@@ -5065,7 +5048,7 @@ bxe_chktso_window(struct bxe_adapter  *sc,
     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
@@ -5073,7 +5056,7 @@ bxe_chktso_window(struct bxe_adapter  *sc,
      * 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 */
@@ -5084,9 +5067,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) */
-        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 */
-        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);
         }
@@ -5236,9 +5219,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 =
-            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 {
-        pbd->global_data = htole16(hlen);
+        pbd->global_data = cpu_to_le16(hlen);
     }
 
     pbd->ip_hlen_w = ip_hlen;
@@ -5262,7 +5245,7 @@ bxe_set_pbd_csum(struct bxe_fastpath        *fp,
         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 |
@@ -5340,7 +5323,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));
 
-    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);
 
@@ -5360,7 +5343,7 @@ bxe_set_pbd_lso(struct mbuf                *m,
 #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);
 }
 
 /*
@@ -5552,9 +5535,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);
 
-    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;
 
@@ -5562,10 +5545,10 @@ bxe_tx_encap_continue:
 
     /* 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) {
-        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 {
@@ -5576,7 +5559,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 = 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
@@ -5660,7 +5643,7 @@ bxe_tx_encap_continue:
 
         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 */
@@ -5673,25 +5656,25 @@ bxe_tx_encap_continue:
 
             /* 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;
-            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",
-                  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);
         }
 
@@ -5703,16 +5686,16 @@ bxe_tx_encap_continue:
     }
 
     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;
-        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;
         }
@@ -5735,8 +5718,8 @@ bxe_tx_encap_continue:
                       "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) {
@@ -5754,7 +5737,7 @@ bxe_tx_encap_continue:
                           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 "
@@ -5777,9 +5760,9 @@ bxe_tx_encap_continue:
                       "-> 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);
@@ -5822,12 +5805,14 @@ bxe_tx_encap_continue:
 
     return (0);
 }
+#endif
 
 static void
 bxe_tx_start_locked(struct bxe_adapter *sc,
                     if_t ifp,
                     struct bxe_fastpath *fp)
 {
+#if 0
     struct mbuf *m = NULL;
     int tx_count = 0;
     uint16_t tx_bd_avail;
@@ -5891,12 +5876,14 @@ bxe_tx_start_locked(struct bxe_adapter *sc,
         /* reset the TX watchdog timeout timer */
         fp->watchdog_timer = BXE_TX_TIMEOUT;
     }
+#endif
 }
 
 /* Legacy (non-RSS) dispatch routine */
 static void
 bxe_tx_start(if_t ifp)
 {
+#if 0
     struct bxe_adapter *sc;
     struct bxe_fastpath *fp;
 
@@ -5922,8 +5909,10 @@ bxe_tx_start(if_t ifp)
     BXE_FP_TX_LOCK(fp);
     bxe_tx_start_locked(sc, ifp, fp);
     BXE_FP_TX_UNLOCK(fp);
+#endif
 }
 
+#if 0
 #if __FreeBSD_version >= 800000
 
 static int
@@ -6098,7 +6087,7 @@ bxe_mq_flush(struct ifnet *ifp)
 }
 
 #endif /* FreeBSD_version >= 800000 */
-
+#endif
 static uint16_t
 bxe_cid_ilt_lines(struct bxe_adapter *sc)
 {
@@ -6138,7 +6127,7 @@ bxe_ilt_set_info(struct bxe_adapter *sc)
           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)) {
@@ -6159,7 +6148,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,
-              ilog2(ilt_client->page_size >> 12));
+              LOG2_UP(ilt_client->page_size >> 12));
     }
 
     if (CNIC_SUPPORT(sc)) {
@@ -6177,7 +6166,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,
-              ilog2(ilt_client->page_size >> 12));
+              LOG2_UP(ilt_client->page_size >> 12));
 
         /* TM */
         ilt_client = &ilt->clients[ILT_CLIENT_TM];
@@ -6193,15 +6182,16 @@ 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,
-              ilog2(ilt_client->page_size >> 12));
+              LOG2_UP(ilt_client->page_size >> 12));
     }
 
-    KASSERT((line <= ILT_MAX_LINES), ("Invalid number of ILT lines!"));
+    //assert((line <= ILT_MAX_LINES), ("Invalid number of ILT lines!"));
 }
 
 static void
 bxe_set_fp_rx_buf_size(struct bxe_adapter *sc)
 {
+#if 0
     int i;
 
     BLOGD(sc, DBG_LOAD, "mtu = %d\n", sc->mtu);
@@ -6228,20 +6218,18 @@ bxe_set_fp_rx_buf_size(struct bxe_adapter *sc)
         BLOGD(sc, DBG_LOAD, "mbuf_alloc_size for fp[%02d] = %d\n",
               i, sc->fp[i].mbuf_alloc_size);
     }
+#endif
 }
 
 static int
 bxe_alloc_ilt_mem(struct bxe_adapter *sc)
 {
     int rc = 0;
-
     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;
     }
-
     return (rc);
 }
 
@@ -6249,14 +6237,11 @@ static int
 bxe_alloc_ilt_lines_mem(struct bxe_adapter *sc)
 {
     int rc = 0;
-
     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;
     }
-
     return (rc);
 }
 
@@ -6264,7 +6249,7 @@ static void
 bxe_free_ilt_mem(struct bxe_adapter *sc)
 {
     if (sc->ilt != NULL) {
-        free(sc->ilt, M_BXE_ILT);
+      kfree(sc->ilt);
         sc->ilt = NULL;
     }
 }
@@ -6273,7 +6258,7 @@ static void
 bxe_free_ilt_lines_mem(struct bxe_adapter *sc)
 {
     if (sc->ilt->lines != NULL) {
-        free(sc->ilt->lines, M_BXE_ILT);
+      kfree(sc->ilt->lines);
         sc->ilt->lines = NULL;
     }
 }
@@ -6283,12 +6268,10 @@ bxe_free_mem(struct bxe_adapter *sc)
 {
     int i;
 
-#if 0
     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++) {
         bxe_dma_free(sc, &sc->context[i].vcxt_dma);
@@ -6312,15 +6295,13 @@ bxe_alloc_mem(struct bxe_adapter *sc)
     int allocated;
     int i;
 
-#if 0
     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);
         }
     }
-#endif
 
     /*
      * Allocate memory for CDU context:
@@ -6338,7 +6319,8 @@ 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++) {
-        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,
@@ -6352,6 +6334,7 @@ bxe_alloc_mem(struct bxe_adapter *sc)
             (union cdu_context *)sc->context[i].vcxt_dma.vaddr;
 
         allocated += sc->context[i].size;
+      */
     }
 
     bxe_alloc_ilt_lines_mem(sc);
@@ -6398,7 +6381,7 @@ bxe_free_rx_bd_chain(struct bxe_fastpath *fp)
     if (fp->rx_mbuf_tag == NULL) {
         return;
     }
-
+#if 0
     /* free all mbufs and unload all maps */
     for (i = 0; i < RX_BD_TOTAL; i++) {
         if (fp->rx_mbuf_chain[i].m_map != NULL) {
@@ -6415,6 +6398,7 @@ bxe_free_rx_bd_chain(struct bxe_fastpath *fp)
             fp->eth_q_stats.mbuf_alloc_rx--;
         }
     }
+#endif
 }
 
 static void
@@ -6430,7 +6414,7 @@ bxe_free_tpa_pool(struct bxe_fastpath *fp)
     }
 
     max_agg_queues = MAX_AGG_QS(sc);
-
+#if 0
     /* release all mbufs and unload all DMA maps in the TPA pool */
     for (i = 0; i < max_agg_queues; i++) {
         if (fp->rx_tpa_info[i].bd.m_map != NULL) {
@@ -6447,6 +6431,7 @@ bxe_free_tpa_pool(struct bxe_fastpath *fp)
             fp->eth_q_stats.mbuf_alloc_tpa--;
         }
     }
+#endif
 }
 
 static void
@@ -6460,7 +6445,7 @@ bxe_free_sge_chain(struct bxe_fastpath *fp)
     if (fp->rx_sge_mbuf_tag == NULL) {
         return;
     }
-
+#if 0
     /* rree all mbufs and unload all maps */
     for (i = 0; i < RX_SGE_TOTAL; i++) {
         if (fp->rx_sge_mbuf_chain[i].m_map != NULL) {
@@ -6477,11 +6462,13 @@ bxe_free_sge_chain(struct bxe_fastpath *fp)
             fp->eth_q_stats.mbuf_alloc_sge--;
         }
     }
+#endif
 }
 
 static void
 bxe_free_fp_buffers(struct bxe_adapter *sc)
 {
+#if 0
     struct bxe_fastpath *fp;
     int i;
 
@@ -6535,6 +6522,7 @@ bxe_free_fp_buffers(struct bxe_adapter *sc)
             mtx_destroy(&fp->rx_mtx);
         }
     }
+#endif
 }
 
 static int
@@ -6542,6 +6530,7 @@ bxe_alloc_rx_bd_mbuf(struct bxe_fastpath *fp,
                      uint16_t            prev_index,
                      uint16_t            index)
 {
+#if 0
     struct bxe_sw_rx_bd *rx_buf;
     struct eth_rx_bd *rx_bd;
     bus_dma_segment_t segs[1];
@@ -6615,16 +6604,19 @@ bxe_alloc_rx_bd_mbuf(struct bxe_fastpath *fp,
     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 -1;
 }
 
 static int
 bxe_alloc_rx_tpa_mbuf(struct bxe_fastpath *fp,
                       int                 queue)
 {
+#if 0
     struct bxe_sw_tpa_info *tpa_info = &fp->rx_tpa_info[queue];
     bus_dma_segment_t segs[1];
     bus_dmamap_t map;
@@ -6675,6 +6667,8 @@ bxe_alloc_rx_tpa_mbuf(struct bxe_fastpath *fp,
     tpa_info->seg = segs[0];
 
     return (rc);
+#endif
+    return 1;
 }
 
 /*
@@ -6686,6 +6680,7 @@ static int
 bxe_alloc_rx_sge_mbuf(struct bxe_fastpath *fp,
                       uint16_t            index)
 {
+#if 0
     struct bxe_sw_rx_bd *sge_buf;
     struct eth_rx_sge *sge;
     bus_dma_segment_t segs[1];
@@ -6738,15 +6733,18 @@ bxe_alloc_rx_sge_mbuf(struct bxe_fastpath *fp,
     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 -1;
 }
 
 static __noinline int
 bxe_alloc_fp_buffers(struct bxe_adapter *sc)
 {
+#if 0
     struct bxe_fastpath *fp;
     int i, j, rc = 0;
     int ring_prod, cqe_ring_prod;
@@ -6834,6 +6832,8 @@ bxe_alloc_fp_buffers_error:
     bxe_free_sge_chain(fp);
 
     return (ENOBUFS);
+#endif
+    return -1;
 }
 
 static void
@@ -6844,17 +6844,18 @@ bxe_free_fw_stats_mem(struct bxe_adapter *sc)
     sc->fw_stats_num = 0;
 
     sc->fw_stats_req_size = 0;
-    sc->fw_stats_req = NULL;
+    //    sc->fw_stats_req = NULL;
     sc->fw_stats_req_mapping = 0;
 
     sc->fw_stats_data_size = 0;
-    sc->fw_stats_data = NULL;
+    //sc->fw_stats_data = NULL;
     sc->fw_stats_data_mapping = 0;
 }
 
 static int
 bxe_alloc_fw_stats_mem(struct bxe_adapter *sc)
 {
+#if 0
     uint8_t num_queue_stats;
     int num_groups;
 
@@ -6922,7 +6923,7 @@ bxe_alloc_fw_stats_mem(struct bxe_adapter *sc)
 
     BLOGD(sc, DBG_LOAD, "statistics data base address set to %#jx\n",
           (uintmax_t)sc->fw_stats_data_mapping);
-
+#endif
     return (0);
 }
 
@@ -7117,7 +7118,7 @@ bxe_clear_pf_load(struct bxe_adapter *sc)
 /* send load requrest to mcp and analyze response */
 static int
 bxe_nic_load_request(struct bxe_adapter *sc,
-                     uint32_t         *load_code)
+                    int         *load_code)
 {
     /* init fw_seq */
     sc->fw_seq =
@@ -7228,6 +7229,7 @@ bxe_nic_load_pmf(struct bxe_adapter *sc,
 static void
 bxe_read_mf_cfg(struct bxe_adapter *sc)
 {
+#if 0
     int n = (CHIP_IS_MODE_4_PORT(sc) ? 2 : 1);
     int abs_func;
     int vn;
@@ -7260,6 +7262,7 @@ bxe_read_mf_cfg(struct bxe_adapter *sc)
         BLOGD(sc, DBG_LOAD, "mf_cfg function enabled\n");
         sc->flags &= ~BXE_MF_FUNC_DIS;
     }
+#endif
 }
 
 /* acquire split MCP access lock register */
@@ -7274,7 +7277,7 @@ static int bxe_acquire_alr(struct bxe_adapter *sc)
         if (val & (1L << 31))
             break;
 
-        DELAY(5000);
+        udelay(5000);
     }
 
     if (!(val & (1L << 31))) {
@@ -7986,6 +7989,7 @@ bxe_handle_eee_event(struct bxe_adapter *sc)
 static void
 bxe_drv_info_ether_stat(struct bxe_adapter *sc)
 {
+#if 0
     struct eth_stats_info *ether_stat =
         &sc->sp->drv_info_to_mcp.ether_stat;
 
@@ -8011,6 +8015,7 @@ bxe_drv_info_ether_stat(struct bxe_adapter *sc)
 
     ether_stat->txq_size = sc->tx_ring_size;
     ether_stat->rxq_size = sc->rx_ring_size;
+#endif
 }
 
 static void
@@ -8594,8 +8599,8 @@ static void
 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 */
@@ -8689,9 +8694,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 */
-    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;
@@ -8765,7 +8770,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;
 
-    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.
@@ -8785,7 +8790,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",
-          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;
@@ -8944,7 +8949,7 @@ next_spqe:
     } /* 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;
@@ -8983,7 +8988,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,
-                   le16toh(sc->def_idx), IGU_INT_NOP, 1);
+                   le16_to_cpu(sc->def_idx), IGU_INT_NOP, 1);
         status &= ~BXE_DEF_SB_IDX;
     }
 
@@ -8994,7 +8999,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,
-               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
@@ -9059,7 +9064,7 @@ bxe_handle_fp_tq(void *context,
     }
 
     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
@@ -9100,7 +9105,7 @@ bxe_task_fp(struct bxe_fastpath *fp)
      * 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);
 }
 
 /*
@@ -9208,7 +9213,7 @@ bxe_intr_fp(void *xfp)
 
     BLOGD(sc, DBG_INTR,
           "(cpu=%d) MSI-X fp=%d fw_sb=%d igu_sb=%d\n",
-          curcpu, fp->index, fp->fw_sb_id, fp->igu_sb_id);
+          hw_core_id(), fp->index, fp->fw_sb_id, fp->igu_sb_id);
 
 #if 0
     /* Don't handle any interrupts if we're not ready. */
@@ -9227,13 +9232,14 @@ bxe_intr_fp(void *xfp)
 static void
 bxe_interrupt_free(struct bxe_adapter *sc)
 {
+#if 0
     int i;
 
     switch (sc->interrupt_mode) {
     case INTR_MODE_INTX:
         BLOGD(sc, DBG_LOAD, "Releasing legacy INTx vector\n");
         if (sc->intr[0].resource != NULL) {
-            bus_release_resource(sc->dev,
+            bus_release_resource(sc->pcidev,
                                  SYS_RES_IRQ,
                                  sc->intr[0].rid,
                                  sc->intr[0].resource);
@@ -9243,30 +9249,31 @@ bxe_interrupt_free(struct bxe_adapter *sc)
         for (i = 0; i < sc->intr_count; i++) {
             BLOGD(sc, DBG_LOAD, "Releasing MSI vector %d\n", i);
             if (sc->intr[i].resource && sc->intr[i].rid) {
-                bus_release_resource(sc->dev,
+                bus_release_resource(sc->pcidev,
                                      SYS_RES_IRQ,
                                      sc->intr[i].rid,
                                      sc->intr[i].resource);
             }
         }
-        pci_release_msi(sc->dev);
+        pci_release_msi(sc->pcidev);
         break;
     case INTR_MODE_MSIX:
         for (i = 0; i < sc->intr_count; i++) {
             BLOGD(sc, DBG_LOAD, "Releasing MSI-X vector %d\n", i);
             if (sc->intr[i].resource && sc->intr[i].rid) {
-                bus_release_resource(sc->dev,
+                bus_release_resource(sc->pcidev,
                                      SYS_RES_IRQ,
                                      sc->intr[i].rid,
                                      sc->intr[i].resource);
             }
         }
-        pci_release_msi(sc->dev);
+        pci_release_msi(sc->pcidev);
         break;
     default:
         /* nothing to do as initial allocation failed */
         break;
     }
+#endif
 }
 
 /*
@@ -9289,6 +9296,7 @@ bxe_interrupt_free(struct bxe_adapter *sc)
 static int
 bxe_interrupt_alloc(struct bxe_adapter *sc)
 {
+#if 0
     int msix_count = 0;
     int msi_count = 0;
     int num_requested = 0;
@@ -9299,11 +9307,11 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
     /* get the number of available MSI/MSI-X interrupts from the OS */
     if (sc->interrupt_mode > 0) {
         if (sc->devinfo.pcie_cap_flags & BXE_MSIX_CAPABLE_FLAG) {
-            msix_count = pci_msix_count(sc->dev);
+            msix_count = pci_msix_count(sc->pcidev);
         }
 
         if (sc->devinfo.pcie_cap_flags & BXE_MSI_CAPABLE_FLAG) {
-            msi_count = pci_msi_count(sc->dev);
+            msi_count = pci_msi_count(sc->pcidev);
         }
 
         BLOGD(sc, DBG_LOAD, "%d MSI and %d MSI-X vectors available\n",
@@ -9322,12 +9330,12 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
         }
 
         /* 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);
 
         num_allocated = num_requested;
-        if ((rc = pci_alloc_msix(sc->dev, &num_allocated)) != 0) {
+        if ((rc = pci_alloc_msix(sc->pcidev, &num_allocated)) != 0) {
             BLOGE(sc, "MSI-X alloc failed! (%d)\n", rc);
             sc->interrupt_mode = INTR_MODE_MSI; /* try MSI next */
             break;
@@ -9336,7 +9344,7 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
         if (num_allocated < 2) { /* possible? */
             BLOGE(sc, "MSI-X allocation less than 2!\n");
             sc->interrupt_mode = INTR_MODE_MSI; /* try MSI next */
-            pci_release_msi(sc->dev);
+            pci_release_msi(sc->pcidev);
             break;
         }
 
@@ -9354,7 +9362,7 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
             sc->intr[i].rid = (rid + i);
 
             if ((sc->intr[i].resource =
-                 bus_alloc_resource_any(sc->dev,
+                 bus_alloc_resource_any(sc->pcidev,
                                         SYS_RES_IRQ,
                                         &sc->intr[i].rid,
                                         RF_ACTIVE)) == NULL) {
@@ -9362,7 +9370,7 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
                       i, (rid + i));
 
                 for (j = (i - 1); j >= 0; j--) {
-                    bus_release_resource(sc->dev,
+                    bus_release_resource(sc->pcidev,
                                          SYS_RES_IRQ,
                                          sc->intr[j].rid,
                                          sc->intr[j].resource);
@@ -9371,7 +9379,7 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
                 sc->intr_count = 0;
                 sc->num_queues = 0;
                 sc->interrupt_mode = INTR_MODE_MSI; /* try MSI next */
-                pci_release_msi(sc->dev);
+                pci_release_msi(sc->pcidev);
                 break;
             }
 
@@ -9396,7 +9404,7 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
         BLOGD(sc, DBG_LOAD, "Requesting %d MSI vectors\n", num_requested);
 
         num_allocated = num_requested;
-        if ((rc = pci_alloc_msi(sc->dev, &num_allocated)) != 0) {
+        if ((rc = pci_alloc_msi(sc->pcidev, &num_allocated)) != 0) {
             BLOGE(sc, "MSI alloc failed (%d)!\n", rc);
             sc->interrupt_mode = INTR_MODE_INTX; /* try INTx next */
             break;
@@ -9405,7 +9413,7 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
         if (num_allocated != 1) { /* possible? */
             BLOGE(sc, "MSI allocation is not 1!\n");
             sc->interrupt_mode = INTR_MODE_INTX; /* try INTx next */
-            pci_release_msi(sc->dev);
+            pci_release_msi(sc->pcidev);
             break;
         }
 
@@ -9421,7 +9429,7 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
         sc->intr[0].rid = rid;
 
         if ((sc->intr[0].resource =
-             bus_alloc_resource_any(sc->dev,
+             bus_alloc_resource_any(sc->pcidev,
                                     SYS_RES_IRQ,
                                     &sc->intr[0].rid,
                                     RF_ACTIVE)) == NULL) {
@@ -9429,7 +9437,7 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
             sc->intr_count = 0;
             sc->num_queues = 0;
             sc->interrupt_mode = INTR_MODE_INTX; /* try INTx next */
-            pci_release_msi(sc->dev);
+            pci_release_msi(sc->pcidev);
             break;
         }
 
@@ -9452,7 +9460,7 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
         sc->intr[0].rid = rid;
 
         if ((sc->intr[0].resource =
-             bus_alloc_resource_any(sc->dev,
+             bus_alloc_resource_any(sc->pcidev,
                                     SYS_RES_IRQ,
                                     &sc->intr[0].rid,
                                     (RF_ACTIVE | RF_SHAREABLE))) == NULL) {
@@ -9477,6 +9485,8 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
     }
 
     return (rc);
+#endif
+    return -1;
 }
 
 static void
@@ -9489,7 +9499,7 @@ bxe_interrupt_detach(struct bxe_adapter *sc)
     for (i = 0; i < sc->intr_count; i++) {
         if (sc->intr[i].resource && sc->intr[i].tag) {
             BLOGD(sc, DBG_LOAD, "Disabling interrupt vector %d\n", i);
-            bus_teardown_intr(sc->dev, sc->intr[i].resource, sc->intr[i].tag);
+            bus_teardown_intr(sc->pcidev, sc->intr[i].resource, sc->intr[i].tag);
         }
     }
 
@@ -9569,18 +9579,18 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
          * Setup the interrupt handler. Note that we pass the driver instance
          * to the interrupt handler for the slowpath.
          */
-        if ((rc = bus_setup_intr(sc->dev, sc->intr[0].resource,
-                                 (INTR_TYPE_NET | INTR_MPSAFE),
+        if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
+                                 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);
             goto bxe_interrupt_attach_exit;
         }
 
-        bus_describe_intr(sc->dev, sc->intr[0].resource,
+        bus_describe_intr(sc->pcidev, sc->intr[0].resource,
                           sc->intr[0].tag, "sp");
 
-        /* bus_bind_intr(sc->dev, sc->intr[0].resource, 0); */
+        /* bus_bind_intr(sc->pcidev, sc->intr[0].resource, 0); */
 
         /* initialize the fastpath vectors (note the first was used for sp) */
         for (i = 0; i < sc->num_queues; i++) {
@@ -9592,8 +9602,8 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
              * fastpath context to the interrupt handler in this
              * case.
              */
-            if ((rc = bus_setup_intr(sc->dev, sc->intr[i + 1].resource,
-                                     (INTR_TYPE_NET | INTR_MPSAFE),
+            if ((rc = bus_setup_intr(sc->pcidev, sc->intr[i + 1].resource,
+                                     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",
@@ -9601,12 +9611,12 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
                 goto bxe_interrupt_attach_exit;
             }
 
-            bus_describe_intr(sc->dev, sc->intr[i + 1].resource,
+            bus_describe_intr(sc->pcidev, sc->intr[i + 1].resource,
                               sc->intr[i + 1].tag, "fp%02d", i);
 
             /* bind the fastpath instance to a cpu */
             if (sc->num_queues > 1) {
-                bus_bind_intr(sc->dev, sc->intr[i + 1].resource, i);
+                bus_bind_intr(sc->pcidev, sc->intr[i + 1].resource, i);
             }
 
             fp->state = BXE_FP_STATE_IRQ;
@@ -9619,8 +9629,8 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
          * driver instance to the interrupt handler which
          * will handle both the slowpath and fastpath.
          */
-        if ((rc = bus_setup_intr(sc->dev, sc->intr[0].resource,
-                                 (INTR_TYPE_NET | INTR_MPSAFE),
+        if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
+                                 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);
@@ -9635,8 +9645,8 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
          * driver instance to the interrupt handler which
          * will handle both the slowpath and fastpath.
          */
-        if ((rc = bus_setup_intr(sc->dev, sc->intr[0].resource,
-                                 (INTR_TYPE_NET | INTR_MPSAFE),
+        if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
+                                 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);
@@ -9701,7 +9711,7 @@ bxe_init_hw(struct bxe_adapter *sc,
     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;
@@ -9978,11 +9988,11 @@ bxe_init_eth_fp(struct bxe_adapter *sc,
 
     snprintf(fp->tx_mtx_name, sizeof(fp->tx_mtx_name),
              "bxe%d_fp%d_tx_lock", sc->unit, idx);
-    mtx_init(&fp->tx_mtx, fp->tx_mtx_name, NULL, MTX_DEF);
+    //mtx_init(&fp->tx_mtx, fp->tx_mtx_name, NULL, MTX_DEF);
 
     snprintf(fp->rx_mtx_name, sizeof(fp->rx_mtx_name),
              "bxe%d_fp%d_rx_lock", sc->unit, idx);
-    mtx_init(&fp->rx_mtx, fp->rx_mtx_name, NULL, MTX_DEF);
+    //mtx_init(&fp->rx_mtx, fp->rx_mtx_name, NULL, MTX_DEF);
 
     fp->igu_sb_id = (sc->igu_base_sb + idx + CNIC_SUPPORT(sc));
     fp->fw_sb_id = (sc->base_fw_ndsb + idx + CNIC_SUPPORT(sc));
@@ -10027,8 +10037,8 @@ bxe_init_eth_fp(struct bxe_adapter *sc,
     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,
@@ -10255,7 +10265,7 @@ bxe_init_def_sb(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;
@@ -10271,10 +10281,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];
 
-        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)));
-        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)));
     }
@@ -10283,8 +10293,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];
 
-    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));
 }
 
@@ -10594,7 +10604,8 @@ 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.
      */
-    flags |= (if_getcapenable(sc->ifp) & IFCAP_LRO) ? FUNC_FLG_TPA : 0;
+#warning "no getcapenable"
+//    flags |= (if_getcapenable(sc->ifp) & IFCAP_LRO) ? FUNC_FLG_TPA : 0;
 
     func_init.func_flgs = flags;
     func_init.pf_id     = SC_FUNC(sc);
@@ -10895,6 +10906,7 @@ bxe_nic_init(struct bxe_adapter *sc,
 static inline void
 bxe_init_objs(struct bxe_adapter *sc)
 {
+#if 0
     /* mcast rules must be added to tx if tx switching is enabled */
     ecore_obj_type o_type =
         (sc->flags & BXE_TX_SWITCHING) ? ECORE_OBJ_TYPE_RX_TX :
@@ -10940,6 +10952,7 @@ bxe_init_objs(struct bxe_adapter *sc)
                               BXE_SP_MAPPING(sc, rss_rdata),
                               ECORE_FILTER_RSS_CONF_PENDING,
                               &sc->sp_state, ECORE_OBJ_TYPE_RX);
+#endif
 }
 
 /*
@@ -10949,11 +10962,13 @@ bxe_init_objs(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 */
-    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;
@@ -10972,12 +10987,14 @@ bxe_func_start(struct bxe_adapter *sc)
     start_params->gre_tunnel_rss  = 0;
 
     return (ecore_func_state_change(sc, &func_params));
+#endif
 }
 
 static int
 bxe_set_power_state(struct bxe_adapter *sc,
                     uint8_t          state)
 {
+#if 0
     uint16_t pmcsr;
 
     /* If there is no power capability, silently succeed */
@@ -10986,19 +11003,18 @@ bxe_set_power_state(struct bxe_adapter *sc,
         return (0);
     }
 
-    pmcsr = pci_read_config(sc->dev,
-                            (sc->devinfo.pcie_pm_cap_reg + PCIR_POWER_STATUS),
-                            2);
+    pmcsr = pcidev_read16(sc->pcidev,
+                            (sc->devinfo.pcie_pm_cap_reg + PCIR_POWER_STATUS));
 
     switch (state) {
     case PCI_PM_D0:
-        pci_write_config(sc->dev,
-                         (sc->devinfo.pcie_pm_cap_reg + PCIR_POWER_STATUS),
-                         ((pmcsr & ~PCIM_PSTAT_DMASK) | PCIM_PSTAT_PME), 2);
+        pcidev_write16(sc->pcidev,
+                      (sc->devinfo.pcie_pm_cap_reg + PCIR_POWER_STATUS),
+                      ((pmcsr & ~PCIM_PSTAT_DMASK) | PCIM_PSTAT_PME));
 
         if (pmcsr & PCIM_PSTAT_DMASK) {
             /* delay required during transition out of D3hot */
-            DELAY(20000);
+            udelay(20000);
         }
 
         break;
@@ -11018,9 +11034,9 @@ bxe_set_power_state(struct bxe_adapter *sc,
             pmcsr |= PCIM_PSTAT_PMEENABLE;
         }
 
-        pci_write_config(sc->dev,
-                         (sc->devinfo.pcie_pm_cap_reg + PCIR_POWER_STATUS),
-                         pmcsr, 4);
+        pcidev_write32(sc->pcidev,
+                      (sc->devinfo.pcie_pm_cap_reg + PCIR_POWER_STATUS),
+                      pmcsr);
 
         /*
          * No more memory access after this point until device is brought back
@@ -11033,6 +11049,7 @@ bxe_set_power_state(struct bxe_adapter *sc,
         return (-1);
     }
 
+#endif
     return (0);
 }
 
@@ -11042,6 +11059,7 @@ static uint8_t
 bxe_trylock_hw_lock(struct bxe_adapter *sc,
                     uint32_t         resource)
 {
+#if 0
     uint32_t lock_status;
     uint32_t resource_bit = (1 << resource);
     int func = SC_FUNC(sc);
@@ -11070,6 +11088,7 @@ bxe_trylock_hw_lock(struct bxe_adapter *sc,
         return (TRUE);
     }
 
+#endif
     BLOGE(sc, "Failed to get a resource lock 0x%x\n", resource);
 
     return (FALSE);
@@ -11159,7 +11178,7 @@ bxe_er_poll_igu_vq(struct bxe_adapter *sc)
             break;
         }
 
-        DELAY(1000);
+        udelay(1000);
     } while (--cnt > 0);
 
     if (cnt == 0) {
@@ -11225,9 +11244,9 @@ bxe_mcp_wait_one(struct bxe_adapter *sc)
 {
     /* special handling for emulation and FPGA (10 times longer) */
     if (CHIP_REV_IS_SLOW(sc)) {
-        DELAY((MCP_ONE_TIMEOUT*10) * 1000);
+        udelay((MCP_ONE_TIMEOUT*10) * 1000);
     } else {
-        DELAY((MCP_ONE_TIMEOUT) * 1000);
+        udelay((MCP_ONE_TIMEOUT) * 1000);
     }
 }
 
@@ -11418,7 +11437,7 @@ bxe_process_kill(struct bxe_adapter *sc,
             (pgl_exp_rom2 == 0xffffffff) &&
             (!CHIP_IS_E3(sc) || (tags_63_32 == 0xffffffff)))
             break;
-        DELAY(1000);
+        udelay(1000);
     } while (cnt-- > 0);
 
     if (cnt <= 0) {
@@ -11454,7 +11473,7 @@ bxe_process_kill(struct bxe_adapter *sc,
      * Wait for 1ms to empty GLUE and PCI-E core queues,
      * PSWHST, GRC and PSWRD Tetris buffer.
      */
-    DELAY(1000);
+    udelay(1000);
 
     /* Prepare to chip reset: */
     /* MCP */
@@ -11605,7 +11624,8 @@ bxe_pf_q_prep_init(struct bxe_adapter               *sc,
         /* fp->txdata[cos]->cid */
         cxt_index = fp->index / ILT_PAGE_CIDS;
         cxt_offset = fp->index - (cxt_index * ILT_PAGE_CIDS);
-        init_params->cxts[cos] = &sc->context[cxt_index].vcxt[cxt_offset].eth;
+// FIX
+//        init_params->cxts[cos] = &sc->context[cxt_index].vcxt[cxt_offset].eth;
     }
 }
 
@@ -11649,6 +11669,7 @@ bxe_get_q_flags(struct bxe_adapter    *sc,
                 struct bxe_fastpath *fp,
                 uint8_t             leading)
 {
+#if 0
     unsigned long flags = 0;
 
     if (IS_MF_SD(sc)) {
@@ -11680,6 +11701,8 @@ bxe_get_q_flags(struct bxe_adapter    *sc,
 
     /* merge with common flags */
     return (flags | bxe_get_common_flags(sc, fp, TRUE));
+#endif
+    return 0;
 }
 
 static void
@@ -11700,6 +11723,7 @@ bxe_pf_rx_q_prep(struct bxe_adapter              *sc,
                  struct rxq_pause_params       *pause,
                  struct ecore_rxq_setup_params *rxq_init)
 {
+#if 0
     uint8_t max_sge = 0;
     uint16_t sge_sz = 0;
     uint16_t tpa_agg_size = 0;
@@ -11724,7 +11748,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;
-        sge_sz = (uint16_t)min(SGE_PAGES, 0xffff);
+        sge_sz = (uint16_t)MIN(SGE_PAGES, 0xffff);
     }
 
     /* pause - not for e1 */
@@ -11792,6 +11816,7 @@ bxe_pf_rx_q_prep(struct bxe_adapter              *sc,
             sc->devinfo.mf_info.afex_def_vlan_tag;
         rxq_init->silent_removal_mask = EVL_VLID_MASK;
     }
+#endif
 }
 
 static void
@@ -11800,6 +11825,7 @@ bxe_pf_tx_q_prep(struct bxe_adapter              *sc,
                  struct ecore_txq_setup_params *txq_init,
                  uint8_t                       cos)
 {
+#if 0
     /*
      * XXX If multiple CoS is ever supported then each fastpath structure
      * will need to maintain tx producer/consumer/dma/etc values *per* CoS.
@@ -11815,6 +11841,7 @@ bxe_pf_tx_q_prep(struct bxe_adapter              *sc,
      * leading RSS client id
      */
     txq_init->tss_leading_cl_id = BXE_FP(sc, 0, cl_id);
+#endif
 }
 
 /*
@@ -11841,7 +11868,8 @@ bxe_setup_queue(struct bxe_adapter    *sc,
 
     bxe_ack_sb(sc, fp->igu_sb_id, USTORM_ID, 0, IGU_INT_ENABLE, 0);
 
-    q_params.q_obj = &BXE_SP_OBJ(sc, fp).q_obj;
+    // FIX ME. 
+    //q_params.q_obj = &BXE_SP_OBJ(sc, fp).q_obj;
 
     /* we want to wait for completion in this context */
     bxe_set_bit(RAMROD_COMP_WAIT, &q_params.ramrod_flags);
@@ -11952,10 +11980,7 @@ bxe_config_rss_pf(struct bxe_adapter            *sc,
 
     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);
     }
 
@@ -12227,6 +12252,7 @@ bxe_fill_report_data(struct bxe_adapter            *sc,
 static void
 bxe_link_report_locked(struct bxe_adapter *sc)
 {
+
     struct bxe_link_report_data cur_data;
 
     /* reread mf_cfg */
@@ -12253,7 +12279,7 @@ bxe_link_report_locked(struct bxe_adapter *sc)
 
     if (bxe_test_bit(BXE_LINK_REPORT_LINK_DOWN,
                      &cur_data.link_report_flags)) {
-        if_link_state_change(sc->ifp, LINK_STATE_DOWN);
+  //if_link_state_change(sc->ifp, LINK_STATE_DOWN);
         BLOGI(sc, "NIC Link is Down\n");
     } else {
         const char *duplex;
@@ -12294,7 +12320,7 @@ bxe_link_report_locked(struct bxe_adapter *sc)
             flow = "none";
         }
 
-        if_link_state_change(sc->ifp, LINK_STATE_UP);
+        //if_link_state_change(sc->ifp, LINK_STATE_UP);
         BLOGI(sc, "NIC Link is Up, %d Mbps %s duplex, Flow control: %s\n",
               cur_data.line_speed, duplex, flow);
     }
@@ -12459,18 +12485,20 @@ bxe_initial_phy_init(struct bxe_adapter *sc,
     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)
 {
     if_t ifp = sc->ifp;
     int mc_count = 0;
-    int mcnt, i;
+    int i;
     struct ecore_mcast_list_elem *mc_mac;
     unsigned char *mta;
 
-    mc_count = if_multiaddr_count(ifp, -1);/* XXX they don't have a limit */
+    mc_count = ifp->nmaddr;
                                            /* should we enforce one? */
     ECORE_LIST_INIT(&p->mcast_list);
     p->mcast_list_len = 0;
@@ -12479,27 +12507,16 @@ bxe_init_mcast_macs_list(struct bxe_adapter                 *sc,
         return (0);
     }
 
-    mta = malloc(sizeof(unsigned char) * ETHER_ADDR_LEN *
-            mc_count, M_DEVBUF, M_NOWAIT);
-
-    if(mta == NULL) {
-        BLOGE(sc, "Failed to allocate temp mcast list\n");
-        return (-1);
-    }
+    mta = ifp->maddr;
     
-    mc_mac = malloc(sizeof(*mc_mac) * mc_count, M_DEVBUF,
-                    (M_NOWAIT | M_ZERO));
+    mc_mac = kzmalloc(sizeof(*mc_mac) * mc_count, KMALLOC_WAIT);
     if (!mc_mac) {
-        free(mta, M_DEVBUF);
         BLOGE(sc, "Failed to allocate temp mcast list\n");
         return (-1);
     }
 
-    if_multiaddr_array(ifp, mta, &mcnt, mc_count); /* mta and mcnt not expected 
-                                                      to be  different */
-    for(i=0; i< mcnt; i++) {
-
-        bcopy((mta + (i * ETHER_ADDR_LEN)), mc_mac->mac, ETHER_ADDR_LEN);
+    for(i=0; i< mc_count; i++) {
+        bcopy((mta + (i * ETH_ADDR_LEN)), mc_mac->mac, ETH_ADDR_LEN);
         ECORE_LIST_PUSH_TAIL(&mc_mac->link, &p->mcast_list);
 
         BLOGD(sc, DBG_LOAD,
@@ -12511,7 +12528,6 @@ bxe_init_mcast_macs_list(struct bxe_adapter                 *sc,
     }
 
     p->mcast_list_len = mc_count;
-    free(mta, M_DEVBUF);
 
     return (0);
 }
@@ -12526,7 +12542,7 @@ bxe_free_mcast_macs_list(struct ecore_mcast_ramrod_params *p)
 
     if (mc_mac) {
         /* only a single free as all mc_macs are in the same heap array */
-        free(mc_mac, M_DEVBUF);
+      kfree(mc_mac);
     }
 }
 
@@ -12571,27 +12587,21 @@ bxe_set_mc_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;
     struct ifaddr *ifa;
     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) {
+unlock ehre.
         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);
     }
 
@@ -12610,27 +12620,20 @@ bxe_set_uc_list(struct bxe_adapter *sc)
             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);
     }
 
-#if __FreeBSD_version < 800000
-    IF_ADDR_UNLOCK(ifp);
-#else
-    if_addr_runlock(ifp);
-#endif
+unlock here.
 
     /* 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
 }
 
 static void
@@ -12650,7 +12653,7 @@ bxe_handle_rx_mode_tq(void *context,
     }
 
     BLOGD(sc, DBG_SP, "if_flags(ifp)=0x%x\n", if_getflags(sc->ifp));
-
+#if 0
     if (if_getflags(ifp) & IFF_PROMISC) {
         rx_mode = BXE_RX_MODE_PROMISC;
     } else if ((if_getflags(ifp) & IFF_ALLMULTI) ||
@@ -12680,7 +12683,7 @@ bxe_handle_rx_mode_tq(void *context,
         }
 #endif
     }
-
+#endif
     sc->rx_mode = rx_mode;
 
     /* schedule the rx_mode command */
@@ -12713,7 +12716,7 @@ bxe_handle_rx_mode_tq(void *context,
 static void
 bxe_set_rx_mode(struct bxe_adapter *sc)
 {
-    taskqueue_enqueue(sc->rx_mode_tq, &sc->rx_mode_tq_task);
+//    taskqueue_enqueue(sc->rx_mode_tq, &sc->rx_mode_tq_task);
 }
 
 /* update flags in shmem */
@@ -12744,29 +12747,31 @@ bxe_update_drv_flags(struct bxe_adapter *sc,
 /* periodic timer callout routine, only runs when the interface is up */
 
 static void
-bxe_periodic_callout_func(void *xsc)
+bxe_alarm_handler(struct alarm_waiter *waiter,
+                                struct hw_trapframe *hw_tf)
 {
-    struct bxe_adapter *sc = (struct bxe_adapter *)xsc;
+       struct timer_chain *tchain = &per_cpu_info[0].tchain;
+
+       struct bxe_adapter *sc = (struct bxe_adapter *) waiter->data;
     int i;
 
     if (!BXE_CORE_TRYLOCK(sc)) {
         /* just bail and try again next time */
 
         if ((sc->state == BXE_STATE_OPEN) &&
-            (atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_GO)) {
-            /* schedule the next periodic callout */
-            callout_reset(&sc->periodic_callout, hz,
-                          bxe_periodic_callout_func, sc);
+            (atomic_read(&sc->periodic_flags) == PERIODIC_GO)) {
+               goto done;
+
         }
 
         return;
     }
 
     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;
+       goto done;
     }
 
     /* Check for TX timeouts on any fastpath. */
@@ -12830,25 +12835,32 @@ bxe_periodic_callout_func(void *xsc)
     BXE_CORE_UNLOCK(sc);
 
     if ((sc->state == BXE_STATE_OPEN) &&
-        (atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_GO)) {
-        /* schedule the next periodic callout */
-        callout_reset(&sc->periodic_callout, hz,
-                      bxe_periodic_callout_func, sc);
+        (atomic_read(&sc->periodic_flags) == PERIODIC_GO)) {
+           goto done;
     }
+    // we're not restarting it. That's how it ends.
+    return;
+    /* schedule the next periodic callout */
+done:
+    __reset_alarm_rel(tchain, waiter, bxe_periodic_alarm);
 }
 
 static void
 bxe_periodic_start(struct bxe_adapter *sc)
 {
-    atomic_store_rel_long(&sc->periodic_flags, PERIODIC_GO);
-    callout_reset(&sc->periodic_callout, hz, bxe_periodic_callout_func, sc);
+       struct timer_chain *tchain = &per_cpu_info[0].tchain;
+
+       if (! sc->waiter) {
+               sc->waiter = kzmalloc(sizeof(struct alarm_waiter), KMALLOC_WAIT);
+               init_awaiter_irq(sc->waiter, bxe_alarm_handler);
+       }
+       reset_alarm_rel(tchain, sc->waiter, bxe_periodic_alarm);
 }
 
 static void
 bxe_periodic_stop(struct bxe_adapter *sc)
 {
-    atomic_store_rel_long(&sc->periodic_flags, PERIODIC_STOP);
-    callout_drain(&sc->periodic_callout);
+       atomic_set(&sc->periodic_flags, PERIODIC_STOP);
 }
 
 /* start the controller */
@@ -12871,7 +12883,7 @@ bxe_nic_load(struct bxe_adapter *sc,
         bxe_ilt_set_info(sc);
     }
 
-    sc->last_reported_link_state = LINK_STATE_UNKNOWN;
+//    sc->last_reported_link_state = LINK_STATE_UNKNOWN;
 
     bxe_set_fp_rx_buf_size(sc);
 
@@ -13073,7 +13085,7 @@ bxe_nic_load(struct bxe_adapter *sc,
         bxe_link_status_update(sc);
     }
 
-    /* start the periodic timer callout */
+    /* start the periodic timer alarm */
     bxe_periodic_start(sc);
 
     if (IS_PF(sc) && SHMEM2_HAS(sc, drv_capabilities_flag)) {
@@ -13101,7 +13113,7 @@ bxe_nic_load(struct bxe_adapter *sc,
 #endif
 
     /* Tell the stack the driver is running! */
-    if_setdrvflags(sc->ifp, IFF_DRV_RUNNING);
+    //if_setdrvflags(sc->ifp, IFF_DRV_RUNNING);
 
     BLOGD(sc, DBG_LOAD, "NIC successfully loaded\n");
 
@@ -13154,10 +13166,10 @@ bxe_init_locked(struct bxe_adapter *sc)
     BXE_CORE_LOCK_ASSERT(sc);
 
     /* check if the driver is already running */
-    if (if_getdrvflags(sc->ifp) & IFF_DRV_RUNNING) {
-        BLOGD(sc, DBG_LOAD, "Init called while driver is running!\n");
-        return (0);
-    }
+//    if (if_getdrvflags(sc->ifp) & IFF_DRV_RUNNING) {
+//        BLOGD(sc, DBG_LOAD, "Init called while driver is running!\n");
+//        return (0);
+//    }
 
     bxe_set_power_state(sc, PCI_PM_D0);
 
@@ -13219,7 +13231,7 @@ bxe_init_locked_done:
         /* Tell the stack the driver is NOT running! */
         BLOGE(sc, "Initialization failed, "
                   "stack notified driver is NOT running!\n");
-       if_setdrvflagbits(sc->ifp, 0, IFF_DRV_RUNNING);
+//     if_setdrvflagbits(sc->ifp, 0, IFF_DRV_RUNNING);
     }
 
     return (rc);
@@ -13252,6 +13264,7 @@ bxe_init(void *xsc)
 static int
 bxe_init_ifnet(struct bxe_adapter *sc)
 {
+#if 0
     if_t ifp;
     int capabilities;
 
@@ -13274,7 +13287,7 @@ bxe_init_ifnet(struct bxe_adapter *sc)
     }
 
     if_setsoftc(ifp, sc);
-    if_initname(ifp, device_get_name(sc->dev), device_get_unit(sc->dev));
+    if_initname(ifp, device_get_name(sc->pcidev), device_get_unit(sc->pcidev));
     if_setflags(ifp, (IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST));
     if_setioctlfn(ifp, bxe_ioctl);
     if_setstartfn(ifp, bxe_tx_start);
@@ -13326,7 +13339,7 @@ bxe_init_ifnet(struct bxe_adapter *sc)
 
     /* attach to the Ethernet interface list */
     ether_ifattach(ifp, sc->link_params.mac_addr);
-
+#endif
     return (0);
 }
 
@@ -13334,10 +13347,10 @@ static void
 bxe_deallocate_bars(struct bxe_adapter *sc)
 {
     int i;
-
+#if 0
     for (i = 0; i < MAX_BARS; i++) {
         if (sc->bar[i].resource != NULL) {
-            bus_release_resource(sc->dev,
+            bus_release_resource(sc->pcidev,
                                  SYS_RES_MEMORY,
                                  sc->bar[i].rid,
                                  sc->bar[i].resource);
@@ -13345,14 +13358,15 @@ bxe_deallocate_bars(struct bxe_adapter *sc)
                   i, PCIR_BAR(i));
         }
     }
+#endif
 }
 
 static int
 bxe_allocate_bars(struct bxe_adapter *sc)
 {
-    u_int flags;
+    unsigned int flags;
     int i;
-
+#if 0
     memset(sc->bar, 0, sizeof(sc->bar));
 
     for (i = 0; i < MAX_BARS; i++) {
@@ -13371,7 +13385,7 @@ bxe_allocate_bars(struct bxe_adapter *sc)
         }
 
         if ((sc->bar[i].resource =
-             bus_alloc_resource_any(sc->dev,
+             bus_alloc_resource_any(sc->pcidev,
                                     SYS_RES_MEMORY,
                                     &sc->bar[i].rid,
                                     flags)) == NULL) {
@@ -13394,7 +13408,7 @@ bxe_allocate_bars(struct bxe_adapter *sc)
               rman_get_size(sc->bar[i].resource),
               (void *)sc->bar[i].kva);
     }
-
+#endif
     return (0);
 }
 
@@ -13461,13 +13475,23 @@ bxe_pcie_capability_read(struct bxe_adapter *sc,
     int pcie_reg;
 
     /* ensure PCIe capability is enabled */
-    if (pci_find_cap(sc->dev, PCIY_EXPRESS, &pcie_reg) == 0) {
+#if 0
+    if (pci_find_cap(sc->pcidev, PCIY_EXPRESS, &pcie_reg) == 0) {
         if (pcie_reg != 0) {
             BLOGD(sc, DBG_LOAD, "PCIe capability at 0x%04x\n", pcie_reg);
-            return (pci_read_config(sc->dev, (pcie_reg + reg), width));
+                       switch (width) {
+                               case 4:
+                                       return pcidev_read32(sc->pcidev, (pcie_reg + reg));
+                               case 2:
+                                       return pcidev_read16(sc->pcidev, (pcie_reg + reg));
+                               case 1:
+                                       return pcidev_read8(sc->pcidev, (pcie_reg + reg));
+                               default:
+                                       BLOGE(sc, "Bad width %d in PCIE Cap read\n", width);
+                       }
         }
     }
-
+#endif
     BLOGE(sc, "PCIe capability NOT FOUND!!!\n");
 
     return (0);
@@ -13476,8 +13500,11 @@ bxe_pcie_capability_read(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);
+#endif
 }
 
 /*
@@ -13488,11 +13515,12 @@ bxe_is_pcie_pending(struct bxe_adapter *sc)
 static void
 bxe_probe_pci_caps(struct bxe_adapter *sc)
 {
+#if 0
     uint16_t link_status;
     int reg;
 
     /* check if PCI Power Management is enabled */
-    if (pci_find_cap(sc->dev, PCIY_PMG, &reg) == 0) {
+    if (pci_find_cap(sc->pcidev, PCIY_PMG, &reg) == 0) {
         if (reg != 0) {
             BLOGD(sc, DBG_LOAD, "Found PM capability at 0x%04x\n", reg);
 
@@ -13530,7 +13558,7 @@ bxe_probe_pci_caps(struct bxe_adapter *sc)
     sc->devinfo.pcie_pcie_cap_reg = (uint16_t)reg;
 
     /* check if MSI capability is enabled */
-    if (pci_find_cap(sc->dev, PCIY_MSI, &reg) == 0) {
+    if (pci_find_cap(sc->pcidev, PCIY_MSI, &reg) == 0) {
         if (reg != 0) {
             BLOGD(sc, DBG_LOAD, "Found MSI capability at 0x%04x\n", reg);
 
@@ -13540,7 +13568,7 @@ bxe_probe_pci_caps(struct bxe_adapter *sc)
     }
 
     /* check if MSI-X capability is enabled */
-    if (pci_find_cap(sc->dev, PCIY_MSIX, &reg) == 0) {
+    if (pci_find_cap(sc->pcidev, PCIY_MSIX, &reg) == 0) {
         if (reg != 0) {
             BLOGD(sc, DBG_LOAD, "Found MSI-X capability at 0x%04x\n", reg);
 
@@ -13548,11 +13576,13 @@ bxe_probe_pci_caps(struct bxe_adapter *sc)
             sc->devinfo.pcie_msix_cap_reg = (uint16_t)reg;
         }
     }
+#endif
 }
 
 static int
 bxe_get_shmem_mf_cfg_info_sd(struct bxe_adapter *sc)
 {
+#if 0
     struct bxe_mf_info *mf_info = &sc->devinfo.mf_info;
     uint32_t val;
 
@@ -13581,7 +13611,7 @@ bxe_get_shmem_mf_cfg_info_sd(struct bxe_adapter *sc)
 
     mf_info->vnics_per_port =
         (CHIP_PORT_MODE(sc) == CHIP_4_PORT_MODE) ? 2 : 4;
-
+#endif
     return (0);
 }
 
@@ -14047,7 +14077,7 @@ static void
 bxe_get_tunable_params(struct bxe_adapter *sc)
 {
     /* sanity checks */
-
+#if 0
     if ((bxe_interrupt_mode != INTR_MODE_INTX) &&
         (bxe_interrupt_mode != INTR_MODE_MSI)  &&
         (bxe_interrupt_mode != INTR_MODE_MSIX)) {
@@ -14105,7 +14135,7 @@ bxe_get_tunable_params(struct bxe_adapter *sc)
     }
 
     /* pull in user settings */
-
+#endif
     sc->interrupt_mode       = bxe_interrupt_mode;
     sc->max_rx_bufs          = bxe_max_rx_bufs;
     sc->hc_rx_ticks          = bxe_hc_rx_ticks;
@@ -14114,18 +14144,18 @@ bxe_get_tunable_params(struct bxe_adapter *sc)
     sc->mrrs                 = bxe_mrrs;
     sc->autogreeen           = bxe_autogreeen;
     sc->udp_rss              = bxe_udp_rss;
-
+#if 0
     if (bxe_interrupt_mode == INTR_MODE_INTX) {
         sc->num_queues = 1;
     } else { /* INTR_MODE_MSI or INTR_MODE_MSIX */
         sc->num_queues =
-            min((bxe_queue_count ? bxe_queue_count : 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;
         }
     }
-
+#endif
     BLOGD(sc, DBG_LOAD,
           "User Config: "
           "debug=0x%lx "
@@ -14153,6 +14183,7 @@ bxe_get_tunable_params(struct bxe_adapter *sc)
 static void
 bxe_media_detect(struct bxe_adapter *sc)
 {
+#if 0
     uint32_t phy_idx = bxe_get_cur_phy_idx(sc);
     switch (sc->link_params.phy[phy_idx].media_type) {
     case ELINK_ETH_PHY_SFPP_10G_FIBER:
@@ -14193,6 +14224,8 @@ bxe_media_detect(struct bxe_adapter *sc)
         sc->media = 0;
         break;
     }
+#endif
+    assert(0);
 }
 
 #define GET_FIELD(value, fname)                     \
@@ -14251,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
      */
-    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");
@@ -14272,10 +14305,10 @@ bxe_get_device_info(struct bxe_adapter *sc)
     int rc;
 
     /* Get the data for the device */
-    sc->devinfo.vendor_id    = pci_get_vendor(sc->dev);
-    sc->devinfo.device_id    = pci_get_device(sc->dev);
-    sc->devinfo.subvendor_id = pci_get_subvendor(sc->dev);
-    sc->devinfo.subdevice_id = pci_get_subdevice(sc->dev);
+    sc->devinfo.vendor_id    = pci_get_vendor(sc->pcidev);
+    sc->devinfo.device_id    = pci_get_device(sc->pcidev);
+    sc->devinfo.subvendor_id = pci_get_subvendor(sc->pcidev);
+    sc->devinfo.subdevice_id = pci_get_subdevice(sc->pcidev);
 
     /* get the chip revision (chip metal comes from pci config space) */
     sc->devinfo.chip_id     =
@@ -14382,7 +14415,7 @@ bxe_get_device_info(struct bxe_adapter *sc)
     BLOGD(sc, DBG_LOAD, "mf_cfg_base=0x08%x \n", sc->devinfo.mf_cfg_base);
 
     /* clean indirect addresses as they're not used */
-    pci_write_config(sc->dev, PCICFG_GRC_ADDRESS, 0, 4);
+    pcidev_write32(sc->pcidev, PCICFG_GRC_ADDRESS, 0);
     if (IS_PF(sc)) {
         REG_WR(sc, PXP2_REG_PGL_ADDR_88_F0, 0);
         REG_WR(sc, PXP2_REG_PGL_ADDR_8C_F0, 0);
@@ -14420,11 +14453,11 @@ bxe_get_device_info(struct bxe_adapter *sc)
     bxe_get_shmem_info(sc);
 
     if (sc->devinfo.pcie_msix_cap_reg != 0) {
-        val = pci_read_config(sc->dev,
-                              (sc->devinfo.pcie_msix_cap_reg +
-                               PCIR_MSIX_CTRL),
-                              2);
-        sc->igu_sb_cnt = (val & PCIM_MSIXCTRL_TABLE_SIZE);
+       assert(0);
+//        val = pcidev_read16(sc->pcidev,
+//                              (sc->devinfo.pcie_msix_cap_reg +
+//                               PCIR_MSIX_CTRL));
+//        sc->igu_sb_cnt = (val & PCIM_MSIXCTRL_TABLE_SIZE);
     } else {
         sc->igu_sb_cnt = 1;
     }
@@ -14455,7 +14488,7 @@ bxe_get_device_info(struct bxe_adapter *sc)
 
             while (tout && REG_RD(sc, IGU_REG_RESET_MEMORIES)) {
                 tout--;
-                DELAY(1000);
+                udelay(1000);
             }
 
             if (REG_RD(sc, IGU_REG_RESET_MEMORIES)) {
@@ -14921,9 +14954,9 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
     int i, j;
 
     /* XXX zero out all vars here and call bxe_alloc_hsi_mem on error */
-
+#if 0
     /* allocate the parent bus DMA tag */
-    rc = bus_dma_tag_create(bus_get_dma_tag(sc->dev), /* parent tag */
+    rc = bus_dma_tag_create(bus_get_dma_tag(sc->pcidev), /* parent tag */
                             1,                        /* alignment */
                             0,                        /* boundary limit */
                             BUS_SPACE_MAXADDR,        /* restricted low */
@@ -14937,6 +14970,7 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
                             NULL,                     /* lock() */
                             NULL,                     /* lock() arg */
                             &sc->parent_dma_tag);     /* returned dma tag */
+#endif
     if (rc != 0) {
         BLOGE(sc, "Failed to alloc parent DMA tag (%d)!\n", rc);
         return (1);
@@ -15025,25 +15059,9 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
         return (1);
     }
 
+       // The compress/decompress shit never worked. But they use the buffer. */
     sc->gz_buf = (void *)sc->gz_buf_dma.vaddr;
 
-    if ((sc->gz_strm =
-         malloc(sizeof(*sc->gz_strm), M_DEVBUF, M_NOWAIT)) == NULL) {
-        /* XXX */
-        bxe_dma_free(sc, &sc->gz_buf_dma);
-        sc->gz_buf = NULL;
-        bxe_dma_free(sc, &sc->spq_dma);
-        sc->spq = NULL;
-        bxe_dma_free(sc, &sc->sp_dma);
-        sc->sp = NULL;
-        bxe_dma_free(sc, &sc->eq_dma);
-        sc->eq = NULL;
-        bxe_dma_free(sc, &sc->def_sb_dma);
-        sc->def_sb = NULL;
-        bus_dma_tag_destroy(sc->parent_dma_tag);
-        return (1);
-    }
-
     /*************/
     /* FASTPATHS */
     /*************/
@@ -15096,8 +15114,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)));
-            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));
         }
 
         /******************/
@@ -15122,8 +15140,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)));
-            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));
         }
 
         /*******************/
@@ -15149,8 +15167,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)));
-            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));
         }
 
         /*******************/
@@ -15175,25 +15193,27 @@ 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)));
-            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));
         }
 
         /***********************/
         /* FP TX MBUF DMA MAPS */
         /***********************/
-
+#if 0
         /* set required sizes before mapping to conserve resources */
         if (if_getcapenable(sc->ifp) & (IFCAP_TSO4 | IFCAP_TSO6)) {
             max_size     = BXE_TSO_MAX_SIZE;
             max_segments = BXE_TSO_MAX_SEGMENTS;
             max_seg_size = BXE_TSO_MAX_SEG_SIZE;
         } else {
+#endif
             max_size     = (MCLBYTES * BXE_MAX_SEGMENTS);
             max_segments = BXE_MAX_SEGMENTS;
-            max_seg_size = MCLBYTES;
-        }
+            max_seg_size = 0; // ?? MCLBYTES;
+//        }
 
+#if 0
         /* create a dma tag for the tx mbufs */
         rc = bus_dma_tag_create(sc->parent_dma_tag, /* parent tag */
                                 1,                  /* alignment */
@@ -15209,6 +15229,8 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
                                 NULL,               /* lock() */
                                 NULL,               /* lock() arg */
                                 &fp->tx_mbuf_tag);  /* returned dma tag */
+#endif
+       rc = 1;
         if (rc != 0) {
             /* XXX unwind and free previous fastpath allocations */
             BLOGE(sc, "Failed to create dma tag for "
@@ -15216,7 +15238,7 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
                   i, rc);
             return (1);
         }
-
+#if 0
         /* create dma maps for each of the tx mbuf clusters */
         for (j = 0; j < TX_BD_TOTAL; j++) {
             if (bus_dmamap_create(fp->tx_mbuf_tag,
@@ -15249,6 +15271,8 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
                                 NULL,               /* lock() */
                                 NULL,               /* lock() arg */
                                 &fp->rx_mbuf_tag);  /* returned dma tag */
+#endif
+       rc = 1;
         if (rc != 0) {
             /* XXX unwind and free previous fastpath allocations */
             BLOGE(sc, "Failed to create dma tag for "
@@ -15256,7 +15280,7 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
                   i, rc);
             return (1);
         }
-
+#if 0
         /* create dma maps for each of the rx mbuf clusters */
         for (j = 0; j < RX_BD_TOTAL; j++) {
             if (bus_dmamap_create(fp->rx_mbuf_tag,
@@ -15280,11 +15304,11 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
                   i, rc);
             return (1);
         }
-
+#endif
         /***************************/
         /* FP RX SGE MBUF DMA MAPS */
         /***************************/
-
+#if 0
         /* create a dma tag for the rx sge mbufs */
         rc = bus_dma_tag_create(sc->parent_dma_tag, /* parent tag */
                                 1,                  /* alignment */
@@ -15300,6 +15324,7 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
                                 NULL,               /* lock() */
                                 NULL,               /* lock() arg */
                                 &fp->rx_sge_mbuf_tag); /* returned dma tag */
+#endif
         if (rc != 0) {
             /* XXX unwind and free previous fastpath allocations */
             BLOGE(sc, "Failed to create dma tag for "
@@ -15307,7 +15332,7 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
                   i, rc);
             return (1);
         }
-
+#if 0
         /* create dma maps for the rx sge mbuf clusters */
         for (j = 0; j < RX_SGE_TOTAL; j++) {
             if (bus_dmamap_create(fp->rx_sge_mbuf_tag,
@@ -15331,14 +15356,14 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
                   i, rc);
             return (1);
         }
-
+#endif
         /***************************/
         /* FP RX TPA MBUF DMA MAPS */
         /***************************/
 
         /* create dma maps for the rx tpa mbuf clusters */
         max_agg_queues = MAX_AGG_QS(sc);
-
+#if 0
         for (j = 0; j < max_agg_queues; j++) {
             if (bus_dmamap_create(fp->rx_mbuf_tag,
                                   BUS_DMA_NOWAIT,
@@ -15363,6 +15388,7 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
         }
 
         bxe_init_sge_ring_bit_mask(fp);
+#endif
     }
 
     return (0);
@@ -15374,7 +15400,7 @@ bxe_free_hsi_mem(struct bxe_adapter *sc)
     struct bxe_fastpath *fp;
     int max_agg_queues;
     int i, j;
-
+#if 0
     if (sc->parent_dma_tag == NULL) {
         return; /* assume nothing was allocated */
     }
@@ -15545,6 +15571,7 @@ bxe_free_hsi_mem(struct bxe_adapter *sc)
 
     bus_dma_tag_destroy(sc->parent_dma_tag);
     sc->parent_dma_tag = NULL;
+#endif
 }
 
 /*
@@ -15586,7 +15613,7 @@ static struct bxe_prev_list_node *
 bxe_prev_path_get_entry(struct bxe_adapter *sc)
 {
     struct bxe_prev_list_node *tmp;
-
+#if 0
     LIST_FOREACH(tmp, &bxe_prev_list, node) {
         if ((sc->pcie_bus == tmp->bus) &&
             (sc->pcie_device == tmp->slot) &&
@@ -15594,7 +15621,7 @@ bxe_prev_path_get_entry(struct bxe_adapter *sc)
             return (tmp);
         }
     }
-
+#endif
     return (NULL);
 }
 
@@ -15603,8 +15630,7 @@ bxe_prev_is_path_marked(struct bxe_adapter *sc)
 {
     struct bxe_prev_list_node *tmp;
     int rc = FALSE;
-
-    mtx_lock(&bxe_prev_mtx);
+    qlock(&bxe_prev_mtx);
 
     tmp = bxe_prev_path_get_entry(sc);
     if (tmp) {
@@ -15620,7 +15646,7 @@ bxe_prev_is_path_marked(struct bxe_adapter *sc)
         }
     }
 
-    mtx_unlock(&bxe_prev_mtx);
+    qunlock(&bxe_prev_mtx);
 
     return (rc);
 }
@@ -15631,7 +15657,7 @@ bxe_prev_mark_path(struct bxe_adapter *sc,
 {
     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);
@@ -15647,15 +15673,15 @@ bxe_prev_mark_path(struct bxe_adapter *sc,
             tmp->aer = 0;
         }
 
-        mtx_unlock(&bxe_prev_mtx);
+               qunlock(&bxe_prev_mtx);
         return (0);
     }
 
-    mtx_unlock(&bxe_prev_mtx);
+    qunlock(&bxe_prev_mtx);
 
     /* Create an entry for this path and add it */
-    tmp = malloc(sizeof(struct bxe_prev_list_node), M_DEVBUF,
-                 (M_NOWAIT | M_ZERO));
+    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");
         return (-1);
@@ -15667,14 +15693,14 @@ bxe_prev_mark_path(struct bxe_adapter *sc,
     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);
+    //    LIST_INSERT_HEAD(&bxe_prev_list, tmp, node);
 
-    mtx_unlock(&bxe_prev_mtx);
+    qunlock(&bxe_prev_mtx);
 
     return (0);
 }
@@ -15700,7 +15726,7 @@ bxe_do_flr(struct bxe_adapter *sc)
     /* Wait for Transaction Pending bit clean */
     for (i = 0; i < 4; i++) {
         if (i) {
-            DELAY(((1 << (i - 1)) * 100) * 1000);
+            udelay(((1 << (i - 1)) * 100) * 1000);
         }
 
         if (!bxe_is_pcie_pending(sc)) {
@@ -15803,7 +15829,7 @@ bxe_prev_unload_close_mac(struct bxe_adapter *sc,
     }
 
     if (mac_stopped) {
-        DELAY(20000);
+        udelay(20000);
     }
 }
 
@@ -15903,7 +15929,7 @@ bxe_prev_unload_common(struct bxe_adapter *sc)
                 bxe_prev_unload_undi_inc(sc, SC_PORT(sc), 1);
             }
 
-            DELAY(10);
+            udelay(10);
         }
 
         if (!timer_count) {
@@ -15974,7 +16000,7 @@ bxe_prev_unload_uncommon(struct bxe_adapter *sc)
     /* Close the MCP request, return failure*/
     rc = bxe_prev_mcp_done(sc);
     if (!rc) {
-        rc = BXE_PREV_WAIT_NEEDED;
+      //        rc = BXE_PREV_WAIT_NEEDED;
     }
 
     return (rc);
@@ -16033,11 +16059,12 @@ bxe_prev_unload(struct bxe_adapter *sc)
 
         /* non-common reply from MCP night require looping */
         rc = bxe_prev_unload_uncommon(sc);
-        if (rc != BXE_PREV_WAIT_NEEDED) {
-            break;
-        }
+#warning "bxe_prev_wait_needed?"
+       //        if (rc != BXE_PREV_WAIT_NEEDED) {
+       //            break;
+       //        }
 
-        DELAY(20000);
+        udelay(20000);
     } while (--time_counter);
 
     if (!time_counter || rc) {
@@ -16083,7 +16110,7 @@ bxe_set_qm_cid_count(struct bxe_adapter *sc)
         cid_count += CNIC_CID_MAX;
     }
 
-    return (roundup(cid_count, QM_CID_ROUND));
+    return (ROUNDUP(cid_count, QM_CID_ROUND));
 }
 
 static void
@@ -16106,6 +16133,8 @@ bxe_init_multi_cos(struct bxe_adapter *sc)
     }
 }
 
+#warning "move sysctl to write to ctl file"
+#if 0
 static int
 bxe_sysctl_state(SYSCTL_HANDLER_ARGS)
 {
@@ -16128,6 +16157,7 @@ bxe_sysctl_state(SYSCTL_HANDLER_ARGS)
     return (error);
 }
 
+
 static int
 bxe_sysctl_eth_stat(SYSCTL_HANDLER_ARGS)
 {
@@ -16195,7 +16225,8 @@ bxe_sysctl_eth_q_stat(SYSCTL_HANDLER_ARGS)
 
     return (sysctl_handle_64(oidp, &value, 0, req));
 }
-
+#endif
+#if 0
 static void
 bxe_add_sysctls(struct bxe_adapter *sc)
 {
@@ -16207,8 +16238,8 @@ bxe_add_sysctls(struct bxe_adapter *sc)
     uint32_t q_stat;
     int i, j;
 
-    ctx = device_get_sysctl_ctx(sc->dev);
-    children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev));
+    ctx = device_get_sysctl_ctx(sc->pcidev);
+    children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->pcidev));
 
     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "version",
                       CTLFLAG_RD, BXE_DRIVER_VERSION, 0,
@@ -16322,7 +16353,7 @@ bxe_attach(device_t dev)
 
     sc->state = BXE_STATE_CLOSED;
 
-    sc->dev  = dev;
+       // TODO: sc->pcidev  = /* SOMETHING */
     sc->unit = device_get_unit(dev);
 
     BLOGD(sc, DBG_LOAD, "softc = %p\n", sc);
@@ -16342,9 +16373,6 @@ bxe_attach(device_t dev)
     /* initialize the mutexes */
     bxe_init_mutexes(sc);
 
-    /* prepare the periodic callout */
-    callout_init(&sc->periodic_callout, 0);
-
     /* prepare the chip taskqueue */
     sc->chip_tq_flags = CHIP_TQ_NONE;
     snprintf(sc->chip_tq_name, sizeof(sc->chip_tq_name),
@@ -16492,7 +16520,7 @@ bxe_detach(device_t dev)
     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);
@@ -16579,6 +16607,7 @@ bxe_igu_ack_sb(struct bxe_adapter *sc,
     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,
@@ -16625,7 +16654,7 @@ bxe_igu_clear_sb_gen(struct bxe_adapter *sc,
 
     /* wait for clean up to finish */
     while (!(REG_RD(sc, igu_addr_ack) & sb_bit) && --cnt) {
-        DELAY(20000);
+        udelay(20000);
     }
 
     if (!(REG_RD(sc, igu_addr_ack) & sb_bit)) {
@@ -16648,7 +16677,6 @@ bxe_igu_clear_sb(struct bxe_adapter *sc,
 
 
 
-
 /*******************/
 /* ECORE CALLBACKS */
 /*******************/
@@ -16713,7 +16741,7 @@ bxe_init_pxp(struct bxe_adapter *sc)
 {
     uint16_t devctl;
     int r_order, w_order;
-
+#if 0
     devctl = bxe_pcie_capability_read(sc, PCIR_EXPRESS_DEVICE_CTL, 2);
 
     BLOGD(sc, DBG_LOAD, "read 0x%08x from devctl\n", devctl);
@@ -16728,6 +16756,7 @@ bxe_init_pxp(struct bxe_adapter *sc)
     }
 
     ecore_init_pxp_arb(sc, r_order, w_order);
+#endif
 }
 
 static uint32_t
@@ -16813,7 +16842,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);
-    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
@@ -16909,7 +16938,7 @@ bxe_int_mem_test(struct bxe_adapter *sc)
             break;
         }
 
-        DELAY(10000);
+        udelay(10000);
         count--;
     }
 
@@ -16926,7 +16955,7 @@ bxe_int_mem_test(struct bxe_adapter *sc)
             break;
         }
 
-        DELAY(10000);
+        udelay(10000);
         count--;
     }
 
@@ -16937,9 +16966,9 @@ bxe_int_mem_test(struct bxe_adapter *sc)
 
     /* Reset and init BRB, PRS */
     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
-    DELAY(50000);
+    udelay(50000);
     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
-    DELAY(50000);
+    udelay(50000);
     ecore_init_block(sc, BLOCK_BRB1, PHASE_COMMON);
     ecore_init_block(sc, BLOCK_PRS, PHASE_COMMON);
 
@@ -16966,7 +16995,7 @@ bxe_int_mem_test(struct bxe_adapter *sc)
             break;
         }
 
-        DELAY(10000);
+        udelay(10000);
         count--;
     }
 
@@ -16985,7 +17014,7 @@ bxe_int_mem_test(struct bxe_adapter *sc)
     REG_WR(sc, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x1);
 
     /* Wait until PRS register shows 3 packets */
-    DELAY(10000 * factor);
+    udelay(10000 * factor);
 
     /* Wait until NIG register shows 1 packet of size 0x10 */
     val = REG_RD(sc, PRS_REG_NUM_OF_PACKETS);
@@ -17006,9 +17035,9 @@ bxe_int_mem_test(struct bxe_adapter *sc)
 
     /* Reset and init BRB, PRS, NIG */
     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
-    DELAY(50000);
+    udelay(50000);
     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
-    DELAY(50000);
+    udelay(50000);
     ecore_init_block(sc, BLOCK_BRB1, PHASE_COMMON);
     ecore_init_block(sc, BLOCK_PRS, PHASE_COMMON);
     if (!CNIC_SUPPORT(sc)) {
@@ -17236,7 +17265,7 @@ bxe_init_hw_common(struct bxe_adapter *sc)
     }
 
     /* let the HW do it's magic... */
-    DELAY(100000);
+    udelay(100000);
 
     /* finish PXP init */
     val = REG_RD(sc, PXP2_REG_RQ_CFG_DONE);
@@ -17366,7 +17395,7 @@ bxe_init_hw_common(struct bxe_adapter *sc)
 
         /* let the HW do it's magic... */
         do {
-            DELAY(200000);
+            udelay(200000);
             val = REG_RD(sc, ATC_REG_ATC_INIT_DONE);
         } while (factor-- && (val != 1));
 
@@ -17462,7 +17491,7 @@ bxe_init_hw_common(struct bxe_adapter *sc)
                VFC_MEMORIES_RST_REG_CAM_RST |
                VFC_MEMORIES_RST_REG_RAM_RST);
 
-        DELAY(20000);
+        udelay(20000);
     }
 
     ecore_init_block(sc, BLOCK_TSEM, PHASE_COMMON);
@@ -17574,7 +17603,7 @@ bxe_init_hw_common(struct bxe_adapter *sc)
     }
 
     if (CHIP_REV_IS_SLOW(sc)) {
-        DELAY(200000);
+        udelay(200000);
     }
 
     /* finish CFC init */
@@ -17774,7 +17803,7 @@ bxe_init_hw_port(struct bxe_adapter *sc)
 
         /* probe changes */
         REG_WR(sc, PBF_REG_INIT_P0 + port*4, 1);
-        DELAY(50);
+        udelay(50);
         REG_WR(sc, PBF_REG_INIT_P0 + port*4, 0);
     }
 
@@ -17878,7 +17907,7 @@ bxe_flr_clnup_reg_poll(struct bxe_adapter *sc,
     uint32_t val;
 
     while ((val = REG_RD(sc, reg)) != expected && cur_cnt--) {
-        DELAY(FLR_WAIT_INTERVAL);
+        udelay(FLR_WAIT_INTERVAL);
     }
 
     return (val);
@@ -18034,7 +18063,7 @@ bxe_pbf_pN_buf_flushed(struct bxe_adapter       *sc,
            ((uint32_t)((int32_t)crd_freed - (int32_t)crd_freed_start) <
             (init_crd - crd_start))) {
         if (cur_cnt--) {
-            DELAY(FLR_WAIT_INTERVAL);
+            udelay(FLR_WAIT_INTERVAL);
             crd = REG_RD(sc, regs->crd);
             crd_freed = REG_RD(sc, regs->crd_freed);
         } else {
@@ -18066,7 +18095,7 @@ bxe_pbf_pN_cmd_flushed(struct bxe_adapter       *sc,
     while (occup &&
            ((uint32_t)((int32_t)freed - (int32_t)freed_start) < to_free)) {
         if (cur_cnt--) {
-            DELAY(FLR_WAIT_INTERVAL);
+            udelay(FLR_WAIT_INTERVAL);
             occup = REG_RD(sc, regs->lines_occup);
             freed = REG_RD(sc, regs->lines_freed);
         } else {
@@ -18207,7 +18236,7 @@ bxe_pf_flr_clnup(struct bxe_adapter *sc)
     bxe_tx_hw_flushed(sc, poll_cnt);
 
     /* Wait 100ms (not adjusted according to platform) */
-    DELAY(100000);
+    udelay(100000);
 
     /* Verify no pending pci transactions */
     if (bxe_is_pcie_pending(sc)) {
@@ -18292,10 +18321,10 @@ bxe_init_hw_func(struct bxe_adapter *sc)
 #endif
 
     for (i = 0; i < L2_ILT_LINES(sc); i++) {
-        ilt->lines[cdu_ilt_start + i].page = sc->context[i].vcxt;
-        ilt->lines[cdu_ilt_start + i].page_mapping =
-            sc->context[i].vcxt_dma.paddr;
-        ilt->lines[cdu_ilt_start + i].size = sc->context[i].size;
+      //ilt->lines[cdu_ilt_start + i].page = sc->context[i].vcxt;
+       //        ilt->lines[cdu_ilt_start + i].page_mapping =
+       //            sc->context[i].vcxt_dma.paddr;
+        //ilt->lines[cdu_ilt_start + i].size = sc->context[i].size;
     }
     ecore_ilt_init_op(sc, INITOP_SET);
 
@@ -18328,7 +18357,7 @@ bxe_init_hw_func(struct bxe_adapter *sc)
          * needed to make sure there are no requests in
          * one of the PXP internal queues with "old" ILT addresses
          */
-        DELAY(20000);
+        udelay(20000);
 
         /*
          * Master enable - Due to WB DMAE writes performed before this
@@ -18600,7 +18629,7 @@ bxe_reset_port(struct bxe_adapter *sc)
     /* Configure AEU */
     REG_WR(sc, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, 0);
 
-    DELAY(100000);
+    udelay(100000);
 
     /* Check for BRB port occupancy */
     val = REG_RD(sc, BRB1_REG_PORT_NUM_OCC_BLOCKS_0 + port*4);
@@ -18698,7 +18727,7 @@ bxe_reset_func(struct bxe_adapter *sc)
          * scan to complete
          */
         for (i = 0; i < 200; i++) {
-            DELAY(10000);
+            udelay(10000);
             if (!REG_RD(sc, TM_REG_LIN0_SCAN_ON + port*4))
                 break;
         }
@@ -18807,4 +18836,3 @@ ecore_storm_memset_struct(struct bxe_adapter *sc,
         REG_WR(sc, addr + (i * 4), data[i]);
     }
 }
-