[SCSI] zfcp: Use common code definitions for FC ELS structs

Use common code definitions for FC plogi, logo, rscn and adisc structs
instead of inventing private ones. Move the private struct for issuing
ELS ADISC inside zfcp to zfcp_fc header file.

Reviewed-by: Swen Schillig <swen@vnet.ibm.com>
Signed-off-by: Christof Schmitt <christof.schmitt@de.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>

1 files changed, 66 insertions, 65 deletions

diff --git a/drivers/s390/scsi/zfcp_fc.c b/drivers/s390/scsi/zfcp_fc.c
index 7d6b3cadfb73..e03410043cd7 100644
--- a/drivers/s390/scsi/zfcp_fc.c
+++ b/drivers/s390/scsi/zfcp_fc.c
@@ -9,20 +9,17 @@
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/types.h>
+#include <scsi/fc/fc_els.h>
+#include <scsi/libfc.h>
 #include "zfcp_ext.h"
+#include "zfcp_fc.h"
 
-enum rscn_address_format {
-        RSCN_PORT_ADDRESS       = 0x0,
-        RSCN_AREA_ADDRESS       = 0x1,
-        RSCN_DOMAIN_ADDRESS     = 0x2,
-        RSCN_FABRIC_ADDRESS     = 0x3,
-};
-
-static u32 rscn_range_mask[] = {
-        [RSCN_PORT_ADDRESS]             = 0xFFFFFF,
-        [RSCN_AREA_ADDRESS]             = 0xFFFF00,
-        [RSCN_DOMAIN_ADDRESS]           = 0xFF0000,
-        [RSCN_FABRIC_ADDRESS]           = 0x000000,
+static u32 zfcp_fc_rscn_range_mask[] = {
+        [ELS_ADDR_FMT_PORT]             = 0xFFFFFF,
+        [ELS_ADDR_FMT_AREA]             = 0xFFFF00,
+        [ELS_ADDR_FMT_DOM]              = 0xFF0000,
+        [ELS_ADDR_FMT_FAB]              = 0x000000,
 };
 
 struct gpn_ft_resp_acc {
@@ -144,7 +141,7 @@ void zfcp_fc_wka_ports_force_offline(struct zfcp_wka_ports *gs)
 }
 
 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
-                                   struct fcp_rscn_element *elem)
+                                   struct fc_els_rscn_page *page)
 {
         unsigned long flags;
         struct zfcp_adapter *adapter = fsf_req->adapter;
@@ -152,7 +149,7 @@ static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
 
         read_lock_irqsave(&adapter->port_list_lock, flags);
         list_for_each_entry(port, &adapter->port_list, list) {
-                if ((port->d_id & range) == (elem->nport_did & range))
+                if ((port->d_id & range) == (ntoh24(page->rscn_fid) & range))
                         zfcp_fc_test_link(port);
                 if (!port->d_id)
                         zfcp_erp_port_reopen(port,
@@ -165,24 +162,24 @@ static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req)
 {
         struct fsf_status_read_buffer *status_buffer = (void *)fsf_req->data;
-        struct fcp_rscn_head *fcp_rscn_head;
-        struct fcp_rscn_element *fcp_rscn_element;
+        struct fc_els_rscn *head;
+        struct fc_els_rscn_page *page;
         u16 i;
         u16 no_entries;
-        u32 range_mask;
+        unsigned int afmt;
 
-        fcp_rscn_head = (struct fcp_rscn_head *) status_buffer->payload.data;
-        fcp_rscn_element = (struct fcp_rscn_element *) fcp_rscn_head;
+        head = (struct fc_els_rscn *) status_buffer->payload.data;
+        page = (struct fc_els_rscn_page *) head;
 
         /* see FC-FS */
-        no_entries = fcp_rscn_head->payload_len /
-                        sizeof(struct fcp_rscn_element);
+        no_entries = head->rscn_plen / sizeof(struct fc_els_rscn_page);
 
         for (i = 1; i < no_entries; i++) {
                 /* skip head and start with 1st element */
-                fcp_rscn_element++;
-                range_mask = rscn_range_mask[fcp_rscn_element->addr_format];
-                _zfcp_fc_incoming_rscn(fsf_req, range_mask, fcp_rscn_element);
+                page++;
+                afmt = page->rscn_page_flags & ELS_RSCN_ADDR_FMT_MASK;
+                _zfcp_fc_incoming_rscn(fsf_req, zfcp_fc_rscn_range_mask[afmt],
+                                       page);
         }
         queue_work(fsf_req->adapter->work_queue, &fsf_req->adapter->scan_work);
 }
@@ -204,22 +201,22 @@ static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn)
 
 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req *req)
 {
-        struct fsf_status_read_buffer *status_buffer =
-                (struct fsf_status_read_buffer *)req->data;
-        struct fsf_plogi *els_plogi =
-                (struct fsf_plogi *) status_buffer->payload.data;
+        struct fsf_status_read_buffer *status_buffer;
+        struct fc_els_flogi *plogi;
 
-        zfcp_fc_incoming_wwpn(req, els_plogi->serv_param.wwpn);
+        status_buffer = (struct fsf_status_read_buffer *) req->data;
+        plogi = (struct fc_els_flogi *) status_buffer->payload.data;
+        zfcp_fc_incoming_wwpn(req, plogi->fl_wwpn);
 }
 
 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req *req)
 {
         struct fsf_status_read_buffer *status_buffer =
                 (struct fsf_status_read_buffer *)req->data;
-        struct fcp_logo *els_logo =
-                (struct fcp_logo *) status_buffer->payload.data;
+        struct fc_els_logo *logo =
+                (struct fc_els_logo *) status_buffer->payload.data;
 
-        zfcp_fc_incoming_wwpn(req, els_logo->nport_wwpn);
+        zfcp_fc_incoming_wwpn(req, logo->fl_n_port_wwn);
 }
 
 /**
@@ -233,11 +230,11 @@ void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req)
         unsigned int els_type = status_buffer->payload.data[0];
 
         zfcp_dbf_san_incoming_els(fsf_req);
-        if (els_type == LS_PLOGI)
+        if (els_type == ELS_PLOGI)
                 zfcp_fc_incoming_plogi(fsf_req);
-        else if (els_type == LS_LOGO)
+        else if (els_type == ELS_LOGO)
                 zfcp_fc_incoming_logo(fsf_req);
-        else if (els_type == LS_RSCN)
+        else if (els_type == ELS_RSCN)
                 zfcp_fc_incoming_rscn(fsf_req);
 }
 
@@ -379,33 +376,36 @@ void zfcp_fc_trigger_did_lookup(struct zfcp_port *port)
  *
  * Evaluate PLOGI playload and copy important fields into zfcp_port structure
  */
-void zfcp_fc_plogi_evaluate(struct zfcp_port *port, struct fsf_plogi *plogi)
-{
-        port->maxframe_size = plogi->serv_param.common_serv_param[7] |
-                ((plogi->serv_param.common_serv_param[6] & 0x0F) << 8);
-        if (plogi->serv_param.class1_serv_param[0] & 0x80)
+void zfcp_fc_plogi_evaluate(struct zfcp_port *port, struct fc_els_flogi *plogi)
+{
+        if (plogi->fl_wwpn != port->wwpn) {
+                port->d_id = 0;
+                dev_warn(&port->adapter->ccw_device->dev,
+                         "A port opened with WWPN 0x%016Lx returned data that "
+                         "identifies it as WWPN 0x%016Lx\n",
+                         (unsigned long long) port->wwpn,
+                         (unsigned long long) plogi->fl_wwpn);
+                return;
+        }
+
+        port->wwnn = plogi->fl_wwnn;
+        port->maxframe_size = plogi->fl_csp.sp_bb_data;
+
+        if (plogi->fl_cssp[0].cp_class & FC_CPC_VALID)
                 port->supported_classes |= FC_COS_CLASS1;
-        if (plogi->serv_param.class2_serv_param[0] & 0x80)
+        if (plogi->fl_cssp[1].cp_class & FC_CPC_VALID)
                 port->supported_classes |= FC_COS_CLASS2;
-        if (plogi->serv_param.class3_serv_param[0] & 0x80)
+        if (plogi->fl_cssp[2].cp_class & FC_CPC_VALID)
                 port->supported_classes |= FC_COS_CLASS3;
-        if (plogi->serv_param.class4_serv_param[0] & 0x80)
+        if (plogi->fl_cssp[3].cp_class & FC_CPC_VALID)
                 port->supported_classes |= FC_COS_CLASS4;
 }
 
-struct zfcp_els_adisc {
-        struct zfcp_send_els els;
-        struct scatterlist req;
-        struct scatterlist resp;
-        struct zfcp_ls_adisc ls_adisc;
-        struct zfcp_ls_adisc ls_adisc_acc;
-};
-
 static void zfcp_fc_adisc_handler(unsigned long data)
 {
-        struct zfcp_els_adisc *adisc = (struct zfcp_els_adisc *) data;
+        struct zfcp_fc_els_adisc *adisc = (struct zfcp_fc_els_adisc *) data;
         struct zfcp_port *port = adisc->els.port;
-        struct zfcp_ls_adisc *ls_adisc = &adisc->ls_adisc_acc;
+        struct fc_els_adisc *adisc_resp = &adisc->adisc_resp;
 
         if (adisc->els.status) {
                 /* request rejected or timed out */
@@ -415,9 +415,9 @@ static void zfcp_fc_adisc_handler(unsigned long data)
         }
 
         if (!port->wwnn)
-                port->wwnn = ls_adisc->wwnn;
+                port->wwnn = adisc_resp->adisc_wwnn;
 
-        if ((port->wwpn != ls_adisc->wwpn) ||
+        if ((port->wwpn != adisc_resp->adisc_wwpn) ||
             !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)) {
                 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
                                      "fcadh_2", NULL);
@@ -434,32 +434,33 @@ static void zfcp_fc_adisc_handler(unsigned long data)
 
 static int zfcp_fc_adisc(struct zfcp_port *port)
 {
-        struct zfcp_els_adisc *adisc;
+        struct zfcp_fc_els_adisc *adisc;
         struct zfcp_adapter *adapter = port->adapter;
 
-        adisc = kzalloc(sizeof(struct zfcp_els_adisc), GFP_ATOMIC);
+        adisc = kzalloc(sizeof(struct zfcp_fc_els_adisc), GFP_ATOMIC);
         if (!adisc)
                 return -ENOMEM;
 
         adisc->els.req = &adisc->req;
         adisc->els.resp = &adisc->resp;
-        sg_init_one(adisc->els.req, &adisc->ls_adisc,
-                    sizeof(struct zfcp_ls_adisc));
-        sg_init_one(adisc->els.resp, &adisc->ls_adisc_acc,
-                    sizeof(struct zfcp_ls_adisc));
+        sg_init_one(adisc->els.req, &adisc->adisc_req,
+                    sizeof(struct fc_els_adisc));
+        sg_init_one(adisc->els.resp, &adisc->adisc_resp,
+                    sizeof(struct fc_els_adisc));
 
         adisc->els.adapter = adapter;
         adisc->els.port = port;
         adisc->els.d_id = port->d_id;
         adisc->els.handler = zfcp_fc_adisc_handler;
         adisc->els.handler_data = (unsigned long) adisc;
-        adisc->els.ls_code = adisc->ls_adisc.code = ZFCP_LS_ADISC;
+        adisc->els.ls_code = adisc->adisc_req.adisc_cmd = ELS_ADISC;
 
         /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
            without FC-AL-2 capability, so we don't set it */
-        adisc->ls_adisc.wwpn = fc_host_port_name(adapter->scsi_host);
-        adisc->ls_adisc.wwnn = fc_host_node_name(adapter->scsi_host);
-        adisc->ls_adisc.nport_id = fc_host_port_id(adapter->scsi_host);
+        adisc->adisc_req.adisc_wwpn = fc_host_port_name(adapter->scsi_host);
+        adisc->adisc_req.adisc_wwnn = fc_host_node_name(adapter->scsi_host);
+        hton24(adisc->adisc_req.adisc_port_id,
+               fc_host_port_id(adapter->scsi_host));
 
         return zfcp_fsf_send_els(&adisc->els);
 }