bxe: properly get the maddr from the netif.
[akaros.git] / kern / drivers / net / bxe / bxe.c
index 5a2b33d..c7290e3 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");
 
@@ -249,7 +250,8 @@ static device_method_t bxe_methods[] = {
 };
 
 #endif
-//MTX_SYSINIT(bxe_prev_mtx, &bxe_prev_mtx, "bxe_prev_lock", MTX_DEF);
+qlock_t bxe_prev_mtx;
+
 struct bxe_prev_list_node {
     LIST_ENTRY(bxe_prev_list_node) node;
     uint8_t bus;
@@ -319,6 +321,8 @@ static int bxe_udp_rss = 0;
 //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 */
 
 #define STATS_OFFSET32(stat_name)                   \
@@ -658,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,
@@ -826,20 +832,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 */
@@ -893,7 +901,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,
@@ -904,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
     }
-#endif
     memset(dma, 0, sizeof(*dma));
 }
 
@@ -1238,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;
         }
@@ -1397,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);
     }
@@ -2521,7 +2530,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);
 
@@ -2534,7 +2543,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++;
@@ -2946,7 +2955,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",
@@ -3168,6 +3177,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;
@@ -3431,6 +3441,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;
@@ -3502,7 +3513,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)) {
@@ -3516,7 +3526,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);
 }
 
@@ -3525,6 +3534,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;
@@ -3609,7 +3619,6 @@ bxe_drain_tx_queues(struct bxe_adapter *sc)
         }
     }
 #endif
-    return;
 }
 
 static int
@@ -3766,6 +3775,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;
@@ -3791,6 +3801,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);
@@ -3817,6 +3828,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);
@@ -4025,7 +4037,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);
         }
 
@@ -4034,7 +4046,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",
@@ -4558,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);
         }
@@ -4587,7 +4598,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);
@@ -4600,6 +4611,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));
@@ -6115,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)) {
@@ -6136,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)) {
@@ -6154,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];
@@ -6170,7 +6182,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!"));
@@ -6213,14 +6225,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);
 }
 
@@ -6228,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);
 }
 
@@ -6262,17 +6268,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);
@@ -6291,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:
@@ -6318,7 +6320,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,
@@ -8646,8 +8648,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)
@@ -8655,7 +8655,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)
@@ -8695,7 +8694,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:
@@ -9060,8 +9059,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;
     }
 
@@ -9095,7 +9093,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;
     }
 
@@ -9179,7 +9177,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;
     }
@@ -9201,7 +9199,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 */
@@ -9332,7 +9330,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);
 
@@ -9494,7 +9492,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;
 
@@ -9526,7 +9523,6 @@ bxe_interrupt_detach(struct bxe_adapter *sc)
         taskqueue_free(sc->sp_tq);
         sc->sp_tq = NULL;
     }
-#endif
 }
 
 /*
@@ -9541,7 +9537,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;
@@ -9585,7 +9580,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);
@@ -9608,7 +9603,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",
@@ -9635,7 +9630,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);
@@ -9651,7 +9646,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);
@@ -9662,8 +9657,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);
@@ -9718,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;
@@ -10044,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,
@@ -10301,7 +10294,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));
 }
 
@@ -10611,7 +10604,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;
@@ -10969,12 +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;
@@ -11754,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 */
@@ -11986,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);
     }
 
@@ -12494,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;
@@ -12514,28 +12507,15 @@ 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 = NULL;
-
-    if(mta == NULL) {
-        BLOGE(sc, "Failed to allocate temp mcast list\n");
-        return (-1);
-    }
+    mta = ifp->maddr;
     
-    mc_mac = kmalloc(sizeof(*mc_mac) * mc_count, 0); //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);
     }
 
-    // BSD thing
-    //    if_multiaddr_array(ifp, mta, &mcnt, mc_count); /* mta and mcnt not expected 
-    //                                   to be  different */
-    for(i=0; i< mcnt; i++) {
-
+    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);
 
@@ -12548,7 +12528,6 @@ bxe_init_mcast_macs_list(struct bxe_adapter                 *sc,
     }
 
     p->mcast_list_len = mc_count;
-    kfree(mta); //, M_DEVBUF);
 
     return (0);
 }
@@ -12563,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 */
-      kfree(mc_mac); //, M_DEVBUF);
+      kfree(mc_mac);
     }
 }
 
@@ -12608,6 +12587,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;
@@ -12615,21 +12595,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);
     }
 
@@ -12648,25 +12620,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
@@ -12689,7 +12653,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;
@@ -12784,9 +12747,12 @@ 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)) {
@@ -12794,9 +12760,8 @@ bxe_periodic_callout_func(void *xsc)
 
         if ((sc->state == BXE_STATE_OPEN) &&
             (atomic_read(&sc->periodic_flags) == PERIODIC_GO)) {
-            /* schedule the next periodic callout */
-               //callout_reset(&sc->periodic_callout, hz,
-               //        bxe_periodic_callout_func, sc);
+               goto done;
+
         }
 
         return;
@@ -12806,7 +12771,7 @@ bxe_periodic_callout_func(void *xsc)
         (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. */
@@ -12871,24 +12836,31 @@ bxe_periodic_callout_func(void *xsc)
 
     if ((sc->state == BXE_STATE_OPEN) &&
         (atomic_read(&sc->periodic_flags) == PERIODIC_GO)) {
-        /* schedule the next periodic callout */
-//        callout_reset(&sc->periodic_callout, hz,
-//                      bxe_periodic_callout_func, sc);
+           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_set(&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_set(&sc->periodic_flags, PERIODIC_STOP);
-//    callout_drain(&sc->periodic_callout);
+       atomic_set(&sc->periodic_flags, PERIODIC_STOP);
 }
 
 /* start the controller */
@@ -13113,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)) {
@@ -13528,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);
@@ -14176,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;
@@ -14311,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");
@@ -15086,27 +15059,9 @@ bxe_alloc_hsi_mem(struct bxe_adapter *sc)
         return (1);
     }
 
-#warning "what the hell is gz_strm"
-#if 0
+       // 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);
-    }
-#endif
     /*************/
     /* FASTPATHS */
     /*************/
@@ -15675,8 +15630,7 @@ bxe_prev_is_path_marked(struct bxe_adapter *sc)
 {
     struct bxe_prev_list_node *tmp;
     int rc = FALSE;
-#warning "TODO: figure out bxe_prev_mtx"
-    //    mtx_lock(&bxe_prev_mtx);
+    qlock(&bxe_prev_mtx);
 
     tmp = bxe_prev_path_get_entry(sc);
     if (tmp) {
@@ -15692,7 +15646,7 @@ bxe_prev_is_path_marked(struct bxe_adapter *sc)
         }
     }
 
-    //    mtx_unlock(&bxe_prev_mtx);
+    qunlock(&bxe_prev_mtx);
 
     return (rc);
 }
@@ -15703,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);
@@ -15719,14 +15673,14 @@ 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 = 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");
@@ -15739,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);
 
-    //    mtx_unlock(&bxe_prev_mtx);
+    qunlock(&bxe_prev_mtx);
 
     return (0);
 }
@@ -16419,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),
@@ -16656,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,
@@ -16721,7 +16673,6 @@ bxe_igu_clear_sb(struct bxe_adapter *sc,
 }
 
 
-#endif
 
 
 
@@ -16891,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
@@ -18885,4 +18836,3 @@ ecore_storm_memset_struct(struct bxe_adapter *sc,
         REG_WR(sc, addr + (i * 4), data[i]);
     }
 }
-