bxe: more cleanup.
[akaros.git] / kern / drivers / net / bxe / bxe.c
index d6aebe7..8e0e234 100644 (file)
@@ -216,7 +216,8 @@ static struct bxe_device_type bxe_devs[] = {
     }
 };
 
-#warning "MALLOC_DECLARE?"
+/* This is some sort of malloc zone for BSD.  The flag is passed later to
+ * various malloc invocations. */
 //MALLOC_DECLARE(M_BXE_ILT);
 //MALLOC_DEFINE(M_BXE_ILT, "bxe_ilt", "bxe ILT pointer");
 
@@ -827,20 +828,22 @@ bxe_dma_alloc(struct bxe_adapter *sc,
               struct bxe_dma   *dma,
               const char       *msg)
 {
-#if 0
-    int rc;
-
     if (dma->size > 0) {
         BLOGE(sc, "dma block '%s' already has size %lu\n", msg,
               (unsigned long)dma->size);
         return (1);
     }
 
-    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 */
@@ -894,7 +897,6 @@ void
 bxe_dma_free(struct bxe_adapter *sc,
              struct bxe_dma   *dma)
 {
-#if 0
     if (dma->size > 0) {
 #if 0
         BLOGD(sc, DBG_LOAD,
@@ -905,13 +907,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
     }
-#endif
     memset(dma, 0, sizeof(*dma));
 }
 
@@ -1239,7 +1243,7 @@ bxe_nvram_read_dword(struct bxe_adapter *sc,
              * but ethtool sees it as an array of bytes
              * converting to big-endian will do the work
              */
-            *ret_val = htobe32(val);
+            *ret_val = cpu_to_be32(val);
             rc = 0;
             break;
         }
@@ -1398,7 +1402,7 @@ bxe_nvram_write1(struct bxe_adapter *sc,
         /* nvram data is returned as an array of bytes
          * convert it back to cpu order
          */
-        val = be32toh(val);
+        val = be32_to_cpu(val);
 
         rc = bxe_nvram_write_dword(sc, align_offset, val, cmd_flags);
     }
@@ -2522,7 +2526,7 @@ bxe_probe(device_t dev)
         if ((vid == t->bxe_vid) && (did == t->bxe_did) &&
             ((svid == t->bxe_svid) || (t->bxe_svid == PCI_ANY_ID)) &&
             ((sdid == t->bxe_sdid) || (t->bxe_sdid == PCI_ANY_ID))) {
-            descbuf = malloc(BXE_DEVDESC_MAX, M_TEMP, M_NOWAIT);
+            descbuf = kmalloc(BXE_DEVDESC_MAX, 0); /* M_TEMP */
             if (descbuf == NULL)
                 return (ENOMEM);
 
@@ -2535,7 +2539,7 @@ bxe_probe(device_t dev)
                      BXE_DRIVER_VERSION);
 
             device_set_desc_copy(dev, descbuf);
-            free(descbuf, M_TEMP);
+            kfree(descbuf); /* M_TEMP */
             return (BUS_PROBE_DEFAULT);
         }
         t++;
@@ -2947,7 +2951,7 @@ bxe_fill_frag_mbuf(struct bxe_adapter          *sc,
          * 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",
@@ -3169,6 +3173,7 @@ 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;
@@ -3432,6 +3437,7 @@ 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;
@@ -3503,7 +3509,6 @@ static int
 bxe_watchdog(struct bxe_adapter    *sc,
              struct bxe_fastpath *fp)
 {
-#if 0
     BXE_FP_TX_LOCK(fp);
 
     if ((fp->watchdog_timer == 0) || (--fp->watchdog_timer)) {
@@ -3517,7 +3522,6 @@ bxe_watchdog(struct bxe_adapter    *sc,
 
     atomic_set(&sc->chip_tq_flags, CHIP_TQ_REINIT);
     taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task);
-#endif
     return (-1);
 }
 
@@ -3526,6 +3530,7 @@ 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;
@@ -3610,7 +3615,6 @@ bxe_drain_tx_queues(struct bxe_adapter *sc)
         }
     }
 #endif
-    return;
 }
 
 static int
@@ -3767,6 +3771,7 @@ bxe_set_q_rx_mode(struct bxe_adapter *sc,
 static int
 bxe_set_storm_rx_mode(struct bxe_adapter *sc)
 {
+       return 0xaa;
 #if 0
     unsigned long rx_mode_flags = 0, ramrod_flags = 0;
     unsigned long rx_accept_flags = 0, tx_accept_flags = 0;
@@ -3792,6 +3797,7 @@ bxe_set_storm_rx_mode(struct bxe_adapter *sc)
 static int
 bxe_nic_load_no_mcp(struct bxe_adapter *sc)
 {
+       return 0xaa;
 #if 0
     int path = SC_PATH(sc);
     int port = SC_PORT(sc);
@@ -3818,6 +3824,7 @@ bxe_nic_load_no_mcp(struct bxe_adapter *sc)
 static int
 bxe_nic_unload_no_mcp(struct bxe_adapter *sc)
 {
+       return 0xaa;
 #if 0
     int port = SC_PORT(sc);
     int path = SC_PATH(sc);
@@ -4026,7 +4033,7 @@ bxe_wait_sp_comp(struct bxe_adapter *sc,
 
     while (tout--) {
         mb();
-        if (!(atomic_read(&sc->sp_state) & mask)) {
+        if (!(ACCESS_ONCE(sc->sp_state) & mask)) {
             return (TRUE);
         }
 
@@ -4035,7 +4042,7 @@ bxe_wait_sp_comp(struct bxe_adapter *sc,
 
     mb();
 
-    tmp = atomic_read(&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",
@@ -4559,8 +4566,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);
         }
@@ -4588,7 +4594,7 @@ bxe_ioctl_nvram(struct bxe_adapter *sc,
     }
 
     if (len > sizeof(struct bxe_nvram_data)) {
-        free(nvdata, M_DEVBUF);
+        kfree(nvdata); /* M_DEVBUF */
     }
 
     return (error);
@@ -4601,6 +4607,7 @@ 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));
@@ -6116,7 +6123,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)) {
@@ -6137,7 +6144,7 @@ bxe_ilt_set_info(struct bxe_adapter *sc)
               "psz 0x%x, flags 0x%x, hw psz %d\n",
               ilt_client->start, ilt_client->end,
               ilt_client->page_size, ilt_client->flags,
-              ilog2(ilt_client->page_size >> 12));
+              LOG2_UP(ilt_client->page_size >> 12));
     }
 
     if (CNIC_SUPPORT(sc)) {
@@ -6155,7 +6162,7 @@ bxe_ilt_set_info(struct bxe_adapter *sc)
               "psz 0x%x, flags 0x%x, hw psz %d\n",
               ilt_client->start, ilt_client->end,
               ilt_client->page_size, ilt_client->flags,
-              ilog2(ilt_client->page_size >> 12));
+              LOG2_UP(ilt_client->page_size >> 12));
 
         /* TM */
         ilt_client = &ilt->clients[ILT_CLIENT_TM];
@@ -6171,7 +6178,7 @@ bxe_ilt_set_info(struct bxe_adapter *sc)
               "psz 0x%x, flags 0x%x, hw psz %d\n",
               ilt_client->start, ilt_client->end,
               ilt_client->page_size, ilt_client->flags,
-              ilog2(ilt_client->page_size >> 12));
+              LOG2_UP(ilt_client->page_size >> 12));
     }
 
     //assert((line <= ILT_MAX_LINES), ("Invalid number of ILT lines!"));
@@ -6214,14 +6221,11 @@ 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);
 }
 
@@ -6229,14 +6233,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);
 }
 
@@ -6263,17 +6264,15 @@ 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);
-      //sc->context[i].vcxt = NULL;
-      //sc->context[i].size = 0;
+        bxe_dma_free(sc, &sc->context[i].vcxt_dma);
+        sc->context[i].vcxt = NULL;
+        sc->context[i].size = 0;
     }
 
     ecore_ilt_mem_op(sc, ILT_MEMOP_FREE);
@@ -6292,15 +6291,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:
@@ -6319,7 +6316,7 @@ bxe_alloc_mem(struct bxe_adapter *sc)
     context_size = (sizeof(union cdu_context) * BXE_L2_CID_COUNT(sc));
     for (i = 0, allocated = 0; allocated < context_size; i++) {
       /*
-        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,
@@ -8647,8 +8644,6 @@ bxe_update_dsb_idx(struct bxe_adapter *sc)
     return (rc);
 }
 
-#warning "fix"
-#if 0
 static inline struct ecore_queue_sp_obj *
 bxe_cid_to_q_obj(struct bxe_adapter *sc,
                  uint32_t         cid)
@@ -8656,7 +8651,6 @@ bxe_cid_to_q_obj(struct bxe_adapter *sc,
     BLOGD(sc, DBG_SP, "retrieving fp from cid %d\n", cid);
     return (&sc->sp_objs[CID_TO_FP(cid, sc)].q_obj);
 }
-#endif
 
 static void
 bxe_handle_mcast_eqe(struct bxe_adapter *sc)
@@ -8696,7 +8690,7 @@ 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 (le32_to_cpu(elem->message.data.eth_event.echo) >> BXE_SWCID_SHIFT) {
     case ECORE_FILTER_MAC_PENDING:
@@ -9061,8 +9055,7 @@ bxe_handle_fp_tq(void *context,
 
     if (more_rx /*|| more_tx*/) {
         /* still more work to do */
-#warning "task queue"
-      //taskqueue_enqueue_fast(fp->tq, &fp->tq_task);
+        taskqueue_enqueue_fast(fp->tq, &fp->tq_task);
         return;
     }
 
@@ -9096,7 +9089,7 @@ bxe_task_fp(struct bxe_fastpath *fp)
 
     if (more_rx /*|| more_tx*/) {
         /* still more work to do, bail out if this ISR and process later */
-      //taskqueue_enqueue_fast(fp->tq, &fp->tq_task);
+        taskqueue_enqueue_fast(fp->tq, &fp->tq_task);
         return;
     }
 
@@ -9180,7 +9173,7 @@ bxe_intr_legacy(void *xsc)
         bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
 
         /* schedule slowpath handler */
-        //taskqueue_enqueue_fast(sc->sp_tq, &sc->sp_tq_task);
+        taskqueue_enqueue_fast(sc->sp_tq, &sc->sp_tq_task);
 
         status &= ~0x1;
     }
@@ -9202,7 +9195,7 @@ bxe_intr_sp(void *xsc)
     bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
 
     /* schedule slowpath handler */
-    //taskqueue_enqueue_fast(sc->sp_tq, &sc->sp_tq_task);
+    taskqueue_enqueue_fast(sc->sp_tq, &sc->sp_tq_task);
 }
 
 /* fastpath interrupt entry point */
@@ -9333,7 +9326,7 @@ 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);
 
@@ -9495,7 +9488,6 @@ bxe_interrupt_alloc(struct bxe_adapter *sc)
 static void
 bxe_interrupt_detach(struct bxe_adapter *sc)
 {
-#if 0
     struct bxe_fastpath *fp;
     int i;
 
@@ -9527,7 +9519,6 @@ bxe_interrupt_detach(struct bxe_adapter *sc)
         taskqueue_free(sc->sp_tq);
         sc->sp_tq = NULL;
     }
-#endif
 }
 
 /*
@@ -9542,7 +9533,6 @@ bxe_interrupt_detach(struct bxe_adapter *sc)
 static int
 bxe_interrupt_attach(struct bxe_adapter *sc)
 {
-#if 0
     struct bxe_fastpath *fp;
     int rc = 0;
     int i;
@@ -9586,7 +9576,7 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
          * to the interrupt handler for the slowpath.
          */
         if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
-                                 (INTR_TYPE_NET | INTR_MPSAFE),
+                                 0, //(INTR_TYPE_NET | INTR_MPSAFE),
                                  NULL, bxe_intr_sp, sc,
                                  &sc->intr[0].tag)) != 0) {
             BLOGE(sc, "Failed to allocate MSI-X[0] vector (%d)\n", rc);
@@ -9609,7 +9599,7 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
              * case.
              */
             if ((rc = bus_setup_intr(sc->pcidev, sc->intr[i + 1].resource,
-                                     (INTR_TYPE_NET | INTR_MPSAFE),
+                                     0, //(INTR_TYPE_NET | INTR_MPSAFE),
                                      NULL, bxe_intr_fp, fp,
                                      &sc->intr[i + 1].tag)) != 0) {
                 BLOGE(sc, "Failed to allocate MSI-X[%d] vector (%d)\n",
@@ -9636,7 +9626,7 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
          * will handle both the slowpath and fastpath.
          */
         if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
-                                 (INTR_TYPE_NET | INTR_MPSAFE),
+                                 0, //(INTR_TYPE_NET | INTR_MPSAFE),
                                  NULL, bxe_intr_legacy, sc,
                                  &sc->intr[0].tag)) != 0) {
             BLOGE(sc, "Failed to allocate MSI[0] vector (%d)\n", rc);
@@ -9652,7 +9642,7 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
          * will handle both the slowpath and fastpath.
          */
         if ((rc = bus_setup_intr(sc->pcidev, sc->intr[0].resource,
-                                 (INTR_TYPE_NET | INTR_MPSAFE),
+                                 0, //(INTR_TYPE_NET | INTR_MPSAFE),
                                  NULL, bxe_intr_legacy, sc,
                                  &sc->intr[0].tag)) != 0) {
             BLOGE(sc, "Failed to allocate INTx interrupt (%d)\n", rc);
@@ -9663,8 +9653,6 @@ bxe_interrupt_attach(struct bxe_adapter *sc)
 bxe_interrupt_attach_exit:
 
     return (rc);
-#endif
-    return -1;
 }
 
 static int  bxe_init_hw_common_chip(struct bxe_adapter *sc);
@@ -9719,7 +9707,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;
@@ -10045,8 +10033,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,
@@ -10302,7 +10290,7 @@ bxe_init_eq_ring(struct bxe_adapter *sc)
     sc->eq_cons_sb = &sc->def_sb->sp_sb.index_values[HC_SP_INDEX_EQ_CONS];
 
     atomic_set(&sc->eq_spq_left,
-                          (min((MAX_SP_DESC_CNT - MAX_SPQ_PENDING),
+                          (MIN((MAX_SP_DESC_CNT - MAX_SPQ_PENDING),
                                NUM_EQ_DESC) - 1));
 }
 
@@ -10612,7 +10600,7 @@ bxe_pf_init(struct bxe_adapter *sc)
      * This flag is relevant for E1x only.
      * E2 doesn't have a TPA configuration in a function level.
      */
-#warning "no getcapenable
+#warning "no getcapenable"
 //    flags |= (if_getcapenable(sc->ifp) & IFCAP_LRO) ? FUNC_FLG_TPA : 0;
 
     func_init.func_flgs = flags;
@@ -10970,12 +10958,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;
@@ -11755,7 +11744,7 @@ bxe_pf_rx_q_prep(struct bxe_adapter              *sc,
         max_sge = SGE_PAGE_ALIGN(sc->mtu) >> SGE_PAGE_SHIFT;
         max_sge = ((max_sge + PAGES_PER_SGE - 1) &
                    (~(PAGES_PER_SGE - 1))) >> PAGES_PER_SGE_SHIFT;
-        sge_sz = (uint16_t)min(SGE_PAGES, 0xffff);
+        sge_sz = (uint16_t)MIN(SGE_PAGES, 0xffff);
     }
 
     /* pause - not for e1 */
@@ -11987,10 +11976,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);
     }
 
@@ -12495,7 +12481,9 @@ 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)
@@ -12515,8 +12503,8 @@ bxe_init_mcast_macs_list(struct bxe_adapter                 *sc,
         return (0);
     }
 
-    mta = malloc(sizeof(unsigned char) * ETH_ADDR_LEN *
-                mc_count, 0); //M_DEVBUF, M_NOWAIT);
+    mta = kmalloc(sizeof(unsigned char) * ETH_ADDR_LEN * mc_count,
+                     0); //M_DEVBUF, M_NOWAIT);
     mta = NULL;
 
     if(mta == NULL) {
@@ -12524,10 +12512,9 @@ bxe_init_mcast_macs_list(struct bxe_adapter                 *sc,
         return (-1);
     }
     
-    mc_mac = kmalloc(sizeof(*mc_mac) * mc_count, 0); //M_DEVBUF,
-    //(M_NOWAIT | M_ZERO));
+    mc_mac = kzmalloc(sizeof(*mc_mac) * mc_count, 0); //M_DEVBUF,
     if (!mc_mac) {
-      free(mta); //, M_DEVBUF);
+        kfree(mta); //, M_DEVBUF);
         BLOGE(sc, "Failed to allocate temp mcast list\n");
         return (-1);
     }
@@ -12609,6 +12596,7 @@ 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;
@@ -12616,21 +12604,13 @@ bxe_set_uc_list(struct bxe_adapter *sc)
     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);
     }
 
@@ -12649,25 +12629,17 @@ bxe_set_uc_list(struct bxe_adapter *sc)
             rc = 0;
         } else if (rc < 0) {
             BLOGE(sc, "Failed to schedule ADD operations (%d)\n", rc);
-#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
@@ -12690,7 +12662,6 @@ bxe_handle_rx_mode_tq(void *context,
     }
 
     BLOGD(sc, DBG_SP, "if_flags(ifp)=0x%x\n", if_getflags(sc->ifp));
-#warning "FIX ALL FLAGS"
 #if 0
     if (if_getflags(ifp) & IFF_PROMISC) {
         rx_mode = BXE_RX_MODE_PROMISC;
@@ -13529,6 +13500,7 @@ 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);
@@ -14177,7 +14149,7 @@ bxe_get_tunable_params(struct bxe_adapter *sc)
         sc->num_queues = 1;
     } else { /* INTR_MODE_MSI or INTR_MODE_MSIX */
         sc->num_queues =
-               min((bxe_queue_count ? bxe_queue_count : 8) //mp_ncpus),
+               MIN((bxe_queue_count ? bxe_queue_count : 8) //mp_ncpus),
                 MAX_RSS_CHAINS);
         if (sc->num_queues > mp_ncpus) {
             sc->num_queues = mp_ncpus;
@@ -14312,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");
@@ -15092,7 +15064,7 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
     sc->gz_buf = (void *)sc->gz_buf_dma.vaddr;
 
     if ((sc->gz_strm =
-         malloc(sizeof(*sc->gz_strm), M_DEVBUF, M_NOWAIT)) == NULL) {
+         kmalloc(sizeof(*sc->gz_strm), /*M_DEVBUF,*/ M_NOWAIT)) == NULL) {
         /* XXX */
         bxe_dma_free(sc, &sc->gz_buf_dma);
         sc->gz_buf = NULL;
@@ -15726,7 +15698,7 @@ bxe_prev_mark_path(struct bxe_adapter *sc,
     qunlock(&bxe_prev_mtx);
 
     /* Create an entry for this path and add it */
-    tmp = kmalloc(sizeof(struct bxe_prev_list_node), 0); //M_DEVBUF,
+    tmp = kzmalloc(sizeof(struct bxe_prev_list_node), 0); //M_DEVBUF,
 //                 (M_NOWAIT | M_ZERO));
     if (!tmp) {
         BLOGE(sc, "Failed to allocate 'bxe_prev_list_node'\n");
@@ -16656,6 +16628,7 @@ bxe_igu_ack_sb(struct bxe_adapter *sc,
     bxe_igu_ack_sb_gen(sc, igu_sb_id, segment, index, op, update, igu_addr);
 }
 
+#endif
 static void
 bxe_igu_clear_sb_gen(struct bxe_adapter *sc,
                      uint8_t          func,
@@ -16721,7 +16694,6 @@ bxe_igu_clear_sb(struct bxe_adapter *sc,
 }
 
 
-#endif
 
 
 
@@ -16891,7 +16863,7 @@ bxe_iov_init_dq(struct bxe_adapter *sc)
 
     /* Set the DQ such that the CID reflect the abs_vfid */
     REG_WR(sc, DORQ_REG_VF_NORM_VF_BASE, 0);
-    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
@@ -18885,4 +18857,3 @@ ecore_storm_memset_struct(struct bxe_adapter *sc,
         REG_WR(sc, addr + (i * 4), data[i]);
     }
 }
-