[SCSI] qla2xxx: Refactor qla data structures

Following changes have been made to the qla2xxx FC driver in
preparation for the multi- queue and future SR IOV hardware.

1. scsi_qla_host structure has been changed to contain scsi host
   specific data only.

2. A new structure, qla_hw_data is created to contain HBA specific
   hardware data.

3. Request and response IO specific data strucures are created.

4. The global list of fcports for the hba is not maintained anymore,
   instead a fcport list is construted on per scsi_qla_host.

Signed-of-by: Anirban Chakraborty <anirban.chakraborty@qlogic.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>

1 files changed, 243 insertions, 236 deletions

diff --git a/drivers/scsi/qla2xxx/qla_gs.c b/drivers/scsi/qla2xxx/qla_gs.c
index c2a4bfbcb05b..db8de063e1cb 100644
--- a/drivers/scsi/qla2xxx/qla_gs.c
+++ b/drivers/scsi/qla2xxx/qla_gs.c
@@ -22,8 +22,9 @@ static int qla2x00_sns_rnn_id(scsi_qla_host_t *);
  * Returns a pointer to the @ha's ms_iocb.
  */
 void *
-qla2x00_prep_ms_iocb(scsi_qla_host_t *ha, uint32_t req_size, uint32_t rsp_size)
+qla2x00_prep_ms_iocb(scsi_qla_host_t *vha, uint32_t req_size, uint32_t rsp_size)
 {
+        struct qla_hw_data *ha = vha->hw;
         ms_iocb_entry_t *ms_pkt;
 
         ms_pkt = ha->ms_iocb;
@@ -59,8 +60,9 @@ qla2x00_prep_ms_iocb(scsi_qla_host_t *ha, uint32_t req_size, uint32_t rsp_size)
  * Returns a pointer to the @ha's ms_iocb.
  */
 void *
-qla24xx_prep_ms_iocb(scsi_qla_host_t *ha, uint32_t req_size, uint32_t rsp_size)
+qla24xx_prep_ms_iocb(scsi_qla_host_t *vha, uint32_t req_size, uint32_t rsp_size)
 {
+        struct qla_hw_data *ha = vha->hw;
         struct ct_entry_24xx *ct_pkt;
 
         ct_pkt = (struct ct_entry_24xx *)ha->ms_iocb;
@@ -82,7 +84,7 @@ qla24xx_prep_ms_iocb(scsi_qla_host_t *ha, uint32_t req_size, uint32_t rsp_size)
         ct_pkt->dseg_1_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma));
         ct_pkt->dseg_1_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma));
         ct_pkt->dseg_1_len = ct_pkt->rsp_byte_count;
-        ct_pkt->vp_index = ha->vp_idx;
+        ct_pkt->vp_index = vha->vp_idx;
 
         return (ct_pkt);
 }
@@ -110,16 +112,17 @@ qla2x00_prep_ct_req(struct ct_sns_req *ct_req, uint16_t cmd, uint16_t rsp_size)
 }
 
 static int
-qla2x00_chk_ms_status(scsi_qla_host_t *ha, ms_iocb_entry_t *ms_pkt,
+qla2x00_chk_ms_status(scsi_qla_host_t *vha, ms_iocb_entry_t *ms_pkt,
     struct ct_sns_rsp *ct_rsp, const char *routine)
 {
         int rval;
         uint16_t comp_status;
+        struct qla_hw_data *ha = vha->hw;
 
         rval = QLA_FUNCTION_FAILED;
         if (ms_pkt->entry_status != 0) {
                 DEBUG2_3(printk("scsi(%ld): %s failed, error status (%x).\n",
-                    ha->host_no, routine, ms_pkt->entry_status));
+                    vha->host_no, routine, ms_pkt->entry_status));
         } else {
                 if (IS_FWI2_CAPABLE(ha))
                         comp_status = le16_to_cpu(
@@ -133,7 +136,7 @@ qla2x00_chk_ms_status(scsi_qla_host_t *ha, ms_iocb_entry_t *ms_pkt,
                         if (ct_rsp->header.response !=
                             __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) {
                                 DEBUG2_3(printk("scsi(%ld): %s failed, "
-                                    "rejected request:\n", ha->host_no,
+                                    "rejected request:\n", vha->host_no,
                                     routine));
                                 DEBUG2_3(qla2x00_dump_buffer(
                                     (uint8_t *)&ct_rsp->header,
@@ -144,7 +147,7 @@ qla2x00_chk_ms_status(scsi_qla_host_t *ha, ms_iocb_entry_t *ms_pkt,
                         break;
                 default:
                         DEBUG2_3(printk("scsi(%ld): %s failed, completion "
-                            "status (%x).\n", ha->host_no, routine,
+                            "status (%x).\n", vha->host_no, routine,
                             comp_status));
                         break;
                 }
@@ -160,21 +163,21 @@ qla2x00_chk_ms_status(scsi_qla_host_t *ha, ms_iocb_entry_t *ms_pkt,
  * Returns 0 on success.
  */
 int
-qla2x00_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport)
+qla2x00_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
 {
         int             rval;
 
         ms_iocb_entry_t *ms_pkt;
         struct ct_sns_req       *ct_req;
         struct ct_sns_rsp       *ct_rsp;
+        struct qla_hw_data *ha = vha->hw;
 
-        if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
-                return (qla2x00_sns_ga_nxt(ha, fcport));
-        }
+        if (IS_QLA2100(ha) || IS_QLA2200(ha))
+                return qla2x00_sns_ga_nxt(vha, fcport);
 
         /* Issue GA_NXT */
         /* Prepare common MS IOCB */
-        ms_pkt = ha->isp_ops->prep_ms_iocb(ha, GA_NXT_REQ_SIZE,
+        ms_pkt = ha->isp_ops->prep_ms_iocb(vha, GA_NXT_REQ_SIZE,
             GA_NXT_RSP_SIZE);
 
         /* Prepare CT request */
@@ -188,13 +191,13 @@ qla2x00_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport)
         ct_req->req.port_id.port_id[2] = fcport->d_id.b.al_pa;
 
         /* Execute MS IOCB */
-        rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+        rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): GA_NXT issue IOCB failed (%d).\n",
-                    ha->host_no, rval));
-        } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp, "GA_NXT") !=
+                    vha->host_no, rval));
+        } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "GA_NXT") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
@@ -216,7 +219,7 @@ qla2x00_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport)
                     "nn %02x%02x%02x%02x%02x%02x%02x%02x "
                     "pn %02x%02x%02x%02x%02x%02x%02x%02x "
                     "portid=%02x%02x%02x.\n",
-                    ha->host_no,
+                    vha->host_no,
                     fcport->node_name[0], fcport->node_name[1],
                     fcport->node_name[2], fcport->node_name[3],
                     fcport->node_name[4], fcport->node_name[5],
@@ -242,7 +245,7 @@ qla2x00_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport)
  * Returns 0 on success.
  */
 int
-qla2x00_gid_pt(scsi_qla_host_t *ha, sw_info_t *list)
+qla2x00_gid_pt(scsi_qla_host_t *vha, sw_info_t *list)
 {
         int             rval;
         uint16_t        i;
@@ -252,16 +255,16 @@ qla2x00_gid_pt(scsi_qla_host_t *ha, sw_info_t *list)
         struct ct_sns_rsp       *ct_rsp;
 
         struct ct_sns_gid_pt_data *gid_data;
+        struct qla_hw_data *ha = vha->hw;
 
-        if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
-                return (qla2x00_sns_gid_pt(ha, list));
-        }
+        if (IS_QLA2100(ha) || IS_QLA2200(ha))
+                return qla2x00_sns_gid_pt(vha, list);
 
         gid_data = NULL;
 
         /* Issue GID_PT */
         /* Prepare common MS IOCB */
-        ms_pkt = ha->isp_ops->prep_ms_iocb(ha, GID_PT_REQ_SIZE,
+        ms_pkt = ha->isp_ops->prep_ms_iocb(vha, GID_PT_REQ_SIZE,
             GID_PT_RSP_SIZE);
 
         /* Prepare CT request */
@@ -273,13 +276,13 @@ qla2x00_gid_pt(scsi_qla_host_t *ha, sw_info_t *list)
         ct_req->req.gid_pt.port_type = NS_NX_PORT_TYPE;
 
         /* Execute MS IOCB */
-        rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+        rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): GID_PT issue IOCB failed (%d).\n",
-                    ha->host_no, rval));
-        } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp, "GID_PT") !=
+                    vha->host_no, rval));
+        } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "GID_PT") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
@@ -320,7 +323,7 @@ qla2x00_gid_pt(scsi_qla_host_t *ha, sw_info_t *list)
  * Returns 0 on success.
  */
 int
-qla2x00_gpn_id(scsi_qla_host_t *ha, sw_info_t *list)
+qla2x00_gpn_id(scsi_qla_host_t *vha, sw_info_t *list)
 {
         int             rval;
         uint16_t        i;
@@ -328,15 +331,15 @@ qla2x00_gpn_id(scsi_qla_host_t *ha, sw_info_t *list)
         ms_iocb_entry_t *ms_pkt;
         struct ct_sns_req       *ct_req;
         struct ct_sns_rsp       *ct_rsp;
+        struct qla_hw_data *ha = vha->hw;
 
-        if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
-                return (qla2x00_sns_gpn_id(ha, list));
-        }
+        if (IS_QLA2100(ha) || IS_QLA2200(ha))
+                return qla2x00_sns_gpn_id(vha, list);
 
         for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
                 /* Issue GPN_ID */
                 /* Prepare common MS IOCB */
-                ms_pkt = ha->isp_ops->prep_ms_iocb(ha, GPN_ID_REQ_SIZE,
+                ms_pkt = ha->isp_ops->prep_ms_iocb(vha, GPN_ID_REQ_SIZE,
                     GPN_ID_RSP_SIZE);
 
                 /* Prepare CT request */
@@ -350,13 +353,13 @@ qla2x00_gpn_id(scsi_qla_host_t *ha, sw_info_t *list)
                 ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa;
 
                 /* Execute MS IOCB */
-                rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+                rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
                     sizeof(ms_iocb_entry_t));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
                         DEBUG2_3(printk("scsi(%ld): GPN_ID issue IOCB failed "
-                            "(%d).\n", ha->host_no, rval));
-                } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp,
+                            "(%d).\n", vha->host_no, rval));
+                } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
                     "GPN_ID") != QLA_SUCCESS) {
                         rval = QLA_FUNCTION_FAILED;
                 } else {
@@ -381,23 +384,22 @@ qla2x00_gpn_id(scsi_qla_host_t *ha, sw_info_t *list)
  * Returns 0 on success.
  */
 int
-qla2x00_gnn_id(scsi_qla_host_t *ha, sw_info_t *list)
+qla2x00_gnn_id(scsi_qla_host_t *vha, sw_info_t *list)
 {
         int             rval;
         uint16_t        i;
-
+        struct qla_hw_data *ha = vha->hw;
         ms_iocb_entry_t *ms_pkt;
         struct ct_sns_req       *ct_req;
         struct ct_sns_rsp       *ct_rsp;
 
-        if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
-                return (qla2x00_sns_gnn_id(ha, list));
-        }
+        if (IS_QLA2100(ha) || IS_QLA2200(ha))
+                return qla2x00_sns_gnn_id(vha, list);
 
         for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
                 /* Issue GNN_ID */
                 /* Prepare common MS IOCB */
-                ms_pkt = ha->isp_ops->prep_ms_iocb(ha, GNN_ID_REQ_SIZE,
+                ms_pkt = ha->isp_ops->prep_ms_iocb(vha, GNN_ID_REQ_SIZE,
                     GNN_ID_RSP_SIZE);
 
                 /* Prepare CT request */
@@ -411,13 +413,13 @@ qla2x00_gnn_id(scsi_qla_host_t *ha, sw_info_t *list)
                 ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa;
 
                 /* Execute MS IOCB */
-                rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+                rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
                     sizeof(ms_iocb_entry_t));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
                         DEBUG2_3(printk("scsi(%ld): GNN_ID issue IOCB failed "
-                            "(%d).\n", ha->host_no, rval));
-                } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp,
+                            "(%d).\n", vha->host_no, rval));
+                } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
                     "GNN_ID") != QLA_SUCCESS) {
                         rval = QLA_FUNCTION_FAILED;
                 } else {
@@ -429,7 +431,7 @@ qla2x00_gnn_id(scsi_qla_host_t *ha, sw_info_t *list)
                             "nn %02x%02x%02x%02x%02x%02x%02x%02x "
                             "pn %02x%02x%02x%02x%02x%02x%02x%02x "
                             "portid=%02x%02x%02x.\n",
-                            ha->host_no,
+                            vha->host_no,
                             list[i].node_name[0], list[i].node_name[1],
                             list[i].node_name[2], list[i].node_name[3],
                             list[i].node_name[4], list[i].node_name[5],
@@ -457,21 +459,20 @@ qla2x00_gnn_id(scsi_qla_host_t *ha, sw_info_t *list)
  * Returns 0 on success.
  */
 int
-qla2x00_rft_id(scsi_qla_host_t *ha)
+qla2x00_rft_id(scsi_qla_host_t *vha)
 {
         int             rval;
-
+        struct qla_hw_data *ha = vha->hw;
         ms_iocb_entry_t *ms_pkt;
         struct ct_sns_req       *ct_req;
         struct ct_sns_rsp       *ct_rsp;
 
-        if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
-                return (qla2x00_sns_rft_id(ha));
-        }
+        if (IS_QLA2100(ha) || IS_QLA2200(ha))
+                return qla2x00_sns_rft_id(vha);
 
         /* Issue RFT_ID */
         /* Prepare common MS IOCB */
-        ms_pkt = ha->isp_ops->prep_ms_iocb(ha, RFT_ID_REQ_SIZE,
+        ms_pkt = ha->isp_ops->prep_ms_iocb(vha, RFT_ID_REQ_SIZE,
             RFT_ID_RSP_SIZE);
 
         /* Prepare CT request */
@@ -480,25 +481,25 @@ qla2x00_rft_id(scsi_qla_host_t *ha)
         ct_rsp = &ha->ct_sns->p.rsp;
 
         /* Prepare CT arguments -- port_id, FC-4 types */
-        ct_req->req.rft_id.port_id[0] = ha->d_id.b.domain;
-        ct_req->req.rft_id.port_id[1] = ha->d_id.b.area;
-        ct_req->req.rft_id.port_id[2] = ha->d_id.b.al_pa;
+        ct_req->req.rft_id.port_id[0] = vha->d_id.b.domain;
+        ct_req->req.rft_id.port_id[1] = vha->d_id.b.area;
+        ct_req->req.rft_id.port_id[2] = vha->d_id.b.al_pa;
 
         ct_req->req.rft_id.fc4_types[2] = 0x01;         /* FCP-3 */
 
         /* Execute MS IOCB */
-        rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+        rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): RFT_ID issue IOCB failed (%d).\n",
-                    ha->host_no, rval));
-        } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp, "RFT_ID") !=
+                    vha->host_no, rval));
+        } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RFT_ID") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 DEBUG2(printk("scsi(%ld): RFT_ID exiting normally.\n",
-                    ha->host_no));
+                    vha->host_no));
         }
 
         return (rval);
@@ -511,23 +512,23 @@ qla2x00_rft_id(scsi_qla_host_t *ha)
  * Returns 0 on success.
  */
 int
-qla2x00_rff_id(scsi_qla_host_t *ha)
+qla2x00_rff_id(scsi_qla_host_t *vha)
 {
         int             rval;
-
+        struct qla_hw_data *ha = vha->hw;
         ms_iocb_entry_t *ms_pkt;
         struct ct_sns_req       *ct_req;
         struct ct_sns_rsp       *ct_rsp;
 
         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
                 DEBUG2(printk("scsi(%ld): RFF_ID call unsupported on "
-                    "ISP2100/ISP2200.\n", ha->host_no));
+                    "ISP2100/ISP2200.\n", vha->host_no));
                 return (QLA_SUCCESS);
         }
 
         /* Issue RFF_ID */
         /* Prepare common MS IOCB */
-        ms_pkt = ha->isp_ops->prep_ms_iocb(ha, RFF_ID_REQ_SIZE,
+        ms_pkt = ha->isp_ops->prep_ms_iocb(vha, RFF_ID_REQ_SIZE,
             RFF_ID_RSP_SIZE);
 
         /* Prepare CT request */
@@ -536,26 +537,26 @@ qla2x00_rff_id(scsi_qla_host_t *ha)
         ct_rsp = &ha->ct_sns->p.rsp;
 
         /* Prepare CT arguments -- port_id, FC-4 feature, FC-4 type */
-        ct_req->req.rff_id.port_id[0] = ha->d_id.b.domain;
-        ct_req->req.rff_id.port_id[1] = ha->d_id.b.area;
-        ct_req->req.rff_id.port_id[2] = ha->d_id.b.al_pa;
+        ct_req->req.rff_id.port_id[0] = vha->d_id.b.domain;
+        ct_req->req.rff_id.port_id[1] = vha->d_id.b.area;
+        ct_req->req.rff_id.port_id[2] = vha->d_id.b.al_pa;
 
         ct_req->req.rff_id.fc4_feature = BIT_1;
         ct_req->req.rff_id.fc4_type = 0x08;             /* SCSI - FCP */
 
         /* Execute MS IOCB */
-        rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+        rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): RFF_ID issue IOCB failed (%d).\n",
-                    ha->host_no, rval));
-        } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp, "RFF_ID") !=
+                    vha->host_no, rval));
+        } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RFF_ID") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 DEBUG2(printk("scsi(%ld): RFF_ID exiting normally.\n",
-                    ha->host_no));
+                    vha->host_no));
         }
 
         return (rval);
@@ -568,21 +569,20 @@ qla2x00_rff_id(scsi_qla_host_t *ha)
  * Returns 0 on success.
  */
 int
-qla2x00_rnn_id(scsi_qla_host_t *ha)
+qla2x00_rnn_id(scsi_qla_host_t *vha)
 {
         int             rval;
-
+        struct qla_hw_data *ha = vha->hw;
         ms_iocb_entry_t *ms_pkt;
         struct ct_sns_req       *ct_req;
         struct ct_sns_rsp       *ct_rsp;
 
-        if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
-                return (qla2x00_sns_rnn_id(ha));
-        }
+        if (IS_QLA2100(ha) || IS_QLA2200(ha))
+                return qla2x00_sns_rnn_id(vha);
 
         /* Issue RNN_ID */
         /* Prepare common MS IOCB */
-        ms_pkt = ha->isp_ops->prep_ms_iocb(ha, RNN_ID_REQ_SIZE,
+        ms_pkt = ha->isp_ops->prep_ms_iocb(vha, RNN_ID_REQ_SIZE,
             RNN_ID_RSP_SIZE);
 
         /* Prepare CT request */
@@ -591,33 +591,34 @@ qla2x00_rnn_id(scsi_qla_host_t *ha)
         ct_rsp = &ha->ct_sns->p.rsp;
 
         /* Prepare CT arguments -- port_id, node_name */
-        ct_req->req.rnn_id.port_id[0] = ha->d_id.b.domain;
-        ct_req->req.rnn_id.port_id[1] = ha->d_id.b.area;
-        ct_req->req.rnn_id.port_id[2] = ha->d_id.b.al_pa;
+        ct_req->req.rnn_id.port_id[0] = vha->d_id.b.domain;
+        ct_req->req.rnn_id.port_id[1] = vha->d_id.b.area;
+        ct_req->req.rnn_id.port_id[2] = vha->d_id.b.al_pa;
 
-        memcpy(ct_req->req.rnn_id.node_name, ha->node_name, WWN_SIZE);
+        memcpy(ct_req->req.rnn_id.node_name, vha->node_name, WWN_SIZE);
 
         /* Execute MS IOCB */
-        rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+        rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): RNN_ID issue IOCB failed (%d).\n",
-                    ha->host_no, rval));
-        } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp, "RNN_ID") !=
+                    vha->host_no, rval));
+        } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RNN_ID") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 DEBUG2(printk("scsi(%ld): RNN_ID exiting normally.\n",
-                    ha->host_no));
+                    vha->host_no));
         }
 
         return (rval);
 }
 
 void
-qla2x00_get_sym_node_name(scsi_qla_host_t *ha, uint8_t *snn)
+qla2x00_get_sym_node_name(scsi_qla_host_t *vha, uint8_t *snn)
 {
+        struct qla_hw_data *ha = vha->hw;
         sprintf(snn, "%s FW:v%d.%02d.%02d DVR:v%s",ha->model_number,
             ha->fw_major_version, ha->fw_minor_version,
             ha->fw_subminor_version, qla2x00_version_str);
@@ -630,23 +631,24 @@ qla2x00_get_sym_node_name(scsi_qla_host_t *ha, uint8_t *snn)
  * Returns 0 on success.
  */
 int
-qla2x00_rsnn_nn(scsi_qla_host_t *ha)
+qla2x00_rsnn_nn(scsi_qla_host_t *vha)
 {
         int             rval;
+        struct qla_hw_data *ha = vha->hw;
         ms_iocb_entry_t *ms_pkt;
         struct ct_sns_req       *ct_req;
         struct ct_sns_rsp       *ct_rsp;
 
         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
                 DEBUG2(printk("scsi(%ld): RSNN_ID call unsupported on "
-                    "ISP2100/ISP2200.\n", ha->host_no));
+                    "ISP2100/ISP2200.\n", vha->host_no));
                 return (QLA_SUCCESS);
         }
 
         /* Issue RSNN_NN */
         /* Prepare common MS IOCB */
         /*   Request size adjusted after CT preparation */
-        ms_pkt = ha->isp_ops->prep_ms_iocb(ha, 0, RSNN_NN_RSP_SIZE);
+        ms_pkt = ha->isp_ops->prep_ms_iocb(vha, 0, RSNN_NN_RSP_SIZE);
 
         /* Prepare CT request */
         ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, RSNN_NN_CMD,
@@ -654,10 +656,10 @@ qla2x00_rsnn_nn(scsi_qla_host_t *ha)
         ct_rsp = &ha->ct_sns->p.rsp;
 
         /* Prepare CT arguments -- node_name, symbolic node_name, size */
-        memcpy(ct_req->req.rsnn_nn.node_name, ha->node_name, WWN_SIZE);
+        memcpy(ct_req->req.rsnn_nn.node_name, vha->node_name, WWN_SIZE);
 
         /* Prepare the Symbolic Node Name */
-        qla2x00_get_sym_node_name(ha, ct_req->req.rsnn_nn.sym_node_name);
+        qla2x00_get_sym_node_name(vha, ct_req->req.rsnn_nn.sym_node_name);
 
         /* Calculate SNN length */
         ct_req->req.rsnn_nn.name_len =
@@ -669,18 +671,18 @@ qla2x00_rsnn_nn(scsi_qla_host_t *ha)
         ms_pkt->dseg_req_length = ms_pkt->req_bytecount;
 
         /* Execute MS IOCB */
-        rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+        rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): RSNN_NN issue IOCB failed (%d).\n",
-                    ha->host_no, rval));
-        } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp, "RSNN_NN") !=
+                    vha->host_no, rval));
+        } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RSNN_NN") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 DEBUG2(printk("scsi(%ld): RSNN_NN exiting normally.\n",
-                    ha->host_no));
+                    vha->host_no));
         }
 
         return (rval);
@@ -696,11 +698,12 @@ qla2x00_rsnn_nn(scsi_qla_host_t *ha)
  * Returns a pointer to the @ha's sns_cmd.
  */
 static inline struct sns_cmd_pkt *
-qla2x00_prep_sns_cmd(scsi_qla_host_t *ha, uint16_t cmd, uint16_t scmd_len,
+qla2x00_prep_sns_cmd(scsi_qla_host_t *vha, uint16_t cmd, uint16_t scmd_len,
     uint16_t data_size)
 {
         uint16_t                wc;
         struct sns_cmd_pkt      *sns_cmd;
+        struct qla_hw_data *ha = vha->hw;
 
         sns_cmd = ha->sns_cmd;
         memset(sns_cmd, 0, sizeof(struct sns_cmd_pkt));
@@ -726,15 +729,15 @@ qla2x00_prep_sns_cmd(scsi_qla_host_t *ha, uint16_t cmd, uint16_t scmd_len,
  * Returns 0 on success.
  */
 static int
-qla2x00_sns_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport)
+qla2x00_sns_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
 {
         int             rval;
-
+        struct qla_hw_data *ha = vha->hw;
         struct sns_cmd_pkt      *sns_cmd;
 
         /* Issue GA_NXT. */
         /* Prepare SNS command request. */
-        sns_cmd = qla2x00_prep_sns_cmd(ha, GA_NXT_CMD, GA_NXT_SNS_SCMD_LEN,
+        sns_cmd = qla2x00_prep_sns_cmd(vha, GA_NXT_CMD, GA_NXT_SNS_SCMD_LEN,
             GA_NXT_SNS_DATA_SIZE);
 
         /* Prepare SNS command arguments -- port_id. */
@@ -743,16 +746,16 @@ qla2x00_sns_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport)
         sns_cmd->p.cmd.param[2] = fcport->d_id.b.domain;
 
         /* Execute SNS command. */
-        rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, GA_NXT_SNS_CMD_SIZE / 2,
+        rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, GA_NXT_SNS_CMD_SIZE / 2,
             sizeof(struct sns_cmd_pkt));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): GA_NXT Send SNS failed (%d).\n",
-                    ha->host_no, rval));
+                    vha->host_no, rval));
         } else if (sns_cmd->p.gan_data[8] != 0x80 ||
             sns_cmd->p.gan_data[9] != 0x02) {
                 DEBUG2_3(printk("scsi(%ld): GA_NXT failed, rejected request, "
-                    "ga_nxt_rsp:\n", ha->host_no));
+                    "ga_nxt_rsp:\n", vha->host_no));
                 DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gan_data, 16));
                 rval = QLA_FUNCTION_FAILED;
         } else {
@@ -772,7 +775,7 @@ qla2x00_sns_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport)
                     "nn %02x%02x%02x%02x%02x%02x%02x%02x "
                     "pn %02x%02x%02x%02x%02x%02x%02x%02x "
                     "portid=%02x%02x%02x.\n",
-                    ha->host_no,
+                    vha->host_no,
                     fcport->node_name[0], fcport->node_name[1],
                     fcport->node_name[2], fcport->node_name[3],
                     fcport->node_name[4], fcport->node_name[5],
@@ -800,33 +803,33 @@ qla2x00_sns_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport)
  * Returns 0 on success.
  */
 static int
-qla2x00_sns_gid_pt(scsi_qla_host_t *ha, sw_info_t *list)
+qla2x00_sns_gid_pt(scsi_qla_host_t *vha, sw_info_t *list)
 {
         int             rval;
-
+        struct qla_hw_data *ha = vha->hw;
         uint16_t        i;
         uint8_t         *entry;
         struct sns_cmd_pkt      *sns_cmd;
 
         /* Issue GID_PT. */
         /* Prepare SNS command request. */
-        sns_cmd = qla2x00_prep_sns_cmd(ha, GID_PT_CMD, GID_PT_SNS_SCMD_LEN,
+        sns_cmd = qla2x00_prep_sns_cmd(vha, GID_PT_CMD, GID_PT_SNS_SCMD_LEN,
             GID_PT_SNS_DATA_SIZE);
 
         /* Prepare SNS command arguments -- port_type. */
         sns_cmd->p.cmd.param[0] = NS_NX_PORT_TYPE;
 
         /* Execute SNS command. */
-        rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, GID_PT_SNS_CMD_SIZE / 2,
+        rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, GID_PT_SNS_CMD_SIZE / 2,
             sizeof(struct sns_cmd_pkt));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): GID_PT Send SNS failed (%d).\n",
-                    ha->host_no, rval));
+                    vha->host_no, rval));
         } else if (sns_cmd->p.gid_data[8] != 0x80 ||
             sns_cmd->p.gid_data[9] != 0x02) {
                 DEBUG2_3(printk("scsi(%ld): GID_PT failed, rejected request, "
-                    "gid_rsp:\n", ha->host_no));
+                    "gid_rsp:\n", vha->host_no));
                 DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gid_data, 16));
                 rval = QLA_FUNCTION_FAILED;
         } else {
@@ -867,17 +870,17 @@ qla2x00_sns_gid_pt(scsi_qla_host_t *ha, sw_info_t *list)
  * Returns 0 on success.
  */
 static int
-qla2x00_sns_gpn_id(scsi_qla_host_t *ha, sw_info_t *list)
+qla2x00_sns_gpn_id(scsi_qla_host_t *vha, sw_info_t *list)
 {
         int             rval;
-
+        struct qla_hw_data *ha = vha->hw;
         uint16_t        i;
         struct sns_cmd_pkt      *sns_cmd;
 
         for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
                 /* Issue GPN_ID */
                 /* Prepare SNS command request. */
-                sns_cmd = qla2x00_prep_sns_cmd(ha, GPN_ID_CMD,
+                sns_cmd = qla2x00_prep_sns_cmd(vha, GPN_ID_CMD,
                     GPN_ID_SNS_SCMD_LEN, GPN_ID_SNS_DATA_SIZE);
 
                 /* Prepare SNS command arguments -- port_id. */
@@ -886,16 +889,16 @@ qla2x00_sns_gpn_id(scsi_qla_host_t *ha, sw_info_t *list)
                 sns_cmd->p.cmd.param[2] = list[i].d_id.b.domain;
 
                 /* Execute SNS command. */
-                rval = qla2x00_send_sns(ha, ha->sns_cmd_dma,
+                rval = qla2x00_send_sns(vha, ha->sns_cmd_dma,
                     GPN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
                         DEBUG2_3(printk("scsi(%ld): GPN_ID Send SNS failed "
-                            "(%d).\n", ha->host_no, rval));
+                            "(%d).\n", vha->host_no, rval));
                 } else if (sns_cmd->p.gpn_data[8] != 0x80 ||
                     sns_cmd->p.gpn_data[9] != 0x02) {
                         DEBUG2_3(printk("scsi(%ld): GPN_ID failed, rejected "
-                            "request, gpn_rsp:\n", ha->host_no));
+                            "request, gpn_rsp:\n", vha->host_no));
                         DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gpn_data, 16));
                         rval = QLA_FUNCTION_FAILED;
                 } else {
@@ -922,17 +925,17 @@ qla2x00_sns_gpn_id(scsi_qla_host_t *ha, sw_info_t *list)
  * Returns 0 on success.
  */
 static int
-qla2x00_sns_gnn_id(scsi_qla_host_t *ha, sw_info_t *list)
+qla2x00_sns_gnn_id(scsi_qla_host_t *vha, sw_info_t *list)
 {
         int             rval;
-
+        struct qla_hw_data *ha = vha->hw;
         uint16_t        i;
         struct sns_cmd_pkt      *sns_cmd;
 
         for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
                 /* Issue GNN_ID */
                 /* Prepare SNS command request. */
-                sns_cmd = qla2x00_prep_sns_cmd(ha, GNN_ID_CMD,
+                sns_cmd = qla2x00_prep_sns_cmd(vha, GNN_ID_CMD,
                     GNN_ID_SNS_SCMD_LEN, GNN_ID_SNS_DATA_SIZE);
 
                 /* Prepare SNS command arguments -- port_id. */
@@ -941,16 +944,16 @@ qla2x00_sns_gnn_id(scsi_qla_host_t *ha, sw_info_t *list)
                 sns_cmd->p.cmd.param[2] = list[i].d_id.b.domain;
 
                 /* Execute SNS command. */
-                rval = qla2x00_send_sns(ha, ha->sns_cmd_dma,
+                rval = qla2x00_send_sns(vha, ha->sns_cmd_dma,
                     GNN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
                         DEBUG2_3(printk("scsi(%ld): GNN_ID Send SNS failed "
-                            "(%d).\n", ha->host_no, rval));
+                            "(%d).\n", vha->host_no, rval));
                 } else if (sns_cmd->p.gnn_data[8] != 0x80 ||
                     sns_cmd->p.gnn_data[9] != 0x02) {
                         DEBUG2_3(printk("scsi(%ld): GNN_ID failed, rejected "
-                            "request, gnn_rsp:\n", ha->host_no));
+                            "request, gnn_rsp:\n", vha->host_no));
                         DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gnn_data, 16));
                         rval = QLA_FUNCTION_FAILED;
                 } else {
@@ -962,7 +965,7 @@ qla2x00_sns_gnn_id(scsi_qla_host_t *ha, sw_info_t *list)
                             "nn %02x%02x%02x%02x%02x%02x%02x%02x "
                             "pn %02x%02x%02x%02x%02x%02x%02x%02x "
                             "portid=%02x%02x%02x.\n",
-                            ha->host_no,
+                            vha->host_no,
                             list[i].node_name[0], list[i].node_name[1],
                             list[i].node_name[2], list[i].node_name[3],
                             list[i].node_name[4], list[i].node_name[5],
@@ -992,40 +995,40 @@ qla2x00_sns_gnn_id(scsi_qla_host_t *ha, sw_info_t *list)
  * Returns 0 on success.
  */
 static int
-qla2x00_sns_rft_id(scsi_qla_host_t *ha)
+qla2x00_sns_rft_id(scsi_qla_host_t *vha)
 {
         int             rval;
-
+        struct qla_hw_data *ha = vha->hw;
         struct sns_cmd_pkt      *sns_cmd;
 
         /* Issue RFT_ID. */
         /* Prepare SNS command request. */
-        sns_cmd = qla2x00_prep_sns_cmd(ha, RFT_ID_CMD, RFT_ID_SNS_SCMD_LEN,
+        sns_cmd = qla2x00_prep_sns_cmd(vha, RFT_ID_CMD, RFT_ID_SNS_SCMD_LEN,
             RFT_ID_SNS_DATA_SIZE);
 
         /* Prepare SNS command arguments -- port_id, FC-4 types */
-        sns_cmd->p.cmd.param[0] = ha->d_id.b.al_pa;
-        sns_cmd->p.cmd.param[1] = ha->d_id.b.area;
-        sns_cmd->p.cmd.param[2] = ha->d_id.b.domain;
+        sns_cmd->p.cmd.param[0] = vha->d_id.b.al_pa;
+        sns_cmd->p.cmd.param[1] = vha->d_id.b.area;
+        sns_cmd->p.cmd.param[2] = vha->d_id.b.domain;
 
         sns_cmd->p.cmd.param[5] = 0x01;                 /* FCP-3 */
 
         /* Execute SNS command. */
-        rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, RFT_ID_SNS_CMD_SIZE / 2,
+        rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, RFT_ID_SNS_CMD_SIZE / 2,
             sizeof(struct sns_cmd_pkt));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): RFT_ID Send SNS failed (%d).\n",
-                    ha->host_no, rval));
+                    vha->host_no, rval));
         } else if (sns_cmd->p.rft_data[8] != 0x80 ||
             sns_cmd->p.rft_data[9] != 0x02) {
                 DEBUG2_3(printk("scsi(%ld): RFT_ID failed, rejected request, "
-                    "rft_rsp:\n", ha->host_no));
+                    "rft_rsp:\n", vha->host_no));
                 DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.rft_data, 16));
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 DEBUG2(printk("scsi(%ld): RFT_ID exiting normally.\n",
-                    ha->host_no));
+                    vha->host_no));
         }
 
         return (rval);
@@ -1041,47 +1044,47 @@ qla2x00_sns_rft_id(scsi_qla_host_t *ha)
  * Returns 0 on success.
  */
 static int
-qla2x00_sns_rnn_id(scsi_qla_host_t *ha)
+qla2x00_sns_rnn_id(scsi_qla_host_t *vha)
 {
         int             rval;
-
+        struct qla_hw_data *ha = vha->hw;
         struct sns_cmd_pkt      *sns_cmd;
 
         /* Issue RNN_ID. */
         /* Prepare SNS command request. */
-        sns_cmd = qla2x00_prep_sns_cmd(ha, RNN_ID_CMD, RNN_ID_SNS_SCMD_LEN,
+        sns_cmd = qla2x00_prep_sns_cmd(vha, RNN_ID_CMD, RNN_ID_SNS_SCMD_LEN,
             RNN_ID_SNS_DATA_SIZE);
 
         /* Prepare SNS command arguments -- port_id, nodename. */
-        sns_cmd->p.cmd.param[0] = ha->d_id.b.al_pa;
-        sns_cmd->p.cmd.param[1] = ha->d_id.b.area;
-        sns_cmd->p.cmd.param[2] = ha->d_id.b.domain;
-
-        sns_cmd->p.cmd.param[4] = ha->node_name[7];
-        sns_cmd->p.cmd.param[5] = ha->node_name[6];
-        sns_cmd->p.cmd.param[6] = ha->node_name[5];
-        sns_cmd->p.cmd.param[7] = ha->node_name[4];
-        sns_cmd->p.cmd.param[8] = ha->node_name[3];
-        sns_cmd->p.cmd.param[9] = ha->node_name[2];
-        sns_cmd->p.cmd.param[10] = ha->node_name[1];
-        sns_cmd->p.cmd.param[11] = ha->node_name[0];
+        sns_cmd->p.cmd.param[0] = vha->d_id.b.al_pa;
+        sns_cmd->p.cmd.param[1] = vha->d_id.b.area;
+        sns_cmd->p.cmd.param[2] = vha->d_id.b.domain;
+
+        sns_cmd->p.cmd.param[4] = vha->node_name[7];
+        sns_cmd->p.cmd.param[5] = vha->node_name[6];
+        sns_cmd->p.cmd.param[6] = vha->node_name[5];
+        sns_cmd->p.cmd.param[7] = vha->node_name[4];
+        sns_cmd->p.cmd.param[8] = vha->node_name[3];
+        sns_cmd->p.cmd.param[9] = vha->node_name[2];
+        sns_cmd->p.cmd.param[10] = vha->node_name[1];
+        sns_cmd->p.cmd.param[11] = vha->node_name[0];
 
         /* Execute SNS command. */
-        rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, RNN_ID_SNS_CMD_SIZE / 2,
+        rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, RNN_ID_SNS_CMD_SIZE / 2,
             sizeof(struct sns_cmd_pkt));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): RNN_ID Send SNS failed (%d).\n",
-                    ha->host_no, rval));
+                    vha->host_no, rval));
         } else if (sns_cmd->p.rnn_data[8] != 0x80 ||
             sns_cmd->p.rnn_data[9] != 0x02) {
                 DEBUG2_3(printk("scsi(%ld): RNN_ID failed, rejected request, "
-                    "rnn_rsp:\n", ha->host_no));
+                    "rnn_rsp:\n", vha->host_no));
                 DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.rnn_data, 16));
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 DEBUG2(printk("scsi(%ld): RNN_ID exiting normally.\n",
-                    ha->host_no));
+                    vha->host_no));
         }
 
         return (rval);
@@ -1094,25 +1097,25 @@ qla2x00_sns_rnn_id(scsi_qla_host_t *ha)
  * Returns 0 on success.
  */
 static int
-qla2x00_mgmt_svr_login(scsi_qla_host_t *ha)
+qla2x00_mgmt_svr_login(scsi_qla_host_t *vha)
 {
         int ret;
         uint16_t mb[MAILBOX_REGISTER_COUNT];
-
+        struct qla_hw_data *ha = vha->hw;
         ret = QLA_SUCCESS;
-        if (ha->flags.management_server_logged_in)
+        if (vha->flags.management_server_logged_in)
                 return ret;
 
-        ha->isp_ops->fabric_login(ha, ha->mgmt_svr_loop_id, 0xff, 0xff, 0xfa,
+        ha->isp_ops->fabric_login(vha, vha->mgmt_svr_loop_id, 0xff, 0xff, 0xfa,
             mb, BIT_1);
         if (mb[0] != MBS_COMMAND_COMPLETE) {
                 DEBUG2_13(printk("%s(%ld): Failed MANAGEMENT_SERVER login: "
                     "loop_id=%x mb[0]=%x mb[1]=%x mb[2]=%x mb[6]=%x mb[7]=%x\n",
-                    __func__, ha->host_no, ha->mgmt_svr_loop_id, mb[0], mb[1],
+                    __func__, vha->host_no, vha->mgmt_svr_loop_id, mb[0], mb[1],
                     mb[2], mb[6], mb[7]));
                 ret = QLA_FUNCTION_FAILED;
         } else
-                ha->flags.management_server_logged_in = 1;
+                vha->flags.management_server_logged_in = 1;
 
         return ret;
 }
@@ -1126,17 +1129,17 @@ qla2x00_mgmt_svr_login(scsi_qla_host_t *ha)
  * Returns a pointer to the @ha's ms_iocb.
  */
 void *
-qla2x00_prep_ms_fdmi_iocb(scsi_qla_host_t *ha, uint32_t req_size,
+qla2x00_prep_ms_fdmi_iocb(scsi_qla_host_t *vha, uint32_t req_size,
     uint32_t rsp_size)
 {
         ms_iocb_entry_t *ms_pkt;
-
+        struct qla_hw_data *ha = vha->hw;
         ms_pkt = ha->ms_iocb;
         memset(ms_pkt, 0, sizeof(ms_iocb_entry_t));
 
         ms_pkt->entry_type = MS_IOCB_TYPE;
         ms_pkt->entry_count = 1;
-        SET_TARGET_ID(ha, ms_pkt->loop_id, ha->mgmt_svr_loop_id);
+        SET_TARGET_ID(ha, ms_pkt->loop_id, vha->mgmt_svr_loop_id);
         ms_pkt->control_flags = __constant_cpu_to_le16(CF_READ | CF_HEAD_TAG);
         ms_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
         ms_pkt->cmd_dsd_count = __constant_cpu_to_le16(1);
@@ -1164,17 +1167,18 @@ qla2x00_prep_ms_fdmi_iocb(scsi_qla_host_t *ha, uint32_t req_size,
  * Returns a pointer to the @ha's ms_iocb.
  */
 void *
-qla24xx_prep_ms_fdmi_iocb(scsi_qla_host_t *ha, uint32_t req_size,
+qla24xx_prep_ms_fdmi_iocb(scsi_qla_host_t *vha, uint32_t req_size,
     uint32_t rsp_size)
 {
         struct ct_entry_24xx *ct_pkt;
+        struct qla_hw_data *ha = vha->hw;
 
         ct_pkt = (struct ct_entry_24xx *)ha->ms_iocb;
         memset(ct_pkt, 0, sizeof(struct ct_entry_24xx));
 
         ct_pkt->entry_type = CT_IOCB_TYPE;
         ct_pkt->entry_count = 1;
-        ct_pkt->nport_handle = cpu_to_le16(ha->mgmt_svr_loop_id);
+        ct_pkt->nport_handle = cpu_to_le16(vha->mgmt_svr_loop_id);
         ct_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
         ct_pkt->cmd_dsd_count = __constant_cpu_to_le16(1);
         ct_pkt->rsp_dsd_count = __constant_cpu_to_le16(1);
@@ -1188,14 +1192,15 @@ qla24xx_prep_ms_fdmi_iocb(scsi_qla_host_t *ha, uint32_t req_size,
         ct_pkt->dseg_1_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma));
         ct_pkt->dseg_1_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma));
         ct_pkt->dseg_1_len = ct_pkt->rsp_byte_count;
-        ct_pkt->vp_index = ha->vp_idx;
+        ct_pkt->vp_index = vha->vp_idx;
 
         return ct_pkt;
 }
 
 static inline ms_iocb_entry_t *
-qla2x00_update_ms_fdmi_iocb(scsi_qla_host_t *ha, uint32_t req_size)
+qla2x00_update_ms_fdmi_iocb(scsi_qla_host_t *vha, uint32_t req_size)
 {
+        struct qla_hw_data *ha = vha->hw;
         ms_iocb_entry_t *ms_pkt = ha->ms_iocb;
         struct ct_entry_24xx *ct_pkt = (struct ct_entry_24xx *)ha->ms_iocb;
 
@@ -1240,7 +1245,7 @@ qla2x00_prep_ct_fdmi_req(struct ct_sns_req *ct_req, uint16_t cmd,
  * Returns 0 on success.
  */
 static int
-qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
+qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
 {
         int rval, alen;
         uint32_t size, sn;
@@ -1250,11 +1255,12 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
         struct ct_sns_rsp *ct_rsp;
         uint8_t *entries;
         struct ct_fdmi_hba_attr *eiter;
+        struct qla_hw_data *ha = vha->hw;
 
         /* Issue RHBA */
         /* Prepare common MS IOCB */
         /*   Request size adjusted after CT preparation */
-        ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(ha, 0, RHBA_RSP_SIZE);
+        ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RHBA_RSP_SIZE);
 
         /* Prepare CT request */
         ct_req = qla2x00_prep_ct_fdmi_req(&ha->ct_sns->p.req, RHBA_CMD,
@@ -1262,9 +1268,9 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
         ct_rsp = &ha->ct_sns->p.rsp;
 
         /* Prepare FDMI command arguments -- attribute block, attributes. */
-        memcpy(ct_req->req.rhba.hba_identifier, ha->port_name, WWN_SIZE);
+        memcpy(ct_req->req.rhba.hba_identifier, vha->port_name, WWN_SIZE);
         ct_req->req.rhba.entry_count = __constant_cpu_to_be32(1);
-        memcpy(ct_req->req.rhba.port_name, ha->port_name, WWN_SIZE);
+        memcpy(ct_req->req.rhba.port_name, vha->port_name, WWN_SIZE);
         size = 2 * WWN_SIZE + 4 + 4;
 
         /* Attributes */
@@ -1276,11 +1282,11 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
         eiter = (struct ct_fdmi_hba_attr *) (entries + size);
         eiter->type = __constant_cpu_to_be16(FDMI_HBA_NODE_NAME);
         eiter->len = __constant_cpu_to_be16(4 + WWN_SIZE);
-        memcpy(eiter->a.node_name, ha->node_name, WWN_SIZE);
+        memcpy(eiter->a.node_name, vha->node_name, WWN_SIZE);
         size += 4 + WWN_SIZE;
 
         DEBUG13(printk("%s(%ld): NODENAME=%02x%02x%02x%02x%02x%02x%02x%02x.\n",
-            __func__, ha->host_no,
+            __func__, vha->host_no,
             eiter->a.node_name[0], eiter->a.node_name[1], eiter->a.node_name[2],
             eiter->a.node_name[3], eiter->a.node_name[4], eiter->a.node_name[5],
             eiter->a.node_name[6], eiter->a.node_name[7]));
@@ -1294,7 +1300,7 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): MANUFACTURER=%s.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): MANUFACTURER=%s.\n", __func__, vha->host_no,
             eiter->a.manufacturer));
 
         /* Serial number. */
@@ -1307,7 +1313,7 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): SERIALNO=%s.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): SERIALNO=%s.\n", __func__, vha->host_no,
             eiter->a.serial_num));
 
         /* Model name. */
@@ -1319,7 +1325,7 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): MODEL_NAME=%s.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): MODEL_NAME=%s.\n", __func__, vha->host_no,
             eiter->a.model));
 
         /* Model description. */
@@ -1332,7 +1338,7 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): MODEL_DESC=%s.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): MODEL_DESC=%s.\n", __func__, vha->host_no,
             eiter->a.model_desc));
 
         /* Hardware version. */
@@ -1344,7 +1350,7 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): HARDWAREVER=%s.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): HARDWAREVER=%s.\n", __func__, vha->host_no,
             eiter->a.hw_version));
 
         /* Driver version. */
@@ -1356,7 +1362,7 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): DRIVERVER=%s.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): DRIVERVER=%s.\n", __func__, vha->host_no,
             eiter->a.driver_version));
 
         /* Option ROM version. */
@@ -1368,27 +1374,27 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): OPTROMVER=%s.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): OPTROMVER=%s.\n", __func__, vha->host_no,
             eiter->a.orom_version));
 
         /* Firmware version */
         eiter = (struct ct_fdmi_hba_attr *) (entries + size);
         eiter->type = __constant_cpu_to_be16(FDMI_HBA_FIRMWARE_VERSION);
-        ha->isp_ops->fw_version_str(ha, eiter->a.fw_version);
+        ha->isp_ops->fw_version_str(vha, eiter->a.fw_version);
         alen = strlen(eiter->a.fw_version);
         alen += (alen & 3) ? (4 - (alen & 3)) : 4;
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): FIRMWAREVER=%s.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): FIRMWAREVER=%s.\n", __func__, vha->host_no,
             eiter->a.fw_version));
 
         /* Update MS request size. */
-        qla2x00_update_ms_fdmi_iocb(ha, size + 16);
+        qla2x00_update_ms_fdmi_iocb(vha, size + 16);
 
         DEBUG13(printk("%s(%ld): RHBA identifier="
             "%02x%02x%02x%02x%02x%02x%02x%02x size=%d.\n", __func__,
-            ha->host_no, ct_req->req.rhba.hba_identifier[0],
+            vha->host_no, ct_req->req.rhba.hba_identifier[0],
             ct_req->req.rhba.hba_identifier[1],
             ct_req->req.rhba.hba_identifier[2],
             ct_req->req.rhba.hba_identifier[3],
@@ -1399,25 +1405,25 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
         DEBUG13(qla2x00_dump_buffer(entries, size));
 
         /* Execute MS IOCB */
-        rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+        rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): RHBA issue IOCB failed (%d).\n",
-                    ha->host_no, rval));
-        } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp, "RHBA") !=
+                    vha->host_no, rval));
+        } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RHBA") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
                 if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
                     ct_rsp->header.explanation_code ==
                     CT_EXPL_ALREADY_REGISTERED) {
                         DEBUG2_13(printk("%s(%ld): HBA already registered.\n",
-                            __func__, ha->host_no));
+                            __func__, vha->host_no));
                         rval = QLA_ALREADY_REGISTERED;
                 }
         } else {
                 DEBUG2(printk("scsi(%ld): RHBA exiting normally.\n",
-                    ha->host_no));
+                    vha->host_no));
         }
 
         return rval;
@@ -1430,17 +1436,17 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *ha)
  * Returns 0 on success.
  */
 static int
-qla2x00_fdmi_dhba(scsi_qla_host_t *ha)
+qla2x00_fdmi_dhba(scsi_qla_host_t *vha)
 {
         int rval;
-
+        struct qla_hw_data *ha = vha->hw;
         ms_iocb_entry_t *ms_pkt;
         struct ct_sns_req *ct_req;
         struct ct_sns_rsp *ct_rsp;
 
         /* Issue RPA */
         /* Prepare common MS IOCB */
-        ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(ha, DHBA_REQ_SIZE,
+        ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, DHBA_REQ_SIZE,
             DHBA_RSP_SIZE);
 
         /* Prepare CT request */
@@ -1449,28 +1455,28 @@ qla2x00_fdmi_dhba(scsi_qla_host_t *ha)
         ct_rsp = &ha->ct_sns->p.rsp;
 
         /* Prepare FDMI command arguments -- portname. */
-        memcpy(ct_req->req.dhba.port_name, ha->port_name, WWN_SIZE);
+        memcpy(ct_req->req.dhba.port_name, vha->port_name, WWN_SIZE);
 
         DEBUG13(printk("%s(%ld): DHBA portname="
-            "%02x%02x%02x%02x%02x%02x%02x%02x.\n", __func__, ha->host_no,
+            "%02x%02x%02x%02x%02x%02x%02x%02x.\n", __func__, vha->host_no,
             ct_req->req.dhba.port_name[0], ct_req->req.dhba.port_name[1],
             ct_req->req.dhba.port_name[2], ct_req->req.dhba.port_name[3],
             ct_req->req.dhba.port_name[4], ct_req->req.dhba.port_name[5],
             ct_req->req.dhba.port_name[6], ct_req->req.dhba.port_name[7]));
 
         /* Execute MS IOCB */
-        rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+        rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): DHBA issue IOCB failed (%d).\n",
-                    ha->host_no, rval));
-        } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp, "DHBA") !=
+                    vha->host_no, rval));
+        } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "DHBA") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 DEBUG2(printk("scsi(%ld): DHBA exiting normally.\n",
-                    ha->host_no));
+                    vha->host_no));
         }
 
         return rval;
@@ -1483,11 +1489,11 @@ qla2x00_fdmi_dhba(scsi_qla_host_t *ha)
  * Returns 0 on success.
  */
 static int
-qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
+qla2x00_fdmi_rpa(scsi_qla_host_t *vha)
 {
         int rval, alen;
         uint32_t size, max_frame_size;
-
+        struct qla_hw_data *ha = vha->hw;
         ms_iocb_entry_t *ms_pkt;
         struct ct_sns_req *ct_req;
         struct ct_sns_rsp *ct_rsp;
@@ -1498,7 +1504,7 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
         /* Issue RPA */
         /* Prepare common MS IOCB */
         /*   Request size adjusted after CT preparation */
-        ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(ha, 0, RPA_RSP_SIZE);
+        ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RPA_RSP_SIZE);
 
         /* Prepare CT request */
         ct_req = qla2x00_prep_ct_fdmi_req(&ha->ct_sns->p.req, RPA_CMD,
@@ -1506,7 +1512,7 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
         ct_rsp = &ha->ct_sns->p.rsp;
 
         /* Prepare FDMI command arguments -- attribute block, attributes. */
-        memcpy(ct_req->req.rpa.port_name, ha->port_name, WWN_SIZE);
+        memcpy(ct_req->req.rpa.port_name, vha->port_name, WWN_SIZE);
         size = WWN_SIZE + 4;
 
         /* Attributes */
@@ -1521,8 +1527,9 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
         eiter->a.fc4_types[2] = 0x01;
         size += 4 + 32;
 
-        DEBUG13(printk("%s(%ld): FC4_TYPES=%02x %02x.\n", __func__, ha->host_no,
-            eiter->a.fc4_types[2], eiter->a.fc4_types[1]));
+        DEBUG13(printk("%s(%ld): FC4_TYPES=%02x %02x.\n", __func__,
+                vha->host_no, eiter->a.fc4_types[2],
+                eiter->a.fc4_types[1]));
 
         /* Supported speed. */
         eiter = (struct ct_fdmi_port_attr *) (entries + size);
@@ -1544,7 +1551,7 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
                     FDMI_PORT_SPEED_1GB);
         size += 4 + 4;
 
-        DEBUG13(printk("%s(%ld): SUPPORTED_SPEED=%x.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): SUPPORTED_SPEED=%x.\n", __func__, vha->host_no,
             eiter->a.sup_speed));
 
         /* Current speed. */
@@ -1575,7 +1582,7 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
         }
         size += 4 + 4;
 
-        DEBUG13(printk("%s(%ld): CURRENT_SPEED=%x.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): CURRENT_SPEED=%x.\n", __func__, vha->host_no,
             eiter->a.cur_speed));
 
         /* Max frame size. */
@@ -1588,7 +1595,7 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
         eiter->a.max_frame_size = cpu_to_be32(max_frame_size);
         size += 4 + 4;
 
-        DEBUG13(printk("%s(%ld): MAX_FRAME_SIZE=%x.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): MAX_FRAME_SIZE=%x.\n", __func__, vha->host_no,
             eiter->a.max_frame_size));
 
         /* OS device name. */
@@ -1600,32 +1607,32 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): OS_DEVICE_NAME=%s.\n", __func__, ha->host_no,
+        DEBUG13(printk("%s(%ld): OS_DEVICE_NAME=%s.\n", __func__, vha->host_no,
             eiter->a.os_dev_name));
 
         /* Hostname. */
-        if (strlen(fc_host_system_hostname(ha->host))) {
+        if (strlen(fc_host_system_hostname(vha->host))) {
                 ct_req->req.rpa.attrs.count =
                     __constant_cpu_to_be32(FDMI_PORT_ATTR_COUNT);
                 eiter = (struct ct_fdmi_port_attr *) (entries + size);
                 eiter->type = __constant_cpu_to_be16(FDMI_PORT_HOST_NAME);
                 snprintf(eiter->a.host_name, sizeof(eiter->a.host_name),
-                    "%s", fc_host_system_hostname(ha->host));
+                    "%s", fc_host_system_hostname(vha->host));
                 alen = strlen(eiter->a.host_name);
                 alen += (alen & 3) ? (4 - (alen & 3)) : 4;
                 eiter->len = cpu_to_be16(4 + alen);
                 size += 4 + alen;
 
                 DEBUG13(printk("%s(%ld): HOSTNAME=%s.\n", __func__,
-                    ha->host_no, eiter->a.host_name));
+                    vha->host_no, eiter->a.host_name));
         }
 
         /* Update MS request size. */
-        qla2x00_update_ms_fdmi_iocb(ha, size + 16);
+        qla2x00_update_ms_fdmi_iocb(vha, size + 16);
 
         DEBUG13(printk("%s(%ld): RPA portname="
             "%02x%02x%02x%02x%02x%02x%02x%02x size=%d.\n", __func__,
-            ha->host_no, ct_req->req.rpa.port_name[0],
+            vha->host_no, ct_req->req.rpa.port_name[0],
             ct_req->req.rpa.port_name[1], ct_req->req.rpa.port_name[2],
             ct_req->req.rpa.port_name[3], ct_req->req.rpa.port_name[4],
             ct_req->req.rpa.port_name[5], ct_req->req.rpa.port_name[6],
@@ -1633,18 +1640,18 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
         DEBUG13(qla2x00_dump_buffer(entries, size));
 
         /* Execute MS IOCB */
-        rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+        rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
                 DEBUG2_3(printk("scsi(%ld): RPA issue IOCB failed (%d).\n",
-                    ha->host_no, rval));
-        } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp, "RPA") !=
+                    vha->host_no, rval));
+        } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RPA") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 DEBUG2(printk("scsi(%ld): RPA exiting normally.\n",
-                    ha->host_no));
+                    vha->host_no));
         }
 
         return rval;
@@ -1657,34 +1664,34 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
  * Returns 0 on success.
  */
 int
-qla2x00_fdmi_register(scsi_qla_host_t *ha)
+qla2x00_fdmi_register(scsi_qla_host_t *vha)
 {
         int rval;
 
-        if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
+        if (IS_QLA2100(vha->hw) || IS_QLA2200(vha->hw)) {
                 DEBUG2(printk("scsi(%ld): FDMI unsupported on "
-                    "ISP2100/ISP2200.\n", ha->host_no));
+                    "ISP2100/ISP2200.\n", vha->host_no));
                 return QLA_SUCCESS;
         }
 
-        rval = qla2x00_mgmt_svr_login(ha);
+        rval = qla2x00_mgmt_svr_login(vha);
         if (rval)
                 return rval;
 
-        rval = qla2x00_fdmi_rhba(ha);
+        rval = qla2x00_fdmi_rhba(vha);
         if (rval) {
                 if (rval != QLA_ALREADY_REGISTERED)
                         return rval;
 
-                rval = qla2x00_fdmi_dhba(ha);
+                rval = qla2x00_fdmi_dhba(vha);
                 if (rval)
                         return rval;
 
-                rval = qla2x00_fdmi_rhba(ha);
+                rval = qla2x00_fdmi_rhba(vha);
                 if (rval)
                         return rval;
         }
-        rval = qla2x00_fdmi_rpa(ha);
+        rval = qla2x00_fdmi_rpa(vha);
 
         return rval;
 }
@@ -1697,11 +1704,11 @@ qla2x00_fdmi_register(scsi_qla_host_t *ha)
  * Returns 0 on success.
  */
 int
-qla2x00_gfpn_id(scsi_qla_host_t *ha, sw_info_t *list)
+qla2x00_gfpn_id(scsi_qla_host_t *vha, sw_info_t *list)
 {
         int             rval;
         uint16_t        i;
-
+        struct qla_hw_data *ha = vha->hw;
         ms_iocb_entry_t *ms_pkt;
         struct ct_sns_req       *ct_req;
         struct ct_sns_rsp       *ct_rsp;
@@ -1712,7 +1719,7 @@ qla2x00_gfpn_id(scsi_qla_host_t *ha, sw_info_t *list)
         for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
                 /* Issue GFPN_ID */
                 /* Prepare common MS IOCB */
-                ms_pkt = ha->isp_ops->prep_ms_iocb(ha, GFPN_ID_REQ_SIZE,
+                ms_pkt = ha->isp_ops->prep_ms_iocb(vha, GFPN_ID_REQ_SIZE,
                     GFPN_ID_RSP_SIZE);
 
                 /* Prepare CT request */
@@ -1726,13 +1733,13 @@ qla2x00_gfpn_id(scsi_qla_host_t *ha, sw_info_t *list)
                 ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa;
 
                 /* Execute MS IOCB */
-                rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+                rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
                     sizeof(ms_iocb_entry_t));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
                         DEBUG2_3(printk("scsi(%ld): GFPN_ID issue IOCB "
-                            "failed (%d).\n", ha->host_no, rval));
-                } else if (qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp,
+                            "failed (%d).\n", vha->host_no, rval));
+                } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
                     "GFPN_ID") != QLA_SUCCESS) {
                         rval = QLA_FUNCTION_FAILED;
                 } else {
@@ -1750,17 +1757,17 @@ qla2x00_gfpn_id(scsi_qla_host_t *ha, sw_info_t *list)
 }
 
 static inline void *
-qla24xx_prep_ms_fm_iocb(scsi_qla_host_t *ha, uint32_t req_size,
+qla24xx_prep_ms_fm_iocb(scsi_qla_host_t *vha, uint32_t req_size,
     uint32_t rsp_size)
 {
         struct ct_entry_24xx *ct_pkt;
-
+        struct qla_hw_data *ha = vha->hw;
         ct_pkt = (struct ct_entry_24xx *)ha->ms_iocb;
         memset(ct_pkt, 0, sizeof(struct ct_entry_24xx));
 
         ct_pkt->entry_type = CT_IOCB_TYPE;
         ct_pkt->entry_count = 1;
-        ct_pkt->nport_handle = cpu_to_le16(ha->mgmt_svr_loop_id);
+        ct_pkt->nport_handle = cpu_to_le16(vha->mgmt_svr_loop_id);
         ct_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
         ct_pkt->cmd_dsd_count = __constant_cpu_to_le16(1);
         ct_pkt->rsp_dsd_count = __constant_cpu_to_le16(1);
@@ -1774,7 +1781,7 @@ qla24xx_prep_ms_fm_iocb(scsi_qla_host_t *ha, uint32_t req_size,
         ct_pkt->dseg_1_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma));
         ct_pkt->dseg_1_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma));
         ct_pkt->dseg_1_len = ct_pkt->rsp_byte_count;
-        ct_pkt->vp_index = ha->vp_idx;
+        ct_pkt->vp_index = vha->vp_idx;
 
         return ct_pkt;
 }
@@ -1803,11 +1810,11 @@ qla24xx_prep_ct_fm_req(struct ct_sns_req *ct_req, uint16_t cmd,
  * Returns 0 on success.
  */
 int
-qla2x00_gpsc(scsi_qla_host_t *ha, sw_info_t *list)
+qla2x00_gpsc(scsi_qla_host_t *vha, sw_info_t *list)
 {
         int             rval;
         uint16_t        i;
-
+        struct qla_hw_data *ha = vha->hw;
         ms_iocb_entry_t *ms_pkt;
         struct ct_sns_req       *ct_req;
         struct ct_sns_rsp       *ct_rsp;
@@ -1817,14 +1824,14 @@ qla2x00_gpsc(scsi_qla_host_t *ha, sw_info_t *list)
         if (!ha->flags.gpsc_supported)
                 return QLA_FUNCTION_FAILED;
 
-        rval = qla2x00_mgmt_svr_login(ha);
+        rval = qla2x00_mgmt_svr_login(vha);
         if (rval)
                 return rval;
 
         for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
                 /* Issue GFPN_ID */
                 /* Prepare common MS IOCB */
-                ms_pkt = qla24xx_prep_ms_fm_iocb(ha, GPSC_REQ_SIZE,
+                ms_pkt = qla24xx_prep_ms_fm_iocb(vha, GPSC_REQ_SIZE,
                     GPSC_RSP_SIZE);
 
                 /* Prepare CT request */
@@ -1837,13 +1844,13 @@ qla2x00_gpsc(scsi_qla_host_t *ha, sw_info_t *list)
                     WWN_SIZE);
 
                 /* Execute MS IOCB */
-                rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
+                rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
                     sizeof(ms_iocb_entry_t));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
                         DEBUG2_3(printk("scsi(%ld): GPSC issue IOCB "
-                            "failed (%d).\n", ha->host_no, rval));
-                } else if ((rval = qla2x00_chk_ms_status(ha, ms_pkt, ct_rsp,
+                            "failed (%d).\n", vha->host_no, rval));
+                } else if ((rval = qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
                     "GPSC")) != QLA_SUCCESS) {
                         /* FM command unsupported? */
                         if (rval == QLA_INVALID_COMMAND &&
@@ -1853,7 +1860,7 @@ qla2x00_gpsc(scsi_qla_host_t *ha, sw_info_t *list)
                                 CT_REASON_COMMAND_UNSUPPORTED)) {
                                 DEBUG2(printk("scsi(%ld): GPSC command "
                                     "unsupported, disabling query...\n",
-                                    ha->host_no));
+                                    vha->host_no));
                                 ha->flags.gpsc_supported = 0;
                                 rval = QLA_FUNCTION_FAILED;
                                 break;
@@ -1878,7 +1885,7 @@ qla2x00_gpsc(scsi_qla_host_t *ha, sw_info_t *list)
 
                         DEBUG2_3(printk("scsi(%ld): GPSC ext entry - "
                             "fpn %02x%02x%02x%02x%02x%02x%02x%02x speeds=%04x "
-                            "speed=%04x.\n", ha->host_no,
+                            "speed=%04x.\n", vha->host_no,
                             list[i].fabric_port_name[0],
                             list[i].fabric_port_name[1],
                             list[i].fabric_port_name[2],