BXE: changes sp_state back to a long
[akaros.git] / kern / drivers / net / bxe / bxe.h
index 41a8798..c59fa61 100644 (file)
 #include <smp.h>
 #include <stdio.h>
 #include <string.h>
+#include <bitmap.h>
+#include <taskqueue.h>
 
 
 /* MACROS for conversion to AKAROS. Might we want this stuff someday? */
 #define __predict_false(x) (x)
+#define __noinline 
+#define ETH_ADDR_LEN 6
+#define MCLBYTES 2048
 /* TYPEDEFS for conversion to AKAROS. These are temporary, but it makes it easier to see what is in need of change. */
 typedef struct netif *if_t;
+typedef uint64_t ift_counter;
+typedef uintptr_t bus_addr_t;
+typedef uintptr_t bus_size_t;
+typedef uintptr_t bus_space_handle_t;
+typedef uintptr_t bus_dma_tag_t;
+typedef uintptr_t bus_dmamap_t;
+typedef uintptr_t bus_dma_segment_t;
+typedef uintptr_t bus_space_tag_t;
+typedef uintptr_t vm_offset_t;
+typedef int device_t;
+// WTF ...
+typedef uint64_t uintmax_t;
+#define MA_OWNED 0
+#define mtx_assert(lock, thing) assert(1)
+#define device_printf(ignore, format, args...) printk(format, args)
 
 #if _BYTE_ORDER == _LITTLE_ENDIAN
 #ifndef LITTLE_ENDIAN
@@ -426,7 +446,7 @@ struct bxe_intr {
 
 /* Used to manage DMA allocations. */
 struct bxe_dma {
-    struct bxe_softc  *sc;
+    struct bxe_adapter  *sc;
     bus_addr_t        paddr;
     void              *vaddr;
     bus_dma_tag_t     tag;
@@ -496,19 +516,17 @@ struct bxe_sw_tpa_info {
  */
 struct bxe_fastpath {
     /* pointer back to parent structure */
-    struct bxe_softc *sc;
-
-    struct mtx tx_mtx;
+    struct bxe_adapter *sc;
+    qlock_t tx_mtx;
     char       tx_mtx_name[32];
-    struct mtx rx_mtx;
+    qlock_t rx_mtx;
     char       rx_mtx_name[32];
-
-#define BXE_FP_TX_LOCK(fp)        mtx_lock(&fp->tx_mtx)
-#define BXE_FP_TX_UNLOCK(fp)      mtx_unlock(&fp->tx_mtx)
+#define BXE_FP_TX_LOCK(fp)        qlock(&fp->tx_mtx)
+#define BXE_FP_TX_UNLOCK(fp)      qunlock(&fp->tx_mtx)
 #define BXE_FP_TX_LOCK_ASSERT(fp) mtx_assert(&fp->tx_mtx, MA_OWNED)
 
-#define BXE_FP_RX_LOCK(fp)        mtx_lock(&fp->rx_mtx)
-#define BXE_FP_RX_UNLOCK(fp)      mtx_unlock(&fp->rx_mtx)
+#define BXE_FP_RX_LOCK(fp)        qlock(&fp->rx_mtx)
+#define BXE_FP_RX_UNLOCK(fp)      qunlock(&fp->rx_mtx)
 #define BXE_FP_RX_LOCK_ASSERT(fp) mtx_assert(&fp->rx_mtx, MA_OWNED)
 
     /* status block */
@@ -672,6 +690,7 @@ struct bxe_fastpath {
 #define FP_SB_MAX_E1x 16
 #define FP_SB_MAX_E2  HC_SB_MAX_SB_E2
 
+#define MAX_CONTEXT 16 /* XXX taken from other fbsd source. */
 union cdu_context {
     struct eth_context eth;
     char pad[1024];
@@ -878,7 +897,9 @@ struct bxe_fw_stats_data {
  * chip/interface being started/stopped/reinitialized, the actual work is
  * offloaded to a taskqueue.
  */
-#define BXE_CORE_LOCK_SX
+//#define BXE_CORE_LOCK_SX
+// For AKAROS, we don't have sx.
+#undef BXE_CORE_LOCK_SX
 
 /*
  * This is the slowpath data structure. It is mapped into non-paged memory
@@ -886,8 +907,6 @@ struct bxe_fw_stats_data {
  * aligned.
  */
 struct bxe_slowpath {
-
-#if 0
     /*
      * The cdu_context array MUST be the first element in this
      * structure. It is used during the leading edge ramrod
@@ -898,7 +917,6 @@ struct bxe_slowpath {
     /* Used as a DMA source for MAC configuration. */
     struct mac_configuration_cmd    mac_config;
     struct mac_configuration_cmd    mcast_config;
-#endif
 
     /* used by the DMAE command executer */
     struct dmae_command dmae[MAX_DMAE_C];
@@ -998,12 +1016,11 @@ struct bxe_port {
 
     uint32_t    phy_addr;
 
-    /* Used to synchronize phy accesses. */
-    struct mtx  phy_mtx;
-    char        phy_mtx_name[32];
+       qlock_t phy_mtx;
+       char        phy_mtx_name[32];
 
-#define BXE_PHY_LOCK(sc)          mtx_lock(&sc->port.phy_mtx)
-#define BXE_PHY_UNLOCK(sc)        mtx_unlock(&sc->port.phy_mtx)
+#define BXE_PHY_LOCK(sc)          qlock(&sc->port.phy_mtx)
+#define BXE_PHY_UNLOCK(sc)        qunlock(&sc->port.phy_mtx)
 #define BXE_PHY_LOCK_ASSERT(sc)   mtx_assert(&sc->port.phy_mtx, MA_OWNED)
 
     /*
@@ -1024,11 +1041,13 @@ struct bxe_mf_info {
     uint32_t multi_vnics_mode; /* can be set even if vnics_per_port = 1 */
     uint32_t path_has_ovlan;   /* MF mode in the path (can be different than the MF mode of the function */
 
-#define IS_MULTI_VNIC(sc)  ((sc)->devinfo.mf_info.multi_vnics_mode)
-#define VNICS_PER_PORT(sc) ((sc)->devinfo.mf_info.vnics_per_port)
-#define VNICS_PER_PATH(sc)                                  \
+#define IS_MULTI_VNIC(sc)  0 /*((sc)->devinfo.mf_info.multi_vnics_mode)*/
+#define VNICS_PER_PORT(sc) 1/*((sc)->devinfo.mf_info.vnics_per_port)*/
+#define VNICS_PER_PATH(sc) 1
+  /*                                                       \
     ((sc)->devinfo.mf_info.vnics_per_port *                 \
      ((CHIP_PORT_MODE(sc) == CHIP_4_PORT_MODE) ? 2 : 1 ))
+  */
 
     uint8_t min_bw[MAX_VNIC_NUM];
     uint8_t max_bw[MAX_VNIC_NUM];
@@ -1097,8 +1116,8 @@ struct bxe_devinfo {
      *   B = Chip Bond ID  (bits 0-3)
      */
     uint32_t chip_id;
-#define CHIP_ID(sc)           ((sc)->devinfo.chip_id & 0xffff0000)
-#define CHIP_NUM(sc)          ((sc)->devinfo.chip_id >> 16)
+#define CHIP_ID(sc)           0 /*((sc)->devinfo.chip_id & 0xffff0000)*/
+#define CHIP_NUM(sc)          0 /*((sc)->devinfo.chip_id >> 16)*/
 /* device ids */
 #define CHIP_NUM_57710        0x164e
 #define CHIP_NUM_57711        0x164f
@@ -1240,7 +1259,7 @@ struct bxe_devinfo {
     uint32_t bc_ver;
     char bc_ver_str[32];
     uint32_t mf_cfg_base; /* bootcode shmem address in BAR memory */
-    struct bxe_mf_info mf_info;
+  struct bxe_mf_info mf_info;
 
     int flash_size;
 #define NVRAM_1MB_SIZE      0x20000
@@ -1288,16 +1307,35 @@ enum {
 };
 
 /* Top level device private data structure. */
-struct bxe_softc {
-    /*
-     * First entry must be a pointer to the BSD ifnet struct which
-     * has a first element of 'void *if_softc' (which is us). XXX
-     */
-    if_t           ifp;
-    struct ifmedia  ifmedia; /* network interface media structure */
-    int             media;
 
-    int             state; /* device state */
+struct bxe_adapter {
+       /*
+        * First entry must be a pointer to the BSD ifnet struct which
+        * has a first element of 'void *if_softc' (which is us). XXX
+        */
+       if_t        ifp;
+       /* OS defined structs */
+       struct net_device *netdev;
+       struct pci_device *pcidev;
+       /* commonly used Plan 9 driver struct members. */
+       struct ether                            *edev;
+
+       bool                                            active;
+       void                                            *mmio;
+       spinlock_t                                      imlock;                         /* interrupt mask lock */
+       spinlock_t                                      tlock;                          /* transmit lock */
+       qlock_t                                         slock;                          /* stats */
+       qlock_t                                         alock;                          /* attach */
+       struct rendez                           rrendez;                        /* rproc rendez */
+#define Nstatistics 2
+       unsigned int                            statistics[Nstatistics];
+
+       //struct net_device_stats net_stats;
+#warning "no ifmedia. "
+       // struct ifmedia  ifmedia; /* network interface media structure */
+       int             media;
+       
+       int             state; /* device state */
 #define BXE_STATE_CLOSED                 0x0000
 #define BXE_STATE_OPENING_WAITING_LOAD   0x1000
 #define BXE_STATE_OPENING_WAITING_PORT   0x2000
@@ -1308,8 +1346,8 @@ struct bxe_softc {
 #define BXE_STATE_DISABLED               0xD000
 #define BXE_STATE_DIAG                   0xE000
 #define BXE_STATE_ERROR                  0xF000
-
-    int flags;
+       
+       int flags;
 #define BXE_ONE_PORT_FLAG    0x00000001
 #define BXE_NO_ISCSI         0x00000002
 #define BXE_NO_FCOE          0x00000004
@@ -1324,53 +1362,52 @@ struct bxe_softc {
 //#define BXE_SAFC_TX_FLAG     0x00000400
 #define BXE_MF_FUNC_DIS      0x00000800
 #define BXE_TX_SWITCHING     0x00001000
-
-    unsigned long debug; /* per-instance debug logging config */
-
+       
+       unsigned long debug; /* per-instance debug logging config */
+       
 #define MAX_BARS 5
-    struct bxe_bar bar[MAX_BARS]; /* map BARs 0, 2, 4 */
-
-    uint16_t doorbell_size;
-
-    /* periodic timer callout */
+       struct bxe_bar bar[MAX_BARS]; /* map BARs 0, 2, 4 */
+       
+       uint16_t doorbell_size;
+       
+#warning "no timer callout"
+       /* periodic timer callout */
 #define PERIODIC_STOP 0
 #define PERIODIC_GO   1
-    volatile unsigned long periodic_flags;
-    struct callout         periodic_callout;
-
-    /* chip start/stop/reset taskqueue */
+       atomic_t periodic_flags;
+       //      struct callout         periodic_callout;
+       /* chip start/stop/reset taskqueue */
 #define CHIP_TQ_NONE   0
 #define CHIP_TQ_START  1
 #define CHIP_TQ_STOP   2
 #define CHIP_TQ_REINIT 3
-    volatile unsigned long chip_tq_flags;
-    struct task            chip_tq_task;
-    struct taskqueue       *chip_tq;
-    char                   chip_tq_name[32];
-
-    /* slowpath interrupt taskqueue */
-    struct task      sp_tq_task;
-    struct taskqueue *sp_tq;
-    char             sp_tq_name[32];
-
-    /* set rx_mode asynchronous taskqueue */
-    struct task      rx_mode_tq_task;
-    struct taskqueue *rx_mode_tq;
-    char             rx_mode_tq_name[32];
-
-    struct bxe_fastpath fp[MAX_RSS_CHAINS];
-    struct bxe_sp_objs  sp_objs[MAX_RSS_CHAINS];
-
-    device_t dev;  /* parent device handle */
-    uint8_t  unit; /* driver instance number */
-
-    int pcie_bus;    /* PCIe bus number */
-    int pcie_device; /* PCIe device/slot number */
-    int pcie_func;   /* PCIe function number */
-
-    uint8_t pfunc_rel; /* function relative */
-    uint8_t pfunc_abs; /* function absolute */
-    uint8_t path_id;   /* function absolute */
+       atomic_t chip_tq_flags;
+       struct task            chip_tq_task;
+       struct taskqueue       *chip_tq;
+       char                   chip_tq_name[32];
+       
+       /* slowpath interrupt taskqueue */
+       struct task      sp_tq_task;
+       struct taskqueue *sp_tq;
+       char             sp_tq_name[32];
+       
+       /* set rx_mode asynchronous taskqueue */
+       struct task      rx_mode_tq_task;
+       struct taskqueue *rx_mode_tq;
+       char             rx_mode_tq_name[32];
+       struct bxe_fastpath fp[MAX_RSS_CHAINS];
+       struct bxe_sp_objs  sp_objs[MAX_RSS_CHAINS];
+       
+
+       uint8_t  unit; /* driver instance number */
+       
+       int pcie_bus;    /* PCIe bus number */
+       int pcie_device; /* PCIe device/slot number */
+       int pcie_func;   /* PCIe function number */
+       
+       uint8_t pfunc_rel; /* function relative */
+       uint8_t pfunc_abs; /* function absolute */
+       uint8_t path_id;   /* function absolute */
 #define SC_PATH(sc)     (sc->path_id)
 #define SC_PORT(sc)     (sc->pfunc_rel & 1)
 #define SC_FUNC(sc)     (sc->pfunc_rel)
@@ -1385,181 +1422,163 @@ struct bxe_softc {
 #define SC_FW_MB_IDX_VN(sc, vn)                                \
     (SC_PORT(sc) + (vn) *                                      \
      ((CHIP_IS_E1x(sc) || (CHIP_IS_MODE_4_PORT(sc))) ? 2 : 1))
-#define SC_FW_MB_IDX(sc) SC_FW_MB_IDX_VN(sc, SC_VN(sc))
-
-    int if_capen; /* enabled interface capabilities */
-
-    struct bxe_devinfo devinfo;
-    char fw_ver_str[32];
-    char mf_mode_str[32];
-    char pci_link_str[32];
-
-    const struct iro *iro_array;
 
+#define SC_FW_MB_IDX(sc) SC_FW_MB_IDX_VN(sc, SC_VN(sc))
+       
+       int if_capen; /* enabled interface capabilities */
+       
+       struct bxe_devinfo devinfo;
+       char fw_ver_str[32];
+       char mf_mode_str[32];
+       char pci_link_str[32];
+       const struct iro *iro_array;
+       
 #ifdef BXE_CORE_LOCK_SX
-    struct sx      core_sx;
-    char           core_sx_name[32];
+       struct sx      core_sx;
+       char           core_sx_name[32];
 #else
-    struct mtx     core_mtx;
-    char           core_mtx_name[32];
+       qlock_t     core_mtx;
+       char           core_mtx_name[32];
 #endif
-    struct mtx     sp_mtx;
-    char           sp_mtx_name[32];
-    struct mtx     dmae_mtx;
-    char           dmae_mtx_name[32];
-    struct mtx     fwmb_mtx;
-    char           fwmb_mtx_name[32];
-    struct mtx     print_mtx;
-    char           print_mtx_name[32];
-    struct mtx     stats_mtx;
-    char           stats_mtx_name[32];
-    struct mtx     mcast_mtx;
-    char           mcast_mtx_name[32];
-
+       qlock_t     sp_mtx;
+       char           sp_mtx_name[32];
+       qlock_t     dmae_mtx;
+       char           dmae_mtx_name[32];
+       qlock_t     fwmb_mtx;
+       char           fwmb_mtx_name[32];
+       qlock_t     print_mtx;
+       char           print_mtx_name[32];
+       qlock_t     stats_mtx;
+       char           stats_mtx_name[32];
+       qlock_t     mcast_mtx;
+       char           mcast_mtx_name[32];
+       
 #ifdef BXE_CORE_LOCK_SX
 #define BXE_CORE_TRYLOCK(sc)      sx_try_xlock(&sc->core_sx)
 #define BXE_CORE_LOCK(sc)         sx_xlock(&sc->core_sx)
 #define BXE_CORE_UNLOCK(sc)       sx_xunlock(&sc->core_sx)
 #define BXE_CORE_LOCK_ASSERT(sc)  sx_assert(&sc->core_sx, SA_XLOCKED)
 #else
-#define BXE_CORE_TRYLOCK(sc)      mtx_trylock(&sc->core_mtx)
-#define BXE_CORE_LOCK(sc)         mtx_lock(&sc->core_mtx)
-#define BXE_CORE_UNLOCK(sc)       mtx_unlock(&sc->core_mtx)
+#define BXE_CORE_TRYLOCK(sc)      canqlock(&sc->core_mtx)
+#define BXE_CORE_LOCK(sc)         qlock(&sc->core_mtx)
+#define BXE_CORE_UNLOCK(sc)       qunlock(&sc->core_mtx)
 #define BXE_CORE_LOCK_ASSERT(sc)  mtx_assert(&sc->core_mtx, MA_OWNED)
 #endif
 
-#define BXE_SP_LOCK(sc)           mtx_lock(&sc->sp_mtx)
-#define BXE_SP_UNLOCK(sc)         mtx_unlock(&sc->sp_mtx)
+#define BXE_SP_LOCK(sc)           qlock(&sc->sp_mtx)
+#define BXE_SP_UNLOCK(sc)         qunlock(&sc->sp_mtx)
 #define BXE_SP_LOCK_ASSERT(sc)    mtx_assert(&sc->sp_mtx, MA_OWNED)
 
-#define BXE_DMAE_LOCK(sc)         mtx_lock(&sc->dmae_mtx)
-#define BXE_DMAE_UNLOCK(sc)       mtx_unlock(&sc->dmae_mtx)
+#define BXE_DMAE_LOCK(sc)         qlock(&sc->dmae_mtx)
+#define BXE_DMAE_UNLOCK(sc)       qunlock(&sc->dmae_mtx)
 #define BXE_DMAE_LOCK_ASSERT(sc)  mtx_assert(&sc->dmae_mtx, MA_OWNED)
 
-#define BXE_FWMB_LOCK(sc)         mtx_lock(&sc->fwmb_mtx)
-#define BXE_FWMB_UNLOCK(sc)       mtx_unlock(&sc->fwmb_mtx)
+#define BXE_FWMB_LOCK(sc)         qlock(&sc->fwmb_mtx)
+#define BXE_FWMB_UNLOCK(sc)       qunlock(&sc->fwmb_mtx)
 #define BXE_FWMB_LOCK_ASSERT(sc)  mtx_assert(&sc->fwmb_mtx, MA_OWNED)
 
-#define BXE_PRINT_LOCK(sc)        mtx_lock(&sc->print_mtx)
-#define BXE_PRINT_UNLOCK(sc)      mtx_unlock(&sc->print_mtx)
+#define BXE_PRINT_LOCK(sc)        qlock(&sc->print_mtx)
+#define BXE_PRINT_UNLOCK(sc)      qunlock(&sc->print_mtx)
 #define BXE_PRINT_LOCK_ASSERT(sc) mtx_assert(&sc->print_mtx, MA_OWNED)
 
-#define BXE_STATS_LOCK(sc)        mtx_lock(&sc->stats_mtx)
-#define BXE_STATS_UNLOCK(sc)      mtx_unlock(&sc->stats_mtx)
+#define BXE_STATS_LOCK(sc)        qlock(&sc->stats_mtx)
+#define BXE_STATS_UNLOCK(sc)      qunlock(&sc->stats_mtx)
 #define BXE_STATS_LOCK_ASSERT(sc) mtx_assert(&sc->stats_mtx, MA_OWNED)
 
-#if __FreeBSD_version < 800000
+#warning "find outwhat IF_ADDR_LOCK is"
 #define BXE_MCAST_LOCK(sc)        \
     do {                          \
-        mtx_lock(&sc->mcast_mtx); \
-        IF_ADDR_LOCK(sc->ifp);  \
-    } while (0)
-#define BXE_MCAST_UNLOCK(sc)        \
-    do {                            \
-        IF_ADDR_UNLOCK(sc->ifp);  \
-        mtx_unlock(&sc->mcast_mtx); \
-    } while (0)
-#else
-#define BXE_MCAST_LOCK(sc)         \
-    do {                           \
-        mtx_lock(&sc->mcast_mtx);  \
-        if_maddr_rlock(sc->ifp); \
-    } while (0)
-#define BXE_MCAST_UNLOCK(sc)         \
-    do {                             \
-        if_maddr_runlock(sc->ifp); \
-        mtx_unlock(&sc->mcast_mtx);  \
+           /*IF_ADDR_LOCK(sc->ifp);*/          \
     } while (0)
-#endif
 #define BXE_MCAST_LOCK_ASSERT(sc) mtx_assert(&sc->mcast_mtx, MA_OWNED)
-
-    int dmae_ready;
+       
+       int dmae_ready;
 #define DMAE_READY(sc) (sc->dmae_ready)
-
-    struct ecore_credit_pool_obj vlans_pool;
-    struct ecore_credit_pool_obj macs_pool;
-    struct ecore_rx_mode_obj     rx_mode_obj;
-    struct ecore_mcast_obj       mcast_obj;
-    struct ecore_rss_config_obj  rss_conf_obj;
-    struct ecore_func_sp_obj     func_obj;
-
-    uint16_t fw_seq;
-    uint16_t fw_drv_pulse_wr_seq;
-    uint32_t func_stx;
-
-    struct elink_params         link_params;
-    struct elink_vars           link_vars;
-    uint32_t                    link_cnt;
-    struct bxe_link_report_data last_reported_link;
-    char mac_addr_str[32];
-
-    int last_reported_link_state;
-
-    int tx_ring_size;
-    int rx_ring_size;
-    int wol;
-
-    int is_leader;
-    int recovery_state;
+       
+       struct ecore_credit_pool_obj vlans_pool;
+       struct ecore_credit_pool_obj macs_pool;
+       struct ecore_rx_mode_obj     rx_mode_obj;
+       struct ecore_mcast_obj       mcast_obj;
+       struct ecore_rss_config_obj  rss_conf_obj;
+       struct ecore_func_sp_obj     func_obj;
+
+       uint16_t fw_seq;
+       uint16_t fw_drv_pulse_wr_seq;
+       uint32_t func_stx;
+       
+       struct elink_params         link_params;
+       struct elink_vars           link_vars;
+       uint32_t                    link_cnt;
+       struct bxe_link_report_data last_reported_link;
+       char mac_addr_str[32];
+       
+       int last_reported_link_state;
+       
+       int tx_ring_size;
+       int rx_ring_size;
+       int wol;
+       
+       int is_leader;
+       int recovery_state;
 #define BXE_RECOVERY_DONE        1
 #define BXE_RECOVERY_INIT        2
 #define BXE_RECOVERY_WAIT        3
 #define BXE_RECOVERY_FAILED      4
 #define BXE_RECOVERY_NIC_LOADING 5
-
-    uint32_t rx_mode;
+       
+       uint32_t rx_mode;
 #define BXE_RX_MODE_NONE     0
 #define BXE_RX_MODE_NORMAL   1
 #define BXE_RX_MODE_ALLMULTI 2
 #define BXE_RX_MODE_PROMISC  3
 #define BXE_MAX_MULTICAST    64
-
-    struct bxe_port port;
-
-    struct cmng_init cmng;
-
-    /* user configs */
-    int      num_queues;
-    int      max_rx_bufs;
-    int      hc_rx_ticks;
-    int      hc_tx_ticks;
-    int      rx_budget;
-    int      max_aggregation_size;
-    int      mrrs;
-    int      autogreeen;
+       
+       struct bxe_port port;
+       
+       struct cmng_init cmng;
+       
+       /* user configs */
+       int      num_queues;
+       int      max_rx_bufs;
+       int      hc_rx_ticks;
+       int      hc_tx_ticks;
+       int      rx_budget;
+       int      max_aggregation_size;
+       int      mrrs;
+       int      autogreeen;
 #define AUTO_GREEN_HW_DEFAULT 0
 #define AUTO_GREEN_FORCE_ON   1
 #define AUTO_GREEN_FORCE_OFF  2
-    int      interrupt_mode;
+       int      interrupt_mode;
 #define INTR_MODE_INTX 0
 #define INTR_MODE_MSI  1
 #define INTR_MODE_MSIX 2
-    int      udp_rss;
-
-    /* interrupt allocations */
-    struct bxe_intr intr[MAX_RSS_CHAINS+1];
-    int             intr_count;
-    uint8_t         igu_dsb_id;
-    uint8_t         igu_base_sb;
-    uint8_t         igu_sb_cnt;
-    //uint8_t         min_msix_vec_cnt;
-    uint32_t        igu_base_addr;
-    //bus_addr_t      def_status_blk_mapping;
-    uint8_t         base_fw_ndsb;
+       int      udp_rss;
+       
+       /* interrupt allocations */
+       struct bxe_intr intr[MAX_RSS_CHAINS+1];
+       int             intr_count;
+       uint8_t         igu_dsb_id;
+       uint8_t         igu_base_sb;
+       uint8_t         igu_sb_cnt;
+       //uint8_t         min_msix_vec_cnt;
+       uint32_t        igu_base_addr;
+       //bus_addr_t      def_status_blk_mapping;
+       uint8_t         base_fw_ndsb;
 #define DEF_SB_IGU_ID 16
 #define DEF_SB_ID     HC_SP_SB_ID
-
-    /* parent bus DMA tag  */
-    bus_dma_tag_t parent_dma_tag;
-
-    /* default status block */
-    struct bxe_dma              def_sb_dma;
-    struct host_sp_status_block *def_sb;
-    uint16_t                    def_idx;
-    uint16_t                    def_att_idx;
-    uint32_t                    attn_state;
-    struct attn_route           attn_group[MAX_DYNAMIC_ATTN_GRPS];
-
+       
+       /* parent bus DMA tag  */
+       bus_dma_tag_t parent_dma_tag;
+       
+       /* default status block */
+       struct bxe_dma              def_sb_dma;
+       struct host_sp_status_block *def_sb;
+       uint16_t                    def_idx;
+       uint16_t                    def_att_idx;
+       uint32_t                    attn_state;
+       struct attn_route           attn_group[MAX_DYNAMIC_ATTN_GRPS];
+       
 /* general SP events - stats query, cfc delete, etc */
 #define HC_SP_INDEX_ETH_DEF_CONS         3
 /* EQ completions */
@@ -1571,12 +1590,12 @@ struct bxe_softc {
 #define HC_SP_INDEX_ETH_ISCSI_CQ_CONS    5
 #define HC_SP_INDEX_ETH_ISCSI_RX_CQ_CONS 1
 
-    /* event queue */
-    struct bxe_dma        eq_dma;
-    union event_ring_elem *eq;
-    uint16_t              eq_prod;
-    uint16_t              eq_cons;
-    uint16_t              *eq_cons_sb;
+       /* event queue */
+       struct bxe_dma        eq_dma;
+       union event_ring_elem *eq;
+       uint16_t              eq_prod;
+       uint16_t              eq_cons;
+       uint16_t              *eq_cons_sb;
 #define NUM_EQ_PAGES     1 /* must be a power of 2 */
 #define EQ_DESC_CNT_PAGE (BCM_PAGE_SIZE / sizeof(union event_ring_elem))
 #define EQ_DESC_MAX_PAGE (EQ_DESC_CNT_PAGE - 1)
@@ -1591,51 +1610,51 @@ struct bxe_softc {
 #define EQ_DESC(x) ((x) & EQ_DESC_MASK)
 
     /* slow path */
-    struct bxe_dma      sp_dma;
-    struct bxe_slowpath *sp;
-    unsigned long       sp_state;
-
-    /* slow path queue */
-    struct bxe_dma spq_dma;
-    struct eth_spe *spq;
+       struct bxe_dma      sp_dma;
+       struct bxe_slowpath *sp;
+       unsigned long       sp_state;
+       
+       /* slow path queue */
+       struct bxe_dma spq_dma;
+struct eth_spe *spq;
 #define SP_DESC_CNT     (BCM_PAGE_SIZE / sizeof(struct eth_spe))
 #define MAX_SP_DESC_CNT (SP_DESC_CNT - 1)
 #define MAX_SPQ_PENDING 8
-
-    uint16_t       spq_prod_idx;
-    struct eth_spe *spq_prod_bd;
-    struct eth_spe *spq_last_bd;
-    uint16_t       *dsb_sp_prod;
-    //uint16_t       *spq_hw_con;
-    //uint16_t       spq_left;
-
-    volatile unsigned long eq_spq_left; /* COMMON_xxx ramrod credit */
-    volatile unsigned long cq_spq_left; /* ETH_xxx ramrod credit */
-
-    /* fw decompression buffer */
-    struct bxe_dma gz_buf_dma;
-    void           *gz_buf;
-    z_streamp      gz_strm;
-    uint32_t       gz_outlen;
+       
+       uint16_t       spq_prod_idx;
+       struct eth_spe *spq_prod_bd;
+       struct eth_spe *spq_last_bd;
+       uint16_t       *dsb_sp_prod;
+       uint16_t       *spq_hw_con;
+       uint16_t       spq_left;
+       
+       atomic_t eq_spq_left; /* COMMON_xxx ramrod credit */
+       atomic_t cq_spq_left; /* ETH_xxx ramrod credit */
+       
+       /* fw decompression buffer */
+       struct bxe_dma gz_buf_dma;
+       void           *gz_buf;
+       //    z_streamp      gz_strm;
+       uint32_t       gz_outlen;
 #define GUNZIP_BUF(sc)    (sc->gz_buf)
 #define GUNZIP_OUTLEN(sc) (sc->gz_outlen)
 #define GUNZIP_PHYS(sc)   (sc->gz_buf_dma.paddr)
 #define FW_BUF_SIZE       0x40000
-
-    const struct raw_op *init_ops;
-    const uint16_t *init_ops_offsets; /* init block offsets inside init_ops */
-    const uint32_t *init_data;        /* data blob, 32 bit granularity */
-    uint32_t       init_mode_flags;
+       
+       const struct raw_op *init_ops;
+       const uint16_t *init_ops_offsets; /* init block offsets inside init_ops */
+       const uint32_t *init_data;        /* data blob, 32 bit granularity */
+       uint32_t       init_mode_flags;
 #define INIT_MODE_FLAGS(sc) (sc->init_mode_flags)
-    /* PRAM blobs - raw data */
-    const uint8_t *tsem_int_table_data;
-    const uint8_t *tsem_pram_data;
-    const uint8_t *usem_int_table_data;
-    const uint8_t *usem_pram_data;
-    const uint8_t *xsem_int_table_data;
-    const uint8_t *xsem_pram_data;
-    const uint8_t *csem_int_table_data;
-    const uint8_t *csem_pram_data;
+       /* PRAM blobs - raw data */
+       const uint8_t *tsem_int_table_data;
+       const uint8_t *tsem_pram_data;
+       const uint8_t *usem_int_table_data;
+       const uint8_t *usem_pram_data;
+       const uint8_t *xsem_int_table_data;
+       const uint8_t *xsem_pram_data;
+       const uint8_t *csem_int_table_data;
+       const uint8_t *csem_pram_data;
 #define INIT_OPS(sc)                 (sc->init_ops)
 #define INIT_OPS_OFFSETS(sc)         (sc->init_ops_offsets)
 #define INIT_DATA(sc)                (sc->init_data)
@@ -1648,116 +1667,115 @@ struct bxe_softc {
 #define INIT_CSEM_INT_TABLE_DATA(sc) (sc->csem_int_table_data)
 #define INIT_CSEM_PRAM_DATA(sc)      (sc->csem_pram_data)
 
-    /* ILT
-     * For max 196 cids (64*3 + non-eth), 32KB ILT page size and 1KB
-     * context size we need 8 ILT entries.
-     */
+       /* ILT
+        * For max 196 cids (64*3 + non-eth), 32KB ILT page size and 1KB
+        * context size we need 8 ILT entries.
+        */
 #define ILT_MAX_L2_LINES 8
-    struct hw_context context[ILT_MAX_L2_LINES];
-    struct ecore_ilt *ilt;
+       //    struct hw_context context[ILT_MAX_L2_LINES];
+       struct ecore_ilt *ilt;
 #define ILT_MAX_LINES 256
-
+       
 /* max supported number of RSS queues: IGU SBs minus one for CNIC */
 #define BXE_MAX_RSS_COUNT(sc) ((sc)->igu_sb_cnt - CNIC_SUPPORT(sc))
 /* max CID count: Max RSS * Max_Tx_Multi_Cos + FCoE + iSCSI */
 #if 1
 #define BXE_L2_MAX_CID(sc)                                              \
-    (BXE_MAX_RSS_COUNT(sc) * ECORE_MULTI_TX_COS + 2 * CNIC_SUPPORT(sc))
+       (BXE_MAX_RSS_COUNT(sc) * ECORE_MULTI_TX_COS + 2 * CNIC_SUPPORT(sc))
 #else
 #define BXE_L2_MAX_CID(sc) /* OOO + FWD */                              \
-    (BXE_MAX_RSS_COUNT(sc) * ECORE_MULTI_TX_COS + 4 * CNIC_SUPPORT(sc))
+       (BXE_MAX_RSS_COUNT(sc) * ECORE_MULTI_TX_COS + 4 * CNIC_SUPPORT(sc))
 #endif
 #if 1
-#define BXE_L2_CID_COUNT(sc)                                             \
-    (BXE_NUM_ETH_QUEUES(sc) * ECORE_MULTI_TX_COS + 2 * CNIC_SUPPORT(sc))
+#define BXE_L2_CID_COUNT(sc)                                           \
+       (BXE_NUM_ETH_QUEUES(sc) * ECORE_MULTI_TX_COS + 2 * CNIC_SUPPORT(sc))
 #else
-#define BXE_L2_CID_COUNT(sc) /* OOO + FWD */                             \
-    (BXE_NUM_ETH_QUEUES(sc) * ECORE_MULTI_TX_COS + 4 * CNIC_SUPPORT(sc))
+#define BXE_L2_CID_COUNT(sc) /* OOO + FWD */                           \
+       (BXE_NUM_ETH_QUEUES(sc) * ECORE_MULTI_TX_COS + 4 * CNIC_SUPPORT(sc))
 #endif
 #define L2_ILT_LINES(sc)                                \
-    (DIV_ROUND_UP(BXE_L2_CID_COUNT(sc), ILT_PAGE_CIDS))
-
-    int qm_cid_count;
-
-    uint8_t dropless_fc;
-
-#if 0
-    struct bxe_dma *t2;
-#endif
-
-    /* total number of FW statistics requests */
-    uint8_t fw_stats_num;
-    /*
-     * This is a memory buffer that will contain both statistics ramrod
-     * request and data.
-     */
-    struct bxe_dma fw_stats_dma;
-    /*
-     * FW statistics request shortcut (points at the beginning of fw_stats
-     * buffer).
-     */
-    int                     fw_stats_req_size;
-    struct bxe_fw_stats_req *fw_stats_req;
-    bus_addr_t              fw_stats_req_mapping;
-    /*
-     * FW statistics data shortcut (points at the beginning of fw_stats
-     * buffer + fw_stats_req_size).
-     */
-    int                      fw_stats_data_size;
-    struct bxe_fw_stats_data *fw_stats_data;
-    bus_addr_t               fw_stats_data_mapping;
-
-    /* tracking a pending STAT_QUERY ramrod */
-    uint16_t stats_pending;
-    /* number of completed statistics ramrods */
-    uint16_t stats_comp;
-    uint16_t stats_counter;
-    uint8_t  stats_init;
-    int      stats_state;
-
-    struct bxe_eth_stats         eth_stats;
-    struct host_func_stats       func_stats;
-    struct bxe_eth_stats_old     eth_stats_old;
-    struct bxe_net_stats_old     net_stats_old;
-    struct bxe_fw_port_stats_old fw_stats_old;
-
-    struct dmae_command stats_dmae; /* used by dmae command loader */
-    int                 executer_idx;
-
-    int mtu;
-
-    /* LLDP params */
-    struct bxe_config_lldp_params lldp_config_params;
-    /* DCB support on/off */
-    int dcb_state;
+       (DIV_ROUND_UP(BXE_L2_CID_COUNT(sc), ILT_PAGE_CIDS))
+       
+       int qm_cid_count;
+       
+       uint8_t dropless_fc;
+
+       struct bxe_dma *t2;
+
+       /* total number of FW statistics requests */
+       uint8_t fw_stats_num;
+       /*
+        * This is a memory buffer that will contain both statistics ramrod
+        * request and data.
+        */
+       struct bxe_dma fw_stats_dma;
+       /*
+        * FW statistics request shortcut (points at the beginning of fw_stats
+        * buffer).
+        */
+       int                     fw_stats_req_size;
+       struct bxe_fw_stats_req *fw_stats_req;
+       bus_addr_t              fw_stats_req_mapping;
+       /*
+        * FW statistics data shortcut (points at the beginning of fw_stats
+        * buffer + fw_stats_req_size).
+        */
+       int                      fw_stats_data_size;
+       struct bxe_fw_stats_data *fw_stats_data;
+       bus_addr_t               fw_stats_data_mapping;
+       
+       /* tracking a pending STAT_QUERY ramrod */
+       uint16_t stats_pending;
+       /* number of completed statistics ramrods */
+       uint16_t stats_comp;
+       uint16_t stats_counter;
+       uint8_t  stats_init;
+       int      stats_state;
+
+       struct bxe_eth_stats         eth_stats;
+       struct host_func_stats       func_stats;
+       struct bxe_eth_stats_old     eth_stats_old;
+       struct bxe_net_stats_old     net_stats_old;
+       struct bxe_fw_port_stats_old fw_stats_old;
+       
+       struct dmae_command stats_dmae; /* used by dmae command loader */
+
+       int                 executer_idx;
+       
+       int mtu;
+       
+       /* LLDP params */
+       struct bxe_config_lldp_params lldp_config_params;
+       /* DCB support on/off */
+       int dcb_state;
 #define BXE_DCB_STATE_OFF 0
 #define BXE_DCB_STATE_ON  1
-    /* DCBX engine mode */
-    int dcbx_enabled;
+       /* DCBX engine mode */
+       int dcbx_enabled;
 #define BXE_DCBX_ENABLED_OFF        0
 #define BXE_DCBX_ENABLED_ON_NEG_OFF 1
 #define BXE_DCBX_ENABLED_ON_NEG_ON  2
 #define BXE_DCBX_ENABLED_INVALID    -1
-    uint8_t dcbx_mode_uset;
-    struct bxe_config_dcbx_params dcbx_config_params;
-    struct bxe_dcbx_port_params   dcbx_port_params;
-    int dcb_version;
-
-    uint8_t cnic_support;
-    uint8_t cnic_enabled;
-    uint8_t cnic_loaded;
+       uint8_t dcbx_mode_uset;
+       struct bxe_config_dcbx_params dcbx_config_params;
+       struct bxe_dcbx_port_params   dcbx_port_params;
+       int dcb_version;
+       
+       uint8_t cnic_support;
+       uint8_t cnic_enabled;
+       uint8_t cnic_loaded;
 #define CNIC_SUPPORT(sc) 0 /* ((sc)->cnic_support) */
 #define CNIC_ENABLED(sc) 0 /* ((sc)->cnic_enabled) */
 #define CNIC_LOADED(sc)  0 /* ((sc)->cnic_loaded) */
-
-    /* multiple tx classes of service */
-    uint8_t max_cos;
+       
+       /* multiple tx classes of service */
+       uint8_t max_cos;
 #define BXE_MAX_PRIORITY 8
-    /* priority to cos mapping */
-    uint8_t prio_to_cos[BXE_MAX_PRIORITY];
-
-    int panic;
-}; /* struct bxe_softc */
+       /* priority to cos mapping */
+       uint8_t prio_to_cos[BXE_MAX_PRIORITY];
+       
+       int panic;
+}; /* struct bxe_adapter */
 
 /* IOCTL sub-commands for edebug and firmware upgrade */
 #define BXE_IOC_RD_NVRAM        1
@@ -1811,15 +1829,16 @@ struct bxe_func_init_params {
 #define BAR1 2
 #define BAR2 4
 
+#define BXE_REG_NO_INLINE
 #ifdef BXE_REG_NO_INLINE
 
-uint8_t bxe_reg_read8(struct bxe_softc *sc, bus_size_t offset);
-uint16_t bxe_reg_read16(struct bxe_softc *sc, bus_size_t offset);
-uint32_t bxe_reg_read32(struct bxe_softc *sc, bus_size_t offset);
+uint8_t bxe_reg_read8(struct bxe_adapter *sc, bus_size_t offset);
+uint16_t bxe_reg_read16(struct bxe_adapter *sc, bus_size_t offset);
+uint32_t bxe_reg_read32(struct bxe_adapter *sc, bus_size_t offset);
 
-void bxe_reg_write8(struct bxe_softc *sc, bus_size_t offset, uint8_t val);
-void bxe_reg_write16(struct bxe_softc *sc, bus_size_t offset, uint16_t val);
-void bxe_reg_write32(struct bxe_softc *sc, bus_size_t offset, uint32_t val);
+void bxe_reg_write8(struct bxe_adapter *sc, bus_size_t offset, uint8_t val);
+void bxe_reg_write16(struct bxe_adapter *sc, bus_size_t offset, uint16_t val);
+void bxe_reg_write32(struct bxe_adapter *sc, bus_size_t offset, uint32_t val);
 
 #define REG_RD8(sc, offset)  bxe_reg_read8(sc, offset)
 #define REG_RD16(sc, offset) bxe_reg_read16(sc, offset)
@@ -1874,7 +1893,7 @@ void bxe_reg_write32(struct bxe_softc *sc, bus_size_t offset, uint32_t val);
     (sc->sp_dma.paddr + offsetof(struct bxe_slowpath, var))
 
 #define BXE_FP(sc, nr, var) ((sc)->fp[(nr)].var)
-#define BXE_SP_OBJ(sc, fp) ((sc)->sp_objs[(fp)->index])
+#define BXE_SP_OBJ(sc, fp) (void *) 0 /*((sc)->sp_objs[(fp)->index])*/
 
 #if 0
 #define bxe_fp(sc, nr, var)   ((sc)->fp[nr].var)
@@ -2063,8 +2082,8 @@ static const uint32_t dmae_reg_go_c[] = {
 #define BXE_SWCID_SHIFT 17
 #define BXE_SWCID_MASK  ((0x1 << BXE_SWCID_SHIFT) - 1)
 
-#define SW_CID(x)  (le32toh(x) & BXE_SWCID_MASK)
-#define CQE_CMD(x) (le32toh(x) >> COMMON_RAMROD_ETH_RX_CQE_CMD_ID_SHIFT)
+#define SW_CID(x)  (le32_to_cpu(x) & BXE_SWCID_MASK)
+#define CQE_CMD(x) (le32_to_cpu(x) >> COMMON_RAMROD_ETH_RX_CQE_CMD_ID_SHIFT)
 
 #define CQE_TYPE(cqe_fp_flags)   ((cqe_fp_flags) & ETH_FAST_PATH_RX_CQE_TYPE)
 #define CQE_TYPE_START(cqe_type) ((cqe_type) == RX_ETH_CQE_TYPE_ETH_START_AGG)
@@ -2085,52 +2104,51 @@ static const uint32_t dmae_reg_go_c[] = {
 #define PCI_PM_D0    1
 #define PCI_PM_D3hot 2
 
-int  bxe_test_bit(int nr, volatile unsigned long * addr);
-void bxe_set_bit(unsigned int nr, volatile unsigned long * addr);
-void bxe_clear_bit(int nr, volatile unsigned long * addr);
-int  bxe_test_and_set_bit(int nr, volatile unsigned long * addr);
-int  bxe_test_and_clear_bit(int nr, volatile unsigned long * addr);
-int  bxe_cmpxchg(volatile int *addr, int old, int new);
+#define bxe_test_bit(nr, addr) test_bit(nr, addr)
+#define bxe_set_bit(nr, addr) set_bit(nr, addr)
+#define bxe_clear_bit(nr, addr) clear_bit(nr, addr)
+#define bxe_test_and_set_bit(nr, addr) test_and_set_bit(nr, addr)
+#define bxe_test_and_clear_bit(nr, addr) test_and_clear_bit(nr, addr)
 
-void bxe_reg_wr_ind(struct bxe_softc *sc, uint32_t addr,
+void bxe_reg_wr_ind(struct bxe_adapter *sc, uint32_t addr,
                     uint32_t val);
-uint32_t bxe_reg_rd_ind(struct bxe_softc *sc, uint32_t addr);
+uint32_t bxe_reg_rd_ind(struct bxe_adapter *sc, uint32_t addr);
 
 
-int bxe_dma_alloc(struct bxe_softc *sc, bus_size_t size,
+int bxe_dma_alloc(struct bxe_adapter *sc, bus_size_t size,
                   struct bxe_dma *dma, const char *msg);
-void bxe_dma_free(struct bxe_softc *sc, struct bxe_dma *dma);
+void bxe_dma_free(struct bxe_adapter *sc, struct bxe_dma *dma);
 
 uint32_t bxe_dmae_opcode_add_comp(uint32_t opcode, uint8_t comp_type);
 uint32_t bxe_dmae_opcode_clr_src_reset(uint32_t opcode);
-uint32_t bxe_dmae_opcode(struct bxe_softc *sc, uint8_t src_type,
+uint32_t bxe_dmae_opcode(struct bxe_adapter *sc, uint8_t src_type,
                          uint8_t dst_type, uint8_t with_comp,
                          uint8_t comp_type);
-void bxe_post_dmae(struct bxe_softc *sc, struct dmae_command *dmae, int idx);
-void bxe_read_dmae(struct bxe_softc *sc, uint32_t src_addr, uint32_t len32);
-void bxe_write_dmae(struct bxe_softc *sc, bus_addr_t dma_addr,
+void bxe_post_dmae(struct bxe_adapter *sc, struct dmae_command *dmae, int idx);
+void bxe_read_dmae(struct bxe_adapter *sc, uint32_t src_addr, uint32_t len32);
+void bxe_write_dmae(struct bxe_adapter *sc, bus_addr_t dma_addr,
                     uint32_t dst_addr, uint32_t len32);
-void bxe_write_dmae_phys_len(struct bxe_softc *sc, bus_addr_t phys_addr,
+void bxe_write_dmae_phys_len(struct bxe_adapter *sc, bus_addr_t phys_addr,
                              uint32_t addr, uint32_t len);
 
-void bxe_set_ctx_validation(struct bxe_softc *sc, struct eth_context *cxt,
+void bxe_set_ctx_validation(struct bxe_adapter *sc, struct eth_context *cxt,
                             uint32_t cid);
-void bxe_update_coalesce_sb_index(struct bxe_softc *sc, uint8_t fw_sb_id,
+void bxe_update_coalesce_sb_index(struct bxe_adapter *sc, uint8_t fw_sb_id,
                                   uint8_t sb_index, uint8_t disable,
                                   uint16_t usec);
 
-int bxe_sp_post(struct bxe_softc *sc, int command, int cid,
+int bxe_sp_post(struct bxe_adapter *sc, int command, int cid,
                 uint32_t data_hi, uint32_t data_lo, int cmd_type);
 
-void bxe_igu_ack_sb(struct bxe_softc *sc, uint8_t igu_sb_id,
+void bxe_igu_ack_sb(struct bxe_adapter *sc, uint8_t igu_sb_id,
                     uint8_t segment, uint16_t index, uint8_t op,
                     uint8_t update);
 
-void ecore_init_e1_firmware(struct bxe_softc *sc);
-void ecore_init_e1h_firmware(struct bxe_softc *sc);
-void ecore_init_e2_firmware(struct bxe_softc *sc);
+void ecore_init_e1_firmware(struct bxe_adapter *sc);
+void ecore_init_e1h_firmware(struct bxe_adapter *sc);
+void ecore_init_e2_firmware(struct bxe_adapter *sc);
 
-void ecore_storm_memset_struct(struct bxe_softc *sc, uint32_t addr,
+void ecore_storm_memset_struct(struct bxe_adapter *sc, uint32_t addr,
                                size_t size, uint32_t *data);
 
 /*********************/
@@ -2165,7 +2183,7 @@ void ecore_storm_memset_struct(struct bxe_softc *sc, uint32_t addr,
 #define BLOGD(sc, codepath, format, args...)           \
     do {                                               \
         if (__predict_false(sc->debug & (codepath))) { \
-            device_printf((sc)->dev,                   \
+            /*device_printf((sc)->dev,*/printk(                   \
                           "%s(%s:%d) " format,         \
                           __FUNCTION__,                \
                           __FILE__,                    \
@@ -2175,51 +2193,51 @@ void ecore_storm_memset_struct(struct bxe_softc *sc, uint32_t addr,
     } while(0)
 
 /* log a info message */
-#define BLOGI(sc, format, args...)             \
+#define BLOGI(sc, format, args...) \
     do {                                       \
         if (__predict_false(sc->debug)) {      \
-            device_printf((sc)->dev,           \
+            /*device_printf((sc)->dev,*/printk(           \
                           "%s(%s:%d) " format, \
                           __FUNCTION__,        \
                           __FILE__,            \
                           __LINE__,            \
                           ## args);            \
         } else {                               \
-            device_printf((sc)->dev,           \
+            /*device_printf((sc)->dev,*/printk(           \
                           format,              \
                           ## args);            \
         }                                      \
     } while(0)
 
 /* log a warning message */
-#define BLOGW(sc, format, args...)                      \
+#define BLOGW(sc, format, args...) \
     do {                                                \
         if (__predict_false(sc->debug)) {               \
-            device_printf((sc)->dev,                    \
+            /*device_printf((sc)->dev,*/printk(                    \
                           "%s(%s:%d) WARNING: " format, \
                           __FUNCTION__,                 \
                           __FILE__,                     \
                           __LINE__,                     \
                           ## args);                     \
         } else {                                        \
-            device_printf((sc)->dev,                    \
+            /*device_printf((sc)->dev,*/printk(                    \
                           "WARNING: " format,           \
                           ## args);                     \
         }                                               \
     } while(0)
 
 /* log a error message */
-#define BLOGE(sc, format, args...)                    \
+#define BLOGE(sc, format, args...) \
     do {                                              \
         if (__predict_false(sc->debug)) {             \
-            device_printf((sc)->dev,                  \
+            /*device_printf((sc)->dev,*/printk(                  \
                           "%s(%s:%d) ERROR: " format, \
                           __FUNCTION__,               \
                           __FILE__,                   \
                           __LINE__,                   \
                           ## args);                   \
         } else {                                      \
-            device_printf((sc)->dev,                  \
+            /*device_printf((sc)->dev,*/printk(                  \
                           "ERROR: " format,           \
                           ## args);                   \
         }                                             \
@@ -2235,24 +2253,27 @@ void ecore_storm_memset_struct(struct bxe_softc *sc, uint32_t addr,
 #else
 
 #define bxe_panic(sc, msg) \
-    device_printf((sc)->dev, "%s (%s,%d)\n", __FUNCTION__, __FILE__, __LINE__);
+    /*device_printf((sc)->dev,*/printk( "%s (%s,%d)\n", __FUNCTION__, __FILE__, __LINE__);
 
 #endif
 
 #define CATC_TRIGGER(sc, data) REG_WR((sc), 0x2000, (data));
 #define CATC_TRIGGER_START(sc) CATC_TRIGGER((sc), 0xcafecafe)
 
-void bxe_dump_mem(struct bxe_softc *sc, char *tag,
+void bxe_dump_mem(struct bxe_adapter *sc, char *tag,
                   uint8_t *mem, uint32_t len);
-void bxe_dump_mbuf_data(struct bxe_softc *sc, char *pTag,
+void bxe_dump_mbuf_data(struct bxe_adapter *sc, char *pTag,
                         struct mbuf *m, uint8_t contents);
 
+/* Defined in bxe.c, init'd in bxereset or something in bxe_dev.c */
+extern qlock_t bxe_prev_mtx;
+
 /***********/
 /* INLINES */
 /***********/
 
 static inline uint32_t
-reg_poll(struct bxe_softc *sc,
+reg_poll(struct bxe_adapter *sc,
          uint32_t         reg,
          uint32_t         expected,
          int              ms,
@@ -2266,7 +2287,7 @@ reg_poll(struct bxe_softc *sc,
             break;
         }
         ms -= wait;
-        DELAY(wait * 1000);
+        udelay(wait);
     } while (ms > 0);
 
     return (val);
@@ -2280,7 +2301,7 @@ bxe_update_fp_sb_idx(struct bxe_fastpath *fp)
 }
 
 static inline void
-bxe_igu_ack_sb_gen(struct bxe_softc *sc,
+bxe_igu_ack_sb_gen(struct bxe_adapter *sc,
                    uint8_t          igu_sb_id,
                    uint8_t          segment,
                    uint16_t         index,
@@ -2301,13 +2322,14 @@ bxe_igu_ack_sb_gen(struct bxe_softc *sc,
     REG_WR(sc, igu_addr, cmd_data.sb_id_and_flags);
 
     /* Make sure that ACK is written */
-    bus_space_barrier(sc->bar[0].tag, sc->bar[0].handle, 0, 0,
-                      BUS_SPACE_BARRIER_WRITE);
+#warning "bus space barrier write"
+    //    bus_space_barrier(sc->bar[0].tag, sc->bar[0].handle, 0, 0,
+    //                BUS_SPACE_BARRIER_WRITE);
     mb();
 }
 
 static inline void
-bxe_hc_ack_sb(struct bxe_softc *sc,
+bxe_hc_ack_sb(struct bxe_adapter *sc,
               uint8_t          sb_id,
               uint8_t          storm,
               uint16_t         index,
@@ -2328,19 +2350,20 @@ bxe_hc_ack_sb(struct bxe_softc *sc,
     REG_WR(sc, hc_addr, (*(uint32_t *)&igu_ack));
 
     /* Make sure that ACK is written */
-    bus_space_barrier(sc->bar[0].tag, sc->bar[0].handle, 0, 0,
-                      BUS_SPACE_BARRIER_WRITE);
+    //    bus_space_barrier(sc->bar[0].tag, sc->bar[0].handle, 0, 0,
+    //                      BUS_SPACE_BARRIER_WRITE);
     mb();
 }
 
 static inline void
-bxe_ack_sb(struct bxe_softc *sc,
+bxe_ack_sb(struct bxe_adapter *sc,
            uint8_t          igu_sb_id,
            uint8_t          storm,
            uint16_t         index,
            uint8_t          op,
            uint8_t          update)
 {
+#if 0
     if (sc->devinfo.int_block == INT_BLOCK_HC)
         bxe_hc_ack_sb(sc, igu_sb_id, storm, index, op, update);
     else {
@@ -2356,10 +2379,11 @@ bxe_ack_sb(struct bxe_softc *sc,
         }
         bxe_igu_ack_sb(sc, igu_sb_id, segment, index, op, update);
     }
+#endif
 }
 
 static inline uint16_t
-bxe_hc_ack_int(struct bxe_softc *sc)
+bxe_hc_ack_int(struct bxe_adapter *sc)
 {
     uint32_t hc_addr = (HC_REG_COMMAND_REG + SC_PORT(sc)*32 +
                         COMMAND_REG_SIMD_MASK);
@@ -2369,9 +2393,11 @@ bxe_hc_ack_int(struct bxe_softc *sc)
     return (result);
 }
 
+#warning "fix all igu stuff"
 static inline uint16_t
-bxe_igu_ack_int(struct bxe_softc *sc)
+bxe_igu_ack_int(struct bxe_adapter *sc)
 {
+#if 0
     uint32_t igu_addr = (BAR_IGU_INTMEM + IGU_REG_SISR_MDPC_WMASK_LSB_UPPER*8);
     uint32_t result = REG_RD(sc, igu_addr);
 
@@ -2380,21 +2406,26 @@ bxe_igu_ack_int(struct bxe_softc *sc)
 
     mb();
     return (result);
+#endif
+    return 0;
 }
 
 static inline uint16_t
-bxe_ack_int(struct bxe_softc *sc)
+bxe_ack_int(struct bxe_adapter *sc)
 {
     mb();
+#if 0
     if (sc->devinfo.int_block == INT_BLOCK_HC) {
         return (bxe_hc_ack_int(sc));
     } else {
         return (bxe_igu_ack_int(sc));
     }
+#endif
+    return 0;
 }
 
 static inline int
-func_by_vn(struct bxe_softc *sc,
+func_by_vn(struct bxe_adapter *sc,
            int              vn)
 {
     return (2 * vn + SC_PORT(sc));
@@ -2407,7 +2438,9 @@ func_by_vn(struct bxe_softc *sc,
 static inline uint8_t
 bxe_stats_id(struct bxe_fastpath *fp)
 {
-    struct bxe_softc *sc = fp->sc;
+  return 0;
+#if 0
+    struct bxe_adapter *sc = fp->sc;
 
     if (!CHIP_IS_E1x(sc)) {
 #if 0
@@ -2420,6 +2453,7 @@ bxe_stats_id(struct bxe_fastpath *fp)
     }
 
     return (fp->cl_id + SC_PORT(sc) * FP_SB_MAX_E1x);
+#endif
 }
 
 #endif /* __BXE_H__ */