cnic: Use pfid for internal memory offsets.

The pfid (physical function ID) is the same as PCI function on production
devices.  The pfid for future devices will be different and will be used
for internal memory offsets.

Signed-off-by: Michael Chan <mchan@broadcom.com>
Signed-off-by: Dmitry Kravkov <dmitry@broadcom.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 74 insertions, 70 deletions

diff --git a/drivers/net/cnic.c b/drivers/net/cnic.c
index 0e31d5aa1dd2..50cded7fff51 100644
--- a/drivers/net/cnic.c
+++ b/drivers/net/cnic.c
@@ -1246,8 +1246,8 @@ static int cnic_bnx2x_iscsi_init1(struct cnic_dev *dev, struct kwqe *kwqe)
 {
         struct cnic_local *cp = dev->cnic_priv;
         struct iscsi_kwqe_init1 *req1 = (struct iscsi_kwqe_init1 *) kwqe;
-        int func = cp->func, pages;
-        int hq_bds;
+        int hq_bds, pages;
+        u32 pfid = cp->pfid;
 
         cp->num_iscsi_tasks = req1->num_tasks_per_conn;
         cp->num_ccells = req1->num_ccells_per_conn;
@@ -1264,60 +1264,60 @@ static int cnic_bnx2x_iscsi_init1(struct cnic_dev *dev, struct kwqe *kwqe)
                 return 0;
 
         /* init Tstorm RAM */
-        CNIC_WR16(dev, BAR_TSTRORM_INTMEM + TSTORM_ISCSI_RQ_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_TSTRORM_INTMEM + TSTORM_ISCSI_RQ_SIZE_OFFSET(pfid),
                   req1->rq_num_wqes);
-        CNIC_WR16(dev, BAR_TSTRORM_INTMEM + TSTORM_ISCSI_PAGE_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_TSTRORM_INTMEM + TSTORM_ISCSI_PAGE_SIZE_OFFSET(pfid),
                   PAGE_SIZE);
         CNIC_WR8(dev, BAR_TSTRORM_INTMEM +
-                 TSTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(func), PAGE_SHIFT);
+                 TSTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(pfid), PAGE_SHIFT);
         CNIC_WR16(dev, BAR_TSTRORM_INTMEM +
-                  TSTORM_ISCSI_NUM_OF_TASKS_OFFSET(func),
+                  TSTORM_ISCSI_NUM_OF_TASKS_OFFSET(pfid),
                   req1->num_tasks_per_conn);
 
         /* init Ustorm RAM */
         CNIC_WR16(dev, BAR_USTRORM_INTMEM +
-                  USTORM_ISCSI_RQ_BUFFER_SIZE_OFFSET(func),
+                  USTORM_ISCSI_RQ_BUFFER_SIZE_OFFSET(pfid),
                   req1->rq_buffer_size);
-        CNIC_WR16(dev, BAR_USTRORM_INTMEM + USTORM_ISCSI_PAGE_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_USTRORM_INTMEM + USTORM_ISCSI_PAGE_SIZE_OFFSET(pfid),
                   PAGE_SIZE);
         CNIC_WR8(dev, BAR_USTRORM_INTMEM +
-                 USTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(func), PAGE_SHIFT);
+                 USTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(pfid), PAGE_SHIFT);
         CNIC_WR16(dev, BAR_USTRORM_INTMEM +
-                  USTORM_ISCSI_NUM_OF_TASKS_OFFSET(func),
+                  USTORM_ISCSI_NUM_OF_TASKS_OFFSET(pfid),
                   req1->num_tasks_per_conn);
-        CNIC_WR16(dev, BAR_USTRORM_INTMEM + USTORM_ISCSI_RQ_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_USTRORM_INTMEM + USTORM_ISCSI_RQ_SIZE_OFFSET(pfid),
                   req1->rq_num_wqes);
-        CNIC_WR16(dev, BAR_USTRORM_INTMEM + USTORM_ISCSI_CQ_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_USTRORM_INTMEM + USTORM_ISCSI_CQ_SIZE_OFFSET(pfid),
                   req1->cq_num_wqes);
-        CNIC_WR16(dev, BAR_USTRORM_INTMEM + USTORM_ISCSI_R2TQ_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_USTRORM_INTMEM + USTORM_ISCSI_R2TQ_SIZE_OFFSET(pfid),
                   cp->num_iscsi_tasks * BNX2X_ISCSI_MAX_PENDING_R2TS);
 
         /* init Xstorm RAM */
-        CNIC_WR16(dev, BAR_XSTRORM_INTMEM + XSTORM_ISCSI_PAGE_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_XSTRORM_INTMEM + XSTORM_ISCSI_PAGE_SIZE_OFFSET(pfid),
                   PAGE_SIZE);
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
-                 XSTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(func), PAGE_SHIFT);
+                 XSTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(pfid), PAGE_SHIFT);
         CNIC_WR16(dev, BAR_XSTRORM_INTMEM +
-                  XSTORM_ISCSI_NUM_OF_TASKS_OFFSET(func),
+                  XSTORM_ISCSI_NUM_OF_TASKS_OFFSET(pfid),
                   req1->num_tasks_per_conn);
-        CNIC_WR16(dev, BAR_XSTRORM_INTMEM + XSTORM_ISCSI_HQ_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_XSTRORM_INTMEM + XSTORM_ISCSI_HQ_SIZE_OFFSET(pfid),
                   hq_bds);
-        CNIC_WR16(dev, BAR_XSTRORM_INTMEM + XSTORM_ISCSI_SQ_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_XSTRORM_INTMEM + XSTORM_ISCSI_SQ_SIZE_OFFSET(pfid),
                   req1->num_tasks_per_conn);
-        CNIC_WR16(dev, BAR_XSTRORM_INTMEM + XSTORM_ISCSI_R2TQ_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_XSTRORM_INTMEM + XSTORM_ISCSI_R2TQ_SIZE_OFFSET(pfid),
                   cp->num_iscsi_tasks * BNX2X_ISCSI_MAX_PENDING_R2TS);
 
         /* init Cstorm RAM */
-        CNIC_WR16(dev, BAR_CSTRORM_INTMEM + CSTORM_ISCSI_PAGE_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_CSTRORM_INTMEM + CSTORM_ISCSI_PAGE_SIZE_OFFSET(pfid),
                   PAGE_SIZE);
         CNIC_WR8(dev, BAR_CSTRORM_INTMEM +
-                 CSTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(func), PAGE_SHIFT);
+                 CSTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(pfid), PAGE_SHIFT);
         CNIC_WR16(dev, BAR_CSTRORM_INTMEM +
-                  CSTORM_ISCSI_NUM_OF_TASKS_OFFSET(func),
+                  CSTORM_ISCSI_NUM_OF_TASKS_OFFSET(pfid),
                   req1->num_tasks_per_conn);
-        CNIC_WR16(dev, BAR_CSTRORM_INTMEM + CSTORM_ISCSI_CQ_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_CSTRORM_INTMEM + CSTORM_ISCSI_CQ_SIZE_OFFSET(pfid),
                   req1->cq_num_wqes);
-        CNIC_WR16(dev, BAR_CSTRORM_INTMEM + CSTORM_ISCSI_HQ_SIZE_OFFSET(func),
+        CNIC_WR16(dev, BAR_CSTRORM_INTMEM + CSTORM_ISCSI_HQ_SIZE_OFFSET(pfid),
                   hq_bds);
 
         return 0;
@@ -1327,7 +1327,7 @@ static int cnic_bnx2x_iscsi_init2(struct cnic_dev *dev, struct kwqe *kwqe)
 {
         struct iscsi_kwqe_init2 *req2 = (struct iscsi_kwqe_init2 *) kwqe;
         struct cnic_local *cp = dev->cnic_priv;
-        int func = cp->func;
+        u32 pfid = cp->pfid;
         struct iscsi_kcqe kcqe;
         struct kcqe *cqes[1];
 
@@ -1339,21 +1339,21 @@ static int cnic_bnx2x_iscsi_init2(struct cnic_dev *dev, struct kwqe *kwqe)
         }
 
         CNIC_WR(dev, BAR_TSTRORM_INTMEM +
-                TSTORM_ISCSI_ERROR_BITMAP_OFFSET(func), req2->error_bit_map[0]);
+                TSTORM_ISCSI_ERROR_BITMAP_OFFSET(pfid), req2->error_bit_map[0]);
         CNIC_WR(dev, BAR_TSTRORM_INTMEM +
-                TSTORM_ISCSI_ERROR_BITMAP_OFFSET(func) + 4,
+                TSTORM_ISCSI_ERROR_BITMAP_OFFSET(pfid) + 4,
                 req2->error_bit_map[1]);
 
         CNIC_WR16(dev, BAR_USTRORM_INTMEM +
-                  USTORM_ISCSI_CQ_SQN_SIZE_OFFSET(func), req2->max_cq_sqn);
+                  USTORM_ISCSI_CQ_SQN_SIZE_OFFSET(pfid), req2->max_cq_sqn);
         CNIC_WR(dev, BAR_USTRORM_INTMEM +
-                USTORM_ISCSI_ERROR_BITMAP_OFFSET(func), req2->error_bit_map[0]);
+                USTORM_ISCSI_ERROR_BITMAP_OFFSET(pfid), req2->error_bit_map[0]);
         CNIC_WR(dev, BAR_USTRORM_INTMEM +
-                USTORM_ISCSI_ERROR_BITMAP_OFFSET(func) + 4,
+                USTORM_ISCSI_ERROR_BITMAP_OFFSET(pfid) + 4,
                 req2->error_bit_map[1]);
 
         CNIC_WR16(dev, BAR_CSTRORM_INTMEM +
-                  CSTORM_ISCSI_CQ_SQN_SIZE_OFFSET(func), req2->max_cq_sqn);
+                  CSTORM_ISCSI_CQ_SQN_SIZE_OFFSET(pfid), req2->max_cq_sqn);
 
         kcqe.completion_status = ISCSI_KCQE_COMPLETION_STATUS_SUCCESS;
 
@@ -1804,37 +1804,37 @@ static void cnic_init_storm_conn_bufs(struct cnic_dev *dev,
 static void cnic_init_bnx2x_mac(struct cnic_dev *dev)
 {
         struct cnic_local *cp = dev->cnic_priv;
-        int func = CNIC_FUNC(cp);
+        u32 pfid = cp->pfid;
         u8 *mac = dev->mac_addr;
 
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
-                 XSTORM_ISCSI_LOCAL_MAC_ADDR0_OFFSET(func), mac[0]);
+                 XSTORM_ISCSI_LOCAL_MAC_ADDR0_OFFSET(pfid), mac[0]);
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
-                 XSTORM_ISCSI_LOCAL_MAC_ADDR1_OFFSET(func), mac[1]);
+                 XSTORM_ISCSI_LOCAL_MAC_ADDR1_OFFSET(pfid), mac[1]);
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
-                 XSTORM_ISCSI_LOCAL_MAC_ADDR2_OFFSET(func), mac[2]);
+                 XSTORM_ISCSI_LOCAL_MAC_ADDR2_OFFSET(pfid), mac[2]);
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
-                 XSTORM_ISCSI_LOCAL_MAC_ADDR3_OFFSET(func), mac[3]);
+                 XSTORM_ISCSI_LOCAL_MAC_ADDR3_OFFSET(pfid), mac[3]);
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
-                 XSTORM_ISCSI_LOCAL_MAC_ADDR4_OFFSET(func), mac[4]);
+                 XSTORM_ISCSI_LOCAL_MAC_ADDR4_OFFSET(pfid), mac[4]);
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
-                 XSTORM_ISCSI_LOCAL_MAC_ADDR5_OFFSET(func), mac[5]);
+                 XSTORM_ISCSI_LOCAL_MAC_ADDR5_OFFSET(pfid), mac[5]);
 
         CNIC_WR8(dev, BAR_TSTRORM_INTMEM +
-                 TSTORM_ISCSI_TCP_VARS_LSB_LOCAL_MAC_ADDR_OFFSET(func), mac[5]);
+                 TSTORM_ISCSI_TCP_VARS_LSB_LOCAL_MAC_ADDR_OFFSET(pfid), mac[5]);
         CNIC_WR8(dev, BAR_TSTRORM_INTMEM +
-                 TSTORM_ISCSI_TCP_VARS_LSB_LOCAL_MAC_ADDR_OFFSET(func) + 1,
+                 TSTORM_ISCSI_TCP_VARS_LSB_LOCAL_MAC_ADDR_OFFSET(pfid) + 1,
                  mac[4]);
         CNIC_WR8(dev, BAR_TSTRORM_INTMEM +
-                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(func), mac[3]);
+                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(pfid), mac[3]);
         CNIC_WR8(dev, BAR_TSTRORM_INTMEM +
-                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(func) + 1,
+                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(pfid) + 1,
                  mac[2]);
         CNIC_WR8(dev, BAR_TSTRORM_INTMEM +
-                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(func) + 2,
+                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(pfid) + 2,
                  mac[1]);
         CNIC_WR8(dev, BAR_TSTRORM_INTMEM +
-                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(func) + 3,
+                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(pfid) + 3,
                  mac[0]);
 }
 
@@ -1850,10 +1850,10 @@ static void cnic_bnx2x_set_tcp_timestamp(struct cnic_dev *dev, int tcp_ts)
         }
 
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
-                 XSTORM_ISCSI_TCP_VARS_FLAGS_OFFSET(cp->func), xstorm_flags);
+                 XSTORM_ISCSI_TCP_VARS_FLAGS_OFFSET(cp->pfid), xstorm_flags);
 
         CNIC_WR16(dev, BAR_TSTRORM_INTMEM +
-                  TSTORM_ISCSI_TCP_VARS_FLAGS_OFFSET(cp->func), tstorm_flags);
+                  TSTORM_ISCSI_TCP_VARS_FLAGS_OFFSET(cp->pfid), tstorm_flags);
 }
 
 static int cnic_bnx2x_connect(struct cnic_dev *dev, struct kwqe *wqes[],
@@ -1928,7 +1928,7 @@ static int cnic_bnx2x_connect(struct cnic_dev *dev, struct kwqe *wqes[],
         cnic_init_storm_conn_bufs(dev, kwqe1, kwqe3, conn_buf);
 
         CNIC_WR16(dev, BAR_XSTRORM_INTMEM +
-                  XSTORM_ISCSI_LOCAL_VLAN_OFFSET(cp->func), csk->vlan_id);
+                  XSTORM_ISCSI_LOCAL_VLAN_OFFSET(cp->pfid), csk->vlan_id);
 
         cnic_bnx2x_set_tcp_timestamp(dev,
                 kwqe1->tcp_flags & L4_KWQ_CONNECT_REQ1_TIME_STAMP);
@@ -3283,30 +3283,30 @@ static void cnic_cm_stop_bnx2x_hw(struct cnic_dev *dev)
 static int cnic_cm_init_bnx2x_hw(struct cnic_dev *dev)
 {
         struct cnic_local *cp = dev->cnic_priv;
-        int func = CNIC_FUNC(cp);
+        u32 pfid = cp->pfid;
 
         cnic_init_bnx2x_mac(dev);
         cnic_bnx2x_set_tcp_timestamp(dev, 1);
 
         CNIC_WR16(dev, BAR_XSTRORM_INTMEM +
-                  XSTORM_ISCSI_LOCAL_VLAN_OFFSET(func), 0);
+                  XSTORM_ISCSI_LOCAL_VLAN_OFFSET(pfid), 0);
 
         CNIC_WR(dev, BAR_XSTRORM_INTMEM +
-                XSTORM_TCP_GLOBAL_DEL_ACK_COUNTER_ENABLED_OFFSET(func), 1);
+                XSTORM_TCP_GLOBAL_DEL_ACK_COUNTER_ENABLED_OFFSET(pfid), 1);
         CNIC_WR(dev, BAR_XSTRORM_INTMEM +
-                XSTORM_TCP_GLOBAL_DEL_ACK_COUNTER_MAX_COUNT_OFFSET(func),
+                XSTORM_TCP_GLOBAL_DEL_ACK_COUNTER_MAX_COUNT_OFFSET(pfid),
                 DEF_MAX_DA_COUNT);
 
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
-                 XSTORM_ISCSI_TCP_VARS_TTL_OFFSET(func), DEF_TTL);
+                 XSTORM_ISCSI_TCP_VARS_TTL_OFFSET(pfid), DEF_TTL);
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
-                 XSTORM_ISCSI_TCP_VARS_TOS_OFFSET(func), DEF_TOS);
+                 XSTORM_ISCSI_TCP_VARS_TOS_OFFSET(pfid), DEF_TOS);
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
-                 XSTORM_ISCSI_TCP_VARS_ADV_WND_SCL_OFFSET(func), 2);
+                 XSTORM_ISCSI_TCP_VARS_ADV_WND_SCL_OFFSET(pfid), 2);
         CNIC_WR(dev, BAR_XSTRORM_INTMEM +
-                XSTORM_TCP_TX_SWS_TIMER_VAL_OFFSET(func), DEF_SWS_TIMER);
+                XSTORM_TCP_TX_SWS_TIMER_VAL_OFFSET(pfid), DEF_SWS_TIMER);
 
-        CNIC_WR(dev, BAR_TSTRORM_INTMEM + TSTORM_TCP_MAX_CWND_OFFSET(func),
+        CNIC_WR(dev, BAR_TSTRORM_INTMEM + TSTORM_TCP_MAX_CWND_OFFSET(pfid),
                 DEF_MAX_CWND);
         return 0;
 }
@@ -4123,9 +4123,13 @@ static int cnic_start_bnx2x_hw(struct cnic_dev *dev)
         struct cnic_local *cp = dev->cnic_priv;
         int func = CNIC_FUNC(cp), ret, i;
         int port = CNIC_PORT(cp);
+        u32 pfid;
         u16 eq_idx;
         u8 sb_id = cp->status_blk_num;
 
+        cp->pfid = func;
+        pfid = cp->pfid;
+
         ret = cnic_init_id_tbl(&cp->cid_tbl, MAX_ISCSI_TBL_SZ,
                                cp->iscsi_start_cid);
 
@@ -4133,7 +4137,7 @@ static int cnic_start_bnx2x_hw(struct cnic_dev *dev)
                 return -ENOMEM;
 
         cp->kcq1.io_addr = BAR_CSTRORM_INTMEM +
-                          CSTORM_ISCSI_EQ_PROD_OFFSET(func, 0);
+                          CSTORM_ISCSI_EQ_PROD_OFFSET(pfid, 0);
         cp->kcq1.sw_prod_idx = 0;
 
         cp->kcq1.hw_prod_idx_ptr =
@@ -4147,41 +4151,41 @@ static int cnic_start_bnx2x_hw(struct cnic_dev *dev)
         /* Only 1 EQ */
         CNIC_WR16(dev, cp->kcq1.io_addr, MAX_KCQ_IDX);
         CNIC_WR(dev, BAR_CSTRORM_INTMEM +
-                CSTORM_ISCSI_EQ_CONS_OFFSET(func, 0), 0);
+                CSTORM_ISCSI_EQ_CONS_OFFSET(pfid, 0), 0);
         CNIC_WR(dev, BAR_CSTRORM_INTMEM +
-                CSTORM_ISCSI_EQ_NEXT_PAGE_ADDR_OFFSET(func, 0),
+                CSTORM_ISCSI_EQ_NEXT_PAGE_ADDR_OFFSET(pfid, 0),
                 cp->kcq1.dma.pg_map_arr[1] & 0xffffffff);
         CNIC_WR(dev, BAR_CSTRORM_INTMEM +
-                CSTORM_ISCSI_EQ_NEXT_PAGE_ADDR_OFFSET(func, 0) + 4,
+                CSTORM_ISCSI_EQ_NEXT_PAGE_ADDR_OFFSET(pfid, 0) + 4,
                 (u64) cp->kcq1.dma.pg_map_arr[1] >> 32);
         CNIC_WR(dev, BAR_CSTRORM_INTMEM +
-                CSTORM_ISCSI_EQ_NEXT_EQE_ADDR_OFFSET(func, 0),
+                CSTORM_ISCSI_EQ_NEXT_EQE_ADDR_OFFSET(pfid, 0),
                 cp->kcq1.dma.pg_map_arr[0] & 0xffffffff);
         CNIC_WR(dev, BAR_CSTRORM_INTMEM +
-                CSTORM_ISCSI_EQ_NEXT_EQE_ADDR_OFFSET(func, 0) + 4,
+                CSTORM_ISCSI_EQ_NEXT_EQE_ADDR_OFFSET(pfid, 0) + 4,
                 (u64) cp->kcq1.dma.pg_map_arr[0] >> 32);
         CNIC_WR8(dev, BAR_CSTRORM_INTMEM +
-                CSTORM_ISCSI_EQ_NEXT_PAGE_ADDR_VALID_OFFSET(func, 0), 1);
+                CSTORM_ISCSI_EQ_NEXT_PAGE_ADDR_VALID_OFFSET(pfid, 0), 1);
         CNIC_WR16(dev, BAR_CSTRORM_INTMEM +
-                CSTORM_ISCSI_EQ_SB_NUM_OFFSET(func, 0), cp->status_blk_num);
+                CSTORM_ISCSI_EQ_SB_NUM_OFFSET(pfid, 0), cp->status_blk_num);
         CNIC_WR8(dev, BAR_CSTRORM_INTMEM +
-                CSTORM_ISCSI_EQ_SB_INDEX_OFFSET(func, 0),
+                CSTORM_ISCSI_EQ_SB_INDEX_OFFSET(pfid, 0),
                 HC_INDEX_C_ISCSI_EQ_CONS);
 
         for (i = 0; i < cp->conn_buf_info.num_pages; i++) {
                 CNIC_WR(dev, BAR_TSTRORM_INTMEM +
-                        TSTORM_ISCSI_CONN_BUF_PBL_OFFSET(func, i),
+                        TSTORM_ISCSI_CONN_BUF_PBL_OFFSET(pfid, i),
                         cp->conn_buf_info.pgtbl[2 * i]);
                 CNIC_WR(dev, BAR_TSTRORM_INTMEM +
-                        TSTORM_ISCSI_CONN_BUF_PBL_OFFSET(func, i) + 4,
+                        TSTORM_ISCSI_CONN_BUF_PBL_OFFSET(pfid, i) + 4,
                         cp->conn_buf_info.pgtbl[(2 * i) + 1]);
         }
 
         CNIC_WR(dev, BAR_USTRORM_INTMEM +
-                USTORM_ISCSI_GLOBAL_BUF_PHYS_ADDR_OFFSET(func),
+                USTORM_ISCSI_GLOBAL_BUF_PHYS_ADDR_OFFSET(pfid),
                 cp->gbl_buf_info.pg_map_arr[0] & 0xffffffff);
         CNIC_WR(dev, BAR_USTRORM_INTMEM +
-                USTORM_ISCSI_GLOBAL_BUF_PHYS_ADDR_OFFSET(func) + 4,
+                USTORM_ISCSI_GLOBAL_BUF_PHYS_ADDR_OFFSET(pfid) + 4,
                 (u64) cp->gbl_buf_info.pg_map_arr[0] >> 32);
 
         cnic_setup_bnx2x_context(dev);
@@ -4386,7 +4390,7 @@ static void cnic_stop_bnx2x_hw(struct cnic_dev *dev)
                            index_values[HC_INDEX_C_ISCSI_EQ_CONS]),
                   0);
         CNIC_WR(dev, BAR_CSTRORM_INTMEM +
-                CSTORM_ISCSI_EQ_CONS_OFFSET(cp->func, 0), 0);
+                CSTORM_ISCSI_EQ_CONS_OFFSET(cp->pfid, 0), 0);
         CNIC_WR16(dev, cp->kcq1.io_addr, 0);
         cnic_free_resc(dev);
 }