Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6

SCSI updates from James Bottomley:
 "The update includes the usual assortment of driver updates (lpfc,
  qla2xxx, qla4xxx, bfa, bnx2fc, bnx2i, isci, fcoe, hpsa) plus a huge
  amount of infrastructure work in the SAS library and transport class
  as well as an iSCSI update.  There's also a new SCSI based virtio
  driver."

* tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6: (177 commits)
  [SCSI] qla4xxx: Update driver version to 5.02.00-k15
  [SCSI] qla4xxx: trivial cleanup
  [SCSI] qla4xxx: Fix sparse warning
  [SCSI] qla4xxx: Add support for multiple session per host.
  [SCSI] qla4xxx: Export CHAP index as sysfs attribute
  [SCSI] scsi_transport: Export CHAP index as sysfs attribute
  [SCSI] qla4xxx: Add support to display CHAP list and delete CHAP entry
  [SCSI] iscsi_transport: Add support to display CHAP list and delete CHAP entry
  [SCSI] pm8001: fix endian issue with code optimization.
  [SCSI] pm8001: Fix possible racing condition.
  [SCSI] pm8001: Fix bogus interrupt state flag issue.
  [SCSI] ipr: update PCI ID definitions for new adapters
  [SCSI] qla2xxx: handle default case in qla2x00_request_firmware()
  [SCSI] isci: improvements in driver unloading routine
  [SCSI] isci: improve phy event warnings
  [SCSI] isci: debug, provide state-enum-to-string conversions
  [SCSI] scsi_transport_sas: 'enable' phys on reset
  [SCSI] libsas: don't recover end devices attached to disabled phys
  [SCSI] libsas: fixup target_port_protocols for expanders that don't report sata
  [SCSI] libsas: set attached device type and target protocols for local phys
  ...

14 files changed, 800 insertions, 69 deletions

diff --git a/include/scsi/fc/fc_ms.h b/include/scsi/fc/fc_ms.h
new file mode 100644
index 00000000000..f52b921b5c7
--- /dev/null
+++ b/include/scsi/fc/fc_ms.h
@@ -0,0 +1,213 @@
+/* * Copyright(c) 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Maintained at www.Open-FCoE.org
+ */
+
+#ifndef _FC_MS_H_
+#define _FC_MS_H_
+
+#include <linux/types.h>
+
+/*
+ * Fibre Channel Services - Management Service (MS)
+ * From T11.org FC-GS-4 Rev 7.91 February 4, 2004
+ */
+
+/*
+ * Fabric Device Management Interface
+ */
+
+/*
+ * Common-transport sub-type for FDMI
+ */
+#define FC_FDMI_SUBTYPE     0x10 /* fs_ct_hdr.ct_fs_subtype */
+
+/*
+ * Management server FDMI Requests.
+ */
+enum fc_fdmi_req {
+        FC_FDMI_GRHL = 0x0100,  /* Get Registered HBA List */
+        FC_FDMI_GHAT = 0x0101,  /* Get HBA Attributes */
+        FC_FDMI_GRPL = 0x0102,  /* Get Registered Port List */
+        FC_FDMI_GPAT = 0x0110,  /* Get Port Attributes */
+        FC_FDMI_RHBA = 0x0200,  /* Register HBA */
+        FC_FDMI_RHAT = 0x0201,  /* Register HBA Attributes */
+        FC_FDMI_RPRT = 0x0210,  /* Register Port */
+        FC_FDMI_RPA = 0x0211,   /* Register Port Attributes */
+        FC_FDMI_DHBA = 0x0300,  /* Deregister HBA */
+        FC_FDMI_DHAT = 0x0301,  /* Deregister HBA Attributes */
+        FC_FDMI_DPRT = 0x0310,  /* Deregister Port */
+        FC_FDMI_DPA = 0x0311,   /* Deregister Port Attributes */
+};
+
+/*
+ * HBA Attribute Entry Type
+ */
+enum fc_fdmi_hba_attr_type {
+        FC_FDMI_HBA_ATTR_NODENAME = 0x0001,
+        FC_FDMI_HBA_ATTR_MANUFACTURER = 0x0002,
+        FC_FDMI_HBA_ATTR_SERIALNUMBER = 0x0003,
+        FC_FDMI_HBA_ATTR_MODEL = 0x0004,
+        FC_FDMI_HBA_ATTR_MODELDESCRIPTION = 0x0005,
+        FC_FDMI_HBA_ATTR_HARDWAREVERSION = 0x0006,
+        FC_FDMI_HBA_ATTR_DRIVERVERSION = 0x0007,
+        FC_FDMI_HBA_ATTR_OPTIONROMVERSION = 0x0008,
+        FC_FDMI_HBA_ATTR_FIRMWAREVERSION = 0x0009,
+        FC_FDMI_HBA_ATTR_OSNAMEVERSION = 0x000A,
+        FC_FDMI_HBA_ATTR_MAXCTPAYLOAD = 0x000B,
+};
+
+/*
+ * HBA Attribute Length
+ */
+#define FC_FDMI_HBA_ATTR_NODENAME_LEN           8
+#define FC_FDMI_HBA_ATTR_MANUFACTURER_LEN       64
+#define FC_FDMI_HBA_ATTR_SERIALNUMBER_LEN       64
+#define FC_FDMI_HBA_ATTR_MODEL_LEN              256
+#define FC_FDMI_HBA_ATTR_MODELDESCR_LEN         256
+#define FC_FDMI_HBA_ATTR_HARDWAREVERSION_LEN    256
+#define FC_FDMI_HBA_ATTR_DRIVERVERSION_LEN      256
+#define FC_FDMI_HBA_ATTR_OPTIONROMVERSION_LEN   256
+#define FC_FDMI_HBA_ATTR_FIRMWAREVERSION_LEN    256
+#define FC_FDMI_HBA_ATTR_OSNAMEVERSION_LEN      256
+#define FC_FDMI_HBA_ATTR_MAXCTPAYLOAD_LEN       4
+
+/*
+ * Port Attribute Type
+ */
+enum fc_fdmi_port_attr_type {
+        FC_FDMI_PORT_ATTR_FC4TYPES = 0x0001,
+        FC_FDMI_PORT_ATTR_SUPPORTEDSPEED = 0x0002,
+        FC_FDMI_PORT_ATTR_CURRENTPORTSPEED = 0x0003,
+        FC_FDMI_PORT_ATTR_MAXFRAMESIZE = 0x0004,
+        FC_FDMI_PORT_ATTR_OSDEVICENAME = 0x0005,
+        FC_FDMI_PORT_ATTR_HOSTNAME = 0x0006,
+};
+
+/*
+ * Port Attribute Length
+ */
+#define FC_FDMI_PORT_ATTR_FC4TYPES_LEN          32
+#define FC_FDMI_PORT_ATTR_SUPPORTEDSPEED_LEN    4
+#define FC_FDMI_PORT_ATTR_CURRENTPORTSPEED_LEN  4
+#define FC_FDMI_PORT_ATTR_MAXFRAMESIZE_LEN      4
+#define FC_FDMI_PORT_ATTR_OSDEVICENAME_LEN      256
+#define FC_FDMI_PORT_ATTR_HOSTNAME_LEN          256
+
+/*
+ * HBA Attribute ID
+ */
+struct fc_fdmi_hba_identifier {
+        __be64          id;
+};
+
+/*
+ * Port Name
+ */
+struct fc_fdmi_port_name {
+        __be64          portname;
+};
+
+/*
+ * Attribute Entry Block for HBA/Port Attributes
+ */
+#define FC_FDMI_ATTR_ENTRY_HEADER_LEN   4
+struct fc_fdmi_attr_entry {
+        __be16          type;
+        __be16          len;
+        __u8            value[1];
+} __attribute__((__packed__));
+
+/*
+ * Common for HBA/Port Attributes
+ */
+struct fs_fdmi_attrs {
+        __be32                          numattrs;
+        struct fc_fdmi_attr_entry       attr[1];
+} __attribute__((__packed__));
+
+/*
+ * Registered Port List
+ */
+struct fc_fdmi_rpl {
+        __be32                          numport;
+        struct fc_fdmi_port_name        port[1];
+} __attribute__((__packed__));
+
+/*
+ * Register HBA (RHBA)
+ */
+struct fc_fdmi_rhba {
+        struct fc_fdmi_hba_identifier hbaid;
+        struct fc_fdmi_rpl               port;
+        struct fs_fdmi_attrs             hba_attrs;
+} __attribute__((__packed__));
+
+/*
+ * Register HBA Attributes (RHAT)
+ */
+struct fc_fdmi_rhat {
+        struct fc_fdmi_hba_identifier hbaid;
+        struct fs_fdmi_attrs             hba_attrs;
+} __attribute__((__packed__));
+
+/*
+ * Register Port (RPRT)
+ */
+struct fc_fdmi_rprt {
+        struct fc_fdmi_hba_identifier hbaid;
+        struct fc_fdmi_port_name         port;
+        struct fs_fdmi_attrs             hba_attrs;
+} __attribute__((__packed__));
+
+/*
+ * Register Port Attributes (RPA)
+ */
+struct fc_fdmi_rpa {
+        struct fc_fdmi_port_name         port;
+        struct fs_fdmi_attrs             hba_attrs;
+} __attribute__((__packed__));
+
+/*
+ * Deregister Port (DPRT)
+ */
+struct fc_fdmi_dprt {
+        struct fc_fdmi_port_name         port;
+} __attribute__((__packed__));
+
+/*
+ * Deregister Port Attributes (DPA)
+ */
+struct fc_fdmi_dpa {
+        struct fc_fdmi_port_name         port;
+        struct fs_fdmi_attrs             hba_attrs;
+} __attribute__((__packed__));
+
+/*
+ * Deregister HBA Attributes (DHAT)
+ */
+struct fc_fdmi_dhat {
+        struct fc_fdmi_hba_identifier hbaid;
+} __attribute__((__packed__));
+
+/*
+ * Deregister HBA (DHBA)
+ */
+struct fc_fdmi_dhba {
+        struct fc_fdmi_hba_identifier hbaid;
+} __attribute__((__packed__));
+
+#endif /* _FC_MS_H_ */
diff --git a/include/scsi/fc_encode.h b/include/scsi/fc_encode.h
index be418d8448a..35fd4744f3e 100644
--- a/include/scsi/fc_encode.h
+++ b/include/scsi/fc_encode.h
@@ -20,6 +20,7 @@
 #ifndef _FC_ENCODE_H_
 #define _FC_ENCODE_H_
 #include <asm/unaligned.h>
+#include <linux/utsname.h>
 
 /*
  * F_CTL values for simple requests and responses.
@@ -43,6 +44,10 @@ struct fc_ct_req {
                 struct fc_ns_fid fid;
                 struct fc_ns_rsnn snn;
                 struct fc_ns_rspn spn;
+                struct fc_fdmi_rhba rhba;
+                struct fc_fdmi_rpa  rpa;
+                struct fc_fdmi_dprt dprt;
+                struct fc_fdmi_dhba dhba;
         } payload;
 };
 
@@ -97,7 +102,9 @@ static inline void fc_adisc_fill(struct fc_lport *lport, struct fc_frame *fp)
  * returns pointer to ct request.
  */
 static inline struct fc_ct_req *fc_ct_hdr_fill(const struct fc_frame *fp,
-                                               unsigned int op, size_t req_size)
+                                               unsigned int op, size_t req_size,
+                                               enum fc_ct_fs_type fs_type,
+                                               u8 subtype)
 {
         struct fc_ct_req *ct;
         size_t ct_plen;
@@ -106,14 +113,14 @@ static inline struct fc_ct_req *fc_ct_hdr_fill(const struct fc_frame *fp,
         ct = fc_frame_payload_get(fp, ct_plen);
         memset(ct, 0, ct_plen);
         ct->hdr.ct_rev = FC_CT_REV;
-        ct->hdr.ct_fs_type = FC_FST_DIR;
-        ct->hdr.ct_fs_subtype = FC_NS_SUBTYPE;
+        ct->hdr.ct_fs_type = fs_type;
+        ct->hdr.ct_fs_subtype = subtype;
         ct->hdr.ct_cmd = htons((u16) op);
         return ct;
 }
 
 /**
- * fc_ct_fill() - Fill in a name service request frame
+ * fc_ct_ns_fill() - Fill in a name service request frame
  * @lport: local port.
  * @fc_id: FC_ID of non-destination rport for GPN_ID and similar inquiries.
  * @fp: frame to contain payload.
@@ -121,7 +128,7 @@ static inline struct fc_ct_req *fc_ct_hdr_fill(const struct fc_frame *fp,
  * @r_ctl: pointer to FC header R_CTL.
  * @fh_type: pointer to FC-4 type.
  */
-static inline int fc_ct_fill(struct fc_lport *lport,
+static inline int fc_ct_ns_fill(struct fc_lport *lport,
                       u32 fc_id, struct fc_frame *fp,
                       unsigned int op, enum fc_rctl *r_ctl,
                       enum fc_fh_type *fh_type)
@@ -131,23 +138,28 @@ static inline int fc_ct_fill(struct fc_lport *lport,
 
         switch (op) {
         case FC_NS_GPN_FT:
-                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_gid_ft));
+                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_gid_ft),
+                                    FC_FST_DIR, FC_NS_SUBTYPE);
                 ct->payload.gid.fn_fc4_type = FC_TYPE_FCP;
                 break;
 
         case FC_NS_GPN_ID:
-                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_fid));
+                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_fid),
+                                    FC_FST_DIR, FC_NS_SUBTYPE);
+                ct->payload.gid.fn_fc4_type = FC_TYPE_FCP;
                 hton24(ct->payload.fid.fp_fid, fc_id);
                 break;
 
         case FC_NS_RFT_ID:
-                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_rft));
+                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_rft),
+                                    FC_FST_DIR, FC_NS_SUBTYPE);
                 hton24(ct->payload.rft.fid.fp_fid, lport->port_id);
                 ct->payload.rft.fts = lport->fcts;
                 break;
 
         case FC_NS_RFF_ID:
-                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_rff_id));
+                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_rff_id),
+                                    FC_FST_DIR, FC_NS_SUBTYPE);
                 hton24(ct->payload.rff.fr_fid.fp_fid, lport->port_id);
                 ct->payload.rff.fr_type = FC_TYPE_FCP;
                 if (lport->service_params & FCP_SPPF_INIT_FCN)
@@ -157,14 +169,16 @@ static inline int fc_ct_fill(struct fc_lport *lport,
                 break;
 
         case FC_NS_RNN_ID:
-                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_rn_id));
+                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_rn_id),
+                                    FC_FST_DIR, FC_NS_SUBTYPE);
                 hton24(ct->payload.rn.fr_fid.fp_fid, lport->port_id);
                 put_unaligned_be64(lport->wwnn, &ct->payload.rn.fr_wwn);
                 break;
 
         case FC_NS_RSPN_ID:
                 len = strnlen(fc_host_symbolic_name(lport->host), 255);
-                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_rspn) + len);
+                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_rspn) + len,
+                                    FC_FST_DIR, FC_NS_SUBTYPE);
                 hton24(ct->payload.spn.fr_fid.fp_fid, lport->port_id);
                 strncpy(ct->payload.spn.fr_name,
                         fc_host_symbolic_name(lport->host), len);
@@ -173,7 +187,8 @@ static inline int fc_ct_fill(struct fc_lport *lport,
 
         case FC_NS_RSNN_NN:
                 len = strnlen(fc_host_symbolic_name(lport->host), 255);
-                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_rsnn) + len);
+                ct = fc_ct_hdr_fill(fp, op, sizeof(struct fc_ns_rsnn) + len,
+                                    FC_FST_DIR, FC_NS_SUBTYPE);
                 put_unaligned_be64(lport->wwnn, &ct->payload.snn.fr_wwn);
                 strncpy(ct->payload.snn.fr_name,
                         fc_host_symbolic_name(lport->host), len);
@@ -189,6 +204,330 @@ static inline int fc_ct_fill(struct fc_lport *lport,
 }
 
 /**
+ * fc_ct_ms_fill() - Fill in a mgmt service request frame
+ * @lport: local port.
+ * @fc_id: FC_ID of non-destination rport for GPN_ID and similar inquiries.
+ * @fp: frame to contain payload.
+ * @op: CT opcode.
+ * @r_ctl: pointer to FC header R_CTL.
+ * @fh_type: pointer to FC-4 type.
+ */
+static inline int fc_ct_ms_fill(struct fc_lport *lport,
+                      u32 fc_id, struct fc_frame *fp,
+                      unsigned int op, enum fc_rctl *r_ctl,
+                      enum fc_fh_type *fh_type)
+{
+        struct fc_ct_req *ct;
+        size_t len;
+        struct fc_fdmi_attr_entry *entry;
+        struct fs_fdmi_attrs *hba_attrs;
+        int numattrs = 0;
+
+        switch (op) {
+        case FC_FDMI_RHBA:
+                numattrs = 10;
+                len = sizeof(struct fc_fdmi_rhba);
+                len -= sizeof(struct fc_fdmi_attr_entry);
+                len += (numattrs * FC_FDMI_ATTR_ENTRY_HEADER_LEN);
+                len += FC_FDMI_HBA_ATTR_NODENAME_LEN;
+                len += FC_FDMI_HBA_ATTR_MANUFACTURER_LEN;
+                len += FC_FDMI_HBA_ATTR_SERIALNUMBER_LEN;
+                len += FC_FDMI_HBA_ATTR_MODEL_LEN;
+                len += FC_FDMI_HBA_ATTR_MODELDESCR_LEN;
+                len += FC_FDMI_HBA_ATTR_HARDWAREVERSION_LEN;
+                len += FC_FDMI_HBA_ATTR_DRIVERVERSION_LEN;
+                len += FC_FDMI_HBA_ATTR_OPTIONROMVERSION_LEN;
+                len += FC_FDMI_HBA_ATTR_FIRMWAREVERSION_LEN;
+                len += FC_FDMI_HBA_ATTR_OSNAMEVERSION_LEN;
+                ct = fc_ct_hdr_fill(fp, op, len, FC_FST_MGMT,
+                                    FC_FDMI_SUBTYPE);
+
+                /* HBA Identifier */
+                put_unaligned_be64(lport->wwpn, &ct->payload.rhba.hbaid.id);
+                /* Number of Ports - always 1 */
+                put_unaligned_be32(1, &ct->payload.rhba.port.numport);
+                /* Port Name */
+                put_unaligned_be64(lport->wwpn,
+                                   &ct->payload.rhba.port.port[0].portname);
+
+                /* HBA Attributes */
+                put_unaligned_be32(numattrs,
+                                   &ct->payload.rhba.hba_attrs.numattrs);
+                hba_attrs = &ct->payload.rhba.hba_attrs;
+                entry = (struct fc_fdmi_attr_entry *)hba_attrs->attr;
+                /* NodeName*/
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_HBA_ATTR_NODENAME_LEN;
+                put_unaligned_be16(FC_FDMI_HBA_ATTR_NODENAME,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                put_unaligned_be64(lport->wwnn,
+                                   (__be64 *)&entry->value[0]);
+
+                /* Manufacturer */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_HBA_ATTR_NODENAME_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_HBA_ATTR_MANUFACTURER_LEN;
+                put_unaligned_be16(FC_FDMI_HBA_ATTR_MANUFACTURER,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                strncpy((char *)&entry->value,
+                        fc_host_manufacturer(lport->host),
+                        FC_FDMI_HBA_ATTR_MANUFACTURER_LEN);
+
+                /* SerialNumber */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_HBA_ATTR_MANUFACTURER_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_HBA_ATTR_SERIALNUMBER_LEN;
+                put_unaligned_be16(FC_FDMI_HBA_ATTR_SERIALNUMBER,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                strncpy((char *)&entry->value,
+                        fc_host_serial_number(lport->host),
+                        FC_FDMI_HBA_ATTR_SERIALNUMBER_LEN);
+
+                /* Model */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_HBA_ATTR_SERIALNUMBER_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_HBA_ATTR_MODEL_LEN;
+                put_unaligned_be16(FC_FDMI_HBA_ATTR_MODEL,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                strncpy((char *)&entry->value,
+                        fc_host_model(lport->host),
+                        FC_FDMI_HBA_ATTR_MODEL_LEN);
+
+                /* Model Description */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_HBA_ATTR_MODEL_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_HBA_ATTR_MODELDESCR_LEN;
+                put_unaligned_be16(FC_FDMI_HBA_ATTR_MODELDESCRIPTION,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                strncpy((char *)&entry->value,
+                        fc_host_model_description(lport->host),
+                        FC_FDMI_HBA_ATTR_MODELDESCR_LEN);
+
+                /* Hardware Version */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_HBA_ATTR_MODELDESCR_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_HBA_ATTR_HARDWAREVERSION_LEN;
+                put_unaligned_be16(FC_FDMI_HBA_ATTR_HARDWAREVERSION,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                strncpy((char *)&entry->value,
+                        fc_host_hardware_version(lport->host),
+                        FC_FDMI_HBA_ATTR_HARDWAREVERSION_LEN);
+
+                /* Driver Version */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_HBA_ATTR_HARDWAREVERSION_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_HBA_ATTR_DRIVERVERSION_LEN;
+                put_unaligned_be16(FC_FDMI_HBA_ATTR_DRIVERVERSION,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                strncpy((char *)&entry->value,
+                        fc_host_driver_version(lport->host),
+                        FC_FDMI_HBA_ATTR_DRIVERVERSION_LEN);
+
+                /* OptionROM Version */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_HBA_ATTR_DRIVERVERSION_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_HBA_ATTR_OPTIONROMVERSION_LEN;
+                put_unaligned_be16(FC_FDMI_HBA_ATTR_OPTIONROMVERSION,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                strncpy((char *)&entry->value,
+                        fc_host_optionrom_version(lport->host),
+                        FC_FDMI_HBA_ATTR_OPTIONROMVERSION_LEN);
+
+                /* Firmware Version */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_HBA_ATTR_OPTIONROMVERSION_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_HBA_ATTR_FIRMWAREVERSION_LEN;
+                put_unaligned_be16(FC_FDMI_HBA_ATTR_FIRMWAREVERSION,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                strncpy((char *)&entry->value,
+                        fc_host_firmware_version(lport->host),
+                        FC_FDMI_HBA_ATTR_FIRMWAREVERSION_LEN);
+
+                /* OS Name and Version */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_HBA_ATTR_FIRMWAREVERSION_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_HBA_ATTR_OSNAMEVERSION_LEN;
+                put_unaligned_be16(FC_FDMI_HBA_ATTR_OSNAMEVERSION,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                snprintf((char *)&entry->value,
+                        FC_FDMI_HBA_ATTR_OSNAMEVERSION_LEN,
+                        "%s v%s",
+                        init_utsname()->sysname,
+                        init_utsname()->release);
+                break;
+        case FC_FDMI_RPA:
+                numattrs = 6;
+                len = sizeof(struct fc_fdmi_rpa);
+                len -= sizeof(struct fc_fdmi_attr_entry);
+                len += (numattrs * FC_FDMI_ATTR_ENTRY_HEADER_LEN);
+                len += FC_FDMI_PORT_ATTR_FC4TYPES_LEN;
+                len += FC_FDMI_PORT_ATTR_SUPPORTEDSPEED_LEN;
+                len += FC_FDMI_PORT_ATTR_CURRENTPORTSPEED_LEN;
+                len += FC_FDMI_PORT_ATTR_MAXFRAMESIZE_LEN;
+                len += FC_FDMI_PORT_ATTR_OSDEVICENAME_LEN;
+                len += FC_FDMI_PORT_ATTR_HOSTNAME_LEN;
+                ct = fc_ct_hdr_fill(fp, op, len, FC_FST_MGMT,
+                                    FC_FDMI_SUBTYPE);
+
+                /* Port Name */
+                put_unaligned_be64(lport->wwpn,
+                                   &ct->payload.rpa.port.portname);
+
+                /* Port Attributes */
+                put_unaligned_be32(numattrs,
+                                   &ct->payload.rpa.hba_attrs.numattrs);
+
+                hba_attrs = &ct->payload.rpa.hba_attrs;
+                entry = (struct fc_fdmi_attr_entry *)hba_attrs->attr;
+
+                /* FC4 types */
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_PORT_ATTR_FC4TYPES_LEN;
+                put_unaligned_be16(FC_FDMI_PORT_ATTR_FC4TYPES,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                memcpy(&entry->value, fc_host_supported_fc4s(lport->host),
+                       FC_FDMI_PORT_ATTR_FC4TYPES_LEN);
+
+                /* Supported Speed */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_PORT_ATTR_FC4TYPES_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_PORT_ATTR_SUPPORTEDSPEED_LEN;
+                put_unaligned_be16(FC_FDMI_PORT_ATTR_SUPPORTEDSPEED,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+
+                put_unaligned_be32(fc_host_supported_speeds(lport->host),
+                                   &entry->value);
+
+                /* Current Port Speed */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_PORT_ATTR_SUPPORTEDSPEED_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_PORT_ATTR_CURRENTPORTSPEED_LEN;
+                put_unaligned_be16(FC_FDMI_PORT_ATTR_CURRENTPORTSPEED,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                put_unaligned_be32(lport->link_speed,
+                                   &entry->value);
+
+                /* Max Frame Size */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_PORT_ATTR_CURRENTPORTSPEED_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_PORT_ATTR_MAXFRAMESIZE_LEN;
+                put_unaligned_be16(FC_FDMI_PORT_ATTR_MAXFRAMESIZE,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                put_unaligned_be32(fc_host_maxframe_size(lport->host),
+                                   &entry->value);
+
+                /* OS Device Name */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_PORT_ATTR_MAXFRAMESIZE_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_PORT_ATTR_OSDEVICENAME_LEN;
+                put_unaligned_be16(FC_FDMI_PORT_ATTR_OSDEVICENAME,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                /* Use the sysfs device name */
+                strncpy((char *)&entry->value,
+                        dev_name(&lport->host->shost_gendev),
+                        strnlen(dev_name(&lport->host->shost_gendev),
+                                FC_FDMI_PORT_ATTR_HOSTNAME_LEN));
+
+                /* Host Name */
+                entry = (struct fc_fdmi_attr_entry *)((char *)entry->value +
+                                        FC_FDMI_PORT_ATTR_OSDEVICENAME_LEN);
+                len = FC_FDMI_ATTR_ENTRY_HEADER_LEN;
+                len += FC_FDMI_PORT_ATTR_HOSTNAME_LEN;
+                put_unaligned_be16(FC_FDMI_PORT_ATTR_HOSTNAME,
+                                   &entry->type);
+                put_unaligned_be16(len, &entry->len);
+                if (strlen(fc_host_system_hostname(lport->host)))
+                        strncpy((char *)&entry->value,
+                                fc_host_system_hostname(lport->host),
+                                strnlen(fc_host_system_hostname(lport->host),
+                                        FC_FDMI_PORT_ATTR_HOSTNAME_LEN));
+                else
+                        strncpy((char *)&entry->value,
+                                init_utsname()->nodename,
+                                FC_FDMI_PORT_ATTR_HOSTNAME_LEN);
+                break;
+        case FC_FDMI_DPRT:
+                len = sizeof(struct fc_fdmi_dprt);
+                ct = fc_ct_hdr_fill(fp, op, len, FC_FST_MGMT,
+                                    FC_FDMI_SUBTYPE);
+                /* Port Name */
+                put_unaligned_be64(lport->wwpn,
+                                   &ct->payload.dprt.port.portname);
+                break;
+        case FC_FDMI_DHBA:
+                len = sizeof(struct fc_fdmi_dhba);
+                ct = fc_ct_hdr_fill(fp, op, len, FC_FST_MGMT,
+                                    FC_FDMI_SUBTYPE);
+                /* HBA Identifier */
+                put_unaligned_be64(lport->wwpn, &ct->payload.dhba.hbaid.id);
+                break;
+        default:
+                return -EINVAL;
+        }
+        *r_ctl = FC_RCTL_DD_UNSOL_CTL;
+        *fh_type = FC_TYPE_CT;
+        return 0;
+}
+
+/**
+ * fc_ct_fill() - Fill in a common transport service request frame
+ * @lport: local port.
+ * @fc_id: FC_ID of non-destination rport for GPN_ID and similar inquiries.
+ * @fp: frame to contain payload.
+ * @op: CT opcode.
+ * @r_ctl: pointer to FC header R_CTL.
+ * @fh_type: pointer to FC-4 type.
+ */
+static inline int fc_ct_fill(struct fc_lport *lport,
+                      u32 fc_id, struct fc_frame *fp,
+                      unsigned int op, enum fc_rctl *r_ctl,
+                      enum fc_fh_type *fh_type, u32 *did)
+{
+        int rc = -EINVAL;
+
+        switch (fc_id) {
+        case FC_FID_MGMT_SERV:
+                rc = fc_ct_ms_fill(lport, fc_id, fp, op, r_ctl, fh_type);
+                *did = FC_FID_MGMT_SERV;
+                break;
+        case FC_FID_DIR_SERV:
+        default:
+                rc = fc_ct_ns_fill(lport, fc_id, fp, op, r_ctl, fh_type);
+                *did = FC_FID_DIR_SERV;
+                break;
+        }
+
+        return rc;
+}
+/**
  * fc_plogi_fill - Fill in plogi request frame
  */
 static inline void fc_plogi_fill(struct fc_lport *lport, struct fc_frame *fp,
diff --git a/include/scsi/iscsi_if.h b/include/scsi/iscsi_if.h
index 2703e3bedbf..9c23ee8fd2d 100644
--- a/include/scsi/iscsi_if.h
+++ b/include/scsi/iscsi_if.h
@@ -60,6 +60,9 @@ enum iscsi_uevent_e {
 
         ISCSI_UEVENT_PATH_UPDATE        = UEVENT_BASE + 20,
         ISCSI_UEVENT_SET_IFACE_PARAMS   = UEVENT_BASE + 21,
+        ISCSI_UEVENT_PING               = UEVENT_BASE + 22,
+        ISCSI_UEVENT_GET_CHAP           = UEVENT_BASE + 23,
+        ISCSI_UEVENT_DELETE_CHAP        = UEVENT_BASE + 24,
 
         /* up events */
         ISCSI_KEVENT_RECV_PDU           = KEVENT_BASE + 1,
@@ -72,6 +75,8 @@ enum iscsi_uevent_e {
         ISCSI_KEVENT_PATH_REQ           = KEVENT_BASE + 7,
         ISCSI_KEVENT_IF_DOWN            = KEVENT_BASE + 8,
         ISCSI_KEVENT_CONN_LOGIN_STATE   = KEVENT_BASE + 9,
+        ISCSI_KEVENT_HOST_EVENT         = KEVENT_BASE + 10,
+        ISCSI_KEVENT_PING_COMP          = KEVENT_BASE + 11,
 };
 
 enum iscsi_tgt_dscvr {
@@ -80,6 +85,13 @@ enum iscsi_tgt_dscvr {
         ISCSI_TGT_DSCVR_SLP             = 3,
 };
 
+enum iscsi_host_event_code {
+        ISCSI_EVENT_LINKUP              = 1,
+        ISCSI_EVENT_LINKDOWN,
+        /* must always be last */
+        ISCSI_EVENT_MAX,
+};
+
 struct iscsi_uevent {
         uint32_t type; /* k/u events type */
         uint32_t iferror; /* carries interface or resource errors */
@@ -178,6 +190,26 @@ struct iscsi_uevent {
                         uint32_t        host_no;
                         uint32_t        count;
                 } set_iface_params;
+                struct msg_iscsi_ping {
+                        uint32_t        host_no;
+                        uint32_t        iface_num;
+                        uint32_t        iface_type;
+                        uint32_t        payload_size;
+                        uint32_t        pid;    /* unique ping id associated
+                                                   with each ping request */
+                } iscsi_ping;
+                struct msg_get_chap {
+                        uint32_t        host_no;
+                        uint32_t        num_entries; /* number of CHAP entries
+                                                      * on request, number of
+                                                      * valid CHAP entries on
+                                                      * response */
+                        uint16_t        chap_tbl_idx;
+                } get_chap;
+                struct msg_delete_chap {
+                       uint32_t        host_no;
+                       uint16_t        chap_tbl_idx;
+                } delete_chap;
         } u;
         union {
                 /* messages k -> u */
@@ -222,6 +254,18 @@ struct iscsi_uevent {
                 struct msg_notify_if_down {
                         uint32_t        host_no;
                 } notify_if_down;
+                struct msg_host_event {
+                        uint32_t        host_no;
+                        uint32_t        data_size;
+                        enum iscsi_host_event_code code;
+                } host_event;
+                struct msg_ping_comp {
+                        uint32_t        host_no;
+                        uint32_t        status;
+                        uint32_t        pid;    /* unique ping id associated
+                                                   with each ping request */
+                        uint32_t        data_size;
+                } ping_comp;
         } r;
 } __attribute__ ((aligned (sizeof(uint64_t))));
 
@@ -406,6 +450,9 @@ enum iscsi_param {
 
         ISCSI_PARAM_TGT_RESET_TMO,
         ISCSI_PARAM_TARGET_ALIAS,
+
+        ISCSI_PARAM_CHAP_IN_IDX,
+        ISCSI_PARAM_CHAP_OUT_IDX,
         /* must always be last */
         ISCSI_PARAM_MAX,
 };
@@ -416,9 +463,26 @@ enum iscsi_host_param {
         ISCSI_HOST_PARAM_INITIATOR_NAME,
         ISCSI_HOST_PARAM_NETDEV_NAME,
         ISCSI_HOST_PARAM_IPADDRESS,
+        ISCSI_HOST_PARAM_PORT_STATE,
+        ISCSI_HOST_PARAM_PORT_SPEED,
         ISCSI_HOST_PARAM_MAX,
 };
 
+/* iSCSI port Speed */
+enum iscsi_port_speed {
+        ISCSI_PORT_SPEED_UNKNOWN        = 0x1,
+        ISCSI_PORT_SPEED_10MBPS         = 0x2,
+        ISCSI_PORT_SPEED_100MBPS        = 0x4,
+        ISCSI_PORT_SPEED_1GBPS          = 0x8,
+        ISCSI_PORT_SPEED_10GBPS         = 0x10,
+};
+
+/* iSCSI port state */
+enum iscsi_port_state {
+        ISCSI_PORT_STATE_DOWN           = 0x1,
+        ISCSI_PORT_STATE_UP             = 0x2,
+};
+
 #define iscsi_ptr(_handle) ((void*)(unsigned long)_handle)
 #define iscsi_handle(_ptr) ((uint64_t)(unsigned long)_ptr)
 
@@ -501,4 +565,19 @@ struct iscsi_stats {
                 __attribute__ ((aligned (sizeof(uint64_t))));
 };
 
+enum chap_type_e {
+        CHAP_TYPE_OUT,
+        CHAP_TYPE_IN,
+};
+
+#define ISCSI_CHAP_AUTH_NAME_MAX_LEN    256
+#define ISCSI_CHAP_AUTH_SECRET_MAX_LEN  256
+struct iscsi_chap_rec {
+        uint16_t chap_tbl_idx;
+        enum chap_type_e chap_type;
+        char username[ISCSI_CHAP_AUTH_NAME_MAX_LEN];
+        uint8_t password[ISCSI_CHAP_AUTH_SECRET_MAX_LEN];
+        uint8_t password_length;
+} __packed;
+
 #endif
diff --git a/include/scsi/libfc.h b/include/scsi/libfc.h
index 6a3922fe0be..8f9dfba3fcf 100644
--- a/include/scsi/libfc.h
+++ b/include/scsi/libfc.h
@@ -30,6 +30,7 @@
 
 #include <scsi/fc/fc_fcp.h>
 #include <scsi/fc/fc_ns.h>
+#include <scsi/fc/fc_ms.h>
 #include <scsi/fc/fc_els.h>
 #include <scsi/fc/fc_gs.h>
 
@@ -52,6 +53,8 @@
  * @LPORT_ST_RPN_ID:   Register port name by ID (RPN_ID) sent
  * @LPORT_ST_RFT_ID:   Register Fibre Channel types by ID (RFT_ID) sent
  * @LPORT_ST_RFF_ID:   Register FC-4 Features by ID (RFF_ID) sent
+ * @LPORT_ST_FDMI:     Waiting for mgmt server rport to become ready
+ * @LPORT_ST_RHBA:
  * @LPORT_ST_SCR:      State Change Register (SCR) sent
  * @LPORT_ST_READY:    Ready for use
  * @LPORT_ST_LOGO:     Local port logout (LOGO) sent
@@ -66,6 +69,11 @@ enum fc_lport_state {
         LPORT_ST_RSPN_ID,
         LPORT_ST_RFT_ID,
         LPORT_ST_RFF_ID,
+        LPORT_ST_FDMI,
+        LPORT_ST_RHBA,
+        LPORT_ST_RPA,
+        LPORT_ST_DHBA,
+        LPORT_ST_DPRT,
         LPORT_ST_SCR,
         LPORT_ST_READY,
         LPORT_ST_LOGO,
@@ -797,6 +805,7 @@ enum fc_lport_event {
  * @host:                  The SCSI host associated with a local port
  * @ema_list:              Exchange manager anchor list
  * @dns_rdata:             The directory server remote port
+ * @ms_rdata:              The management server remote port
  * @ptp_rdata:             Point to point remote port
  * @scsi_priv:             FCP layer internal data
  * @disc:                  Discovery context
@@ -842,6 +851,7 @@ struct fc_lport {
         struct Scsi_Host               *host;
         struct list_head               ema_list;
         struct fc_rport_priv           *dns_rdata;
+        struct fc_rport_priv           *ms_rdata;
         struct fc_rport_priv           *ptp_rdata;
         void                           *scsi_priv;
         struct fc_disc                 disc;
@@ -877,6 +887,7 @@ struct fc_lport {
         u32                            does_npiv:1;
         u32                            npiv_enabled:1;
         u32                            point_to_multipoint:1;
+        u32                            fdmi_enabled:1;
         u32                            mfs;
         u8                             max_retry_count;
         u8                             max_rport_retry_count;
diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h
index cedcff371c8..6e33386a389 100644
--- a/include/scsi/libiscsi.h
+++ b/include/scsi/libiscsi.h
@@ -268,7 +268,7 @@ struct iscsi_session {
         int                     lu_reset_timeout;
         int                     tgt_reset_timeout;
         int                     initial_r2t_en;
-        unsigned                max_r2t;
+        unsigned short          max_r2t;
         int                     imm_data_en;
         unsigned                first_burst;
         unsigned                max_burst;
@@ -284,6 +284,7 @@ struct iscsi_session {
         char                    *password;
         char                    *password_in;
         char                    *targetname;
+        char                    *targetalias;
         char                    *ifacename;
         char                    *initiatorname;
         /* control data */
diff --git a/include/scsi/libiscsi_tcp.h b/include/scsi/libiscsi_tcp.h
index ac0cc1d925e..215469a9b80 100644
--- a/include/scsi/libiscsi_tcp.h
+++ b/include/scsi/libiscsi_tcp.h
@@ -128,7 +128,7 @@ extern void iscsi_tcp_conn_teardown(struct iscsi_cls_conn *cls_conn);
 /* misc helpers */
 extern int iscsi_tcp_r2tpool_alloc(struct iscsi_session *session);
 extern void iscsi_tcp_r2tpool_free(struct iscsi_session *session);
-
+extern int iscsi_tcp_set_max_r2t(struct iscsi_conn *conn, char *buf);
 extern void iscsi_tcp_conn_get_stats(struct iscsi_cls_conn *cls_conn,
                                      struct iscsi_stats *stats);
 #endif /* LIBISCSI_TCP_H */
diff --git a/include/scsi/libsas.h b/include/scsi/libsas.h
index 6a308d42d98..5f5ed1b8b41 100644
--- a/include/scsi/libsas.h
+++ b/include/scsi/libsas.h
@@ -86,7 +86,9 @@ enum discover_event {
         DISCE_DISCOVER_DOMAIN   = 0U,
         DISCE_REVALIDATE_DOMAIN = 1,
         DISCE_PORT_GONE         = 2,
-        DISC_NUM_EVENTS         = 3,
+        DISCE_PROBE             = 3,
+        DISCE_DESTRUCT          = 4,
+        DISC_NUM_EVENTS         = 5,
 };
 
 /* ---------- Expander Devices ---------- */
@@ -151,6 +153,8 @@ struct expander_device {
 
         struct ex_phy *ex_phy;
         struct sas_port *parent_port;
+
+        struct mutex cmd_mutex;
 };
 
 /* ---------- SATA device ---------- */
@@ -162,22 +166,21 @@ enum ata_command_set {
 struct sata_device {
         enum   ata_command_set command_set;
         struct smp_resp        rps_resp; /* report_phy_sata_resp */
-        __le16 *identify_device;
-        __le16 *identify_packet_device;
-
         u8     port_no;        /* port number, if this is a PM (Port) */
         struct list_head children; /* PM Ports if this is a PM */
 
         struct ata_port *ap;
         struct ata_host ata_host;
         struct ata_taskfile tf;
-        u32 sstatus;
-        u32 serror;
-        u32 scontrol;
 };
 
-/* ---------- Domain device ---------- */
+enum {
+        SAS_DEV_GONE,
+        SAS_DEV_DESTROY,
+};
+
 struct domain_device {
+        spinlock_t done_lock;
         enum sas_dev_type dev_type;
 
         enum sas_linkrate linkrate;
@@ -189,8 +192,10 @@ struct domain_device {
         struct domain_device *parent;
         struct list_head siblings; /* devices on the same level */
         struct asd_sas_port *port;        /* shortcut to root of the tree */
+        struct sas_phy *phy;
 
         struct list_head dev_list_node;
+        struct list_head disco_list_node; /* awaiting probe or destruct */
 
         enum sas_protocol    iproto;
         enum sas_protocol    tproto;
@@ -208,7 +213,8 @@ struct domain_device {
         };
 
         void *lldd_dev;
-        int gone;
+        unsigned long state;
+        struct kref kref;
 };
 
 struct sas_discovery_event {
@@ -217,7 +223,6 @@ struct sas_discovery_event {
 };
 
 struct sas_discovery {
-        spinlock_t disc_event_lock;
         struct sas_discovery_event disc_work[DISC_NUM_EVENTS];
         unsigned long    pending;
         u8     fanout_sas_addr[8];
@@ -226,7 +231,6 @@ struct sas_discovery {
         int    max_level;
 };
 
-
 /* The port struct is Class:RW, driver:RO */
 struct asd_sas_port {
 /* private: */
@@ -236,9 +240,10 @@ struct asd_sas_port {
         struct domain_device *port_dev;
         spinlock_t dev_list_lock;
         struct list_head dev_list;
+        struct list_head disco_list;
+        struct list_head destroy_list;
         enum   sas_linkrate linkrate;
 
-        struct sas_phy *phy;
         struct work_struct work;
 
 /* public: */
@@ -274,7 +279,6 @@ struct asd_sas_event {
  */
 struct asd_sas_phy {
 /* private: */
-        /* protected by ha->event_lock */
         struct asd_sas_event   port_events[PORT_NUM_EVENTS];
         struct asd_sas_event   phy_events[PHY_NUM_EVENTS];
 
@@ -320,6 +324,7 @@ struct asd_sas_phy {
 struct scsi_core {
         struct Scsi_Host *shost;
 
+        struct mutex      task_queue_flush;
         spinlock_t        task_queue_lock;
         struct list_head  task_queue;
         int               task_queue_size;
@@ -334,18 +339,23 @@ struct sas_ha_event {
 
 enum sas_ha_state {
         SAS_HA_REGISTERED,
-        SAS_HA_UNREGISTERED
+        SAS_HA_DRAINING,
+        SAS_HA_ATA_EH_ACTIVE,
+        SAS_HA_FROZEN,
 };
 
 struct sas_ha_struct {
 /* private: */
-        spinlock_t       event_lock;
         struct sas_ha_event ha_events[HA_NUM_EVENTS];
         unsigned long    pending;
 
-        enum sas_ha_state state;
+        struct list_head  defer_q; /* work queued while draining */
+        struct mutex      drain_mutex;
+        unsigned long     state;
         spinlock_t        state_lock;
 
+        struct mutex disco_mutex;
+
         struct scsi_core core;
 
 /* public: */
@@ -374,7 +384,8 @@ struct sas_ha_struct {
 
         void *lldd_ha;            /* not touched by sas class code */
 
-        struct list_head eh_done_q;
+        struct list_head eh_done_q;  /* complete via scsi_eh_flush_done_q */
+        struct list_head eh_ata_q; /* scmds to promote from sas to ata eh */
 };
 
 #define SHOST_TO_SAS_HA(_shost) (*(struct sas_ha_struct **)(_shost)->hostdata)
@@ -418,6 +429,11 @@ static inline unsigned int to_sas_gpio_od(int device, int bit)
         return 3 * device + bit;
 }
 
+static inline void sas_put_local_phy(struct sas_phy *phy)
+{
+        put_device(&phy->dev);
+}
+
 #ifdef CONFIG_SCSI_SAS_HOST_SMP
 int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count);
 #else
@@ -447,7 +463,10 @@ enum service_response {
 };
 
 enum exec_status {
-        /* The SAM_STAT_.. codes fit in the lower 6 bits */
+        /* The SAM_STAT_.. codes fit in the lower 6 bits, alias some of
+         * them here to silence 'case value not in enumerated type' warnings
+         */
+        __SAM_STAT_CHECK_CONDITION = SAM_STAT_CHECK_CONDITION,
 
         SAS_DEV_NO_RESPONSE = 0x80,
         SAS_DATA_UNDERRUN,
@@ -487,10 +506,6 @@ enum exec_status {
 struct ata_task_resp {
         u16  frame_len;
         u8   ending_fis[24];      /* dev to host or data-in */
-        u32  sstatus;
-        u32  serror;
-        u32  scontrol;
-        u32  sactive;
 };
 
 #define SAS_STATUS_BUF_SIZE 96
@@ -604,7 +619,8 @@ struct sas_domain_function_template {
         int (*lldd_clear_aca)(struct domain_device *, u8 *lun);
         int (*lldd_clear_task_set)(struct domain_device *, u8 *lun);
         int (*lldd_I_T_nexus_reset)(struct domain_device *);
-        int (*lldd_ata_soft_reset)(struct domain_device *);
+        int (*lldd_ata_check_ready)(struct domain_device *);
+        void (*lldd_ata_set_dmamode)(struct domain_device *);
         int (*lldd_lu_reset)(struct domain_device *, u8 *lun);
         int (*lldd_query_task)(struct sas_task *);
 
@@ -625,14 +641,11 @@ extern int sas_unregister_ha(struct sas_ha_struct *);
 
 int sas_set_phy_speed(struct sas_phy *phy,
                       struct sas_phy_linkrates *rates);
-int sas_phy_enable(struct sas_phy *phy, int enabled);
 int sas_phy_reset(struct sas_phy *phy, int hard_reset);
 int sas_queue_up(struct sas_task *task);
 extern int sas_queuecommand(struct Scsi_Host * ,struct scsi_cmnd *);
 extern int sas_target_alloc(struct scsi_target *);
-extern int sas_slave_alloc(struct scsi_device *);
 extern int sas_slave_configure(struct scsi_device *);
-extern void sas_slave_destroy(struct scsi_device *);
 extern int sas_change_queue_depth(struct scsi_device *, int new_depth,
                                   int reason);
 extern int sas_change_queue_type(struct scsi_device *, int qt);
@@ -649,7 +662,7 @@ void sas_init_ex_attr(void);
 
 int  sas_ex_revalidate_domain(struct domain_device *);
 
-void sas_unregister_domain_devices(struct asd_sas_port *port);
+void sas_unregister_domain_devices(struct asd_sas_port *port, int gone);
 void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *);
 int  sas_discover_event(struct asd_sas_port *, enum discover_event ev);
 
@@ -661,20 +674,20 @@ void sas_unregister_dev(struct asd_sas_port *port, struct domain_device *);
 void sas_init_dev(struct domain_device *);
 
 void sas_task_abort(struct sas_task *);
-int __sas_task_abort(struct sas_task *);
 int sas_eh_device_reset_handler(struct scsi_cmnd *cmd);
 int sas_eh_bus_reset_handler(struct scsi_cmnd *cmd);
 
 extern void sas_target_destroy(struct scsi_target *);
 extern int sas_slave_alloc(struct scsi_device *);
 extern int sas_ioctl(struct scsi_device *sdev, int cmd, void __user *arg);
+extern int sas_drain_work(struct sas_ha_struct *ha);
 
 extern int sas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
                            struct request *req);
 
 extern void sas_ssp_task_response(struct device *dev, struct sas_task *task,
                                   struct ssp_response_iu *iu);
-struct sas_phy *sas_find_local_phy(struct domain_device *dev);
+struct sas_phy *sas_get_local_phy(struct domain_device *dev);
 
 int sas_request_addr(struct Scsi_Host *shost, u8 *addr);
 
diff --git a/include/scsi/sas.h b/include/scsi/sas.h
index 3673d685e6a..a577a833603 100644
--- a/include/scsi/sas.h
+++ b/include/scsi/sas.h
@@ -89,8 +89,7 @@ enum sas_oob_mode {
         SAS_OOB_MODE
 };
 
-/* See sas_discover.c if you plan on changing these.
- */
+/* See sas_discover.c if you plan on changing these */
 enum sas_dev_type {
         NO_DEVICE   = 0,          /* protocol */
         SAS_END_DEV = 1,          /* protocol */
@@ -100,6 +99,7 @@ enum sas_dev_type {
         SATA_DEV    = 5,
         SATA_PM     = 7,
         SATA_PM_PORT= 8,
+        SATA_PENDING  = 9,
 };
 
 enum sas_protocol {
diff --git a/include/scsi/sas_ata.h b/include/scsi/sas_ata.h
index 9c159f74c6d..cdccd2eb7b6 100644
--- a/include/scsi/sas_ata.h
+++ b/include/scsi/sas_ata.h
@@ -32,19 +32,19 @@
 
 static inline int dev_is_sata(struct domain_device *dev)
 {
-        return (dev->rphy->identify.target_port_protocols & SAS_PROTOCOL_SATA);
+        return dev->dev_type == SATA_DEV || dev->dev_type == SATA_PM ||
+               dev->dev_type == SATA_PM_PORT || dev->dev_type == SATA_PENDING;
 }
 
-int sas_ata_init_host_and_port(struct domain_device *found_dev,
-                               struct scsi_target *starget);
-
+int sas_get_ata_info(struct domain_device *dev, struct ex_phy *phy);
+int sas_ata_init_host_and_port(struct domain_device *found_dev);
 void sas_ata_task_abort(struct sas_task *task);
 void sas_ata_strategy_handler(struct Scsi_Host *shost);
-int sas_ata_timed_out(struct scsi_cmnd *cmd, struct sas_task *task,
-                      enum blk_eh_timer_return *rtn);
-int sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q,
-               struct list_head *done_q);
-
+void sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q,
+                struct list_head *done_q);
+void sas_ata_schedule_reset(struct domain_device *dev);
+void sas_ata_wait_eh(struct domain_device *dev);
+void sas_probe_sata(struct asd_sas_port *port);
 #else
 
 
@@ -52,8 +52,7 @@ static inline int dev_is_sata(struct domain_device *dev)
 {
         return 0;
 }
-static inline int sas_ata_init_host_and_port(struct domain_device *found_dev,
-                               struct scsi_target *starget)
+static inline int sas_ata_init_host_and_port(struct domain_device *found_dev)
 {
         return 0;
 }
@@ -65,18 +64,27 @@ static inline void sas_ata_strategy_handler(struct Scsi_Host *shost)
 {
 }
 
-static inline int sas_ata_timed_out(struct scsi_cmnd *cmd,
-                                    struct sas_task *task,
-                                    enum blk_eh_timer_return *rtn)
+static inline void sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q,
+                              struct list_head *done_q)
 {
-        return 0;
 }
-static inline int sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q,
-                             struct list_head *done_q)
+
+static inline void sas_ata_schedule_reset(struct domain_device *dev)
+{
+}
+
+static inline void sas_ata_wait_eh(struct domain_device *dev)
+{
+}
+
+static inline void sas_probe_sata(struct asd_sas_port *port)
 {
-        return 0;
 }
 
+static inline int sas_get_ata_info(struct domain_device *dev, struct ex_phy *phy)
+{
+        return 0;
+}
 #endif
 
 #endif /* _SAS_ATA_H_ */
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index a5e885a111d..377df4a2851 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -10,6 +10,7 @@
 
 struct Scsi_Host;
 struct scsi_device;
+struct scsi_driver;
 
 /*
  * MAX_COMMAND_SIZE is:
@@ -131,6 +132,11 @@ struct scsi_cmnd {
         unsigned char tag;      /* SCSI-II queued command tag */
 };
 
+static inline struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)
+{
+        return *(struct scsi_driver **)cmd->request->rq_disk->private_data;
+}
+
 extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t);
 extern struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *, gfp_t);
 extern void scsi_put_command(struct scsi_cmnd *);
@@ -289,17 +295,17 @@ static inline struct scsi_data_buffer *scsi_prot(struct scsi_cmnd *cmd)
 
 static inline void set_msg_byte(struct scsi_cmnd *cmd, char status)
 {
-        cmd->result |= status << 8;
+        cmd->result = (cmd->result & 0xffff00ff) | (status << 8);
 }
 
 static inline void set_host_byte(struct scsi_cmnd *cmd, char status)
 {
-        cmd->result |= status << 16;
+        cmd->result = (cmd->result & 0xff00ffff) | (status << 16);
 }
 
 static inline void set_driver_byte(struct scsi_cmnd *cmd, char status)
 {
-        cmd->result |= status << 24;
+        cmd->result = (cmd->result & 0x00ffffff) | (status << 24);
 }
 
 #endif /* _SCSI_SCSI_CMND_H */
diff --git a/include/scsi/scsi_driver.h b/include/scsi/scsi_driver.h
index 9fd6702f02e..d443aa06a72 100644
--- a/include/scsi/scsi_driver.h
+++ b/include/scsi/scsi_driver.h
@@ -16,6 +16,7 @@ struct scsi_driver {
 
         void (*rescan)(struct device *);
         int (*done)(struct scsi_cmnd *);
+        int (*eh_action)(struct scsi_cmnd *, unsigned char *, int, int);
 };
 #define to_scsi_driver(drv) \
         container_of((drv), struct scsi_driver, gendrv)
diff --git a/include/scsi/scsi_transport_fc.h b/include/scsi/scsi_transport_fc.h
index 2a65167a8f1..719faf1863a 100644
--- a/include/scsi/scsi_transport_fc.h
+++ b/include/scsi/scsi_transport_fc.h
@@ -126,8 +126,8 @@ enum fc_vport_state {
                                              incapable of reporting */
 #define FC_PORTSPEED_1GBIT              1
 #define FC_PORTSPEED_2GBIT              2
-#define FC_PORTSPEED_4GBIT              4
-#define FC_PORTSPEED_10GBIT             8
+#define FC_PORTSPEED_10GBIT             4
+#define FC_PORTSPEED_4GBIT              8
 #define FC_PORTSPEED_8GBIT              0x10
 #define FC_PORTSPEED_16GBIT             0x20
 #define FC_PORTSPEED_NOT_NEGOTIATED     (1 << 15) /* Speed not established */
@@ -486,6 +486,13 @@ struct fc_host_attrs {
         u32 maxframe_size;
         u16 max_npiv_vports;
         char serial_number[FC_SERIAL_NUMBER_SIZE];
+        char manufacturer[FC_SERIAL_NUMBER_SIZE];
+        char model[FC_SYMBOLIC_NAME_SIZE];
+        char model_description[FC_SYMBOLIC_NAME_SIZE];
+        char hardware_version[FC_VERSION_STRING_SIZE];
+        char driver_version[FC_VERSION_STRING_SIZE];
+        char firmware_version[FC_VERSION_STRING_SIZE];
+        char optionrom_version[FC_VERSION_STRING_SIZE];
 
         /* Dynamic Attributes */
         u32 port_id;
@@ -541,6 +548,20 @@ struct fc_host_attrs {
         (((struct fc_host_attrs *)(x)->shost_data)->max_npiv_vports)
 #define fc_host_serial_number(x)        \
         (((struct fc_host_attrs *)(x)->shost_data)->serial_number)
+#define fc_host_manufacturer(x) \
+        (((struct fc_host_attrs *)(x)->shost_data)->manufacturer)
+#define fc_host_model(x)        \
+        (((struct fc_host_attrs *)(x)->shost_data)->model)
+#define fc_host_model_description(x)    \
+        (((struct fc_host_attrs *)(x)->shost_data)->model_description)
+#define fc_host_hardware_version(x)     \
+        (((struct fc_host_attrs *)(x)->shost_data)->hardware_version)
+#define fc_host_driver_version(x)       \
+        (((struct fc_host_attrs *)(x)->shost_data)->driver_version)
+#define fc_host_firmware_version(x)     \
+        (((struct fc_host_attrs *)(x)->shost_data)->firmware_version)
+#define fc_host_optionrom_version(x)    \
+        (((struct fc_host_attrs *)(x)->shost_data)->optionrom_version)
 #define fc_host_port_id(x)      \
         (((struct fc_host_attrs *)(x)->shost_data)->port_id)
 #define fc_host_port_type(x)    \
@@ -700,6 +721,13 @@ struct fc_function_template {
         unsigned long   show_host_supported_speeds:1;
         unsigned long   show_host_maxframe_size:1;
         unsigned long   show_host_serial_number:1;
+        unsigned long   show_host_manufacturer:1;
+        unsigned long   show_host_model:1;
+        unsigned long   show_host_model_description:1;
+        unsigned long   show_host_hardware_version:1;
+        unsigned long   show_host_driver_version:1;
+        unsigned long   show_host_firmware_version:1;
+        unsigned long   show_host_optionrom_version:1;
         /* host dynamic attributes */
         unsigned long   show_host_port_id:1;
         unsigned long   show_host_port_type:1;
diff --git a/include/scsi/scsi_transport_iscsi.h b/include/scsi/scsi_transport_iscsi.h
index 2c3a46d102f..53f0b361d66 100644
--- a/include/scsi/scsi_transport_iscsi.h
+++ b/include/scsi/scsi_transport_iscsi.h
@@ -144,6 +144,12 @@ struct iscsi_transport {
                                 int param, char *buf);
         umode_t (*attr_is_visible)(int param_type, int param);
         int (*bsg_request)(struct bsg_job *job);
+        int (*send_ping) (struct Scsi_Host *shost, uint32_t iface_num,
+                          uint32_t iface_type, uint32_t payload_size,
+                          uint32_t pid, struct sockaddr *dst_addr);
+        int (*get_chap) (struct Scsi_Host *shost, uint16_t chap_tbl_idx,
+                         uint32_t *num_entries, char *buf);
+        int (*delete_chap) (struct Scsi_Host *shost, uint16_t chap_tbl_idx);
 };
 
 /*
@@ -166,6 +172,17 @@ extern int iscsi_offload_mesg(struct Scsi_Host *shost,
                               struct iscsi_transport *transport, uint32_t type,
                               char *data, uint16_t data_size);
 
+extern void iscsi_post_host_event(uint32_t host_no,
+                                  struct iscsi_transport *transport,
+                                  enum iscsi_host_event_code code,
+                                  uint32_t data_size,
+                                  uint8_t *data);
+
+extern void iscsi_ping_comp_event(uint32_t host_no,
+                                  struct iscsi_transport *transport,
+                                  uint32_t status, uint32_t pid,
+                                  uint32_t data_size, uint8_t *data);
+
 struct iscsi_cls_conn {
         struct list_head conn_list;     /* item in connlist */
         void *dd_data;                  /* LLD private data */
@@ -238,6 +255,8 @@ struct iscsi_cls_host {
         atomic_t nr_scans;
         struct mutex mutex;
         struct request_queue *bsg_q;
+        uint32_t port_speed;
+        uint32_t port_state;
 };
 
 #define iscsi_job_to_shost(_job) \
@@ -307,5 +326,8 @@ extern struct iscsi_iface *iscsi_create_iface(struct Scsi_Host *shost,
                                               uint32_t iface_num, int dd_size);
 extern void iscsi_destroy_iface(struct iscsi_iface *iface);
 extern struct iscsi_iface *iscsi_lookup_iface(int handle);
+extern char *iscsi_get_port_speed_name(struct Scsi_Host *shost);
+extern char *iscsi_get_port_state_name(struct Scsi_Host *shost);
+extern int iscsi_is_session_dev(const struct device *dev);
 
 #endif
diff --git a/include/scsi/scsi_transport_sas.h b/include/scsi/scsi_transport_sas.h
index ffeebc34a4f..98b3a20a010 100644
--- a/include/scsi/scsi_transport_sas.h
+++ b/include/scsi/scsi_transport_sas.h
@@ -75,7 +75,8 @@ struct sas_phy {
         /* for the list of phys belonging to a port */
         struct list_head        port_siblings;
 
-        struct work_struct      reset_work;
+        /* available to the lldd */
+        void                    *hostdata;
 };
 
 #define dev_to_phy(d) \
@@ -169,6 +170,8 @@ struct sas_function_template {
         int (*get_bay_identifier)(struct sas_rphy *);
         int (*phy_reset)(struct sas_phy *, int);
         int (*phy_enable)(struct sas_phy *, int);
+        int (*phy_setup)(struct sas_phy *);
+        void (*phy_release)(struct sas_phy *);
         int (*set_phy_speed)(struct sas_phy *, struct sas_phy_linkrates *);
         int (*smp_handler)(struct Scsi_Host *, struct sas_rphy *, struct request *);
 };
@@ -194,6 +197,7 @@ void sas_rphy_free(struct sas_rphy *);
 extern int sas_rphy_add(struct sas_rphy *);
 extern void sas_rphy_remove(struct sas_rphy *);
 extern void sas_rphy_delete(struct sas_rphy *);
+extern void sas_rphy_unlink(struct sas_rphy *);
 extern int scsi_is_sas_rphy(const struct device *);
 
 struct sas_port *sas_port_alloc(struct device *, int);
@@ -205,6 +209,12 @@ void sas_port_add_phy(struct sas_port *, struct sas_phy *);
 void sas_port_delete_phy(struct sas_port *, struct sas_phy *);
 void sas_port_mark_backlink(struct sas_port *);
 int scsi_is_sas_port(const struct device *);
+struct sas_phy *sas_port_get_phy(struct sas_port *port);
+static inline void sas_port_put_phy(struct sas_phy *phy)
+{
+        if (phy)
+                put_device(&phy->dev);
+}
 
 extern struct scsi_transport_template *
 sas_attach_transport(struct sas_function_template *);