#define USING_SINGLE_MSIX_FLAG         (1 << 20)
 #define BC_SUPPORTS_DCBX_MSG_NON_PMF   (1 << 21)
 #define IS_VF_FLAG                     (1 << 22)
-#define INTERRUPTS_ENABLED_FLAG                (1 << 23)
-#define BC_SUPPORTS_RMMOD_CMD          (1 << 24)
-#define HAS_PHYS_PORT_ID               (1 << 25)
-#define AER_ENABLED                    (1 << 26)
-#define PTP_SUPPORTED                  (1 << 27)
-#define TX_TIMESTAMPING_EN             (1 << 28)
+#define BC_SUPPORTS_RMMOD_CMD          (1 << 23)
+#define HAS_PHYS_PORT_ID               (1 << 24)
+#define AER_ENABLED                    (1 << 25)
+#define PTP_SUPPORTED                  (1 << 26)
+#define TX_TIMESTAMPING_EN             (1 << 27)
 
 #define BP_NOMCP(bp)                   ((bp)->flags & NO_MCP_FLAG)
 
 #define BNX2X_STATE_ERROR              0xf000
 
 #define BNX2X_MAX_PRIORITY             8
-#define BNX2X_MAX_ENTRIES_PER_PRI      16
-#define BNX2X_MAX_COS                  3
-#define BNX2X_MAX_TX_COS               2
        int                     num_queues;
        uint                    num_ethernet_queues;
        uint                    num_cnic_queues;
-       int                     num_napi_queues;
        int                     disable_tpa;
 
        u32                     rx_mode;
 
 static u8 bnx2x_dcbnl_set_all(struct net_device *netdev)
 {
        struct bnx2x *bp = netdev_priv(netdev);
-       int rc = 0;
 
        DP(BNX2X_MSG_DCB, "SET-ALL\n");
 
                                       1);
                bnx2x_dcbx_init(bp, true);
        }
-       DP(BNX2X_MSG_DCB, "set_dcbx_params done (%d)\n", rc);
-       if (rc)
-               return 1;
+       DP(BNX2X_MSG_DCB, "set_dcbx_params done\n");
 
        return 0;
 }
 
        else
                value = 0;
 
-       DP(NETIF_MSG_LINK, "pin %d  value 0x%x\n", gpio_num, value);
-
        return value;
 }
 
        for (i = 0; sig; i++) {
                cur_bit = (0x1UL << i);
                if (sig & cur_bit) {
-                       res |= true; /* Each bit is real error! */
+                       res = true; /* Each bit is real error! */
                        if (print) {
                                switch (cur_bit) {
                                case AEU_INPUTS_ATTN_BITS_CSEMI_PARITY_ERROR:
                                        _print_next_block((*par_num)++,
                                                          "MCP ROM");
                                *global = true;
-                               res |= true;
+                               res = true;
                                break;
                        case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_RX_PARITY:
                                if (print)
                                        _print_next_block((*par_num)++,
                                                          "MCP UMP RX");
                                *global = true;
-                               res |= true;
+                               res = true;
                                break;
                        case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_TX_PARITY:
                                if (print)
                                        _print_next_block((*par_num)++,
                                                          "MCP UMP TX");
                                *global = true;
-                               res |= true;
+                               res = true;
                                break;
                        case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_SCPAD_PARITY:
                                if (print)
        for (i = 0; sig; i++) {
                cur_bit = (0x1UL << i);
                if (sig & cur_bit) {
-                       res |= true; /* Each bit is real error! */
+                       res = true; /* Each bit is real error! */
                        if (print) {
                                switch (cur_bit) {
                                case AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR:
        }
 
        /* Set ACCEPT_ANY_VLAN as we do not enable filtering by VLAN */
-       if (bp->rx_mode != BNX2X_RX_MODE_NONE) {
+       if (rx_mode != BNX2X_RX_MODE_NONE) {
                __set_bit(BNX2X_ACCEPT_ANY_VLAN, rx_accept_flags);
                __set_bit(BNX2X_ACCEPT_ANY_VLAN, tx_accept_flags);
        }
                struct bnx2x_func_state_params func_params = {NULL};
 
                DP(NETIF_MSG_IFDOWN,
-                  "Hmmm... Unexpected function state! Forcing STARTED-->TX_ST0PPED-->STARTED\n");
+                  "Hmmm... Unexpected function state! Forcing STARTED-->TX_STOPPED-->STARTED\n");
 
                func_params.f_obj = &bp->func_obj;
                __set_bit(RAMROD_DRV_CLR_ONLY,
 
                BNX2X_MAX_NUM_VF_QUEUES * sizeof(struct bnx2x_vf_queue),
                GFP_KERNEL);
 
-       DP(BNX2X_MSG_IOV, "bp->vfdb->vfqs was %p\n", bp->vfdb->vfqs);
-
        if (!bp->vfdb->vfqs) {
                BNX2X_ERR("failed to allocate vf queue array\n");
                err = -ENOMEM;
        bp->fw_stats_req->hdr.cmd_num = bp->fw_stats_num + stats_count;
 }
 
-static inline
-struct bnx2x_virtf *__vf_from_stat_id(struct bnx2x *bp, u8 stat_id)
-{
-       int i;
-       struct bnx2x_virtf *vf = NULL;
-
-       for_each_vf(bp, i) {
-               vf = BP_VF(bp, i);
-               if (stat_id >= vf->igu_base_id &&
-                   stat_id < vf->igu_base_id + vf_sb_count(vf))
-                       break;
-       }
-       return vf;
-}
-
 /* VF API helpers */
 static void bnx2x_vf_qtbl_set_q(struct bnx2x *bp, u8 abs_vfid, u8 qid,
                                u8 enable)
        return rc;
 }
 
-static inline void bnx2x_vf_get_sbdf(struct bnx2x *bp,
-                             struct bnx2x_virtf *vf, u32 *sbdf)
-{
-       *sbdf = vf->devfn | (vf->bus << 8);
-}
-
 void bnx2x_lock_vf_pf_channel(struct bnx2x *bp, struct bnx2x_virtf *vf,
                              enum channel_tlvs tlv)
 {
 
        /* log the unlock */
        DP(BNX2X_MSG_IOV, "VF[%d]: vf pf channel unlocked by %d\n",
-          vf->abs_vfid, vf->op_current);
+          vf->abs_vfid, current_tlv);
 }
 
 static int bnx2x_set_pf_tx_switching(struct bnx2x *bp, bool enable)
        }
 
        if (!IS_SRIOV(bp)) {
-               BNX2X_ERR("sriov is disabled - can't utilize iov-realted functionality\n");
+               BNX2X_ERR("sriov is disabled - can't utilize iov-related functionality\n");
                return -EINVAL;
        }
 
 
                        cpu_to_le16(bp->stats_counter++);
 
                DP(BNX2X_MSG_STATS, "Sending statistics ramrod %d\n",
-                       bp->fw_stats_req->hdr.drv_stats_counter);
+                  le16_to_cpu(bp->fw_stats_req->hdr.drv_stats_counter));
 
                /* adjust the ramrod to include VF queues statistics */
                bnx2x_iov_adjust_stats_req(bp);
        }
 }
 
-static int bnx2x_stats_comp(struct bnx2x *bp)
+static void bnx2x_stats_comp(struct bnx2x *bp)
 {
        u32 *stats_comp = bnx2x_sp(bp, stats_comp);
        int cnt = 10;
                cnt--;
                usleep_range(1000, 2000);
        }
-       return 1;
 }
 
 /*
 
        flags |= VFPF_QUEUE_FLG_STATS;
        flags |= VFPF_QUEUE_FLG_CACHE_ALIGN;
        flags |= VFPF_QUEUE_FLG_VLAN;
-       DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
 
        /* Common */
        req->vf_qid = fp_idx;
        REG_WR8(bp, addr, 1);
 }
 
-static inline void bnx2x_set_vf_mbxs_valid(struct bnx2x *bp)
-{
-       int i;
-
-       for_each_vf(bp, i)
-               storm_memset_vf_mbx_valid(bp, bnx2x_vf(bp, i, abs_vfid));
-}
-
 /* enable vf_pf mailbox (aka vf-pf-channel) */
 void bnx2x_vf_enable_mbx(struct bnx2x *bp, u8 abs_vfid)
 {