Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial
[linux-3.10.git] / drivers / scsi / libfc / fc_lport.c
index 6486ae4..74338c8 100644 (file)
@@ -94,6 +94,9 @@
 
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
+#include <linux/scatterlist.h>
+
+#include "fc_libfc.h"
 
 /* Fabric IDs to use for point-to-point mode, chosen on whims. */
 #define FC_LOCAL_PTP_FID_LO   0x010101
@@ -106,8 +109,7 @@ static void fc_lport_error(struct fc_lport *, struct fc_frame *);
 static void fc_lport_enter_reset(struct fc_lport *);
 static void fc_lport_enter_flogi(struct fc_lport *);
 static void fc_lport_enter_dns(struct fc_lport *);
-static void fc_lport_enter_rpn_id(struct fc_lport *);
-static void fc_lport_enter_rft_id(struct fc_lport *);
+static void fc_lport_enter_ns(struct fc_lport *, enum fc_lport_state);
 static void fc_lport_enter_scr(struct fc_lport *);
 static void fc_lport_enter_ready(struct fc_lport *);
 static void fc_lport_enter_logo(struct fc_lport *);
@@ -116,14 +118,40 @@ static const char *fc_lport_state_names[] = {
        [LPORT_ST_DISABLED] = "disabled",
        [LPORT_ST_FLOGI] =    "FLOGI",
        [LPORT_ST_DNS] =      "dNS",
-       [LPORT_ST_RPN_ID] =   "RPN_ID",
+       [LPORT_ST_RNN_ID] =   "RNN_ID",
+       [LPORT_ST_RSNN_NN] =  "RSNN_NN",
+       [LPORT_ST_RSPN_ID] =  "RSPN_ID",
        [LPORT_ST_RFT_ID] =   "RFT_ID",
+       [LPORT_ST_RFF_ID] =   "RFF_ID",
        [LPORT_ST_SCR] =      "SCR",
        [LPORT_ST_READY] =    "Ready",
        [LPORT_ST_LOGO] =     "LOGO",
        [LPORT_ST_RESET] =    "reset",
 };
 
+/**
+ * struct fc_bsg_info - FC Passthrough managemet structure
+ * @job:      The passthrough job
+ * @lport:    The local port to pass through a command
+ * @rsp_code: The expected response code
+ * @sg:              job->reply_payload.sg_list
+ * @nents:    job->reply_payload.sg_cnt
+ * @offset:   The offset into the response data
+ */
+struct fc_bsg_info {
+       struct fc_bsg_job *job;
+       struct fc_lport *lport;
+       u16 rsp_code;
+       struct scatterlist *sg;
+       u32 nents;
+       size_t offset;
+};
+
+/**
+ * fc_frame_drop() - Dummy frame handler
+ * @lport: The local port the frame was received on
+ * @fp:           The received frame
+ */
 static int fc_frame_drop(struct fc_lport *lport, struct fc_frame *fp)
 {
        fc_frame_free(fp);
@@ -150,8 +178,8 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
        switch (event) {
        case RPORT_EV_READY:
                if (lport->state == LPORT_ST_DNS) {
-                       lport->dns_rp = rdata;
-                       fc_lport_enter_rpn_id(lport);
+                       lport->dns_rdata = rdata;
+                       fc_lport_enter_ns(lport, LPORT_ST_RNN_ID);
                } else {
                        FC_LPORT_DBG(lport, "Received an READY event "
                                     "on port (%6x) for the directory "
@@ -165,7 +193,7 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
        case RPORT_EV_LOGO:
        case RPORT_EV_FAILED:
        case RPORT_EV_STOP:
-               lport->dns_rp = NULL;
+               lport->dns_rdata = NULL;
                break;
        case RPORT_EV_NONE:
                break;
@@ -189,8 +217,8 @@ static const char *fc_lport_state(struct fc_lport *lport)
 
 /**
  * fc_lport_ptp_setup() - Create an rport for point-to-point mode
- * @lport: The lport to attach the ptp rport to
- * @fid: The FID of the ptp rport
+ * @lport:      The lport to attach the ptp rport to
+ * @remote_fid:         The FID of the ptp rport
  * @remote_wwpn: The WWPN of the ptp rport
  * @remote_wwnn: The WWNN of the ptp rport
  */
@@ -199,18 +227,22 @@ static void fc_lport_ptp_setup(struct fc_lport *lport,
                               u64 remote_wwnn)
 {
        mutex_lock(&lport->disc.disc_mutex);
-       if (lport->ptp_rp)
-               lport->tt.rport_logoff(lport->ptp_rp);
-       lport->ptp_rp = lport->tt.rport_create(lport, remote_fid);
-       lport->ptp_rp->ids.port_name = remote_wwpn;
-       lport->ptp_rp->ids.node_name = remote_wwnn;
+       if (lport->ptp_rdata)
+               lport->tt.rport_logoff(lport->ptp_rdata);
+       lport->ptp_rdata = lport->tt.rport_create(lport, remote_fid);
+       lport->ptp_rdata->ids.port_name = remote_wwpn;
+       lport->ptp_rdata->ids.node_name = remote_wwnn;
        mutex_unlock(&lport->disc.disc_mutex);
 
-       lport->tt.rport_login(lport->ptp_rp);
+       lport->tt.rport_login(lport->ptp_rdata);
 
        fc_lport_enter_ready(lport);
 }
 
+/**
+ * fc_get_host_port_type() - Return the port type of the given Scsi_Host
+ * @shost: The SCSI host whose port type is to be determined
+ */
 void fc_get_host_port_type(struct Scsi_Host *shost)
 {
        /* TODO - currently just NPORT */
@@ -218,17 +250,33 @@ void fc_get_host_port_type(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(fc_get_host_port_type);
 
+/**
+ * fc_get_host_port_state() - Return the port state of the given Scsi_Host
+ * @shost:  The SCSI host whose port state is to be determined
+ */
 void fc_get_host_port_state(struct Scsi_Host *shost)
 {
-       struct fc_lport *lp = shost_priv(shost);
+       struct fc_lport *lport = shost_priv(shost);
 
-       if (lp->link_up)
-               fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
+       mutex_lock(&lport->lp_mutex);
+       if (!lport->link_up)
+               fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
        else
-               fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
+               switch (lport->state) {
+               case LPORT_ST_READY:
+                       fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
+                       break;
+               default:
+                       fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
+               }
+       mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_get_host_port_state);
 
+/**
+ * fc_get_host_speed() - Return the speed of the given Scsi_Host
+ * @shost: The SCSI host whose port speed is to be determined
+ */
 void fc_get_host_speed(struct Scsi_Host *shost)
 {
        struct fc_lport *lport = shost_priv(shost);
@@ -237,24 +285,28 @@ void fc_get_host_speed(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(fc_get_host_speed);
 
+/**
+ * fc_get_host_stats() - Return the Scsi_Host's statistics
+ * @shost: The SCSI host whose statistics are to be returned
+ */
 struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
 {
        struct fc_host_statistics *fcoe_stats;
-       struct fc_lport *lp = shost_priv(shost);
+       struct fc_lport *lport = shost_priv(shost);
        struct timespec v0, v1;
        unsigned int cpu;
 
-       fcoe_stats = &lp->host_stats;
+       fcoe_stats = &lport->host_stats;
        memset(fcoe_stats, 0, sizeof(struct fc_host_statistics));
 
        jiffies_to_timespec(jiffies, &v0);
-       jiffies_to_timespec(lp->boot_time, &v1);
+       jiffies_to_timespec(lport->boot_time, &v1);
        fcoe_stats->seconds_since_last_reset = (v0.tv_sec - v1.tv_sec);
 
        for_each_possible_cpu(cpu) {
                struct fcoe_dev_stats *stats;
 
-               stats = per_cpu_ptr(lp->dev_stats, cpu);
+               stats = per_cpu_ptr(lport->dev_stats, cpu);
 
                fcoe_stats->tx_frames += stats->TxFrames;
                fcoe_stats->tx_words += stats->TxWords;
@@ -279,12 +331,15 @@ struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(fc_get_host_stats);
 
-/*
- * Fill in FLOGI command for request.
+/**
+ * fc_lport_flogi_fill() - Fill in FLOGI command for request
+ * @lport: The local port the FLOGI is for
+ * @flogi: The FLOGI command
+ * @op:           The opcode
  */
-static void
-fc_lport_flogi_fill(struct fc_lport *lport, struct fc_els_flogi *flogi,
-                   unsigned int op)
+static void fc_lport_flogi_fill(struct fc_lport *lport,
+                               struct fc_els_flogi *flogi,
+                               unsigned int op)
 {
        struct fc_els_csp *sp;
        struct fc_els_cssp *cp;
@@ -312,8 +367,10 @@ fc_lport_flogi_fill(struct fc_lport *lport, struct fc_els_flogi *flogi,
        }
 }
 
-/*
- * Add a supported FC-4 type.
+/**
+ * fc_lport_add_fc4_type() - Add a supported FC-4 type to a local port
+ * @lport: The local port to add a new FC-4 type to
+ * @type:  The new FC-4 type
  */
 static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
 {
@@ -325,11 +382,11 @@ static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
 
 /**
  * fc_lport_recv_rlir_req() - Handle received Registered Link Incident Report.
+ * @sp:           The sequence in the RLIR exchange
+ * @fp:           The RLIR request frame
  * @lport: Fibre Channel local port recieving the RLIR
- * @sp: current sequence in the RLIR exchange
- * @fp: RLIR request frame
  *
- * Locking Note: The lport lock is exected to be held before calling
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
@@ -344,11 +401,11 @@ static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
 
 /**
  * fc_lport_recv_echo_req() - Handle received ECHO request
- * @lport: Fibre Channel local port recieving the ECHO
- * @sp: current sequence in the ECHO exchange
- * @fp: ECHO request frame
+ * @sp:           The sequence in the ECHO exchange
+ * @fp:           ECHO request frame
+ * @lport: The local port recieving the ECHO
  *
- * Locking Note: The lport lock is exected to be held before calling
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
@@ -361,7 +418,7 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
        void *dp;
        u32 f_ctl;
 
-       FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n",
+       FC_LPORT_DBG(lport, "Received ECHO request while in state %s\n",
                     fc_lport_state(lport));
 
        len = fr_len(in_fp) - sizeof(struct fc_frame_header);
@@ -374,7 +431,7 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
        if (fp) {
                dp = fc_frame_payload_get(fp, len);
                memcpy(dp, pp, len);
-               *((u32 *)dp) = htonl(ELS_LS_ACC << 24);
+               *((__be32 *)dp) = htonl(ELS_LS_ACC << 24);
                sp = lport->tt.seq_start_next(sp);
                f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
                fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
@@ -385,12 +442,12 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
 }
 
 /**
- * fc_lport_recv_echo_req() - Handle received Request Node ID data request
- * @lport: Fibre Channel local port recieving the RNID
- * @sp: current sequence in the RNID exchange
- * @fp: RNID request frame
+ * fc_lport_recv_rnid_req() - Handle received Request Node ID data request
+ * @sp:           The sequence in the RNID exchange
+ * @fp:           The RNID request frame
+ * @lport: The local port recieving the RNID
  *
- * Locking Note: The lport lock is exected to be held before calling
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
@@ -453,9 +510,9 @@ static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
 
 /**
  * fc_lport_recv_logo_req() - Handle received fabric LOGO request
- * @lport: Fibre Channel local port recieving the LOGO
- * @sp: current sequence in the LOGO exchange
- * @fp: LOGO request frame
+ * @sp:           The sequence in the LOGO exchange
+ * @fp:           The LOGO request frame
+ * @lport: The local port recieving the LOGO
  *
  * Locking Note: The lport lock is exected to be held before calling
  * this function.
@@ -470,7 +527,7 @@ static void fc_lport_recv_logo_req(struct fc_seq *sp, struct fc_frame *fp,
 
 /**
  * fc_fabric_login() - Start the lport state machine
- * @lport: The lport that should log into the fabric
+ * @lport: The local port that should log into the fabric
  *
  * Locking Note: This function should not be called
  *              with the lport lock held.
@@ -491,47 +548,69 @@ int fc_fabric_login(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_fabric_login);
 
 /**
- * fc_linkup() - Handler for transport linkup events
+ * __fc_linkup() - Handler for transport linkup events
  * @lport: The lport whose link is up
+ *
+ * Locking: must be called with the lp_mutex held
  */
-void fc_linkup(struct fc_lport *lport)
+void __fc_linkup(struct fc_lport *lport)
 {
-       printk(KERN_INFO "libfc: Link up on port (%6x)\n",
-              fc_host_port_id(lport->host));
-
-       mutex_lock(&lport->lp_mutex);
        if (!lport->link_up) {
                lport->link_up = 1;
 
                if (lport->state == LPORT_ST_RESET)
                        fc_lport_enter_flogi(lport);
        }
+}
+
+/**
+ * fc_linkup() - Handler for transport linkup events
+ * @lport: The local port whose link is up
+ */
+void fc_linkup(struct fc_lport *lport)
+{
+       printk(KERN_INFO "host%d: libfc: Link up on port (%6x)\n",
+              lport->host->host_no, fc_host_port_id(lport->host));
+
+       mutex_lock(&lport->lp_mutex);
+       __fc_linkup(lport);
        mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_linkup);
 
 /**
- * fc_linkdown() - Handler for transport linkdown events
+ * __fc_linkdown() - Handler for transport linkdown events
  * @lport: The lport whose link is down
+ *
+ * Locking: must be called with the lp_mutex held
  */
-void fc_linkdown(struct fc_lport *lport)
+void __fc_linkdown(struct fc_lport *lport)
 {
-       mutex_lock(&lport->lp_mutex);
-       printk(KERN_INFO "libfc: Link down on port (%6x)\n",
-              fc_host_port_id(lport->host));
-
        if (lport->link_up) {
                lport->link_up = 0;
                fc_lport_enter_reset(lport);
                lport->tt.fcp_cleanup(lport);
        }
+}
+
+/**
+ * fc_linkdown() - Handler for transport linkdown events
+ * @lport: The local port whose link is down
+ */
+void fc_linkdown(struct fc_lport *lport)
+{
+       printk(KERN_INFO "host%d: libfc: Link down on port (%6x)\n",
+              lport->host->host_no, fc_host_port_id(lport->host));
+
+       mutex_lock(&lport->lp_mutex);
+       __fc_linkdown(lport);
        mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_linkdown);
 
 /**
  * fc_fabric_logoff() - Logout of the fabric
- * @lport:           fc_lport pointer to logoff the fabric
+ * @lport: The local port to logoff the fabric
  *
  * Return value:
  *     0 for success, -1 for failure
@@ -540,8 +619,8 @@ int fc_fabric_logoff(struct fc_lport *lport)
 {
        lport->tt.disc_stop_final(lport);
        mutex_lock(&lport->lp_mutex);
-       if (lport->dns_rp)
-               lport->tt.rport_logoff(lport->dns_rp);
+       if (lport->dns_rdata)
+               lport->tt.rport_logoff(lport->dns_rdata);
        mutex_unlock(&lport->lp_mutex);
        lport->tt.rport_flush_queue();
        mutex_lock(&lport->lp_mutex);
@@ -553,11 +632,9 @@ int fc_fabric_logoff(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_fabric_logoff);
 
 /**
- * fc_lport_destroy() - unregister a fc_lport
- * @lport:           fc_lport pointer to unregister
+ * fc_lport_destroy() - Unregister a fc_lport
+ * @lport: The local port to unregister
  *
- * Return value:
- *     None
  * Note:
  * exit routine for fc_lport instance
  * clean-up all the allocated memory
@@ -580,13 +657,9 @@ int fc_lport_destroy(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_lport_destroy);
 
 /**
- * fc_set_mfs() - sets up the mfs for the corresponding fc_lport
- * @lport: fc_lport pointer to unregister
- * @mfs: the new mfs for fc_lport
- *
- * Set mfs for the given fc_lport to the new mfs.
- *
- * Return: 0 for success
+ * fc_set_mfs() - Set the maximum frame size for a local port
+ * @lport: The local port to set the MFS for
+ * @mfs:   The new MFS
  */
 int fc_set_mfs(struct fc_lport *lport, u32 mfs)
 {
@@ -617,7 +690,7 @@ EXPORT_SYMBOL(fc_set_mfs);
 
 /**
  * fc_lport_disc_callback() - Callback for discovery events
- * @lport: FC local port
+ * @lport: The local port receiving the event
  * @event: The discovery event
  */
 void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
@@ -627,8 +700,9 @@ void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
                FC_LPORT_DBG(lport, "Discovery succeeded\n");
                break;
        case DISC_EV_FAILED:
-               printk(KERN_ERR "libfc: Discovery failed for port (%6x)\n",
-                      fc_host_port_id(lport->host));
+               printk(KERN_ERR "host%d: libfc: "
+                      "Discovery failed for port (%6x)\n",
+                      lport->host->host_no, fc_host_port_id(lport->host));
                mutex_lock(&lport->lp_mutex);
                fc_lport_enter_reset(lport);
                mutex_unlock(&lport->lp_mutex);
@@ -641,7 +715,7 @@ void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
 
 /**
  * fc_rport_enter_ready() - Enter the ready state and start discovery
- * @lport: Fibre Channel local port that is ready
+ * @lport: The local port that is ready
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -652,22 +726,46 @@ static void fc_lport_enter_ready(struct fc_lport *lport)
                     fc_lport_state(lport));
 
        fc_lport_state_enter(lport, LPORT_ST_READY);
+       if (lport->vport)
+               fc_vport_set_state(lport->vport, FC_VPORT_ACTIVE);
+       fc_vports_linkchange(lport);
 
-       if (!lport->ptp_rp)
+       if (!lport->ptp_rdata)
                lport->tt.disc_start(fc_lport_disc_callback, lport);
 }
 
 /**
+ * fc_lport_set_port_id() - set the local port Port ID
+ * @lport: The local port which will have its Port ID set.
+ * @port_id: The new port ID.
+ * @fp: The frame containing the incoming request, or NULL.
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this function.
+ */
+static void fc_lport_set_port_id(struct fc_lport *lport, u32 port_id,
+                                struct fc_frame *fp)
+{
+       if (port_id)
+               printk(KERN_INFO "host%d: Assigned Port ID %6x\n",
+                      lport->host->host_no, port_id);
+
+       fc_host_port_id(lport->host) = port_id;
+       if (lport->tt.lport_set_port_id)
+               lport->tt.lport_set_port_id(lport, port_id, fp);
+}
+
+/**
  * fc_lport_recv_flogi_req() - Receive a FLOGI request
  * @sp_in: The sequence the FLOGI is on
- * @rx_fp: The frame the FLOGI is in
- * @lport: The lport that recieved the request
+ * @rx_fp: The FLOGI frame
+ * @lport: The local port that recieved the request
  *
  * A received FLOGI request indicates a point-to-point connection.
  * Accept it with the common service parameters indicating our N port.
  * Set up to do a PLOGI if we have the higher-number WWPN.
  *
- * Locking Note: The lport lock is exected to be held before calling
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
@@ -695,8 +793,9 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
                goto out;
        remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);
        if (remote_wwpn == lport->wwpn) {
-               printk(KERN_WARNING "libfc: Received FLOGI from port "
-                      "with same WWPN %llx\n", remote_wwpn);
+               printk(KERN_WARNING "host%d: libfc: Received FLOGI from port "
+                      "with same WWPN %llx\n",
+                      lport->host->host_no, remote_wwpn);
                goto out;
        }
        FC_LPORT_DBG(lport, "FLOGI from port WWPN %llx\n", remote_wwpn);
@@ -715,7 +814,7 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
                remote_fid = FC_LOCAL_PTP_FID_HI;
        }
 
-       fc_host_port_id(lport->host) = local_fid;
+       fc_lport_set_port_id(lport, local_fid, rx_fp);
 
        fp = fc_frame_alloc(lport, sizeof(*flp));
        if (fp) {
@@ -747,9 +846,9 @@ out:
 
 /**
  * fc_lport_recv_req() - The generic lport request handler
- * @lport: The lport that received the request
- * @sp: The sequence the request is on
- * @fp: The frame the request is in
+ * @lport: The local port that received the request
+ * @sp:           The sequence the request is on
+ * @fp:           The request frame
  *
  * This function will see if the lport handles the request or
  * if an rport should handle the request.
@@ -817,8 +916,8 @@ static void fc_lport_recv_req(struct fc_lport *lport, struct fc_seq *sp,
 }
 
 /**
- * fc_lport_reset() - Reset an lport
- * @lport: The lport which should be reset
+ * fc_lport_reset() - Reset a local port
+ * @lport: The local port which should be reset
  *
  * Locking Note: This functions should not be called with the
  *              lport lock held.
@@ -834,29 +933,31 @@ int fc_lport_reset(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_lport_reset);
 
 /**
- * fc_lport_reset_locked() - Reset the local port
- * @lport: Fibre Channel local port to be reset
+ * fc_lport_reset_locked() - Reset the local port w/ the lport lock held
+ * @lport: The local port to be reset
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
  */
 static void fc_lport_reset_locked(struct fc_lport *lport)
 {
-       if (lport->dns_rp)
-               lport->tt.rport_logoff(lport->dns_rp);
+       if (lport->dns_rdata)
+               lport->tt.rport_logoff(lport->dns_rdata);
 
-       lport->ptp_rp = NULL;
+       lport->ptp_rdata = NULL;
 
        lport->tt.disc_stop(lport);
 
        lport->tt.exch_mgr_reset(lport, 0, 0);
        fc_host_fabric_name(lport->host) = 0;
-       fc_host_port_id(lport->host) = 0;
+
+       if (fc_host_port_id(lport->host))
+               fc_lport_set_port_id(lport, 0, NULL);
 }
 
 /**
  * fc_lport_enter_reset() - Reset the local port
- * @lport: Fibre Channel local port to be reset
+ * @lport: The local port to be reset
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -866,15 +967,22 @@ static void fc_lport_enter_reset(struct fc_lport *lport)
        FC_LPORT_DBG(lport, "Entered RESET state from %s state\n",
                     fc_lport_state(lport));
 
+       if (lport->vport) {
+               if (lport->link_up)
+                       fc_vport_set_state(lport->vport, FC_VPORT_INITIALIZING);
+               else
+                       fc_vport_set_state(lport->vport, FC_VPORT_LINKDOWN);
+       }
        fc_lport_state_enter(lport, LPORT_ST_RESET);
+       fc_vports_linkchange(lport);
        fc_lport_reset_locked(lport);
        if (lport->link_up)
                fc_lport_enter_flogi(lport);
 }
 
 /**
- * fc_lport_enter_disabled() - disable the local port
- * @lport: Fibre Channel local port to be reset
+ * fc_lport_enter_disabled() - Disable the local port
+ * @lport: The local port to be reset
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -885,13 +993,14 @@ static void fc_lport_enter_disabled(struct fc_lport *lport)
                     fc_lport_state(lport));
 
        fc_lport_state_enter(lport, LPORT_ST_DISABLED);
+       fc_vports_linkchange(lport);
        fc_lport_reset_locked(lport);
 }
 
 /**
  * fc_lport_error() - Handler for any errors
- * @lport: The fc_lport object
- * @fp: The frame pointer
+ * @lport: The local port that the error was on
+ * @fp:           The error code encoded in a frame pointer
  *
  * If the error was caused by a resource allocation failure
  * then wait for half a second and retry, otherwise retry
@@ -922,8 +1031,11 @@ static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
                        case LPORT_ST_DISABLED:
                        case LPORT_ST_READY:
                        case LPORT_ST_RESET:
-                       case LPORT_ST_RPN_ID:
+                       case LPORT_ST_RNN_ID:
+                       case LPORT_ST_RSNN_NN:
+                       case LPORT_ST_RSPN_ID:
                        case LPORT_ST_RFT_ID:
+                       case LPORT_ST_RFF_ID:
                        case LPORT_ST_SCR:
                        case LPORT_ST_DNS:
                        case LPORT_ST_FLOGI:
@@ -936,33 +1048,33 @@ static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
 }
 
 /**
- * fc_lport_rft_id_resp() - Handle response to Register Fibre
- *                         Channel Types by ID (RPN_ID) request
- * @sp: current sequence in RPN_ID exchange
- * @fp: response frame
+ * fc_lport_ns_resp() - Handle response to a name server
+ *                     registration exchange
+ * @sp:            current sequence in exchange
+ * @fp:            response frame
  * @lp_arg: Fibre Channel host port instance
  *
  * Locking Note: This function will be called without the lport lock
- * held, but it will lock, call an _enter_* function or fc_lport_error
+ * held, but it will lock, call an _enter_* function or fc_lport_error()
  * and then unlock the lport.
  */
-static void fc_lport_rft_id_resp(struct fc_seq *sp, struct fc_frame *fp,
-                                void *lp_arg)
+static void fc_lport_ns_resp(struct fc_seq *sp, struct fc_frame *fp,
+                            void *lp_arg)
 {
        struct fc_lport *lport = lp_arg;
        struct fc_frame_header *fh;
        struct fc_ct_hdr *ct;
 
-       FC_LPORT_DBG(lport, "Received a RFT_ID %s\n", fc_els_resp_type(fp));
+       FC_LPORT_DBG(lport, "Received a ns %s\n", fc_els_resp_type(fp));
 
        if (fp == ERR_PTR(-FC_EX_CLOSED))
                return;
 
        mutex_lock(&lport->lp_mutex);
 
-       if (lport->state != LPORT_ST_RFT_ID) {
-               FC_LPORT_DBG(lport, "Received a RFT_ID response, but in state "
-                            "%s\n", fc_lport_state(lport));
+       if (lport->state < LPORT_ST_RNN_ID || lport->state > LPORT_ST_RFF_ID) {
+               FC_LPORT_DBG(lport, "Received a name server response, "
+                            "but in state %s\n", fc_lport_state(lport));
                if (IS_ERR(fp))
                        goto err;
                goto out;
@@ -980,63 +1092,28 @@ static void fc_lport_rft_id_resp(struct fc_seq *sp, struct fc_frame *fp,
            ct->ct_fs_type == FC_FST_DIR &&
            ct->ct_fs_subtype == FC_NS_SUBTYPE &&
            ntohs(ct->ct_cmd) == FC_FS_ACC)
-               fc_lport_enter_scr(lport);
-       else
-               fc_lport_error(lport, fp);
-out:
-       fc_frame_free(fp);
-err:
-       mutex_unlock(&lport->lp_mutex);
-}
-
-/**
- * fc_lport_rpn_id_resp() - Handle response to Register Port
- *                         Name by ID (RPN_ID) request
- * @sp: current sequence in RPN_ID exchange
- * @fp: response frame
- * @lp_arg: Fibre Channel host port instance
- *
- * Locking Note: This function will be called without the lport lock
- * held, but it will lock, call an _enter_* function or fc_lport_error
- * and then unlock the lport.
- */
-static void fc_lport_rpn_id_resp(struct fc_seq *sp, struct fc_frame *fp,
-                                void *lp_arg)
-{
-       struct fc_lport *lport = lp_arg;
-       struct fc_frame_header *fh;
-       struct fc_ct_hdr *ct;
-
-       FC_LPORT_DBG(lport, "Received a RPN_ID %s\n", fc_els_resp_type(fp));
-
-       if (fp == ERR_PTR(-FC_EX_CLOSED))
-               return;
-
-       mutex_lock(&lport->lp_mutex);
-
-       if (lport->state != LPORT_ST_RPN_ID) {
-               FC_LPORT_DBG(lport, "Received a RPN_ID response, but in state "
-                            "%s\n", fc_lport_state(lport));
-               if (IS_ERR(fp))
-                       goto err;
-               goto out;
-       }
-
-       if (IS_ERR(fp)) {
-               fc_lport_error(lport, fp);
-               goto err;
-       }
-
-       fh = fc_frame_header_get(fp);
-       ct = fc_frame_payload_get(fp, sizeof(*ct));
-       if (fh && ct && fh->fh_type == FC_TYPE_CT &&
-           ct->ct_fs_type == FC_FST_DIR &&
-           ct->ct_fs_subtype == FC_NS_SUBTYPE &&
-           ntohs(ct->ct_cmd) == FC_FS_ACC)
-               fc_lport_enter_rft_id(lport);
+               switch (lport->state) {
+               case LPORT_ST_RNN_ID:
+                       fc_lport_enter_ns(lport, LPORT_ST_RSNN_NN);
+                       break;
+               case LPORT_ST_RSNN_NN:
+                       fc_lport_enter_ns(lport, LPORT_ST_RSPN_ID);
+                       break;
+               case LPORT_ST_RSPN_ID:
+                       fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
+                       break;
+               case LPORT_ST_RFT_ID:
+                       fc_lport_enter_ns(lport, LPORT_ST_RFF_ID);
+                       break;
+               case LPORT_ST_RFF_ID:
+                       fc_lport_enter_scr(lport);
+                       break;
+               default:
+                       /* should have already been caught by state checks */
+                       break;
+               }
        else
                fc_lport_error(lport, fp);
-
 out:
        fc_frame_free(fp);
 err:
@@ -1045,8 +1122,8 @@ err:
 
 /**
  * fc_lport_scr_resp() - Handle response to State Change Register (SCR) request
- * @sp: current sequence in SCR exchange
- * @fp: response frame
+ * @sp:            current sequence in SCR exchange
+ * @fp:            response frame
  * @lp_arg: Fibre Channel lport port instance that sent the registration request
  *
  * Locking Note: This function will be called without the lport lock
@@ -1092,8 +1169,8 @@ err:
 }
 
 /**
- * fc_lport_enter_scr() - Send a State Change Register (SCR) request
- * @lport: Fibre Channel local port to register for state changes
+ * fc_lport_enter_scr() - Send a SCR (State Change Register) request
+ * @lport: The local port to register for state changes
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -1114,78 +1191,74 @@ static void fc_lport_enter_scr(struct fc_lport *lport)
        }
 
        if (!lport->tt.elsct_send(lport, FC_FID_FCTRL, fp, ELS_SCR,
-                                 fc_lport_scr_resp, lport, lport->e_d_tov))
-               fc_lport_error(lport, fp);
+                                 fc_lport_scr_resp, lport,
+                                 2 * lport->r_a_tov))
+               fc_lport_error(lport, NULL);
 }
 
 /**
- * fc_lport_enter_rft_id() - Register FC4-types with the name server
+ * fc_lport_enter_ns() - register some object with the name server
  * @lport: Fibre Channel local port to register
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
  */
-static void fc_lport_enter_rft_id(struct fc_lport *lport)
+static void fc_lport_enter_ns(struct fc_lport *lport, enum fc_lport_state state)
 {
        struct fc_frame *fp;
-       struct fc_ns_fts *lps;
-       int i;
+       enum fc_ns_req cmd;
+       int size = sizeof(struct fc_ct_hdr);
+       size_t len;
 
-       FC_LPORT_DBG(lport, "Entered RFT_ID state from %s state\n",
+       FC_LPORT_DBG(lport, "Entered %s state from %s state\n",
+                    fc_lport_state_names[state],
                     fc_lport_state(lport));
 
-       fc_lport_state_enter(lport, LPORT_ST_RFT_ID);
-
-       lps = &lport->fcts;
-       i = sizeof(lps->ff_type_map) / sizeof(lps->ff_type_map[0]);
-       while (--i >= 0)
-               if (ntohl(lps->ff_type_map[i]) != 0)
-                       break;
-       if (i < 0) {
-               /* nothing to register, move on to SCR */
-               fc_lport_enter_scr(lport);
-               return;
-       }
+       fc_lport_state_enter(lport, state);
 
-       fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
-                           sizeof(struct fc_ns_rft));
-       if (!fp) {
-               fc_lport_error(lport, fp);
+       switch (state) {
+       case LPORT_ST_RNN_ID:
+               cmd = FC_NS_RNN_ID;
+               size += sizeof(struct fc_ns_rn_id);
+               break;
+       case LPORT_ST_RSNN_NN:
+               len = strnlen(fc_host_symbolic_name(lport->host), 255);
+               /* if there is no symbolic name, skip to RFT_ID */
+               if (!len)
+                       return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
+               cmd = FC_NS_RSNN_NN;
+               size += sizeof(struct fc_ns_rsnn) + len;
+               break;
+       case LPORT_ST_RSPN_ID:
+               len = strnlen(fc_host_symbolic_name(lport->host), 255);
+               /* if there is no symbolic name, skip to RFT_ID */
+               if (!len)
+                       return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
+               cmd = FC_NS_RSPN_ID;
+               size += sizeof(struct fc_ns_rspn) + len;
+               break;
+       case LPORT_ST_RFT_ID:
+               cmd = FC_NS_RFT_ID;
+               size += sizeof(struct fc_ns_rft);
+               break;
+       case LPORT_ST_RFF_ID:
+               cmd = FC_NS_RFF_ID;
+               size += sizeof(struct fc_ns_rff_id);
+               break;
+       default:
+               fc_lport_error(lport, NULL);
                return;
        }
 
-       if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RFT_ID,
-                                 fc_lport_rft_id_resp,
-                                 lport, lport->e_d_tov))
-               fc_lport_error(lport, fp);
-}
-
-/**
- * fc_rport_enter_rft_id() - Register port name with the name server
- * @lport: Fibre Channel local port to register
- *
- * Locking Note: The lport lock is expected to be held before calling
- * this routine.
- */
-static void fc_lport_enter_rpn_id(struct fc_lport *lport)
-{
-       struct fc_frame *fp;
-
-       FC_LPORT_DBG(lport, "Entered RPN_ID state from %s state\n",
-                    fc_lport_state(lport));
-
-       fc_lport_state_enter(lport, LPORT_ST_RPN_ID);
-
-       fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
-                           sizeof(struct fc_ns_rn_id));
+       fp = fc_frame_alloc(lport, size);
        if (!fp) {
                fc_lport_error(lport, fp);
                return;
        }
 
-       if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RPN_ID,
-                                 fc_lport_rpn_id_resp,
-                                 lport, lport->e_d_tov))
+       if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, cmd,
+                                 fc_lport_ns_resp,
+                                 lport, 3 * lport->r_a_tov))
                fc_lport_error(lport, fp);
 }
 
@@ -1194,8 +1267,8 @@ static struct fc_rport_operations fc_lport_rport_ops = {
 };
 
 /**
- * fc_rport_enter_dns() - Create a rport to the name server
- * @lport: Fibre Channel local port requesting a rport for the name server
+ * fc_rport_enter_dns() - Create a fc_rport for the name server
+ * @lport: The local port requesting a remote port for the name server
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -1224,8 +1297,8 @@ err:
 }
 
 /**
- * fc_lport_timeout() - Handler for the retry_work timer.
- * @work: The work struct of the fc_lport
+ * fc_lport_timeout() - Handler for the retry_work timer
+ * @work: The work struct of the local port
  */
 static void fc_lport_timeout(struct work_struct *work)
 {
@@ -1237,21 +1310,25 @@ static void fc_lport_timeout(struct work_struct *work)
 
        switch (lport->state) {
        case LPORT_ST_DISABLED:
+               WARN_ON(1);
+               break;
        case LPORT_ST_READY:
-       case LPORT_ST_RESET:
                WARN_ON(1);
                break;
+       case LPORT_ST_RESET:
+               break;
        case LPORT_ST_FLOGI:
                fc_lport_enter_flogi(lport);
                break;
        case LPORT_ST_DNS:
                fc_lport_enter_dns(lport);
                break;
-       case LPORT_ST_RPN_ID:
-               fc_lport_enter_rpn_id(lport);
-               break;
+       case LPORT_ST_RNN_ID:
+       case LPORT_ST_RSNN_NN:
+       case LPORT_ST_RSPN_ID:
        case LPORT_ST_RFT_ID:
-               fc_lport_enter_rft_id(lport);
+       case LPORT_ST_RFF_ID:
+               fc_lport_enter_ns(lport, lport->state);
                break;
        case LPORT_ST_SCR:
                fc_lport_enter_scr(lport);
@@ -1266,16 +1343,16 @@ static void fc_lport_timeout(struct work_struct *work)
 
 /**
  * fc_lport_logo_resp() - Handle response to LOGO request
- * @sp: current sequence in LOGO exchange
- * @fp: response frame
- * @lp_arg: Fibre Channel lport port instance that sent the LOGO request
+ * @sp:            The sequence that the LOGO was on
+ * @fp:            The LOGO frame
+ * @lp_arg: The lport port that received the LOGO request
  *
  * Locking Note: This function will be called without the lport lock
- * held, but it will lock, call an _enter_* function or fc_lport_error
+ * held, but it will lock, call an _enter_* function or fc_lport_error()
  * and then unlock the lport.
  */
-static void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
-                              void *lp_arg)
+void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
+                       void *lp_arg)
 {
        struct fc_lport *lport = lp_arg;
        u8 op;
@@ -1311,10 +1388,11 @@ out:
 err:
        mutex_unlock(&lport->lp_mutex);
 }
+EXPORT_SYMBOL(fc_lport_logo_resp);
 
 /**
  * fc_rport_enter_logo() - Logout of the fabric
- * @lport: Fibre Channel local port to be logged out
+ * @lport: The local port to be logged out
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -1328,6 +1406,7 @@ static void fc_lport_enter_logo(struct fc_lport *lport)
                     fc_lport_state(lport));
 
        fc_lport_state_enter(lport, LPORT_ST_LOGO);
+       fc_vports_linkchange(lport);
 
        fp = fc_frame_alloc(lport, sizeof(*logo));
        if (!fp) {
@@ -1336,22 +1415,23 @@ static void fc_lport_enter_logo(struct fc_lport *lport)
        }
 
        if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_LOGO,
-                                 fc_lport_logo_resp, lport, lport->e_d_tov))
-               fc_lport_error(lport, fp);
+                                 fc_lport_logo_resp, lport,
+                                 2 * lport->r_a_tov))
+               fc_lport_error(lport, NULL);
 }
 
 /**
  * fc_lport_flogi_resp() - Handle response to FLOGI request
- * @sp: current sequence in FLOGI exchange
- * @fp: response frame
- * @lp_arg: Fibre Channel lport port instance that sent the FLOGI request
+ * @sp:            The sequence that the FLOGI was on
+ * @fp:            The FLOGI response frame
+ * @lp_arg: The lport port that received the FLOGI response
  *
  * Locking Note: This function will be called without the lport lock
- * held, but it will lock, call an _enter_* function or fc_lport_error
+ * held, but it will lock, call an _enter_* function or fc_lport_error()
  * and then unlock the lport.
  */
-static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
-                               void *lp_arg)
+void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
+                        void *lp_arg)
 {
        struct fc_lport *lport = lp_arg;
        struct fc_frame_header *fh;
@@ -1385,11 +1465,6 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
        fh = fc_frame_header_get(fp);
        did = ntoh24(fh->fh_d_id);
        if (fc_frame_payload_op(fp) == ELS_LS_ACC && did != 0) {
-
-               printk(KERN_INFO "libfc: Assigned FID (%6x) in FLOGI response\n",
-                      did);
-               fc_host_port_id(lport->host) = did;
-
                flp = fc_frame_payload_get(fp, sizeof(*flp));
                if (flp) {
                        mfs = ntohs(flp->fl_csp.sp_bb_data) &
@@ -1402,12 +1477,18 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                        e_d_tov = ntohl(flp->fl_csp.sp_e_d_tov);
                        if (csp_flags & FC_SP_FT_EDTR)
                                e_d_tov /= 1000000;
+
+                       lport->npiv_enabled = !!(csp_flags & FC_SP_FT_NPIV_ACC);
+
                        if ((csp_flags & FC_SP_FT_FPORT) == 0) {
                                if (e_d_tov > lport->e_d_tov)
                                        lport->e_d_tov = e_d_tov;
                                lport->r_a_tov = 2 * e_d_tov;
-                               printk(KERN_INFO "libfc: Port (%6x) entered "
-                                      "point to point mode\n", did);
+                               fc_lport_set_port_id(lport, did, fp);
+                               printk(KERN_INFO "host%d: libfc: "
+                                      "Port (%6x) entered "
+                                      "point-to-point mode\n",
+                                      lport->host->host_no, did);
                                fc_lport_ptp_setup(lport, ntoh24(fh->fh_s_id),
                                                   get_unaligned_be64(
                                                           &flp->fl_wwpn),
@@ -1418,6 +1499,7 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                                lport->r_a_tov = r_a_tov;
                                fc_host_fabric_name(lport->host) =
                                        get_unaligned_be64(&flp->fl_wwnn);
+                               fc_lport_set_port_id(lport, did, fp);
                                fc_lport_enter_dns(lport);
                        }
                }
@@ -1430,6 +1512,7 @@ out:
 err:
        mutex_unlock(&lport->lp_mutex);
 }
+EXPORT_SYMBOL(fc_lport_flogi_resp);
 
 /**
  * fc_rport_enter_flogi() - Send a FLOGI request to the fabric manager
@@ -1451,12 +1534,18 @@ void fc_lport_enter_flogi(struct fc_lport *lport)
        if (!fp)
                return fc_lport_error(lport, fp);
 
-       if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_FLOGI,
-                                 fc_lport_flogi_resp, lport, lport->e_d_tov))
-               fc_lport_error(lport, fp);
+       if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp,
+                                 lport->vport ? ELS_FDISC : ELS_FLOGI,
+                                 fc_lport_flogi_resp, lport,
+                                 lport->vport ? 2 * lport->r_a_tov :
+                                 lport->e_d_tov))
+               fc_lport_error(lport, NULL);
 }
 
-/* Configure a fc_lport */
+/**
+ * fc_lport_config() - Configure a fc_lport
+ * @lport: The local port to be configured
+ */
 int fc_lport_config(struct fc_lport *lport)
 {
        INIT_DELAYED_WORK(&lport->retry_work, fc_lport_timeout);
@@ -1471,6 +1560,10 @@ int fc_lport_config(struct fc_lport *lport)
 }
 EXPORT_SYMBOL(fc_lport_config);
 
+/**
+ * fc_lport_init() - Initialize the lport layer for a local port
+ * @lport: The local port to initialize the exchange layer for
+ */
 int fc_lport_init(struct fc_lport *lport)
 {
        if (!lport->tt.lport_recv)
@@ -1500,7 +1593,253 @@ int fc_lport_init(struct fc_lport *lport)
        if (lport->link_supported_speeds & FC_PORTSPEED_10GBIT)
                fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_10GBIT;
 
-       INIT_LIST_HEAD(&lport->ema_list);
        return 0;
 }
 EXPORT_SYMBOL(fc_lport_init);
+
+/**
+ * fc_lport_bsg_resp() - The common response handler for FC Passthrough requests
+ * @sp:              The sequence for the FC Passthrough response
+ * @fp:              The response frame
+ * @info_arg: The BSG info that the response is for
+ */
+static void fc_lport_bsg_resp(struct fc_seq *sp, struct fc_frame *fp,
+                             void *info_arg)
+{
+       struct fc_bsg_info *info = info_arg;
+       struct fc_bsg_job *job = info->job;
+       struct fc_lport *lport = info->lport;
+       struct fc_frame_header *fh;
+       size_t len;
+       void *buf;
+
+       if (IS_ERR(fp)) {
+               job->reply->result = (PTR_ERR(fp) == -FC_EX_CLOSED) ?
+                       -ECONNABORTED : -ETIMEDOUT;
+               job->reply_len = sizeof(uint32_t);
+               job->state_flags |= FC_RQST_STATE_DONE;
+               job->job_done(job);
+               kfree(info);
+               return;
+       }
+
+       mutex_lock(&lport->lp_mutex);
+       fh = fc_frame_header_get(fp);
+       len = fr_len(fp) - sizeof(*fh);
+       buf = fc_frame_payload_get(fp, 0);
+
+       if (fr_sof(fp) == FC_SOF_I3 && !ntohs(fh->fh_seq_cnt)) {
+               /* Get the response code from the first frame payload */
+               unsigned short cmd = (info->rsp_code == FC_FS_ACC) ?
+                       ntohs(((struct fc_ct_hdr *)buf)->ct_cmd) :
+                       (unsigned short)fc_frame_payload_op(fp);
+
+               /* Save the reply status of the job */
+               job->reply->reply_data.ctels_reply.status =
+                       (cmd == info->rsp_code) ?
+                       FC_CTELS_STATUS_OK : FC_CTELS_STATUS_REJECT;
+       }
+
+       job->reply->reply_payload_rcv_len +=
+               fc_copy_buffer_to_sglist(buf, len, info->sg, &info->nents,
+                                        &info->offset, KM_BIO_SRC_IRQ, NULL);
+
+       if (fr_eof(fp) == FC_EOF_T &&
+           (ntoh24(fh->fh_f_ctl) & (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) ==
+           (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) {
+               if (job->reply->reply_payload_rcv_len >
+                   job->reply_payload.payload_len)
+                       job->reply->reply_payload_rcv_len =
+                               job->reply_payload.payload_len;
+               job->reply->result = 0;
+               job->state_flags |= FC_RQST_STATE_DONE;
+               job->job_done(job);
+               kfree(info);
+       }
+       fc_frame_free(fp);
+       mutex_unlock(&lport->lp_mutex);
+}
+
+/**
+ * fc_lport_els_request() - Send ELS passthrough request
+ * @job:   The BSG Passthrough job
+ * @lport: The local port sending the request
+ * @did:   The destination port id
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
+ */
+static int fc_lport_els_request(struct fc_bsg_job *job,
+                               struct fc_lport *lport,
+                               u32 did, u32 tov)
+{
+       struct fc_bsg_info *info;
+       struct fc_frame *fp;
+       struct fc_frame_header *fh;
+       char *pp;
+       int len;
+
+       fp = fc_frame_alloc(lport, job->request_payload.payload_len);
+       if (!fp)
+               return -ENOMEM;
+
+       len = job->request_payload.payload_len;
+       pp = fc_frame_payload_get(fp, len);
+
+       sg_copy_to_buffer(job->request_payload.sg_list,
+                         job->request_payload.sg_cnt,
+                         pp, len);
+
+       fh = fc_frame_header_get(fp);
+       fh->fh_r_ctl = FC_RCTL_ELS_REQ;
+       hton24(fh->fh_d_id, did);
+       hton24(fh->fh_s_id, fc_host_port_id(lport->host));
+       fh->fh_type = FC_TYPE_ELS;
+       hton24(fh->fh_f_ctl, FC_FC_FIRST_SEQ |
+              FC_FC_END_SEQ | FC_FC_SEQ_INIT);
+       fh->fh_cs_ctl = 0;
+       fh->fh_df_ctl = 0;
+       fh->fh_parm_offset = 0;
+
+       info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
+       if (!info) {
+               fc_frame_free(fp);
+               return -ENOMEM;
+       }
+
+       info->job = job;
+       info->lport = lport;
+       info->rsp_code = ELS_LS_ACC;
+       info->nents = job->reply_payload.sg_cnt;
+       info->sg = job->reply_payload.sg_list;
+
+       if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
+                                    NULL, info, tov))
+               return -ECOMM;
+       return 0;
+}
+
+/**
+ * fc_lport_ct_request() - Send CT Passthrough request
+ * @job:   The BSG Passthrough job
+ * @lport: The local port sending the request
+ * @did:   The destination FC-ID
+ * @tov:   The timeout period to wait for the response
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
+ */
+static int fc_lport_ct_request(struct fc_bsg_job *job,
+                              struct fc_lport *lport, u32 did, u32 tov)
+{
+       struct fc_bsg_info *info;
+       struct fc_frame *fp;
+       struct fc_frame_header *fh;
+       struct fc_ct_req *ct;
+       size_t len;
+
+       fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
+                           job->request_payload.payload_len);
+       if (!fp)
+               return -ENOMEM;
+
+       len = job->request_payload.payload_len;
+       ct = fc_frame_payload_get(fp, len);
+
+       sg_copy_to_buffer(job->request_payload.sg_list,
+                         job->request_payload.sg_cnt,
+                         ct, len);
+
+       fh = fc_frame_header_get(fp);
+       fh->fh_r_ctl = FC_RCTL_DD_UNSOL_CTL;
+       hton24(fh->fh_d_id, did);
+       hton24(fh->fh_s_id, fc_host_port_id(lport->host));
+       fh->fh_type = FC_TYPE_CT;
+       hton24(fh->fh_f_ctl, FC_FC_FIRST_SEQ |
+              FC_FC_END_SEQ | FC_FC_SEQ_INIT);
+       fh->fh_cs_ctl = 0;
+       fh->fh_df_ctl = 0;
+       fh->fh_parm_offset = 0;
+
+       info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
+       if (!info) {
+               fc_frame_free(fp);
+               return -ENOMEM;
+       }
+
+       info->job = job;
+       info->lport = lport;
+       info->rsp_code = FC_FS_ACC;
+       info->nents = job->reply_payload.sg_cnt;
+       info->sg = job->reply_payload.sg_list;
+
+       if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
+                                    NULL, info, tov))
+               return -ECOMM;
+       return 0;
+}
+
+/**
+ * fc_lport_bsg_request() - The common entry point for sending
+ *                         FC Passthrough requests
+ * @job: The BSG passthrough job
+ */
+int fc_lport_bsg_request(struct fc_bsg_job *job)
+{
+       struct request *rsp = job->req->next_rq;
+       struct Scsi_Host *shost = job->shost;
+       struct fc_lport *lport = shost_priv(shost);
+       struct fc_rport *rport;
+       struct fc_rport_priv *rdata;
+       int rc = -EINVAL;
+       u32 did;
+
+       job->reply->reply_payload_rcv_len = 0;
+       rsp->resid_len = job->reply_payload.payload_len;
+
+       mutex_lock(&lport->lp_mutex);
+
+       switch (job->request->msgcode) {
+       case FC_BSG_RPT_ELS:
+               rport = job->rport;
+               if (!rport)
+                       break;
+
+               rdata = rport->dd_data;
+               rc = fc_lport_els_request(job, lport, rport->port_id,
+                                         rdata->e_d_tov);
+               break;
+
+       case FC_BSG_RPT_CT:
+               rport = job->rport;
+               if (!rport)
+                       break;
+
+               rdata = rport->dd_data;
+               rc = fc_lport_ct_request(job, lport, rport->port_id,
+                                        rdata->e_d_tov);
+               break;
+
+       case FC_BSG_HST_CT:
+               did = ntoh24(job->request->rqst_data.h_ct.port_id);
+               if (did == FC_FID_DIR_SERV)
+                       rdata = lport->dns_rdata;
+               else
+                       rdata = lport->tt.rport_lookup(lport, did);
+
+               if (!rdata)
+                       break;
+
+               rc = fc_lport_ct_request(job, lport, did, rdata->e_d_tov);
+               break;
+
+       case FC_BSG_HST_ELS_NOLOGIN:
+               did = ntoh24(job->request->rqst_data.h_els.port_id);
+               rc = fc_lport_els_request(job, lport, did, lport->e_d_tov);
+               break;
+       }
+
+       mutex_unlock(&lport->lp_mutex);
+       return rc;
+}
+EXPORT_SYMBOL(fc_lport_bsg_request);