ibmvfc: fix little endian issues

Added big endian annotations to relevant data structure fields, and necessary
byte swappings to support little endian builds.

Signed-off-by: Brian King <brking@linux.vnet.ibm.com>
Signed-off-by: Tyrel Datwyler <tyreld@linux.vnet.ibm.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>

diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index 6eb47b683569c1161551bf84444732126b8812ac..598c42cba5a86ab939f8a81ade1057dd8eb512f7 100644 (file)
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -166,13 +166,13 @@ static void ibmvfc_trc_start(struct ibmvfc_event *evt)
        switch (entry->fmt) {
        case IBMVFC_CMD_FORMAT:
                entry->op_code = vfc_cmd->iu.cdb[0];
-               entry->scsi_id = vfc_cmd->tgt_scsi_id;
+               entry->scsi_id = be64_to_cpu(vfc_cmd->tgt_scsi_id);
                entry->lun = scsilun_to_int(&vfc_cmd->iu.lun);
                entry->tmf_flags = vfc_cmd->iu.tmf_flags;
-               entry->u.start.xfer_len = vfc_cmd->iu.xfer_len;
+               entry->u.start.xfer_len = be32_to_cpu(vfc_cmd->iu.xfer_len);
                break;
        case IBMVFC_MAD_FORMAT:
-               entry->op_code = mad->opcode;
+               entry->op_code = be32_to_cpu(mad->opcode);
                break;
        default:
                break;
@@ -199,18 +199,18 @@ static void ibmvfc_trc_end(struct ibmvfc_event *evt)
        switch (entry->fmt) {
        case IBMVFC_CMD_FORMAT:
                entry->op_code = vfc_cmd->iu.cdb[0];
-               entry->scsi_id = vfc_cmd->tgt_scsi_id;
+               entry->scsi_id = be64_to_cpu(vfc_cmd->tgt_scsi_id);
                entry->lun = scsilun_to_int(&vfc_cmd->iu.lun);
                entry->tmf_flags = vfc_cmd->iu.tmf_flags;
-               entry->u.end.status = vfc_cmd->status;
-               entry->u.end.error = vfc_cmd->error;
+               entry->u.end.status = be16_to_cpu(vfc_cmd->status);
+               entry->u.end.error = be16_to_cpu(vfc_cmd->error);
                entry->u.end.fcp_rsp_flags = vfc_cmd->rsp.flags;
                entry->u.end.rsp_code = vfc_cmd->rsp.data.info.rsp_code;
                entry->u.end.scsi_status = vfc_cmd->rsp.scsi_status;
                break;
        case IBMVFC_MAD_FORMAT:
-               entry->op_code = mad->opcode;
-               entry->u.end.status = mad->status;
+               entry->op_code = be32_to_cpu(mad->opcode);
+               entry->u.end.status = be16_to_cpu(mad->status);
                break;
        default:
                break;
@@ -270,14 +270,14 @@ static int ibmvfc_get_err_result(struct ibmvfc_cmd *vfc_cmd)
 {
        int err;
        struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
-       int fc_rsp_len = rsp->fcp_rsp_len;
+       int fc_rsp_len = be32_to_cpu(rsp->fcp_rsp_len);
 
        if ((rsp->flags & FCP_RSP_LEN_VALID) &&
            ((fc_rsp_len && fc_rsp_len != 4 && fc_rsp_len != 8) ||
             rsp->data.info.rsp_code))
                return DID_ERROR << 16;
 
-       err = ibmvfc_get_err_index(vfc_cmd->status, vfc_cmd->error);
+       err = ibmvfc_get_err_index(be16_to_cpu(vfc_cmd->status), be16_to_cpu(vfc_cmd->error));
        if (err >= 0)
                return rsp->scsi_status | (cmd_status[err].result << 16);
        return rsp->scsi_status | (DID_ERROR << 16);
@@ -807,7 +807,7 @@ static void ibmvfc_fail_request(struct ibmvfc_event *evt, int error_code)
                evt->cmnd->result = (error_code << 16);
                evt->done = ibmvfc_scsi_eh_done;
        } else
-               evt->xfer_iu->mad_common.status = IBMVFC_MAD_DRIVER_FAILED;
+               evt->xfer_iu->mad_common.status = cpu_to_be16(IBMVFC_MAD_DRIVER_FAILED);
 
        list_del(&evt->queue);
        del_timer(&evt->timer);
@@ -955,7 +955,7 @@ static void ibmvfc_get_host_speed(struct Scsi_Host *shost)
 
        spin_lock_irqsave(shost->host_lock, flags);
        if (vhost->state == IBMVFC_ACTIVE) {
-               switch (vhost->login_buf->resp.link_speed / 100) {
+               switch (be64_to_cpu(vhost->login_buf->resp.link_speed) / 100) {
                case 1:
                        fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
                        break;
@@ -976,7 +976,7 @@ static void ibmvfc_get_host_speed(struct Scsi_Host *shost)
                        break;
                default:
                        ibmvfc_log(vhost, 3, "Unknown port speed: %lld Gbit\n",
-                                  vhost->login_buf->resp.link_speed / 100);
+                                  be64_to_cpu(vhost->login_buf->resp.link_speed) / 100);
                        fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
                        break;
                }
@@ -1171,21 +1171,21 @@ static void ibmvfc_set_login_info(struct ibmvfc_host *vhost)
 
        memset(login_info, 0, sizeof(*login_info));
 
-       login_info->ostype = IBMVFC_OS_LINUX;
-       login_info->max_dma_len = IBMVFC_MAX_SECTORS << 9;
-       login_info->max_payload = sizeof(struct ibmvfc_fcp_cmd_iu);
-       login_info->max_response = sizeof(struct ibmvfc_fcp_rsp);
-       login_info->partition_num = vhost->partition_number;
-       login_info->vfc_frame_version = 1;
-       login_info->fcp_version = 3;
-       login_info->flags = IBMVFC_FLUSH_ON_HALT;
+       login_info->ostype = cpu_to_be32(IBMVFC_OS_LINUX);
+       login_info->max_dma_len = cpu_to_be64(IBMVFC_MAX_SECTORS << 9);
+       login_info->max_payload = cpu_to_be32(sizeof(struct ibmvfc_fcp_cmd_iu));
+       login_info->max_response = cpu_to_be32(sizeof(struct ibmvfc_fcp_rsp));
+       login_info->partition_num = cpu_to_be32(vhost->partition_number);
+       login_info->vfc_frame_version = cpu_to_be32(1);
+       login_info->fcp_version = cpu_to_be16(3);
+       login_info->flags = cpu_to_be16(IBMVFC_FLUSH_ON_HALT);
        if (vhost->client_migrated)
-               login_info->flags |= IBMVFC_CLIENT_MIGRATED;
+               login_info->flags |= cpu_to_be16(IBMVFC_CLIENT_MIGRATED);
 
-       login_info->max_cmds = max_requests + IBMVFC_NUM_INTERNAL_REQ;
-       login_info->capabilities = IBMVFC_CAN_MIGRATE;
-       login_info->async.va = vhost->async_crq.msg_token;
-       login_info->async.len = vhost->async_crq.size * sizeof(*vhost->async_crq.msgs);
+       login_info->max_cmds = cpu_to_be32(max_requests + IBMVFC_NUM_INTERNAL_REQ);
+       login_info->capabilities = cpu_to_be64(IBMVFC_CAN_MIGRATE);
+       login_info->async.va = cpu_to_be64(vhost->async_crq.msg_token);
+       login_info->async.len = cpu_to_be32(vhost->async_crq.size * sizeof(*vhost->async_crq.msgs));
        strncpy(login_info->partition_name, vhost->partition_name, IBMVFC_MAX_NAME);
        strncpy(login_info->device_name,
                dev_name(&vhost->host->shost_gendev), IBMVFC_MAX_NAME);
@@ -1225,7 +1225,7 @@ static int ibmvfc_init_event_pool(struct ibmvfc_host *vhost)
                struct ibmvfc_event *evt = &pool->events[i];
                atomic_set(&evt->free, 1);
                evt->crq.valid = 0x80;
-               evt->crq.ioba = pool->iu_token + (sizeof(*evt->xfer_iu) * i);
+               evt->crq.ioba = cpu_to_be64(pool->iu_token + (sizeof(*evt->xfer_iu) * i));
                evt->xfer_iu = pool->iu_storage + i;
                evt->vhost = vhost;
                evt->ext_list = NULL;
@@ -1310,8 +1310,8 @@ static void ibmvfc_map_sg_list(struct scsi_cmnd *scmd, int nseg,
        struct scatterlist *sg;
 
        scsi_for_each_sg(scmd, sg, nseg, i) {
-               md[i].va = sg_dma_address(sg);
-               md[i].len = sg_dma_len(sg);
+               md[i].va = cpu_to_be64(sg_dma_address(sg));
+               md[i].len = cpu_to_be32(sg_dma_len(sg));
                md[i].key = 0;
        }
 }
@@ -1337,7 +1337,7 @@ static int ibmvfc_map_sg_data(struct scsi_cmnd *scmd,
 
        sg_mapped = scsi_dma_map(scmd);
        if (!sg_mapped) {
-               vfc_cmd->flags |= IBMVFC_NO_MEM_DESC;
+               vfc_cmd->flags |= cpu_to_be16(IBMVFC_NO_MEM_DESC);
                return 0;
        } else if (unlikely(sg_mapped < 0)) {
                if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
@@ -1346,10 +1346,10 @@ static int ibmvfc_map_sg_data(struct scsi_cmnd *scmd,
        }
 
        if (scmd->sc_data_direction == DMA_TO_DEVICE) {
-               vfc_cmd->flags |= IBMVFC_WRITE;
+               vfc_cmd->flags |= cpu_to_be16(IBMVFC_WRITE);
                vfc_cmd->iu.add_cdb_len |= IBMVFC_WRDATA;
        } else {
-               vfc_cmd->flags |= IBMVFC_READ;
+               vfc_cmd->flags |= cpu_to_be16(IBMVFC_READ);
                vfc_cmd->iu.add_cdb_len |= IBMVFC_RDDATA;
        }
 
@@ -1358,7 +1358,7 @@ static int ibmvfc_map_sg_data(struct scsi_cmnd *scmd,
                return 0;
        }
 
-       vfc_cmd->flags |= IBMVFC_SCATTERLIST;
+       vfc_cmd->flags |= cpu_to_be16(IBMVFC_SCATTERLIST);
 
        if (!evt->ext_list) {
                evt->ext_list = dma_pool_alloc(vhost->sg_pool, GFP_ATOMIC,
@@ -1374,8 +1374,8 @@ static int ibmvfc_map_sg_data(struct scsi_cmnd *scmd,
 
        ibmvfc_map_sg_list(scmd, sg_mapped, evt->ext_list);
 
-       data->va = evt->ext_list_token;
-       data->len = sg_mapped * sizeof(struct srp_direct_buf);
+       data->va = cpu_to_be64(evt->ext_list_token);
+       data->len = cpu_to_be32(sg_mapped * sizeof(struct srp_direct_buf));
        data->key = 0;
        return 0;
 }
@@ -1404,15 +1404,15 @@ static void ibmvfc_timeout(struct ibmvfc_event *evt)
 static int ibmvfc_send_event(struct ibmvfc_event *evt,
                             struct ibmvfc_host *vhost, unsigned long timeout)
 {
-       u64 *crq_as_u64 = (u64 *) &evt->crq;
+       __be64 *crq_as_u64 = (__be64 *) &evt->crq;
        int rc;
 
        /* Copy the IU into the transfer area */
        *evt->xfer_iu = evt->iu;
        if (evt->crq.format == IBMVFC_CMD_FORMAT)
-               evt->xfer_iu->cmd.tag = (u64)evt;
+               evt->xfer_iu->cmd.tag = cpu_to_be64((u64)evt);
        else if (evt->crq.format == IBMVFC_MAD_FORMAT)
-               evt->xfer_iu->mad_common.tag = (u64)evt;
+               evt->xfer_iu->mad_common.tag = cpu_to_be64((u64)evt);
        else
                BUG();
 
@@ -1428,7 +1428,8 @@ static int ibmvfc_send_event(struct ibmvfc_event *evt,
 
        mb();
 
-       if ((rc = ibmvfc_send_crq(vhost, crq_as_u64[0], crq_as_u64[1]))) {
+       if ((rc = ibmvfc_send_crq(vhost, be64_to_cpu(crq_as_u64[0]),
+                                 be64_to_cpu(crq_as_u64[1])))) {
                list_del(&evt->queue);
                del_timer(&evt->timer);
 
@@ -1451,7 +1452,7 @@ static int ibmvfc_send_event(struct ibmvfc_event *evt,
                        evt->cmnd->result = DID_ERROR << 16;
                        evt->done = ibmvfc_scsi_eh_done;
                } else
-                       evt->xfer_iu->mad_common.status = IBMVFC_MAD_CRQ_ERROR;
+                       evt->xfer_iu->mad_common.status = cpu_to_be16(IBMVFC_MAD_CRQ_ERROR);
 
                evt->done(evt);
        } else
@@ -1472,7 +1473,7 @@ static void ibmvfc_log_error(struct ibmvfc_event *evt)
        struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
        struct scsi_cmnd *cmnd = evt->cmnd;
        const char *err = unknown_error;
-       int index = ibmvfc_get_err_index(vfc_cmd->status, vfc_cmd->error);
+       int index = ibmvfc_get_err_index(be16_to_cpu(vfc_cmd->status), be16_to_cpu(vfc_cmd->error));
        int logerr = 0;
        int rsp_code = 0;
 
@@ -1526,13 +1527,13 @@ static void ibmvfc_scsi_done(struct ibmvfc_event *evt)
        struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
        struct scsi_cmnd *cmnd = evt->cmnd;
        u32 rsp_len = 0;
-       u32 sense_len = rsp->fcp_sense_len;
+       u32 sense_len = be32_to_cpu(rsp->fcp_sense_len);
 
        if (cmnd) {
-               if (vfc_cmd->response_flags & IBMVFC_ADAPTER_RESID_VALID)
-                       scsi_set_resid(cmnd, vfc_cmd->adapter_resid);
+               if (be16_to_cpu(vfc_cmd->response_flags) & IBMVFC_ADAPTER_RESID_VALID)
+                       scsi_set_resid(cmnd, be32_to_cpu(vfc_cmd->adapter_resid));
                else if (rsp->flags & FCP_RESID_UNDER)
-                       scsi_set_resid(cmnd, rsp->fcp_resid);
+                       scsi_set_resid(cmnd, be32_to_cpu(rsp->fcp_resid));
                else
                        scsi_set_resid(cmnd, 0);
 
@@ -1540,12 +1541,13 @@ static void ibmvfc_scsi_done(struct ibmvfc_event *evt)
                        cmnd->result = ibmvfc_get_err_result(vfc_cmd);
 
                        if (rsp->flags & FCP_RSP_LEN_VALID)
-                               rsp_len = rsp->fcp_rsp_len;
+                               rsp_len = be32_to_cpu(rsp->fcp_rsp_len);
                        if ((sense_len + rsp_len) > SCSI_SENSE_BUFFERSIZE)
                                sense_len = SCSI_SENSE_BUFFERSIZE - rsp_len;
                        if ((rsp->flags & FCP_SNS_LEN_VALID) && rsp->fcp_sense_len && rsp_len <= 8)
                                memcpy(cmnd->sense_buffer, rsp->data.sense + rsp_len, sense_len);
-                       if ((vfc_cmd->status & IBMVFC_VIOS_FAILURE) && (vfc_cmd->error == IBMVFC_PLOGI_REQUIRED))
+                       if ((be16_to_cpu(vfc_cmd->status) & IBMVFC_VIOS_FAILURE) &&
+                           (be16_to_cpu(vfc_cmd->error) == IBMVFC_PLOGI_REQUIRED))
                                ibmvfc_relogin(cmnd->device);
 
                        if (!cmnd->result && (!scsi_get_resid(cmnd) || (rsp->flags & FCP_RESID_OVER)))
@@ -1630,19 +1632,19 @@ static int ibmvfc_queuecommand_lck(struct scsi_cmnd *cmnd,
        cmnd->scsi_done = done;
        vfc_cmd = &evt->iu.cmd;
        memset(vfc_cmd, 0, sizeof(*vfc_cmd));
-       vfc_cmd->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
-       vfc_cmd->resp.len = sizeof(vfc_cmd->rsp);
-       vfc_cmd->frame_type = IBMVFC_SCSI_FCP_TYPE;
-       vfc_cmd->payload_len = sizeof(vfc_cmd->iu);
-       vfc_cmd->resp_len = sizeof(vfc_cmd->rsp);
-       vfc_cmd->cancel_key = (unsigned long)cmnd->device->hostdata;
-       vfc_cmd->tgt_scsi_id = rport->port_id;
-       vfc_cmd->iu.xfer_len = scsi_bufflen(cmnd);
+       vfc_cmd->resp.va = cpu_to_be64(be64_to_cpu(evt->crq.ioba) + offsetof(struct ibmvfc_cmd, rsp));
+       vfc_cmd->resp.len = cpu_to_be32(sizeof(vfc_cmd->rsp));
+       vfc_cmd->frame_type = cpu_to_be32(IBMVFC_SCSI_FCP_TYPE);
+       vfc_cmd->payload_len = cpu_to_be32(sizeof(vfc_cmd->iu));
+       vfc_cmd->resp_len = cpu_to_be32(sizeof(vfc_cmd->rsp));
+       vfc_cmd->cancel_key = cpu_to_be32((unsigned long)cmnd->device->hostdata);
+       vfc_cmd->tgt_scsi_id = cpu_to_be64(rport->port_id);
+       vfc_cmd->iu.xfer_len = cpu_to_be32(scsi_bufflen(cmnd));
        int_to_scsilun(cmnd->device->lun, &vfc_cmd->iu.lun);
        memcpy(vfc_cmd->iu.cdb, cmnd->cmnd, cmnd->cmd_len);
 
        if (scsi_populate_tag_msg(cmnd, tag)) {
-               vfc_cmd->task_tag = tag[1];
+               vfc_cmd->task_tag = cpu_to_be64(tag[1]);
                switch (tag[0]) {
                case MSG_SIMPLE_TAG:
                        vfc_cmd->iu.pri_task_attr = IBMVFC_SIMPLE_TASK;
@@ -1732,12 +1734,12 @@ static int ibmvfc_bsg_timeout(struct fc_bsg_job *job)
 
        tmf = &evt->iu.tmf;
        memset(tmf, 0, sizeof(*tmf));
-       tmf->common.version = 1;
-       tmf->common.opcode = IBMVFC_TMF_MAD;
-       tmf->common.length = sizeof(*tmf);
-       tmf->scsi_id = port_id;
-       tmf->cancel_key = IBMVFC_PASSTHRU_CANCEL_KEY;
-       tmf->my_cancel_key = IBMVFC_INTERNAL_CANCEL_KEY;
+       tmf->common.version = cpu_to_be32(1);
+       tmf->common.opcode = cpu_to_be32(IBMVFC_TMF_MAD);
+       tmf->common.length = cpu_to_be16(sizeof(*tmf));
+       tmf->scsi_id = cpu_to_be64(port_id);
+       tmf->cancel_key = cpu_to_be32(IBMVFC_PASSTHRU_CANCEL_KEY);
+       tmf->my_cancel_key = cpu_to_be32(IBMVFC_INTERNAL_CANCEL_KEY);
        rc = ibmvfc_send_event(evt, vhost, default_timeout);
 
        if (rc != 0) {
@@ -1789,10 +1791,10 @@ static int ibmvfc_bsg_plogi(struct ibmvfc_host *vhost, unsigned int port_id)
        ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
        plogi = &evt->iu.plogi;
        memset(plogi, 0, sizeof(*plogi));
-       plogi->common.version = 1;
-       plogi->common.opcode = IBMVFC_PORT_LOGIN;
-       plogi->common.length = sizeof(*plogi);
-       plogi->scsi_id = port_id;
+       plogi->common.version = cpu_to_be32(1);
+       plogi->common.opcode = cpu_to_be32(IBMVFC_PORT_LOGIN);
+       plogi->common.length = cpu_to_be16(sizeof(*plogi));
+       plogi->scsi_id = cpu_to_be64(port_id);
        evt->sync_iu = &rsp_iu;
        init_completion(&evt->comp);
 
@@ -1904,26 +1906,26 @@ static int ibmvfc_bsg_request(struct fc_bsg_job *job)
        mad = &evt->iu.passthru;
 
        memset(mad, 0, sizeof(*mad));
-       mad->common.version = 1;
-       mad->common.opcode = IBMVFC_PASSTHRU;
-       mad->common.length = sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu);
-
-       mad->cmd_ioba.va = (u64)evt->crq.ioba +
-               offsetof(struct ibmvfc_passthru_mad, iu);
-       mad->cmd_ioba.len = sizeof(mad->iu);
-
-       mad->iu.cmd_len = job->request_payload.payload_len;
-       mad->iu.rsp_len = job->reply_payload.payload_len;
-       mad->iu.flags = fc_flags;
-       mad->iu.cancel_key = IBMVFC_PASSTHRU_CANCEL_KEY;
-
-       mad->iu.cmd.va = sg_dma_address(job->request_payload.sg_list);
-       mad->iu.cmd.len = sg_dma_len(job->request_payload.sg_list);
-       mad->iu.rsp.va = sg_dma_address(job->reply_payload.sg_list);
-       mad->iu.rsp.len = sg_dma_len(job->reply_payload.sg_list);
-       mad->iu.scsi_id = port_id;
-       mad->iu.tag = (u64)evt;
-       rsp_len = mad->iu.rsp.len;
+       mad->common.version = cpu_to_be32(1);
+       mad->common.opcode = cpu_to_be32(IBMVFC_PASSTHRU);
+       mad->common.length = cpu_to_be16(sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu));
+
+       mad->cmd_ioba.va = cpu_to_be64(be64_to_cpu(evt->crq.ioba) +
+               offsetof(struct ibmvfc_passthru_mad, iu));
+       mad->cmd_ioba.len = cpu_to_be32(sizeof(mad->iu));
+
+       mad->iu.cmd_len = cpu_to_be32(job->request_payload.payload_len);
+       mad->iu.rsp_len = cpu_to_be32(job->reply_payload.payload_len);
+       mad->iu.flags = cpu_to_be32(fc_flags);
+       mad->iu.cancel_key = cpu_to_be32(IBMVFC_PASSTHRU_CANCEL_KEY);
+
+       mad->iu.cmd.va = cpu_to_be64(sg_dma_address(job->request_payload.sg_list));
+       mad->iu.cmd.len = cpu_to_be32(sg_dma_len(job->request_payload.sg_list));
+       mad->iu.rsp.va = cpu_to_be64(sg_dma_address(job->reply_payload.sg_list));
+       mad->iu.rsp.len = cpu_to_be32(sg_dma_len(job->reply_payload.sg_list));
+       mad->iu.scsi_id = cpu_to_be64(port_id);
+       mad->iu.tag = cpu_to_be64((u64)evt);
+       rsp_len = be32_to_cpu(mad->iu.rsp.len);
 
        evt->sync_iu = &rsp_iu;
        init_completion(&evt->comp);
@@ -1986,15 +1988,15 @@ static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
 
                tmf = &evt->iu.cmd;
                memset(tmf, 0, sizeof(*tmf));
-               tmf->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
-               tmf->resp.len = sizeof(tmf->rsp);
-               tmf->frame_type = IBMVFC_SCSI_FCP_TYPE;
-               tmf->payload_len = sizeof(tmf->iu);
-               tmf->resp_len = sizeof(tmf->rsp);
-               tmf->cancel_key = (unsigned long)sdev->hostdata;
-               tmf->tgt_scsi_id = rport->port_id;
+               tmf->resp.va = cpu_to_be64(be64_to_cpu(evt->crq.ioba) + offsetof(struct ibmvfc_cmd, rsp));
+               tmf->resp.len = cpu_to_be32(sizeof(tmf->rsp));
+               tmf->frame_type = cpu_to_be32(IBMVFC_SCSI_FCP_TYPE);
+               tmf->payload_len = cpu_to_be32(sizeof(tmf->iu));
+               tmf->resp_len = cpu_to_be32(sizeof(tmf->rsp));
+               tmf->cancel_key = cpu_to_be32((unsigned long)sdev->hostdata);
+               tmf->tgt_scsi_id = cpu_to_be64(rport->port_id);
                int_to_scsilun(sdev->lun, &tmf->iu.lun);
-               tmf->flags = (IBMVFC_NO_MEM_DESC | IBMVFC_TMF);
+               tmf->flags = cpu_to_be16((IBMVFC_NO_MEM_DESC | IBMVFC_TMF));
                tmf->iu.tmf_flags = type;
                evt->sync_iu = &rsp_iu;
 
@@ -2020,8 +2022,8 @@ static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
                        rsp_code = fc_rsp->data.info.rsp_code;
 
                sdev_printk(KERN_ERR, sdev, "%s reset failed: %s (%x:%x) "
-                           "flags: %x fcp_rsp: %x, scsi_status: %x\n",
-                           desc, ibmvfc_get_cmd_error(rsp_iu.cmd.status, rsp_iu.cmd.error),
+                           "flags: %x fcp_rsp: %x, scsi_status: %x\n", desc,
+                           ibmvfc_get_cmd_error(be16_to_cpu(rsp_iu.cmd.status), be16_to_cpu(rsp_iu.cmd.error)),
                            rsp_iu.cmd.status, rsp_iu.cmd.error, fc_rsp->flags, rsp_code,
                            fc_rsp->scsi_status);
                rsp_rc = -EIO;
@@ -2185,19 +2187,19 @@ static int ibmvfc_cancel_all(struct scsi_device *sdev, int type)
 
                tmf = &evt->iu.tmf;
                memset(tmf, 0, sizeof(*tmf));
-               tmf->common.version = 1;
-               tmf->common.opcode = IBMVFC_TMF_MAD;
-               tmf->common.length = sizeof(*tmf);
-               tmf->scsi_id = rport->port_id;
+               tmf->common.version = cpu_to_be32(1);
+               tmf->common.opcode = cpu_to_be32(IBMVFC_TMF_MAD);
+               tmf->common.length = cpu_to_be16(sizeof(*tmf));
+               tmf->scsi_id = cpu_to_be64(rport->port_id);
                int_to_scsilun(sdev->lun, &tmf->lun);
-               if (!(vhost->login_buf->resp.capabilities & IBMVFC_CAN_SUPPRESS_ABTS))
+               if (!(be64_to_cpu(vhost->login_buf->resp.capabilities) & IBMVFC_CAN_SUPPRESS_ABTS))
                        type &= ~IBMVFC_TMF_SUPPRESS_ABTS;
                if (vhost->state == IBMVFC_ACTIVE)
-                       tmf->flags = (type | IBMVFC_TMF_LUA_VALID);
+                       tmf->flags = cpu_to_be32((type | IBMVFC_TMF_LUA_VALID));
                else
-                       tmf->flags = ((type & IBMVFC_TMF_SUPPRESS_ABTS) | IBMVFC_TMF_LUA_VALID);
-               tmf->cancel_key = (unsigned long)sdev->hostdata;
-               tmf->my_cancel_key = (unsigned long)starget->hostdata;
+                       tmf->flags = cpu_to_be32(((type & IBMVFC_TMF_SUPPRESS_ABTS) | IBMVFC_TMF_LUA_VALID));
+               tmf->cancel_key = cpu_to_be32((unsigned long)sdev->hostdata);
+               tmf->my_cancel_key = cpu_to_be32((unsigned long)starget->hostdata);
 
                evt->sync_iu = &rsp;
                init_completion(&evt->comp);
@@ -2217,7 +2219,7 @@ static int ibmvfc_cancel_all(struct scsi_device *sdev, int type)
        sdev_printk(KERN_INFO, sdev, "Cancelling outstanding commands.\n");
 
        wait_for_completion(&evt->comp);
-       status = rsp.mad_common.status;
+       status = be16_to_cpu(rsp.mad_common.status);
        spin_lock_irqsave(vhost->host->host_lock, flags);
        ibmvfc_free_event(evt);
        spin_unlock_irqrestore(vhost->host->host_lock, flags);
@@ -2252,7 +2254,7 @@ static int ibmvfc_match_key(struct ibmvfc_event *evt, void *key)
        unsigned long cancel_key = (unsigned long)key;
 
        if (evt->crq.format == IBMVFC_CMD_FORMAT &&
-           evt->iu.cmd.cancel_key == cancel_key)
+           be32_to_cpu(evt->iu.cmd.cancel_key) == cancel_key)
                return 1;
        return 0;
 }
@@ -2316,15 +2318,15 @@ static int ibmvfc_abort_task_set(struct scsi_device *sdev)
 
                tmf = &evt->iu.cmd;
                memset(tmf, 0, sizeof(*tmf));
-               tmf->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
-               tmf->resp.len = sizeof(tmf->rsp);
-               tmf->frame_type = IBMVFC_SCSI_FCP_TYPE;
-               tmf->payload_len = sizeof(tmf->iu);
-               tmf->resp_len = sizeof(tmf->rsp);
-               tmf->cancel_key = (unsigned long)sdev->hostdata;
-               tmf->tgt_scsi_id = rport->port_id;
+               tmf->resp.va = cpu_to_be64(be64_to_cpu(evt->crq.ioba) + offsetof(struct ibmvfc_cmd, rsp));
+               tmf->resp.len = cpu_to_be32(sizeof(tmf->rsp));
+               tmf->frame_type = cpu_to_be32(IBMVFC_SCSI_FCP_TYPE);
+               tmf->payload_len = cpu_to_be32(sizeof(tmf->iu));
+               tmf->resp_len = cpu_to_be32(sizeof(tmf->rsp));
+               tmf->cancel_key = cpu_to_be32((unsigned long)sdev->hostdata);
+               tmf->tgt_scsi_id = cpu_to_be64(rport->port_id);
                int_to_scsilun(sdev->lun, &tmf->iu.lun);
-               tmf->flags = (IBMVFC_NO_MEM_DESC | IBMVFC_TMF);
+               tmf->flags = cpu_to_be16((IBMVFC_NO_MEM_DESC | IBMVFC_TMF));
                tmf->iu.tmf_flags = IBMVFC_ABORT_TASK_SET;
                evt->sync_iu = &rsp_iu;
 
@@ -2380,7 +2382,7 @@ static int ibmvfc_abort_task_set(struct scsi_device *sdev)
 
                sdev_printk(KERN_ERR, sdev, "Abort failed: %s (%x:%x) "
                            "flags: %x fcp_rsp: %x, scsi_status: %x\n",
-                           ibmvfc_get_cmd_error(rsp_iu.cmd.status, rsp_iu.cmd.error),
+                           ibmvfc_get_cmd_error(be16_to_cpu(rsp_iu.cmd.status), be16_to_cpu(rsp_iu.cmd.error)),
                            rsp_iu.cmd.status, rsp_iu.cmd.error, fc_rsp->flags, rsp_code,
                            fc_rsp->scsi_status);
                rsp_rc = -EIO;
@@ -2641,14 +2643,14 @@ static const char *ibmvfc_get_link_state(enum ibmvfc_ae_link_state state)
 static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
                                struct ibmvfc_host *vhost)
 {
-       const struct ibmvfc_async_desc *desc = ibmvfc_get_ae_desc(crq->event);
+       const struct ibmvfc_async_desc *desc = ibmvfc_get_ae_desc(be64_to_cpu(crq->event));
        struct ibmvfc_target *tgt;
 
        ibmvfc_log(vhost, desc->log_level, "%s event received. scsi_id: %llx, wwpn: %llx,"
                   " node_name: %llx%s\n", desc->desc, crq->scsi_id, crq->wwpn, crq->node_name,
                   ibmvfc_get_link_state(crq->link_state));
 
-       switch (crq->event) {
+       switch (be64_to_cpu(crq->event)) {
        case IBMVFC_AE_RESUME:
                switch (crq->link_state) {
                case IBMVFC_AE_LS_LINK_DOWN:
@@ -2691,15 +2693,15 @@ static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
                list_for_each_entry(tgt, &vhost->targets, queue) {
                        if (!crq->scsi_id && !crq->wwpn && !crq->node_name)
                                break;
-                       if (crq->scsi_id && tgt->scsi_id != crq->scsi_id)
+                       if (crq->scsi_id && cpu_to_be64(tgt->scsi_id) != crq->scsi_id)
                                continue;
-                       if (crq->wwpn && tgt->ids.port_name != crq->wwpn)
+                       if (crq->wwpn && cpu_to_be64(tgt->ids.port_name) != crq->wwpn)
                                continue;
-                       if (crq->node_name && tgt->ids.node_name != crq->node_name)
+                       if (crq->node_name && cpu_to_be64(tgt->ids.node_name) != crq->node_name)
                                continue;
-                       if (tgt->need_login && crq->event == IBMVFC_AE_ELS_LOGO)
+                       if (tgt->need_login && be64_to_cpu(crq->event) == IBMVFC_AE_ELS_LOGO)
                                tgt->logo_rcvd = 1;
-                       if (!tgt->need_login || crq->event == IBMVFC_AE_ELS_PLOGI) {
+                       if (!tgt->need_login || be64_to_cpu(crq->event) == IBMVFC_AE_ELS_PLOGI) {
                                ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
                                ibmvfc_reinit_host(vhost);
                        }
@@ -2730,7 +2732,7 @@ static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
 static void ibmvfc_handle_crq(struct ibmvfc_crq *crq, struct ibmvfc_host *vhost)
 {
        long rc;
-       struct ibmvfc_event *evt = (struct ibmvfc_event *)crq->ioba;
+       struct ibmvfc_event *evt = (struct ibmvfc_event *)be64_to_cpu(crq->ioba);
 
        switch (crq->valid) {
        case IBMVFC_CRQ_INIT_RSP:
@@ -3336,7 +3338,7 @@ static void ibmvfc_tgt_prli_done(struct ibmvfc_event *evt)
        struct ibmvfc_host *vhost = evt->vhost;
        struct ibmvfc_process_login *rsp = &evt->xfer_iu->prli;
        struct ibmvfc_prli_svc_parms *parms = &rsp->parms;
-       u32 status = rsp->common.status;
+       u32 status = be16_to_cpu(rsp->common.status);
        int index, level = IBMVFC_DEFAULT_LOG_LEVEL;
 
        vhost->discovery_threads--;
@@ -3347,14 +3349,14 @@ static void ibmvfc_tgt_prli_done(struct ibmvfc_event *evt)
                        parms->type, parms->flags, parms->service_parms);
 
                if (parms->type == IBMVFC_SCSI_FCP_TYPE) {
-                       index = ibmvfc_get_prli_rsp(parms->flags);
+                       index = ibmvfc_get_prli_rsp(be16_to_cpu(parms->flags));
                        if (prli_rsp[index].logged_in) {
-                               if (parms->flags & IBMVFC_PRLI_EST_IMG_PAIR) {
+                               if (be16_to_cpu(parms->flags) & IBMVFC_PRLI_EST_IMG_PAIR) {
                                        tgt->need_login = 0;
                                        tgt->ids.roles = 0;
-                                       if (parms->service_parms & IBMVFC_PRLI_TARGET_FUNC)
+                                       if (be32_to_cpu(parms->service_parms) & IBMVFC_PRLI_TARGET_FUNC)
                                                tgt->ids.roles |= FC_PORT_ROLE_FCP_TARGET;
-                                       if (parms->service_parms & IBMVFC_PRLI_INITIATOR_FUNC)
+                                       if (be32_to_cpu(parms->service_parms) & IBMVFC_PRLI_INITIATOR_FUNC)
                                                tgt->ids.roles |= FC_PORT_ROLE_FCP_INITIATOR;
                                        tgt->add_rport = 1;
                                } else
@@ -3373,17 +3375,18 @@ static void ibmvfc_tgt_prli_done(struct ibmvfc_event *evt)
                break;
        case IBMVFC_MAD_FAILED:
        default:
-               if ((rsp->status & IBMVFC_VIOS_FAILURE) && rsp->error == IBMVFC_PLOGI_REQUIRED)
+               if ((be16_to_cpu(rsp->status) & IBMVFC_VIOS_FAILURE) &&
+                    be16_to_cpu(rsp->error) == IBMVFC_PLOGI_REQUIRED)
                        level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
                else if (tgt->logo_rcvd)
                        level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
-               else if (ibmvfc_retry_cmd(rsp->status, rsp->error))
+               else if (ibmvfc_retry_cmd(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)))
                        level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
                else
                        ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
 
                tgt_log(tgt, level, "Process Login failed: %s (%x:%x) rc=0x%02X\n",
-                       ibmvfc_get_cmd_error(rsp->status, rsp->error),
+                       ibmvfc_get_cmd_error(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)),
                        rsp->status, rsp->error, status);
                break;
        };
@@ -3414,14 +3417,14 @@ static void ibmvfc_tgt_send_prli(struct ibmvfc_target *tgt)
        evt->tgt = tgt;
        prli = &evt->iu.prli;
        memset(prli, 0, sizeof(*prli));
-       prli->common.version = 1;
-       prli->common.opcode = IBMVFC_PROCESS_LOGIN;
-       prli->common.length = sizeof(*prli);
-       prli->scsi_id = tgt->scsi_id;
+       prli->common.version = cpu_to_be32(1);
+       prli->common.opcode = cpu_to_be32(IBMVFC_PROCESS_LOGIN);
+       prli->common.length = cpu_to_be16(sizeof(*prli));
+       prli->scsi_id = cpu_to_be64(tgt->scsi_id);
 
        prli->parms.type = IBMVFC_SCSI_FCP_TYPE;
-       prli->parms.flags = IBMVFC_PRLI_EST_IMG_PAIR;
-       prli->parms.service_parms = IBMVFC_PRLI_INITIATOR_FUNC;
+       prli->parms.flags = cpu_to_be16(IBMVFC_PRLI_EST_IMG_PAIR);
+       prli->parms.service_parms = cpu_to_be32(IBMVFC_PRLI_INITIATOR_FUNC);
 
        ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
        if (ibmvfc_send_event(evt, vhost, default_timeout)) {
@@ -3442,7 +3445,7 @@ static void ibmvfc_tgt_plogi_done(struct ibmvfc_event *evt)
        struct ibmvfc_target *tgt = evt->tgt;
        struct ibmvfc_host *vhost = evt->vhost;
        struct ibmvfc_port_login *rsp = &evt->xfer_iu->plogi;
-       u32 status = rsp->common.status;
+       u32 status = be16_to_cpu(rsp->common.status);
        int level = IBMVFC_DEFAULT_LOG_LEVEL;
 
        vhost->discovery_threads--;
@@ -3472,15 +3475,15 @@ static void ibmvfc_tgt_plogi_done(struct ibmvfc_event *evt)
                break;
        case IBMVFC_MAD_FAILED:
        default:
-               if (ibmvfc_retry_cmd(rsp->status, rsp->error))
+               if (ibmvfc_retry_cmd(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)))
                        level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
                else
                        ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
 
                tgt_log(tgt, level, "Port Login failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
-                       ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error,
-                       ibmvfc_get_fc_type(rsp->fc_type), rsp->fc_type,
-                       ibmvfc_get_ls_explain(rsp->fc_explain), rsp->fc_explain, status);
+                       ibmvfc_get_cmd_error(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)), rsp->status, rsp->error,
+                       ibmvfc_get_fc_type(be16_to_cpu(rsp->fc_type)), rsp->fc_type,
+                       ibmvfc_get_ls_explain(be16_to_cpu(rsp->fc_explain)), rsp->fc_explain, status);
                break;
        };
 
@@ -3512,10 +3515,10 @@ static void ibmvfc_tgt_send_plogi(struct ibmvfc_target *tgt)
        evt->tgt = tgt;
        plogi = &evt->iu.plogi;
        memset(plogi, 0, sizeof(*plogi));
-       plogi->common.version = 1;
-       plogi->common.opcode = IBMVFC_PORT_LOGIN;
-       plogi->common.length = sizeof(*plogi);
-       plogi->scsi_id = tgt->scsi_id;
+       plogi->common.version = cpu_to_be32(1);
+       plogi->common.opcode = cpu_to_be32(IBMVFC_PORT_LOGIN);
+       plogi->common.length = cpu_to_be16(sizeof(*plogi));
+       plogi->scsi_id = cpu_to_be64(tgt->scsi_id);
 
        if (ibmvfc_send_event(evt, vhost, default_timeout)) {
                vhost->discovery_threads--;
@@ -3535,7 +3538,7 @@ static void ibmvfc_tgt_implicit_logout_done(struct ibmvfc_event *evt)
        struct ibmvfc_target *tgt = evt->tgt;
        struct ibmvfc_host *vhost = evt->vhost;
        struct ibmvfc_implicit_logout *rsp = &evt->xfer_iu->implicit_logout;
-       u32 status = rsp->common.status;
+       u32 status = be16_to_cpu(rsp->common.status);
 
        vhost->discovery_threads--;
        ibmvfc_free_event(evt);
@@ -3585,10 +3588,10 @@ static void ibmvfc_tgt_implicit_logout(struct ibmvfc_target *tgt)
        evt->tgt = tgt;
        mad = &evt->iu.implicit_logout;
        memset(mad, 0, sizeof(*mad));
-       mad->common.version = 1;
-       mad->common.opcode = IBMVFC_IMPLICIT_LOGOUT;
-       mad->common.length = sizeof(*mad);
-       mad->old_scsi_id = tgt->scsi_id;
+       mad->common.version = cpu_to_be32(1);
+       mad->common.opcode = cpu_to_be32(IBMVFC_IMPLICIT_LOGOUT);
+       mad->common.length = cpu_to_be16(sizeof(*mad));
+       mad->old_scsi_id = cpu_to_be64(tgt->scsi_id);
 
        ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
        if (ibmvfc_send_event(evt, vhost, default_timeout)) {
@@ -3616,7 +3619,7 @@ static int ibmvfc_adisc_needs_plogi(struct ibmvfc_passthru_mad *mad,
        if (memcmp(&mad->fc_iu.response[4], &tgt->ids.node_name,
                   sizeof(tgt->ids.node_name)))
                return 1;
-       if (mad->fc_iu.response[6] != tgt->scsi_id)
+       if (be32_to_cpu(mad->fc_iu.response[6]) != tgt->scsi_id)
                return 1;
        return 0;
 }
@@ -3631,7 +3634,7 @@ static void ibmvfc_tgt_adisc_done(struct ibmvfc_event *evt)
        struct ibmvfc_target *tgt = evt->tgt;
        struct ibmvfc_host *vhost = evt->vhost;
        struct ibmvfc_passthru_mad *mad = &evt->xfer_iu->passthru;
-       u32 status = mad->common.status;
+       u32 status = be16_to_cpu(mad->common.status);
        u8 fc_reason, fc_explain;
 
        vhost->discovery_threads--;
@@ -3649,10 +3652,10 @@ static void ibmvfc_tgt_adisc_done(struct ibmvfc_event *evt)
        case IBMVFC_MAD_FAILED:
        default:
                ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
-               fc_reason = (mad->fc_iu.response[1] & 0x00ff0000) >> 16;
-               fc_explain = (mad->fc_iu.response[1] & 0x0000ff00) >> 8;
+               fc_reason = (be32_to_cpu(mad->fc_iu.response[1]) & 0x00ff0000) >> 16;
+               fc_explain = (be32_to_cpu(mad->fc_iu.response[1]) & 0x0000ff00) >> 8;
                tgt_info(tgt, "ADISC failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
-                        ibmvfc_get_cmd_error(mad->iu.status, mad->iu.error),
+                        ibmvfc_get_cmd_error(be16_to_cpu(mad->iu.status), be16_to_cpu(mad->iu.error)),
                         mad->iu.status, mad->iu.error,
                         ibmvfc_get_fc_type(fc_reason), fc_reason,
                         ibmvfc_get_ls_explain(fc_explain), fc_explain, status);
@@ -3674,22 +3677,22 @@ static void ibmvfc_init_passthru(struct ibmvfc_event *evt)
        struct ibmvfc_passthru_mad *mad = &evt->iu.passthru;
 
        memset(mad, 0, sizeof(*mad));
-       mad->common.version = 1;
-       mad->common.opcode = IBMVFC_PASSTHRU;
-       mad->common.length = sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu);
-       mad->cmd_ioba.va = (u64)evt->crq.ioba +
-               offsetof(struct ibmvfc_passthru_mad, iu);
-       mad->cmd_ioba.len = sizeof(mad->iu);
-       mad->iu.cmd_len = sizeof(mad->fc_iu.payload);
-       mad->iu.rsp_len = sizeof(mad->fc_iu.response);
-       mad->iu.cmd.va = (u64)evt->crq.ioba +
+       mad->common.version = cpu_to_be32(1);
+       mad->common.opcode = cpu_to_be32(IBMVFC_PASSTHRU);
+       mad->common.length = cpu_to_be16(sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu));
+       mad->cmd_ioba.va = cpu_to_be64((u64)be64_to_cpu(evt->crq.ioba) +
+               offsetof(struct ibmvfc_passthru_mad, iu));
+       mad->cmd_ioba.len = cpu_to_be32(sizeof(mad->iu));
+       mad->iu.cmd_len = cpu_to_be32(sizeof(mad->fc_iu.payload));
+       mad->iu.rsp_len = cpu_to_be32(sizeof(mad->fc_iu.response));
+       mad->iu.cmd.va = cpu_to_be64((u64)be64_to_cpu(evt->crq.ioba) +
                offsetof(struct ibmvfc_passthru_mad, fc_iu) +
-               offsetof(struct ibmvfc_passthru_fc_iu, payload);
-       mad->iu.cmd.len = sizeof(mad->fc_iu.payload);
-       mad->iu.rsp.va = (u64)evt->crq.ioba +
+               offsetof(struct ibmvfc_passthru_fc_iu, payload));
+       mad->iu.cmd.len = cpu_to_be32(sizeof(mad->fc_iu.payload));
+       mad->iu.rsp.va = cpu_to_be64((u64)be64_to_cpu(evt->crq.ioba) +
                offsetof(struct ibmvfc_passthru_mad, fc_iu) +
-               offsetof(struct ibmvfc_passthru_fc_iu, response);
-       mad->iu.rsp.len = sizeof(mad->fc_iu.response);
+               offsetof(struct ibmvfc_passthru_fc_iu, response));
+       mad->iu.rsp.len = cpu_to_be32(sizeof(mad->fc_iu.response));
 }
 
 /**
@@ -3748,11 +3751,11 @@ static void ibmvfc_adisc_timeout(struct ibmvfc_target *tgt)
        evt->tgt = tgt;
        tmf = &evt->iu.tmf;
        memset(tmf, 0, sizeof(*tmf));
-       tmf->common.version = 1;
-       tmf->common.opcode = IBMVFC_TMF_MAD;
-       tmf->common.length = sizeof(*tmf);
-       tmf->scsi_id = tgt->scsi_id;
-       tmf->cancel_key = tgt->cancel_key;
+       tmf->common.version = cpu_to_be32(1);
+       tmf->common.opcode = cpu_to_be32(IBMVFC_TMF_MAD);
+       tmf->common.length = cpu_to_be16(sizeof(*tmf));
+       tmf->scsi_id = cpu_to_be64(tgt->scsi_id);
+       tmf->cancel_key = cpu_to_be32(tgt->cancel_key);
 
        rc = ibmvfc_send_event(evt, vhost, default_timeout);
 
@@ -3794,16 +3797,16 @@ static void ibmvfc_tgt_adisc(struct ibmvfc_target *tgt)
 
        ibmvfc_init_passthru(evt);
        mad = &evt->iu.passthru;
-       mad->iu.flags = IBMVFC_FC_ELS;
-       mad->iu.scsi_id = tgt->scsi_id;
-       mad->iu.cancel_key = tgt->cancel_key;
+       mad->iu.flags = cpu_to_be32(IBMVFC_FC_ELS);
+       mad->iu.scsi_id = cpu_to_be64(tgt->scsi_id);
+       mad->iu.cancel_key = cpu_to_be32(tgt->cancel_key);
 
-       mad->fc_iu.payload[0] = IBMVFC_ADISC;
+       mad->fc_iu.payload[0] = cpu_to_be32(IBMVFC_ADISC);
        memcpy(&mad->fc_iu.payload[2], &vhost->login_buf->resp.port_name,
               sizeof(vhost->login_buf->resp.port_name));
        memcpy(&mad->fc_iu.payload[4], &vhost->login_buf->resp.node_name,
               sizeof(vhost->login_buf->resp.node_name));
-       mad->fc_iu.payload[6] = vhost->login_buf->resp.scsi_id & 0x00ffffff;
+       mad->fc_iu.payload[6] = cpu_to_be32(be64_to_cpu(vhost->login_buf->resp.scsi_id) & 0x00ffffff);
 
        if (timer_pending(&tgt->timer))
                mod_timer(&tgt->timer, jiffies + (IBMVFC_ADISC_TIMEOUT * HZ));
@@ -3834,7 +3837,7 @@ static void ibmvfc_tgt_query_target_done(struct ibmvfc_event *evt)
        struct ibmvfc_target *tgt = evt->tgt;
        struct ibmvfc_host *vhost = evt->vhost;
        struct ibmvfc_query_tgt *rsp = &evt->xfer_iu->query_tgt;
-       u32 status = rsp->common.status;
+       u32 status = be16_to_cpu(rsp->common.status);
        int level = IBMVFC_DEFAULT_LOG_LEVEL;
 
        vhost->discovery_threads--;
@@ -3842,8 +3845,8 @@ static void ibmvfc_tgt_query_target_done(struct ibmvfc_event *evt)
        switch (status) {
        case IBMVFC_MAD_SUCCESS:
                tgt_dbg(tgt, "Query Target succeeded\n");
-               tgt->new_scsi_id = rsp->scsi_id;
-               if (rsp->scsi_id != tgt->scsi_id)
+               tgt->new_scsi_id = be64_to_cpu(rsp->scsi_id);
+               if (be64_to_cpu(rsp->scsi_id) != tgt->scsi_id)
                        ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
                else
                        ibmvfc_init_tgt(tgt, ibmvfc_tgt_adisc);
@@ -3855,19 +3858,20 @@ static void ibmvfc_tgt_query_target_done(struct ibmvfc_event *evt)
                break;
        case IBMVFC_MAD_FAILED:
        default:
-               if ((rsp->status & IBMVFC_FABRIC_MAPPED) == IBMVFC_FABRIC_MAPPED &&
-                   rsp->error == IBMVFC_UNABLE_TO_PERFORM_REQ &&
-                   rsp->fc_explain == IBMVFC_PORT_NAME_NOT_REG)
+               if ((be16_to_cpu(rsp->status) & IBMVFC_FABRIC_MAPPED) == IBMVFC_FABRIC_MAPPED &&
+                   be16_to_cpu(rsp->error) == IBMVFC_UNABLE_TO_PERFORM_REQ &&
+                   be16_to_cpu(rsp->fc_explain) == IBMVFC_PORT_NAME_NOT_REG)
                        ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
-               else if (ibmvfc_retry_cmd(rsp->status, rsp->error))
+               else if (ibmvfc_retry_cmd(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)))
                        level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_query_target);
                else
                        ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
 
                tgt_log(tgt, level, "Query Target failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
-                       ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error,
-                       ibmvfc_get_fc_type(rsp->fc_type), rsp->fc_type,
-                       ibmvfc_get_gs_explain(rsp->fc_explain), rsp->fc_explain, status);
+                       ibmvfc_get_cmd_error(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)),
+                       rsp->status, rsp->error, ibmvfc_get_fc_type(be16_to_cpu(rsp->fc_type)),
+                       rsp->fc_type, ibmvfc_get_gs_explain(be16_to_cpu(rsp->fc_explain)),
+                       rsp->fc_explain, status);
                break;
        };
 
@@ -3897,10 +3901,10 @@ static void ibmvfc_tgt_query_target(struct ibmvfc_target *tgt)
        ibmvfc_init_event(evt, ibmvfc_tgt_query_target_done, IBMVFC_MAD_FORMAT);
        query_tgt = &evt->iu.query_tgt;
        memset(query_tgt, 0, sizeof(*query_tgt));
-       query_tgt->common.version = 1;
-       query_tgt->common.opcode = IBMVFC_QUERY_TARGET;
-       query_tgt->common.length = sizeof(*query_tgt);
-       query_tgt->wwpn = tgt->ids.port_name;
+       query_tgt->common.version = cpu_to_be32(1);
+       query_tgt->common.opcode = cpu_to_be32(IBMVFC_QUERY_TARGET);
+       query_tgt->common.length = cpu_to_be16(sizeof(*query_tgt));
+       query_tgt->wwpn = cpu_to_be64(tgt->ids.port_name);
 
        ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
        if (ibmvfc_send_event(evt, vhost, default_timeout)) {
@@ -3971,7 +3975,8 @@ static int ibmvfc_alloc_targets(struct ibmvfc_host *vhost)
 
        for (i = 0, rc = 0; !rc && i < vhost->num_targets; i++)
                rc = ibmvfc_alloc_target(vhost,
-                                        vhost->disc_buf->scsi_id[i] & IBMVFC_DISC_TGT_SCSI_ID_MASK);
+                                        be32_to_cpu(vhost->disc_buf->scsi_id[i]) &
+                                        IBMVFC_DISC_TGT_SCSI_ID_MASK);
 
        return rc;
 }
@@ -3985,19 +3990,20 @@ static void ibmvfc_discover_targets_done(struct ibmvfc_event *evt)
 {
        struct ibmvfc_host *vhost = evt->vhost;
        struct ibmvfc_discover_targets *rsp = &evt->xfer_iu->discover_targets;
-       u32 mad_status = rsp->common.status;
+       u32 mad_status = be16_to_cpu(rsp->common.status);
        int level = IBMVFC_DEFAULT_LOG_LEVEL;
 
        switch (mad_status) {
        case IBMVFC_MAD_SUCCESS:
                ibmvfc_dbg(vhost, "Discover Targets succeeded\n");
-               vhost->num_targets = rsp->num_written;
+               vhost->num_targets = be32_to_cpu(rsp->num_written);
                ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_ALLOC_TGTS);
                break;
        case IBMVFC_MAD_FAILED:
                level += ibmvfc_retry_host_init(vhost);
                ibmvfc_log(vhost, level, "Discover Targets failed: %s (%x:%x)\n",
-                          ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error);
+                          ibmvfc_get_cmd_error(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)),
+                          rsp->status, rsp->error);
                break;
        case IBMVFC_MAD_DRIVER_FAILED:
                break;
@@ -4024,12 +4030,12 @@ static void ibmvfc_discover_targets(struct ibmvfc_host *vhost)
        ibmvfc_init_event(evt, ibmvfc_discover_targets_done, IBMVFC_MAD_FORMAT);
        mad = &evt->iu.discover_targets;
        memset(mad, 0, sizeof(*mad));
-       mad->common.version = 1;
-       mad->common.opcode = IBMVFC_DISC_TARGETS;
-       mad->common.length = sizeof(*mad);
-       mad->bufflen = vhost->disc_buf_sz;
-       mad->buffer.va = vhost->disc_buf_dma;
-       mad->buffer.len = vhost->disc_buf_sz;
+       mad->common.version = cpu_to_be32(1);
+       mad->common.opcode = cpu_to_be32(IBMVFC_DISC_TARGETS);
+       mad->common.length = cpu_to_be16(sizeof(*mad));
+       mad->bufflen = cpu_to_be32(vhost->disc_buf_sz);
+       mad->buffer.va = cpu_to_be64(vhost->disc_buf_dma);
+       mad->buffer.len = cpu_to_be32(vhost->disc_buf_sz);
        ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
 
        if (!ibmvfc_send_event(evt, vhost, default_timeout))
@@ -4046,7 +4052,7 @@ static void ibmvfc_discover_targets(struct ibmvfc_host *vhost)
 static void ibmvfc_npiv_login_done(struct ibmvfc_event *evt)
 {
        struct ibmvfc_host *vhost = evt->vhost;
-       u32 mad_status = evt->xfer_iu->npiv_login.common.status;
+       u32 mad_status = be16_to_cpu(evt->xfer_iu->npiv_login.common.status);
        struct ibmvfc_npiv_login_resp *rsp = &vhost->login_buf->resp;
        unsigned int npiv_max_sectors;
        int level = IBMVFC_DEFAULT_LOG_LEVEL;
@@ -4056,12 +4062,13 @@ static void ibmvfc_npiv_login_done(struct ibmvfc_event *evt)
                ibmvfc_free_event(evt);
                break;
        case IBMVFC_MAD_FAILED:
-               if (ibmvfc_retry_cmd(rsp->status, rsp->error))
+               if (ibmvfc_retry_cmd(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)))
                        level += ibmvfc_retry_host_init(vhost);
                else
                        ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
                ibmvfc_log(vhost, level, "NPIV Login failed: %s (%x:%x)\n",
-                          ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error);
+                          ibmvfc_get_cmd_error(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)),
+                                               rsp->status, rsp->error);
                ibmvfc_free_event(evt);
                return;
        case IBMVFC_MAD_CRQ_ERROR:
@@ -4078,7 +4085,7 @@ static void ibmvfc_npiv_login_done(struct ibmvfc_event *evt)
 
        vhost->client_migrated = 0;
 
-       if (!(rsp->flags & IBMVFC_NATIVE_FC)) {
+       if (!(be32_to_cpu(rsp->flags) & IBMVFC_NATIVE_FC)) {
                dev_err(vhost->dev, "Virtual adapter does not support FC. %x\n",
                        rsp->flags);
                ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
@@ -4086,7 +4093,7 @@ static void ibmvfc_npiv_login_done(struct ibmvfc_event *evt)
                return;
        }
 
-       if (rsp->max_cmds <= IBMVFC_NUM_INTERNAL_REQ) {
+       if (be32_to_cpu(rsp->max_cmds) <= IBMVFC_NUM_INTERNAL_REQ) {
                dev_err(vhost->dev, "Virtual adapter supported queue depth too small: %d\n",
                        rsp->max_cmds);
                ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
@@ -4095,27 +4102,27 @@ static void ibmvfc_npiv_login_done(struct ibmvfc_event *evt)
        }
 
        vhost->logged_in = 1;
-       npiv_max_sectors = min((uint)(rsp->max_dma_len >> 9), IBMVFC_MAX_SECTORS);
+       npiv_max_sectors = min((uint)(be64_to_cpu(rsp->max_dma_len) >> 9), IBMVFC_MAX_SECTORS);
        dev_info(vhost->dev, "Host partition: %s, device: %s %s %s max sectors %u\n",
                 rsp->partition_name, rsp->device_name, rsp->port_loc_code,
                 rsp->drc_name, npiv_max_sectors);
 
-       fc_host_fabric_name(vhost->host) = rsp->node_name;
-       fc_host_node_name(vhost->host) = rsp->node_name;
-       fc_host_port_name(vhost->host) = rsp->port_name;
-       fc_host_port_id(vhost->host) = rsp->scsi_id;
+       fc_host_fabric_name(vhost->host) = be64_to_cpu(rsp->node_name);
+       fc_host_node_name(vhost->host) = be64_to_cpu(rsp->node_name);
+       fc_host_port_name(vhost->host) = be64_to_cpu(rsp->port_name);
+       fc_host_port_id(vhost->host) = be64_to_cpu(rsp->scsi_id);
        fc_host_port_type(vhost->host) = FC_PORTTYPE_NPIV;
        fc_host_supported_classes(vhost->host) = 0;
-       if (rsp->service_parms.class1_parms[0] & 0x80000000)
+       if (be32_to_cpu(rsp->service_parms.class1_parms[0]) & 0x80000000)
                fc_host_supported_classes(vhost->host) |= FC_COS_CLASS1;
-       if (rsp->service_parms.class2_parms[0] & 0x80000000)
+       if (be32_to_cpu(rsp->service_parms.class2_parms[0]) & 0x80000000)
                fc_host_supported_classes(vhost->host) |= FC_COS_CLASS2;
-       if (rsp->service_parms.class3_parms[0] & 0x80000000)
+       if (be32_to_cpu(rsp->service_parms.class3_parms[0]) & 0x80000000)
                fc_host_supported_classes(vhost->host) |= FC_COS_CLASS3;
        fc_host_maxframe_size(vhost->host) =
-               rsp->service_parms.common.bb_rcv_sz & 0x0fff;
+               be16_to_cpu(rsp->service_parms.common.bb_rcv_sz) & 0x0fff;
 
-       vhost->host->can_queue = rsp->max_cmds - IBMVFC_NUM_INTERNAL_REQ;
+       vhost->host->can_queue = be32_to_cpu(rsp->max_cmds) - IBMVFC_NUM_INTERNAL_REQ;
        vhost->host->max_sectors = npiv_max_sectors;
        ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
        wake_up(&vhost->work_wait_q);
@@ -4138,11 +4145,11 @@ static void ibmvfc_npiv_login(struct ibmvfc_host *vhost)
        memcpy(vhost->login_buf, &vhost->login_info, sizeof(vhost->login_info));
        mad = &evt->iu.npiv_login;
        memset(mad, 0, sizeof(struct ibmvfc_npiv_login_mad));
-       mad->common.version = 1;
-       mad->common.opcode = IBMVFC_NPIV_LOGIN;
-       mad->common.length = sizeof(struct ibmvfc_npiv_login_mad);
-       mad->buffer.va = vhost->login_buf_dma;
-       mad->buffer.len = sizeof(*vhost->login_buf);
+       mad->common.version = cpu_to_be32(1);
+       mad->common.opcode = cpu_to_be32(IBMVFC_NPIV_LOGIN);
+       mad->common.length = cpu_to_be16(sizeof(struct ibmvfc_npiv_login_mad));
+       mad->buffer.va = cpu_to_be64(vhost->login_buf_dma);
+       mad->buffer.len = cpu_to_be32(sizeof(*vhost->login_buf));
 
        ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
 
@@ -4160,7 +4167,7 @@ static void ibmvfc_npiv_login(struct ibmvfc_host *vhost)
 static void ibmvfc_npiv_logout_done(struct ibmvfc_event *evt)
 {
        struct ibmvfc_host *vhost = evt->vhost;
-       u32 mad_status = evt->xfer_iu->npiv_logout.common.status;
+       u32 mad_status = be16_to_cpu(evt->xfer_iu->npiv_logout.common.status);
 
        ibmvfc_free_event(evt);
 
@@ -4199,9 +4206,9 @@ static void ibmvfc_npiv_logout(struct ibmvfc_host *vhost)
 
        mad = &evt->iu.npiv_logout;
        memset(mad, 0, sizeof(*mad));
-       mad->common.version = 1;
-       mad->common.opcode = IBMVFC_NPIV_LOGOUT;
-       mad->common.length = sizeof(struct ibmvfc_npiv_logout_mad);
+       mad->common.version = cpu_to_be32(1);
+       mad->common.opcode = cpu_to_be32(IBMVFC_NPIV_LOGOUT);
+       mad->common.length = cpu_to_be16(sizeof(struct ibmvfc_npiv_logout_mad));
 
        ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_LOGO_WAIT);
 
@@ -4343,14 +4350,14 @@ static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
        if (rport) {
                tgt_dbg(tgt, "rport add succeeded\n");
                tgt->rport = rport;
-               rport->maxframe_size = tgt->service_parms.common.bb_rcv_sz & 0x0fff;
+               rport->maxframe_size = be16_to_cpu(tgt->service_parms.common.bb_rcv_sz) & 0x0fff;
                rport->supported_classes = 0;
                tgt->target_id = rport->scsi_target_id;
-               if (tgt->service_parms.class1_parms[0] & 0x80000000)
+               if (be32_to_cpu(tgt->service_parms.class1_parms[0]) & 0x80000000)
                        rport->supported_classes |= FC_COS_CLASS1;
-               if (tgt->service_parms.class2_parms[0] & 0x80000000)
+               if (be32_to_cpu(tgt->service_parms.class2_parms[0]) & 0x80000000)
                        rport->supported_classes |= FC_COS_CLASS2;
-               if (tgt->service_parms.class3_parms[0] & 0x80000000)
+               if (be32_to_cpu(tgt->service_parms.class3_parms[0]) & 0x80000000)
                        rport->supported_classes |= FC_COS_CLASS3;
                if (rport->rqst_q)
                        blk_queue_max_segments(rport->rqst_q, 1);

diff --git a/drivers/scsi/ibmvscsi/ibmvfc.h b/drivers/scsi/ibmvscsi/ibmvfc.h
index 017a5290e8c12ba5d27c89a390c4ed6490e05000..8fae03215a85d2d26920146617cbfc68c8a845ed 100644 (file)
--- a/drivers/scsi/ibmvscsi/ibmvfc.h
+++ b/drivers/scsi/ibmvscsi/ibmvfc.h
@@ -135,12 +135,12 @@ enum ibmvfc_mad_types {
 };
 
 struct ibmvfc_mad_common {
-       u32 version;
-       u32 reserved;
-       u32 opcode;
-       u16 status;
-       u16 length;
-       u64 tag;
+       __be32 version;
+       __be32 reserved;
+       __be32 opcode;
+       __be16 status;
+       __be16 length;
+       __be64 tag;
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_npiv_login_mad {
@@ -155,76 +155,76 @@ struct ibmvfc_npiv_logout_mad {
 #define IBMVFC_MAX_NAME 256
 
 struct ibmvfc_npiv_login {
-       u32 ostype;
+       __be32 ostype;
 #define IBMVFC_OS_LINUX        0x02
-       u32 pad;
-       u64 max_dma_len;
-       u32 max_payload;
-       u32 max_response;
-       u32 partition_num;
-       u32 vfc_frame_version;
-       u16 fcp_version;
-       u16 flags;
+       __be32 pad;
+       __be64 max_dma_len;
+       __be32 max_payload;
+       __be32 max_response;
+       __be32 partition_num;
+       __be32 vfc_frame_version;
+       __be16 fcp_version;
+       __be16 flags;
 #define IBMVFC_CLIENT_MIGRATED 0x01
 #define IBMVFC_FLUSH_ON_HALT           0x02
-       u32 max_cmds;
-       u64 capabilities;
+       __be32 max_cmds;
+       __be64 capabilities;
 #define IBMVFC_CAN_MIGRATE             0x01
-       u64 node_name;
+       __be64 node_name;
        struct srp_direct_buf async;
        u8 partition_name[IBMVFC_MAX_NAME];
        u8 device_name[IBMVFC_MAX_NAME];
        u8 drc_name[IBMVFC_MAX_NAME];
-       u64 reserved2[2];
+       __be64 reserved2[2];
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_common_svc_parms {
-       u16 fcph_version;
-       u16 b2b_credit;
-       u16 features;
-       u16 bb_rcv_sz; /* upper nibble is BB_SC_N */
-       u32 ratov;
-       u32 edtov;
+       __be16 fcph_version;
+       __be16 b2b_credit;
+       __be16 features;
+       __be16 bb_rcv_sz; /* upper nibble is BB_SC_N */
+       __be32 ratov;
+       __be32 edtov;
 }__attribute__((packed, aligned (4)));
 
 struct ibmvfc_service_parms {
        struct ibmvfc_common_svc_parms common;
        u8 port_name[8];
        u8 node_name[8];
-       u32 class1_parms[4];
-       u32 class2_parms[4];
-       u32 class3_parms[4];
-       u32 obsolete[4];
-       u32 vendor_version[4];
-       u32 services_avail[2];
-       u32 ext_len;
-       u32 reserved[30];
-       u32 clk_sync_qos[2];
+       __be32 class1_parms[4];
+       __be32 class2_parms[4];
+       __be32 class3_parms[4];
+       __be32 obsolete[4];
+       __be32 vendor_version[4];
+       __be32 services_avail[2];
+       __be32 ext_len;
+       __be32 reserved[30];
+       __be32 clk_sync_qos[2];
 }__attribute__((packed, aligned (4)));
 
 struct ibmvfc_npiv_login_resp {
-       u32 version;
-       u16 status;
-       u16 error;
-       u32 flags;
+       __be32 version;
+       __be16 status;
+       __be16 error;
+       __be32 flags;
 #define IBMVFC_NATIVE_FC               0x01
-       u32 reserved;
-       u64 capabilities;
+       __be32 reserved;
+       __be64 capabilities;
 #define IBMVFC_CAN_FLUSH_ON_HALT       0x08
 #define IBMVFC_CAN_SUPPRESS_ABTS       0x10
-       u32 max_cmds;
-       u32 scsi_id_sz;
-       u64 max_dma_len;
-       u64 scsi_id;
-       u64 port_name;
-       u64 node_name;
-       u64 link_speed;
+       __be32 max_cmds;
+       __be32 scsi_id_sz;
+       __be64 max_dma_len;
+       __be64 scsi_id;
+       __be64 port_name;
+       __be64 node_name;
+       __be64 link_speed;
        u8 partition_name[IBMVFC_MAX_NAME];
        u8 device_name[IBMVFC_MAX_NAME];
        u8 port_loc_code[IBMVFC_MAX_NAME];
        u8 drc_name[IBMVFC_MAX_NAME];
        struct ibmvfc_service_parms service_parms;
-       u64 reserved2;
+       __be64 reserved2;
 }__attribute__((packed, aligned (8)));
 
 union ibmvfc_npiv_login_data {
@@ -233,20 +233,20 @@ union ibmvfc_npiv_login_data {
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_discover_targets_buf {
-       u32 scsi_id[1];
+       __be32 scsi_id[1];
 #define IBMVFC_DISC_TGT_SCSI_ID_MASK   0x00ffffff
 };
 
 struct ibmvfc_discover_targets {
        struct ibmvfc_mad_common common;
        struct srp_direct_buf buffer;
-       u32 flags;
-       u16 status;
-       u16 error;
-       u32 bufflen;
-       u32 num_avail;
-       u32 num_written;
-       u64 reserved[2];
+       __be32 flags;
+       __be16 status;
+       __be16 error;
+       __be32 bufflen;
+       __be32 num_avail;
+       __be32 num_written;
+       __be64 reserved[2];
 }__attribute__((packed, aligned (8)));
 
 enum ibmvfc_fc_reason {
@@ -278,32 +278,32 @@ enum ibmvfc_gs_explain {
 
 struct ibmvfc_port_login {
        struct ibmvfc_mad_common common;
-       u64 scsi_id;
-       u16 reserved;
-       u16 fc_service_class;
-       u32 blksz;
-       u32 hdr_per_blk;
-       u16 status;
-       u16 error;              /* also fc_reason */
-       u16 fc_explain;
-       u16 fc_type;
-       u32 reserved2;
+       __be64 scsi_id;
+       __be16 reserved;
+       __be16 fc_service_class;
+       __be32 blksz;
+       __be32 hdr_per_blk;
+       __be16 status;
+       __be16 error;           /* also fc_reason */
+       __be16 fc_explain;
+       __be16 fc_type;
+       __be32 reserved2;
        struct ibmvfc_service_parms service_parms;
        struct ibmvfc_service_parms service_parms_change;
-       u64 reserved3[2];
+       __be64 reserved3[2];
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_prli_svc_parms {
        u8 type;
 #define IBMVFC_SCSI_FCP_TYPE           0x08
        u8 type_ext;
-       u16 flags;
+       __be16 flags;
 #define IBMVFC_PRLI_ORIG_PA_VALID                      0x8000
 #define IBMVFC_PRLI_RESP_PA_VALID                      0x4000
 #define IBMVFC_PRLI_EST_IMG_PAIR                       0x2000
-       u32 orig_pa;
-       u32 resp_pa;
-       u32 service_parms;
+       __be32 orig_pa;
+       __be32 resp_pa;
+       __be32 service_parms;
 #define IBMVFC_PRLI_TASK_RETRY                 0x00000200
 #define IBMVFC_PRLI_RETRY                              0x00000100
 #define IBMVFC_PRLI_DATA_OVERLAY                       0x00000040
@@ -315,47 +315,47 @@ struct ibmvfc_prli_svc_parms {
 
 struct ibmvfc_process_login {
        struct ibmvfc_mad_common common;
-       u64 scsi_id;
+       __be64 scsi_id;
        struct ibmvfc_prli_svc_parms parms;
        u8 reserved[48];
-       u16 status;
-       u16 error;                      /* also fc_reason */
-       u32 reserved2;
-       u64 reserved3[2];
+       __be16 status;
+       __be16 error;                   /* also fc_reason */
+       __be32 reserved2;
+       __be64 reserved3[2];
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_query_tgt {
        struct ibmvfc_mad_common common;
-       u64 wwpn;
-       u64 scsi_id;
-       u16 status;
-       u16 error;
-       u16 fc_explain;
-       u16 fc_type;
-       u64 reserved[2];
+       __be64 wwpn;
+       __be64 scsi_id;
+       __be16 status;
+       __be16 error;
+       __be16 fc_explain;
+       __be16 fc_type;
+       __be64 reserved[2];
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_implicit_logout {
        struct ibmvfc_mad_common common;
-       u64 old_scsi_id;
-       u64 reserved[2];
+       __be64 old_scsi_id;
+       __be64 reserved[2];
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_tmf {
        struct ibmvfc_mad_common common;
-       u64 scsi_id;
+       __be64 scsi_id;
        struct scsi_lun lun;
-       u32 flags;
+       __be32 flags;
 #define IBMVFC_TMF_ABORT_TASK          0x02
 #define IBMVFC_TMF_ABORT_TASK_SET      0x04
 #define IBMVFC_TMF_LUN_RESET           0x10
 #define IBMVFC_TMF_TGT_RESET           0x20
 #define IBMVFC_TMF_LUA_VALID           0x40
 #define IBMVFC_TMF_SUPPRESS_ABTS       0x80
-       u32 cancel_key;
-       u32 my_cancel_key;
-       u32 pad;
-       u64 reserved[2];
+       __be32 cancel_key;
+       __be32 my_cancel_key;
+       __be32 pad;
+       __be64 reserved[2];
 }__attribute__((packed, aligned (8)));
 
 enum ibmvfc_fcp_rsp_info_codes {
@@ -366,7 +366,7 @@ enum ibmvfc_fcp_rsp_info_codes {
 };
 
 struct ibmvfc_fcp_rsp_info {
-       u16 reserved;
+       __be16 reserved;
        u8 rsp_code;
        u8 reserved2[4];
 }__attribute__((packed, aligned (2)));
@@ -388,13 +388,13 @@ union ibmvfc_fcp_rsp_data {
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_fcp_rsp {
-       u64 reserved;
-       u16 retry_delay_timer;
+       __be64 reserved;
+       __be16 retry_delay_timer;
        u8 flags;
        u8 scsi_status;
-       u32 fcp_resid;
-       u32 fcp_sense_len;
-       u32 fcp_rsp_len;
+       __be32 fcp_resid;
+       __be32 fcp_sense_len;
+       __be32 fcp_rsp_len;
        union ibmvfc_fcp_rsp_data data;
 }__attribute__((packed, aligned (8)));
 
@@ -429,58 +429,58 @@ struct ibmvfc_fcp_cmd_iu {
 #define IBMVFC_RDDATA          0x02
 #define IBMVFC_WRDATA          0x01
        u8 cdb[IBMVFC_MAX_CDB_LEN];
-       u32 xfer_len;
+       __be32 xfer_len;
 }__attribute__((packed, aligned (4)));
 
 struct ibmvfc_cmd {
-       u64 task_tag;
-       u32 frame_type;
-       u32 payload_len;
-       u32 resp_len;
-       u32 adapter_resid;
-       u16 status;
-       u16 error;
-       u16 flags;
-       u16 response_flags;
+       __be64 task_tag;
+       __be32 frame_type;
+       __be32 payload_len;
+       __be32 resp_len;
+       __be32 adapter_resid;
+       __be16 status;
+       __be16 error;
+       __be16 flags;
+       __be16 response_flags;
 #define IBMVFC_ADAPTER_RESID_VALID     0x01
-       u32 cancel_key;
-       u32 exchange_id;
+       __be32 cancel_key;
+       __be32 exchange_id;
        struct srp_direct_buf ext_func;
        struct srp_direct_buf ioba;
        struct srp_direct_buf resp;
-       u64 correlation;
-       u64 tgt_scsi_id;
-       u64 tag;
-       u64 reserved3[2];
+       __be64 correlation;
+       __be64 tgt_scsi_id;
+       __be64 tag;
+       __be64 reserved3[2];
        struct ibmvfc_fcp_cmd_iu iu;
        struct ibmvfc_fcp_rsp rsp;
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_passthru_fc_iu {
-       u32 payload[7];
+       __be32 payload[7];
 #define IBMVFC_ADISC   0x52000000
-       u32 response[7];
+       __be32 response[7];
 };
 
 struct ibmvfc_passthru_iu {
-       u64 task_tag;
-       u32 cmd_len;
-       u32 rsp_len;
-       u16 status;
-       u16 error;
-       u32 flags;
+       __be64 task_tag;
+       __be32 cmd_len;
+       __be32 rsp_len;
+       __be16 status;
+       __be16 error;
+       __be32 flags;
 #define IBMVFC_FC_ELS          0x01
 #define IBMVFC_FC_CT_IU                0x02
-       u32 cancel_key;
+       __be32 cancel_key;
 #define IBMVFC_PASSTHRU_CANCEL_KEY     0x80000000
 #define IBMVFC_INTERNAL_CANCEL_KEY     0x80000001
-       u32 reserved;
+       __be32 reserved;
        struct srp_direct_buf cmd;
        struct srp_direct_buf rsp;
-       u64 correlation;
-       u64 scsi_id;
-       u64 tag;
-       u64 reserved2[2];
+       __be64 correlation;
+       __be64 scsi_id;
+       __be64 tag;
+       __be64 reserved2[2];
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_passthru_mad {
@@ -552,7 +552,7 @@ struct ibmvfc_crq {
        volatile u8 valid;
        volatile u8 format;
        u8 reserved[6];
-       volatile u64 ioba;
+       volatile __be64 ioba;
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_crq_queue {
@@ -572,12 +572,12 @@ struct ibmvfc_async_crq {
        volatile u8 valid;
        u8 link_state;
        u8 pad[2];
-       u32 pad2;
-       volatile u64 event;
-       volatile u64 scsi_id;
-       volatile u64 wwpn;
-       volatile u64 node_name;
-       u64 reserved;
+       __be32 pad2;
+       volatile __be64 event;
+       volatile __be64 scsi_id;
+       volatile __be64 wwpn;
+       volatile __be64 node_name;
+       __be64 reserved;
 }__attribute__((packed, aligned (8)));
 
 struct ibmvfc_async_crq_queue {