BNX2X: spatch changes for BUG and WARN
[akaros.git] / kern / drivers / net / bnx2x / bnx2x_cmn.h
index 84e7882..2bf7413 100644 (file)
@@ -46,7 +46,7 @@ extern int bnx2x_num_queues;
 
 #define BNX2X_PCI_ALLOC(y, size)                                       \
 ({                                                                     \
-       void *x = dma_zalloc_coherent(&bp->pdev->dev, size, y, GFP_KERNEL); \
+       void *x = dma_zalloc_coherent(&bp->pdev->dev, size, y, KMALLOC_WAIT); \
        if (x)                                                          \
                DP(NETIF_MSG_HW,                                        \
                   "BNX2X_PCI_ALLOC: Physical %Lx Virtual %p\n",        \
@@ -55,7 +55,7 @@ extern int bnx2x_num_queues;
 })
 #define BNX2X_PCI_FALLOC(y, size)                                      \
 ({                                                                     \
-       void *x = dma_alloc_coherent(&bp->pdev->dev, size, y, GFP_KERNEL); \
+       void *x = dma_alloc_coherent(&bp->pdev->dev, size, y, KMALLOC_WAIT); \
        if (x) {                                                        \
                memset(x, 0xff, size);                                  \
                DP(NETIF_MSG_HW,                                        \
@@ -232,7 +232,7 @@ uint16_t bnx2x_get_mf_speed(struct bnx2x *bp);
  * @irq:               irq number
  * @dev_instance:      private instance
  */
-irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance);
+void bnx2x_msix_sp_int(struct hw_trapframe *hw_tf, void *dev_instance);
 
 /**
  * bnx2x_interrupt - non MSI-X interrupt handler
@@ -240,7 +240,7 @@ irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance);
  * @irq:               irq number
  * @dev_instance:      private instance
  */
-irqreturn_t bnx2x_interrupt(int irq, void *dev_instance);
+void bnx2x_interrupt(struct hw_trapframe *hw_tf, void *dev_instance);
 
 /**
  * bnx2x_cnic_notify - send command to cnic driver
@@ -457,7 +457,8 @@ void bnx2x_dcbx_init(struct bnx2x *bp, bool update_shmem);
  *
  * Currently only D0 and D3hot are supported.
  */
-int bnx2x_set_power_state(struct bnx2x *bp, pci_power_t state);
+//int bnx2x_set_power_state(struct bnx2x *bp, pci_power_t state);
+#define bnx2x_set_power_state(...)
 
 /**
  * bnx2x_update_max_mf_config - update MAX part of MF configuration in HW.
@@ -476,19 +477,19 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode, bool keep_link);
 int bnx2x_nic_load(struct bnx2x *bp, int load_mode);
 
 /* hard_xmit callback */
-netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev);
+netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct ether *dev);
 
 /* setup_tc callback */
-int bnx2x_setup_tc(struct net_device *dev, uint8_t num_tc);
+int bnx2x_setup_tc(struct ether *dev, uint8_t num_tc);
 
-int bnx2x_get_vf_config(struct net_device *dev, int vf,
+int bnx2x_get_vf_config(struct ether *dev, int vf,
                        struct ifla_vf_info *ivi);
-int bnx2x_set_vf_mac(struct net_device *dev, int queue, uint8_t *mac);
-int bnx2x_set_vf_vlan(struct net_device *netdev, int vf, uint16_t vlan,
+int bnx2x_set_vf_mac(struct ether *dev, int queue, uint8_t *mac);
+int bnx2x_set_vf_vlan(struct ether *netdev, int vf, uint16_t vlan,
                      uint8_t qos);
 
 /* select_queue callback */
-uint16_t bnx2x_select_queue(struct net_device *dev, struct sk_buff *skb,
+uint16_t bnx2x_select_queue(struct ether *dev, struct sk_buff *skb,
                       void *accel_priv, select_queue_fallback_t fallback);
 
 static inline void bnx2x_update_rx_prod(struct bnx2x *bp,
@@ -518,7 +519,7 @@ static inline void bnx2x_update_rx_prod(struct bnx2x *bp,
                REG_WR(bp, fp->ustorm_rx_prods_offset + i*4,
                       ((uint32_t *)&rx_prods)[i]);
 
-       mmiowb(); /* keep prod updates ordered */
+       bus_wmb(); /* keep prod updates ordered */
 
        DP(NETIF_MSG_RX_STATUS,
           "queue[%d]:  wrote  bd_prod %u  cqe_prod %u  sge_prod %u\n",
@@ -526,9 +527,9 @@ static inline void bnx2x_update_rx_prod(struct bnx2x *bp,
 }
 
 /* reload helper */
-int bnx2x_reload_if_running(struct net_device *dev);
+int bnx2x_reload_if_running(struct ether *dev);
 
-int bnx2x_change_mac_addr(struct net_device *dev, void *p);
+int bnx2x_change_mac_addr(struct ether *dev, void *p);
 
 /* NAPI poll Tx part */
 int bnx2x_tx_int(struct bnx2x *bp, struct bnx2x_fp_txdata *txdata);
@@ -593,7 +594,7 @@ void bnx2x_free_mem_bp(struct bnx2x *bp);
  * @new_mtu:   requested mtu
  *
  */
-int bnx2x_change_mtu(struct net_device *dev, int new_mtu);
+int bnx2x_change_mtu(struct ether *dev, int new_mtu);
 
 #ifdef NETDEV_FCOE_WWNN
 /**
@@ -604,25 +605,25 @@ int bnx2x_change_mtu(struct net_device *dev, int new_mtu);
  * @type:      WWN type: NETDEV_FCOE_WWNN (node) or NETDEV_FCOE_WWPN (port)
  *
  */
-int bnx2x_fcoe_get_wwn(struct net_device *dev, uint64_t *wwn, int type);
+int bnx2x_fcoe_get_wwn(struct ether *dev, uint64_t *wwn, int type);
 #endif
 
-netdev_features_t bnx2x_fix_features(struct net_device *dev,
+netdev_features_t bnx2x_fix_features(struct ether *dev,
                                     netdev_features_t features);
-int bnx2x_set_features(struct net_device *dev, netdev_features_t features);
+int bnx2x_set_features(struct ether *dev, netdev_features_t features);
 
 /**
  * bnx2x_tx_timeout - tx timeout netdev callback
  *
  * @dev:       net device
  */
-void bnx2x_tx_timeout(struct net_device *dev);
+void bnx2x_tx_timeout(struct ether *dev);
 
 /*********************** Inlines **********************************/
 /*********************** Fast path ********************************/
 static inline void bnx2x_update_fpsb_idx(struct bnx2x_fastpath *fp)
 {
-       barrier(); /* status block is written to by the chip */
+       cmb(); /* status block is written to by the chip */
        fp->fp_hc_idx = fp->sb_running_index[SM_RX_ID];
 }
 
@@ -644,8 +645,8 @@ static inline void bnx2x_igu_ack_sb_gen(struct bnx2x *bp, uint8_t igu_sb_id,
        REG_WR(bp, igu_addr, cmd_data.sb_id_and_flags);
 
        /* Make sure that ACK is written */
-       mmiowb();
-       barrier();
+       bus_wmb();
+       cmb();
 }
 
 static inline void bnx2x_hc_ack_sb(struct bnx2x *bp, uint8_t sb_id,
@@ -666,8 +667,8 @@ static inline void bnx2x_hc_ack_sb(struct bnx2x *bp, uint8_t sb_id,
        REG_WR(bp, hc_addr, (*(uint32_t *)&igu_ack));
 
        /* Make sure that ACK is written */
-       mmiowb();
-       barrier();
+       bus_wmb();
+       cmb();
 }
 
 static inline void bnx2x_ack_sb(struct bnx2x *bp, uint8_t igu_sb_id,
@@ -697,7 +698,7 @@ static inline uint16_t bnx2x_hc_ack_int(struct bnx2x *bp)
                       COMMAND_REG_SIMD_MASK);
        uint32_t result = REG_RD(bp, hc_addr);
 
-       barrier();
+       cmb();
        return result;
 }
 
@@ -709,13 +710,13 @@ static inline uint16_t bnx2x_igu_ack_int(struct bnx2x *bp)
        DP(NETIF_MSG_INTR, "read 0x%08x from IGU addr 0x%x\n",
           result, igu_addr);
 
-       barrier();
+       cmb();
        return result;
 }
 
 static inline uint16_t bnx2x_ack_int(struct bnx2x *bp)
 {
-       barrier();
+       cmb();
        if (bp->common.int_block == INT_BLOCK_HC)
                return bnx2x_hc_ack_int(bp);
        else
@@ -725,14 +726,14 @@ static inline uint16_t bnx2x_ack_int(struct bnx2x *bp)
 static inline int bnx2x_has_tx_work_unload(struct bnx2x_fp_txdata *txdata)
 {
        /* Tell compiler that consumer and producer can change */
-       barrier();
+       cmb();
        return txdata->tx_pkt_prod != txdata->tx_pkt_cons;
 }
 
 static inline uint16_t bnx2x_tx_avail(struct bnx2x *bp,
                                 struct bnx2x_fp_txdata *txdata)
 {
-       s16 used;
+       int16_t used;
        uint16_t prod;
        uint16_t cons;
 
@@ -742,12 +743,12 @@ static inline uint16_t bnx2x_tx_avail(struct bnx2x *bp,
        used = SUB_S16(prod, cons);
 
 #ifdef BNX2X_STOP_ON_ERROR
-       WARN_ON(used < 0);
-       WARN_ON(used > txdata->tx_ring_size);
-       WARN_ON((txdata->tx_ring_size - used) > MAX_TX_AVAIL);
+       warn_on(used < 0);
+       warn_on(used > txdata->tx_ring_size);
+       warn_on((txdata->tx_ring_size - used) > MAX_TX_AVAIL);
 #endif
 
-       return (s16)(txdata->tx_ring_size) - used;
+       return (int16_t)(txdata->tx_ring_size) - used;
 }
 
 static inline int bnx2x_tx_queue_has_work(struct bnx2x_fp_txdata *txdata)
@@ -755,7 +756,7 @@ static inline int bnx2x_tx_queue_has_work(struct bnx2x_fp_txdata *txdata)
        uint16_t hw_cons;
 
        /* Tell compiler that status block fields can change */
-       barrier();
+       cmb();
        hw_cons = le16_to_cpu(*txdata->tx_cons_sb);
        return hw_cons != txdata->tx_pkt_cons;
 }
@@ -790,8 +791,11 @@ static inline int bnx2x_has_rx_work(struct bnx2x_fastpath *fp)
  */
 static inline void bnx2x_tx_disable(struct bnx2x *bp)
 {
+panic("Not implemented");
+#if 0 // AKAROS_PORT
        netif_tx_disable(bp->dev);
        netif_carrier_off(bp->dev);
+#endif
 }
 
 static inline void bnx2x_free_rx_sge(struct bnx2x *bp,
@@ -808,7 +812,7 @@ static inline void bnx2x_free_rx_sge(struct bnx2x *bp,
 
        dma_unmap_page(&bp->pdev->dev, dma_unmap_addr(sw_buf, mapping),
                       SGE_PAGES, DMA_FROM_DEVICE);
-       __free_pages(page, PAGES_PER_SGE_SHIFT);
+       free_cont_pages(page, PAGES_PER_SGE_SHIFT);
 
        sw_buf->page = NULL;
        sge->addr_hi = 0;
@@ -817,28 +821,36 @@ static inline void bnx2x_free_rx_sge(struct bnx2x *bp,
 
 static inline void bnx2x_del_all_napi_cnic(struct bnx2x *bp)
 {
+panic("Not implemented");
+#if 0 // AKAROS_PORT
        int i;
 
        for_each_rx_queue_cnic(bp, i) {
                napi_hash_del(&bnx2x_fp(bp, i, napi));
                netif_napi_del(&bnx2x_fp(bp, i, napi));
        }
+#endif
 }
 
 static inline void bnx2x_del_all_napi(struct bnx2x *bp)
 {
+panic("Not implemented");
+#if 0 // AKAROS_PORT
        int i;
 
        for_each_eth_queue(bp, i) {
                napi_hash_del(&bnx2x_fp(bp, i, napi));
                netif_napi_del(&bnx2x_fp(bp, i, napi));
        }
+#endif
 }
 
 int bnx2x_set_int_mode(struct bnx2x *bp);
 
 static inline void bnx2x_disable_msi(struct bnx2x *bp)
 {
+panic("Not implemented");
+#if 0 // AKAROS_PORT
        if (bp->flags & USING_MSIX_FLAG) {
                pci_disable_msix(bp->pdev);
                bp->flags &= ~(USING_MSIX_FLAG | USING_SINGLE_MSIX_FLAG);
@@ -846,6 +858,7 @@ static inline void bnx2x_disable_msi(struct bnx2x *bp)
                pci_disable_msi(bp->pdev);
                bp->flags &= ~USING_MSI_FLAG;
        }
+#endif
 }
 
 static inline void bnx2x_clear_sge_mask_next_elems(struct bnx2x_fastpath *fp)
@@ -1059,7 +1072,7 @@ static inline uint8_t bnx2x_get_path_func_num(struct bnx2x *bp)
                }
        }
 
-       WARN_ON(!func_num);
+       warn_on(!func_num);
 
        return func_num;
 }
@@ -1152,7 +1165,7 @@ static inline int bnx2x_clean_tx_queue(struct bnx2x *bp,
 #endif
                }
                cnt--;
-               usleep_range(1000, 2000);
+               kthread_usleep(1000);
        }
 
        return 0;
@@ -1180,27 +1193,27 @@ static inline bool bnx2x_wait_sp_comp(struct bnx2x *bp, unsigned long mask)
        int tout = 5000; /* Wait for 5 secs tops */
 
        while (tout--) {
-               smp_mb();
-               netif_addr_lock_bh(bp->dev);
+               mb();
+               qlock(&bp->dev->qlock);
                if (!(bp->sp_state & mask)) {
-                       netif_addr_unlock_bh(bp->dev);
+                       qunlock(&bp->dev->qlock);
                        return true;
                }
-               netif_addr_unlock_bh(bp->dev);
+               qunlock(&bp->dev->qlock);
 
-               usleep_range(1000, 2000);
+               kthread_usleep(1000);
        }
 
-       smp_mb();
+       mb();
 
-       netif_addr_lock_bh(bp->dev);
+       qlock(&bp->dev->qlock);
        if (bp->sp_state & mask) {
                BNX2X_ERR("Filtering completion timed out. sp_state 0x%lx, mask 0x%lx\n",
                          bp->sp_state, mask);
-               netif_addr_unlock_bh(bp->dev);
+               qunlock(&bp->dev->qlock);
                return false;
        }
-       netif_addr_unlock_bh(bp->dev);
+       qunlock(&bp->dev->qlock);
 
        return true;
 }
@@ -1244,6 +1257,8 @@ static inline uint16_t bnx2x_extract_max_cfg(struct bnx2x *bp,
 /* checks if HW supports GRO for given MTU */
 static inline bool bnx2x_mtu_allows_gro(int mtu)
 {
+panic("Not implemented");
+#if 0 // AKAROS_PORT
        /* gro frags per page */
        int fpp = SGE_PAGE_SIZE / (mtu - ETH_MAX_TPA_HEADER_SIZE);
 
@@ -1252,6 +1267,7 @@ static inline bool bnx2x_mtu_allows_gro(int mtu)
         * 2. Frag must fit the page
         */
        return mtu <= SGE_PAGE_SIZE && (U_ETH_SGL_SIZE * fpp) <= MAX_SKB_FRAGS;
+#endif
 }
 
 /**