BNX2X: spatch changes for BUG and WARN
[akaros.git] / kern / drivers / net / bnx2x / bnx2x_cmn.h
index adcacda..2bf7413 100644 (file)
 #ifndef BNX2X_CMN_H
 #define BNX2X_CMN_H
 
-#include <linux/types.h>
-#include <linux/pci.h>
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/irq.h>
+#include "akaros_compat.h"
 
 #include "bnx2x.h"
 #include "bnx2x_sriov.h"
@@ -50,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",        \
@@ -59,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,                                        \
@@ -82,7 +78,7 @@ extern int bnx2x_num_queues;
  *
  * Return unload mode returned by the MCP: COMMON, PORT or FUNC.
  */
-u32 bnx2x_send_unload_req(struct bnx2x *bp, int unload_mode);
+uint32_t bnx2x_send_unload_req(struct bnx2x *bp, int unload_mode);
 
 /**
  * bnx2x_send_unload_done - send UNLOAD_DONE command to the MCP.
@@ -142,7 +138,7 @@ int bnx2x_setup_leading(struct bnx2x *bp);
  *
  * block until there is a reply
  */
-u32 bnx2x_fw_command(struct bnx2x *bp, u32 command, u32 param);
+uint32_t bnx2x_fw_command(struct bnx2x *bp, uint32_t command, uint32_t param);
 
 /**
  * bnx2x_initial_phy_init - initialize link parameters structure variables.
@@ -175,7 +171,7 @@ void bnx2x_force_link_reset(struct bnx2x *bp);
  *
  * Returns 0 if link is UP.
  */
-u8 bnx2x_link_test(struct bnx2x *bp, u8 is_serdes);
+uint8_t bnx2x_link_test(struct bnx2x *bp, uint8_t is_serdes);
 
 /**
  * bnx2x_drv_pulse - write driver pulse to shmem
@@ -197,12 +193,12 @@ void bnx2x_drv_pulse(struct bnx2x *bp);
  * @op:                SB operation
  * @update:    is HW update required
  */
-void bnx2x_igu_ack_sb(struct bnx2x *bp, u8 igu_sb_id, u8 segment,
-                     u16 index, u8 op, u8 update);
+void bnx2x_igu_ack_sb(struct bnx2x *bp, uint8_t igu_sb_id, uint8_t segment,
+                     uint16_t index, uint8_t op, uint8_t update);
 
 /* Disable transactions from chip to host */
 void bnx2x_pf_disable(struct bnx2x *bp);
-int bnx2x_pretend_func(struct bnx2x *bp, u16 pretend_func_val);
+int bnx2x_pretend_func(struct bnx2x *bp, uint16_t pretend_func_val);
 
 /**
  * bnx2x__link_status_update - handles link status change.
@@ -228,7 +224,7 @@ void __bnx2x_link_report(struct bnx2x *bp);
  *
  * Takes into account current linespeed and MF configuration.
  */
-u16 bnx2x_get_mf_speed(struct bnx2x *bp);
+uint16_t bnx2x_get_mf_speed(struct bnx2x *bp);
 
 /**
  * bnx2x_msix_sp_int - MSI-X slowpath interrupt handler
@@ -236,7 +232,7 @@ u16 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
@@ -244,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
@@ -322,7 +318,7 @@ void bnx2x_pre_irq_nic_init(struct bnx2x *bp);
  *  - slowpath rings
  *  - etc.
  */
-void bnx2x_post_irq_nic_init(struct bnx2x *bp, u32 load_code);
+void bnx2x_post_irq_nic_init(struct bnx2x *bp, uint32_t load_code);
 /**
  * bnx2x_alloc_mem_cnic - allocate driver's memory for cnic.
  *
@@ -375,7 +371,7 @@ void bnx2x_chip_cleanup(struct bnx2x *bp, int unload_mode, bool keep_link);
  * @bp:                driver handle
  * @resource:  resource bit which was locked
  */
-int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource);
+int bnx2x_acquire_hw_lock(struct bnx2x *bp, uint32_t resource);
 
 /**
  * bnx2x_release_hw_lock - release HW lock.
@@ -383,7 +379,7 @@ int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource);
  * @bp:                driver handle
  * @resource:  resource bit which was locked
  */
-int bnx2x_release_hw_lock(struct bnx2x *bp, u32 resource);
+int bnx2x_release_hw_lock(struct bnx2x *bp, uint32_t resource);
 
 /**
  * bnx2x_release_leader_lock - release recovery leader lock
@@ -461,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.
@@ -469,7 +466,7 @@ int bnx2x_set_power_state(struct bnx2x *bp, pci_power_t state);
  * @bp:                driver handle
  * @value:     new value
  */
-void bnx2x_update_max_mf_config(struct bnx2x *bp, u32 value);
+void bnx2x_update_max_mf_config(struct bnx2x *bp, uint32_t value);
 /* Error handling */
 void bnx2x_fw_dump_lvl(struct bnx2x *bp, const char *lvl);
 
@@ -480,27 +477,29 @@ 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, u8 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, u8 *mac);
-int bnx2x_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos);
+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 */
-u16 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,
                                        struct bnx2x_fastpath *fp,
-                                       u16 bd_prod, u16 rx_comp_prod,
-                                       u16 rx_sge_prod)
+                                       uint16_t bd_prod,
+                                       uint16_t rx_comp_prod,
+                                       uint16_t rx_sge_prod)
 {
        struct ustorm_eth_rx_producers rx_prods = {0};
-       u32 i;
+       uint32_t i;
 
        /* Update producers */
        rx_prods.bd_prod = bd_prod;
@@ -518,9 +517,9 @@ static inline void bnx2x_update_rx_prod(struct bnx2x *bp,
 
        for (i = 0; i < sizeof(rx_prods)/4; i++)
                REG_WR(bp, fp->ustorm_rx_prods_offset + i*4,
-                      ((u32 *)&rx_prods)[i]);
+                      ((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",
@@ -528,16 +527,16 @@ 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);
 
 /* suspend/resume callbacks */
-int bnx2x_suspend(struct pci_dev *pdev, pm_message_t state);
-int bnx2x_resume(struct pci_dev *pdev);
+int bnx2x_suspend(struct pci_device *pdev, pm_message_t state);
+int bnx2x_resume(struct pci_device *pdev);
 
 /* Release IRQ vectors */
 void bnx2x_free_irq(struct bnx2x *bp);
@@ -595,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
 /**
@@ -606,31 +605,32 @@ 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, u64 *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];
 }
 
-static inline void bnx2x_igu_ack_sb_gen(struct bnx2x *bp, u8 igu_sb_id,
-                                       u8 segment, u16 index, u8 op,
-                                       u8 update, u32 igu_addr)
+static inline void bnx2x_igu_ack_sb_gen(struct bnx2x *bp, uint8_t igu_sb_id,
+                                       uint8_t segment, uint16_t index,
+                                       uint8_t op,
+                                       uint8_t update, uint32_t igu_addr)
 {
        struct igu_regular cmd_data = {0};
 
@@ -645,14 +645,15 @@ static inline void bnx2x_igu_ack_sb_gen(struct bnx2x *bp, u8 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, u8 sb_id,
-                                  u8 storm, u16 index, u8 op, u8 update)
+static inline void bnx2x_hc_ack_sb(struct bnx2x *bp, uint8_t sb_id,
+                                  uint8_t storm, uint16_t index, uint8_t op,
+                                  uint8_t update)
 {
-       u32 hc_addr = (HC_REG_COMMAND_REG + BP_PORT(bp)*32 +
+       uint32_t hc_addr = (HC_REG_COMMAND_REG + BP_PORT(bp)*32 +
                       COMMAND_REG_INT_ACK);
        struct igu_ack_register igu_ack;
 
@@ -663,20 +664,21 @@ static inline void bnx2x_hc_ack_sb(struct bnx2x *bp, u8 sb_id,
                         (update << IGU_ACK_REGISTER_UPDATE_INDEX_SHIFT) |
                         (op << IGU_ACK_REGISTER_INTERRUPT_MODE_SHIFT));
 
-       REG_WR(bp, hc_addr, (*(u32 *)&igu_ack));
+       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, u8 igu_sb_id, u8 storm,
-                               u16 index, u8 op, u8 update)
+static inline void bnx2x_ack_sb(struct bnx2x *bp, uint8_t igu_sb_id,
+                               uint8_t storm,
+                               uint16_t index, uint8_t op, uint8_t update)
 {
        if (bp->common.int_block == INT_BLOCK_HC)
                bnx2x_hc_ack_sb(bp, igu_sb_id, storm, index, op, update);
        else {
-               u8 segment;
+               uint8_t segment;
 
                if (CHIP_INT_MODE_IS_BC(bp))
                        segment = storm;
@@ -690,31 +692,31 @@ static inline void bnx2x_ack_sb(struct bnx2x *bp, u8 igu_sb_id, u8 storm,
        }
 }
 
-static inline u16 bnx2x_hc_ack_int(struct bnx2x *bp)
+static inline uint16_t bnx2x_hc_ack_int(struct bnx2x *bp)
 {
-       u32 hc_addr = (HC_REG_COMMAND_REG + BP_PORT(bp)*32 +
+       uint32_t hc_addr = (HC_REG_COMMAND_REG + BP_PORT(bp)*32 +
                       COMMAND_REG_SIMD_MASK);
-       u32 result = REG_RD(bp, hc_addr);
+       uint32_t result = REG_RD(bp, hc_addr);
 
-       barrier();
+       cmb();
        return result;
 }
 
-static inline u16 bnx2x_igu_ack_int(struct bnx2x *bp)
+static inline uint16_t bnx2x_igu_ack_int(struct bnx2x *bp)
 {
-       u32 igu_addr = (BAR_IGU_INTMEM + IGU_REG_SISR_MDPC_WMASK_LSB_UPPER*8);
-       u32 result = REG_RD(bp, igu_addr);
+       uint32_t igu_addr = (BAR_IGU_INTMEM + IGU_REG_SISR_MDPC_WMASK_LSB_UPPER*8);
+       uint32_t result = REG_RD(bp, igu_addr);
 
        DP(NETIF_MSG_INTR, "read 0x%08x from IGU addr 0x%x\n",
           result, igu_addr);
 
-       barrier();
+       cmb();
        return result;
 }
 
-static inline u16 bnx2x_ack_int(struct bnx2x *bp)
+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
@@ -724,16 +726,16 @@ static inline u16 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 u16 bnx2x_tx_avail(struct bnx2x *bp,
+static inline uint16_t bnx2x_tx_avail(struct bnx2x *bp,
                                 struct bnx2x_fp_txdata *txdata)
 {
-       s16 used;
-       u16 prod;
-       u16 cons;
+       int16_t used;
+       uint16_t prod;
+       uint16_t cons;
 
        prod = txdata->tx_bd_prod;
        cons = txdata->tx_bd_cons;
@@ -741,27 +743,27 @@ static inline u16 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)
 {
-       u16 hw_cons;
+       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;
 }
 
 static inline bool bnx2x_has_tx_work(struct bnx2x_fastpath *fp)
 {
-       u8 cos;
+       uint8_t cos;
        for_each_cos_in_tx_queue(fp, cos)
                if (bnx2x_tx_queue_has_work(fp->txdata_ptr[cos]))
                        return true;
@@ -772,7 +774,7 @@ static inline bool bnx2x_has_tx_work(struct bnx2x_fastpath *fp)
 #define BNX2X_SEED_CQE(cqe_fp) (cqe_fp->marker = 0xFFFFFFFF)
 static inline int bnx2x_has_rx_work(struct bnx2x_fastpath *fp)
 {
-       u16 cons;
+       uint16_t cons;
        union eth_rx_cqe *cqe;
        struct eth_fast_path_rx_cqe *cqe_fp;
 
@@ -789,12 +791,16 @@ 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,
-                                    struct bnx2x_fastpath *fp, u16 index)
+                                    struct bnx2x_fastpath *fp,
+                                    uint16_t index)
 {
        struct sw_rx_page *sw_buf = &fp->rx_page_ring[index];
        struct page *page = sw_buf->page;
@@ -806,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;
@@ -815,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);
@@ -844,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)
@@ -878,7 +893,7 @@ static inline void bnx2x_init_sge_ring_bit_mask(struct bnx2x_fastpath *fp)
  * so there is no need to check for dma_mapping_error().
  */
 static inline void bnx2x_reuse_rx_data(struct bnx2x_fastpath *fp,
-                                     u16 cons, u16 prod)
+                                     uint16_t cons, uint16_t prod)
 {
        struct sw_rx_bd *cons_rx_buf = &fp->rx_buf_ring[cons];
        struct sw_rx_bd *prod_rx_buf = &fp->rx_buf_ring[prod];
@@ -954,14 +969,14 @@ static inline int bnx2x_func_start(struct bnx2x *bp)
  * @mac:       pointer to MAC address
  */
 static inline void bnx2x_set_fw_mac_addr(__le16 *fw_hi, __le16 *fw_mid,
-                                        __le16 *fw_lo, u8 *mac)
+                                        __le16 *fw_lo, uint8_t *mac)
 {
-       ((u8 *)fw_hi)[0]  = mac[1];
-       ((u8 *)fw_hi)[1]  = mac[0];
-       ((u8 *)fw_mid)[0] = mac[3];
-       ((u8 *)fw_mid)[1] = mac[2];
-       ((u8 *)fw_lo)[0]  = mac[5];
-       ((u8 *)fw_lo)[1]  = mac[4];
+       ((uint8_t *)fw_hi)[0]  = mac[1];
+       ((uint8_t *)fw_hi)[1]  = mac[0];
+       ((uint8_t *)fw_mid)[0] = mac[3];
+       ((uint8_t *)fw_mid)[1] = mac[2];
+       ((uint8_t *)fw_lo)[0]  = mac[5];
+       ((uint8_t *)fw_lo)[1]  = mac[4];
 }
 
 static inline void bnx2x_free_rx_sge_range(struct bnx2x *bp,
@@ -996,7 +1011,7 @@ static inline void bnx2x_set_next_page_rx_bd(struct bnx2x_fastpath *fp)
 /* Statistics ID are global per chip/path, while Client IDs for E1x are per
  * port.
  */
-static inline u8 bnx2x_stats_id(struct bnx2x_fastpath *fp)
+static inline uint8_t bnx2x_stats_id(struct bnx2x_fastpath *fp)
 {
        struct bnx2x *bp = fp->bp;
        if (!CHIP_IS_E1x(bp)) {
@@ -1030,9 +1045,9 @@ static inline void bnx2x_init_vlan_mac_fp_objs(struct bnx2x_fastpath *fp,
  * Calculates the number of active (not hidden) functions on the
  * current path.
  */
-static inline u8 bnx2x_get_path_func_num(struct bnx2x *bp)
+static inline uint8_t bnx2x_get_path_func_num(struct bnx2x *bp)
 {
-       u8 func_num = 0, i;
+       uint8_t func_num = 0, i;
 
        /* 57710 has only one function per-port */
        if (CHIP_IS_E1(bp))
@@ -1048,7 +1063,7 @@ static inline u8 bnx2x_get_path_func_num(struct bnx2x *bp)
                        func_num = 2;
        } else {
                for (i = 0; i < E1H_FUNC_MAX / 2; i++) {
-                       u32 func_config =
+                       uint32_t func_config =
                                MF_CFG_RD(bp,
                                          func_mf_config[BP_PORT(bp) + 2 * i].
                                          config);
@@ -1057,7 +1072,7 @@ static inline u8 bnx2x_get_path_func_num(struct bnx2x *bp)
                }
        }
 
-       WARN_ON(!func_num);
+       warn_on(!func_num);
 
        return func_num;
 }
@@ -1091,7 +1106,7 @@ static inline void bnx2x_init_bp_objs(struct bnx2x *bp)
                                  BNX2X_OBJ_TYPE_RX);
 }
 
-static inline u8 bnx2x_fp_qzone_id(struct bnx2x_fastpath *fp)
+static inline uint8_t bnx2x_fp_qzone_id(struct bnx2x_fastpath *fp)
 {
        if (CHIP_IS_E1x(fp->bp))
                return fp->cl_id + BP_PORT(fp->bp) * ETH_MAX_RX_CLIENTS_E1H;
@@ -1100,7 +1115,8 @@ static inline u8 bnx2x_fp_qzone_id(struct bnx2x_fastpath *fp)
 }
 
 static inline void bnx2x_init_txdata(struct bnx2x *bp,
-                                    struct bnx2x_fp_txdata *txdata, u32 cid,
+                                    struct bnx2x_fp_txdata *txdata,
+                                    uint32_t cid,
                                     int txq_index, __le16 *tx_cons_sb,
                                     struct bnx2x_fastpath *fp)
 {
@@ -1114,19 +1130,19 @@ static inline void bnx2x_init_txdata(struct bnx2x *bp,
           txdata->cid, txdata->txq_index);
 }
 
-static inline u8 bnx2x_cnic_eth_cl_id(struct bnx2x *bp, u8 cl_idx)
+static inline uint8_t bnx2x_cnic_eth_cl_id(struct bnx2x *bp, uint8_t cl_idx)
 {
        return bp->cnic_base_cl_id + cl_idx +
                (bp->pf_num >> 1) * BNX2X_MAX_CNIC_ETH_CL_ID_IDX;
 }
 
-static inline u8 bnx2x_cnic_fw_sb_id(struct bnx2x *bp)
+static inline uint8_t bnx2x_cnic_fw_sb_id(struct bnx2x *bp)
 {
        /* the 'first' id is allocated for the cnic */
        return bp->base_fw_ndsb;
 }
 
-static inline u8 bnx2x_cnic_igu_sb_id(struct bnx2x *bp)
+static inline uint8_t bnx2x_cnic_igu_sb_id(struct bnx2x *bp)
 {
        return bp->igu_base_sb;
 }
@@ -1149,7 +1165,7 @@ static inline int bnx2x_clean_tx_queue(struct bnx2x *bp,
 #endif
                }
                cnt--;
-               usleep_range(1000, 2000);
+               kthread_usleep(1000);
        }
 
        return 0;
@@ -1158,7 +1174,8 @@ static inline int bnx2x_clean_tx_queue(struct bnx2x *bp,
 int bnx2x_get_link_cfg_idx(struct bnx2x *bp);
 
 static inline void __storm_memset_struct(struct bnx2x *bp,
-                                        u32 addr, size_t size, u32 *data)
+                                        uint32_t addr, size_t size,
+                                        uint32_t *data)
 {
        int i;
        for (i = 0; i < size/4; i++)
@@ -1176,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;
 }
@@ -1209,10 +1226,11 @@ static inline bool bnx2x_wait_sp_comp(struct bnx2x *bp, unsigned long mask)
  * @cid:       SW CID of the connection to be configured
  */
 void bnx2x_set_ctx_validation(struct bnx2x *bp, struct eth_context *cxt,
-                             u32 cid);
+                             uint32_t cid);
 
-void bnx2x_update_coalesce_sb_index(struct bnx2x *bp, u8 fw_sb_id,
-                                   u8 sb_index, u8 disable, u16 usec);
+void bnx2x_update_coalesce_sb_index(struct bnx2x *bp, uint8_t fw_sb_id,
+                                   uint8_t sb_index, uint8_t disable,
+                                   uint16_t usec);
 void bnx2x_acquire_phy_lock(struct bnx2x *bp);
 void bnx2x_release_phy_lock(struct bnx2x *bp);
 
@@ -1223,9 +1241,10 @@ void bnx2x_release_phy_lock(struct bnx2x *bp);
  * @mf_cfg:    MF configuration
  *
  */
-static inline u16 bnx2x_extract_max_cfg(struct bnx2x *bp, u32 mf_cfg)
+static inline uint16_t bnx2x_extract_max_cfg(struct bnx2x *bp,
+                                            uint32_t mf_cfg)
 {
-       u16 max_cfg = (mf_cfg & FUNC_MF_CFG_MAX_BW_MASK) >>
+       uint16_t max_cfg = (mf_cfg & FUNC_MF_CFG_MAX_BW_MASK) >>
                              FUNC_MF_CFG_MAX_BW_SHIFT;
        if (!max_cfg) {
                DP(NETIF_MSG_IFUP | BNX2X_MSG_ETHTOOL,
@@ -1238,6 +1257,8 @@ static inline u16 bnx2x_extract_max_cfg(struct bnx2x *bp, u32 mf_cfg)
 /* 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);
 
@@ -1246,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
 }
 
 /**
@@ -1286,10 +1308,11 @@ static inline void bnx2x_link_sync_notify(struct bnx2x *bp)
  * @set:       set or clear
  *
  */
-static inline void bnx2x_update_drv_flags(struct bnx2x *bp, u32 flags, u32 set)
+static inline void bnx2x_update_drv_flags(struct bnx2x *bp, uint32_t flags,
+                                         uint32_t set)
 {
        if (SHMEM2_HAS(bp, drv_flags)) {
-               u32 drv_flags;
+               uint32_t drv_flags;
                bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_DRV_FLAGS);
                drv_flags = SHMEM2_RD(bp, drv_flags);
 
@@ -1320,6 +1343,6 @@ int bnx2x_drain_tx_queues(struct bnx2x *bp);
 void bnx2x_squeeze_objects(struct bnx2x *bp);
 
 void bnx2x_schedule_sp_rtnl(struct bnx2x*, enum sp_rtnl_flag,
-                           u32 verbose);
+                           uint32_t verbose);
 
 #endif /* BNX2X_CMN_H */