bxe: properly get the maddr from the netif.
[akaros.git] / kern / drivers / net / bxe / bxe.c
index 560a4fa..c7290e3 100644 (file)
@@ -321,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)                   \
@@ -660,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,
@@ -1243,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;
         }
@@ -1402,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);
     }
@@ -3173,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;
@@ -3436,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;
@@ -3528,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;
@@ -3612,7 +3619,6 @@ bxe_drain_tx_queues(struct bxe_adapter *sc)
         }
     }
 #endif
-    return;
 }
 
 static int
@@ -3769,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;
@@ -3794,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);
@@ -3820,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);
@@ -4602,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));
@@ -8638,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)
@@ -8647,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)
@@ -8687,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:
@@ -9704,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;
@@ -10030,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,
@@ -10597,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;
@@ -10955,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;
@@ -11972,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);
     }
 
@@ -12480,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;
@@ -12500,27 +12507,15 @@ bxe_init_mcast_macs_list(struct bxe_adapter                 *sc,
         return (0);
     }
 
-    mta = kmalloc(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 = kzmalloc(sizeof(*mc_mac) * mc_count, 0); //M_DEVBUF,
+    mc_mac = kzmalloc(sizeof(*mc_mac) * mc_count, KMALLOC_WAIT);
     if (!mc_mac) {
-        kfree(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);
 
@@ -12533,7 +12528,6 @@ bxe_init_mcast_macs_list(struct bxe_adapter                 *sc,
     }
 
     p->mcast_list_len = mc_count;
-    kfree(mta); //, M_DEVBUF);
 
     return (0);
 }
@@ -12548,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);
     }
 }
 
@@ -12593,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;
@@ -12600,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);
     }
 
@@ -12633,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
@@ -12674,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;
@@ -12769,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)) {
@@ -12779,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;
@@ -12791,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. */
@@ -12856,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 */
@@ -13098,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)) {
@@ -13513,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);
@@ -15071,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 =
-         kmalloc(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 */
     /*************/
@@ -16403,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),
@@ -16640,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,
@@ -16705,7 +16673,6 @@ bxe_igu_clear_sb(struct bxe_adapter *sc,
 }
 
 
-#endif