megaraid_sas: add support for secure JBOD

This patch adds support for Secure Encrypting Drives (SED) in JBOD mode:

1) If the firmware supports SED JBOD, all non read/write commands to JBODs
   will be sent via firmware path, and read/write commands to JBODs will
   be sent via fastpath.
2) If the firmware does not support SED JBOD, driver will fall back to the
   old design, i.e. send all JBOD I/O via fastpath.

Signed-off-by: Sumit Saxena <sumit.saxena@avagotech.com>
Signed-off-by: Chaitra Basappa <chaitra.basappa@avagotech.com>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>

3 files changed, 107 insertions, 51 deletions

diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index 0d44d91c2fce..b8b378dec7ec 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -969,7 +969,20 @@ struct megasas_ctrl_info {
 
         struct {
 #if defined(__BIG_ENDIAN_BITFIELD)
-                u32     reserved:25;
+                u32     reserved:12;
+                u32     discardCacheDuringLDDelete:1;
+                u32     supportSecurityonJBOD:1;
+                u32     supportCacheBypassModes:1;
+                u32     supportDisableSESMonitoring:1;
+                u32     supportForceFlash:1;
+                u32     supportNVDRAM:1;
+                u32     supportDrvActivityLEDSetting:1;
+                u32     supportAllowedOpsforDrvRemoval:1;
+                u32     supportHOQRebuild:1;
+                u32     supportForceTo512e:1;
+                u32     supportNVCacheErase:1;
+                u32     supportDebugQueue:1;
+                u32     supportSwZone:1;
                 u32     supportCrashDump:1;
                 u32     supportMaxExtLDs:1;
                 u32     supportT10RebuildAssist:1;
@@ -981,9 +994,22 @@ struct megasas_ctrl_info {
                 u32     supportThermalPollInterval:1;
                 u32     supportDisableImmediateIO:1;
                 u32     supportT10RebuildAssist:1;
-                u32     supportMaxExtLDs:1;
-                u32     supportCrashDump:1;
-                u32     reserved:25;
+                u32     supportMaxExtLDs:1;
+                u32     supportCrashDump:1;
+                u32     supportSwZone:1;
+                u32     supportDebugQueue:1;
+                u32     supportNVCacheErase:1;
+                u32     supportForceTo512e:1;
+                u32     supportHOQRebuild:1;
+                u32     supportAllowedOpsforDrvRemoval:1;
+                u32     supportDrvActivityLEDSetting:1;
+                u32     supportNVDRAM:1;
+                u32     supportForceFlash:1;
+                u32     supportDisableSESMonitoring:1;
+                u32     supportCacheBypassModes:1;
+                u32     supportSecurityonJBOD:1;
+                u32     discardCacheDuringLDDelete:1;
+                u32     reserved:12;
 #endif
         } adapterOperations3;
 
@@ -1022,6 +1048,13 @@ enum MR_MFI_MPT_PTHR_FLAGS {
         MFI_MPT_ATTACHED = 2,
 };
 
+enum MR_SCSI_CMD_TYPE {
+        READ_WRITE_LDIO = 0,
+        NON_READ_WRITE_LDIO = 1,
+        READ_WRITE_SYSPDIO = 2,
+        NON_READ_WRITE_SYSPDIO = 3,
+};
+
 /* Frame Type */
 #define IO_FRAME                                0
 #define PTHRU_FRAME                             1
@@ -1194,19 +1227,23 @@ union megasas_sgl_frame {
 typedef union _MFI_CAPABILITIES {
         struct {
 #if   defined(__BIG_ENDIAN_BITFIELD)
-                u32     reserved:27;
+                u32     reserved:25;
+                u32     security_protocol_cmds_fw:1;
+                u32     support_core_affinity:1;
                 u32     support_ndrive_r1_lb:1;
                 u32     support_max_255lds:1;
-                u32     reserved1:1;
+                u32     support_fastpath_wb:1;
                 u32     support_additional_msix:1;
                 u32     support_fp_remote_lun:1;
 #else
                 u32     support_fp_remote_lun:1;
                 u32     support_additional_msix:1;
-                u32     reserved1:1;
+                u32     support_fastpath_wb:1;
                 u32     support_max_255lds:1;
                 u32     support_ndrive_r1_lb:1;
-                u32     reserved:27;
+                u32     support_core_affinity:1;
+                u32     security_protocol_cmds_fw:1;
+                u32     reserved:25;
 #endif
         } mfi_capabilities;
         u32     reg;
@@ -1638,13 +1675,14 @@ struct megasas_instance {
         u32 crash_dump_fw_support;
         u32 crash_dump_drv_support;
         u32 crash_dump_app_support;
+        u32 secure_jbod_support;
         spinlock_t crashdump_lock;
 
         struct megasas_register_set __iomem *reg_set;
         u32 *reply_post_host_index_addr[MR_MAX_MSIX_REG_ARRAY];
         struct megasas_pd_list          pd_list[MEGASAS_MAX_PD];
         struct megasas_pd_list          local_pd_list[MEGASAS_MAX_PD];
-        u8     ld_ids[MEGASAS_MAX_LD_IDS];
+        u8 ld_ids[MEGASAS_MAX_LD_IDS];
         s8 init_id;
 
         u16 max_num_sge;
@@ -1946,5 +1984,6 @@ void __megasas_return_cmd(struct megasas_instance *instance,
 
 void megasas_return_mfi_mpt_pthr(struct megasas_instance *instance,
         struct megasas_cmd *cmd_mfi, struct megasas_cmd_fusion *cmd_fusion);
+int megasas_cmd_type(struct scsi_cmnd *cmd);
 
 #endif                          /*LSI_MEGARAID_SAS_H */
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 401ed67cf4c1..9f37ddee4d8c 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -1417,16 +1417,15 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
 }
 
 /**
- * megasas_is_ldio -            Checks if the cmd is for logical drive
+ * megasas_cmd_type -           Checks if the cmd is for logical drive/sysPD
+ *                              and whether it's RW or non RW
  * @scmd:                       SCSI command
  *
- * Called by megasas_queue_command to find out if the command to be queued
- * is a logical drive command
  */
-inline int megasas_is_ldio(struct scsi_cmnd *cmd)
+inline int megasas_cmd_type(struct scsi_cmnd *cmd)
 {
-        if (!MEGASAS_IS_LOGICAL(cmd))
-                return 0;
+        int ret;
+
         switch (cmd->cmnd[0]) {
         case READ_10:
         case WRITE_10:
@@ -1436,10 +1435,14 @@ inline int megasas_is_ldio(struct scsi_cmnd *cmd)
         case WRITE_6:
         case READ_16:
         case WRITE_16:
-                return 1;
+                ret = (MEGASAS_IS_LOGICAL(cmd)) ?
+                        READ_WRITE_LDIO : READ_WRITE_SYSPDIO;
+                break;
         default:
-                return 0;
+                ret = (MEGASAS_IS_LOGICAL(cmd)) ?
+                        NON_READ_WRITE_LDIO : NON_READ_WRITE_SYSPDIO;
         }
+        return ret;
 }
 
  /**
@@ -1471,7 +1474,7 @@ megasas_dump_pending_frames(struct megasas_instance *instance)
                 if(!cmd->scmd)
                         continue;
                 printk(KERN_ERR "megasas[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
-                if (megasas_is_ldio(cmd->scmd)){
+                if (megasas_cmd_type(cmd->scmd) == READ_WRITE_LDIO) {
                         ldio = (struct megasas_io_frame *)cmd->frame;
                         mfi_sgl = &ldio->sgl;
                         sgcount = ldio->sge_count;
@@ -1531,7 +1534,7 @@ megasas_build_and_issue_cmd(struct megasas_instance *instance,
         /*
          * Logical drive command
          */
-        if (megasas_is_ldio(scmd))
+        if (megasas_cmd_type(scmd) == READ_WRITE_LDIO)
                 frame_count = megasas_build_ldio(instance, scmd, cmd);
         else
                 frame_count = megasas_build_dcdb(instance, scmd, cmd);
@@ -4629,6 +4632,11 @@ static int megasas_init_fw(struct megasas_instance *instance)
                                 instance->crash_dump_h);
                 instance->crash_dump_buf = NULL;
         }
+
+        instance->secure_jbod_support =
+                ctrl_info->adapterOperations3.supportSecurityonJBOD;
+        if (instance->secure_jbod_support)
+                dev_info(&instance->pdev->dev, "Firmware supports Secure JBOD\n");
         instance->max_sectors_per_req = instance->max_num_sge *
                                                 PAGE_SIZE / 512;
         if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
index b5362c196000..af5ab9e5e8e5 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -63,7 +63,6 @@ extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance
 extern void
 megasas_complete_cmd(struct megasas_instance *instance,
                      struct megasas_cmd *cmd, u8 alt_status);
-int megasas_is_ldio(struct scsi_cmnd *cmd);
 int
 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
               int seconds);
@@ -196,6 +195,7 @@ inline void megasas_return_cmd_fusion(struct megasas_instance *instance,
 
         cmd->scmd = NULL;
         cmd->sync_cmd_idx = (u32)ULONG_MAX;
+        memset(cmd->io_request, 0, sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));
         list_add(&cmd->list, (&fusion->cmd_pool)->next);
 
         spin_unlock_irqrestore(&fusion->mpt_pool_lock, flags);
@@ -689,6 +689,8 @@ megasas_ioc_init_fusion(struct megasas_instance *instance)
                 = 1;
         init_frame->driver_operations.mfi_capabilities.support_ndrive_r1_lb
                 = 1;
+        init_frame->driver_operations.mfi_capabilities.security_protocol_cmds_fw
+                = 1;
         /* Convert capability to LE32 */
         cpu_to_le32s((u32 *)&init_frame->driver_operations.mfi_capabilities);
 
@@ -1284,6 +1286,7 @@ megasas_make_sgl_fusion(struct megasas_instance *instance,
 
                         sgl_ptr =
                           (struct MPI25_IEEE_SGE_CHAIN64 *)cmd->sg_frame;
+                        memset(sgl_ptr, 0, MEGASAS_MAX_SZ_CHAIN_FRAME);
                 }
         }
 
@@ -1657,6 +1660,8 @@ megasas_build_dcdb_fusion(struct megasas_instance *instance,
         u32 device_id;
         struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
         u16 pd_index = 0;
+        u16 os_timeout_value;
+        u16 timeout_limit;
         struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
         struct fusion_context *fusion = instance->ctrl_context;
         u8                          span, physArm;
@@ -1673,44 +1678,48 @@ megasas_build_dcdb_fusion(struct megasas_instance *instance,
 
         io_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
 
-
-        /* Check if this is a system PD I/O */
         if (scmd->device->channel < MEGASAS_MAX_PD_CHANNELS &&
             instance->pd_list[pd_index].driveState == MR_PD_STATE_SYSTEM) {
-                io_request->Function = 0;
                 if (fusion->fast_path_io)
                         io_request->DevHandle =
                         local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
-                io_request->RaidContext.timeoutValue =
-                        local_map_ptr->raidMap.fpPdIoTimeoutSec;
-                io_request->RaidContext.regLockFlags = 0;
-                io_request->RaidContext.regLockRowLBA = 0;
-                io_request->RaidContext.regLockLength = 0;
                 io_request->RaidContext.RAIDFlags =
-                        MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD <<
-                        MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
-                if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
-                        (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
-                        io_request->IoFlags |= cpu_to_le16(
-                                MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
-                cmd->request_desc->SCSIIO.RequestFlags =
-                        (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
-                         MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
-                cmd->request_desc->SCSIIO.DevHandle =
-                        local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
+                        MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD
+                        << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
+                cmd->request_desc->SCSIIO.DevHandle = io_request->DevHandle;
                 cmd->request_desc->SCSIIO.MSIxIndex =
                         instance->msix_vectors ? smp_processor_id() % instance->msix_vectors : 0;
-                /*
-                 * If the command is for the tape device, set the
-                 * FP timeout to the os layer timeout value.
-                 */
-                if (scmd->device->type == TYPE_TAPE) {
-                        if ((scmd->request->timeout / HZ) > 0xFFFF)
-                                io_request->RaidContext.timeoutValue =
-                                        0xFFFF;
-                        else
-                                io_request->RaidContext.timeoutValue =
-                                        scmd->request->timeout / HZ;
+                os_timeout_value = scmd->request->timeout / HZ;
+
+                if (instance->secure_jbod_support &&
+                        (megasas_cmd_type(scmd) == NON_READ_WRITE_SYSPDIO)) {
+                        /* system pd firmware path */
+                        io_request->Function  =
+                                MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
+                        cmd->request_desc->SCSIIO.RequestFlags =
+                                (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
+                                MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
+                        io_request->RaidContext.timeoutValue =
+                                cpu_to_le16(os_timeout_value);
+                } else {
+                        /* system pd Fast Path */
+                        io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
+                        io_request->RaidContext.regLockFlags = 0;
+                        io_request->RaidContext.regLockRowLBA = 0;
+                        io_request->RaidContext.regLockLength = 0;
+                        timeout_limit = (scmd->device->type == TYPE_DISK) ?
+                                        255 : 0xFFFF;
+                        io_request->RaidContext.timeoutValue =
+                                cpu_to_le16((os_timeout_value > timeout_limit) ?
+                                timeout_limit : os_timeout_value);
+                if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
+                        (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
+                        io_request->IoFlags |=
+                        cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
+
+                        cmd->request_desc->SCSIIO.RequestFlags =
+                                (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
+                                MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
                 }
         } else {
                 if (scmd->device->channel < MEGASAS_MAX_PD_CHANNELS)
@@ -1810,7 +1819,7 @@ megasas_build_io_fusion(struct megasas_instance *instance,
          */
         io_request->IoFlags = cpu_to_le16(scp->cmd_len);
 
-        if (megasas_is_ldio(scp))
+        if (megasas_cmd_type(scp) == READ_WRITE_LDIO)
                 megasas_build_ldio_fusion(instance, scp, cmd);
         else
                 megasas_build_dcdb_fusion(instance, scp, cmd);