scsi: smartpqi: Resolve delay issue with PQI_HZ value

Change PQI_HZ to HZ.

PQI_HZ macro was set to 1000 when HZ value is less than 1000.  By default,
PQI_HZ will result into a delay of 10 seconds(for kernel, which has HZ =
100). So in this case when firmware raises an event, rescan worker will be
scheduled after a delay of (10 x PQI_HZ) = 100 seconds instead of 10
seconds.

Also driver uses PQI_HZ at many instances, which might result in some other
issues with respect to delay.

Link: https://lore.kernel.org/r/164375210825.440833.15510172447583227486.stgit@brunhilda.pdev.net
Reviewed-by: Kevin Barnett <kevin.barnett@microchip.com>
Reviewed-by: Mike McGowen <mike.mcgowen@microchip.com>
Reviewed-by: Scott Benesh <scott.benesh@microchip.com>
Reviewed-by: Scott Teel <scott.teel@microchip.com>
Signed-off-by: Balsundar P <balsundar.p@microchip.com>
Signed-off-by: Don Brace <don.brace@microchip.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/smartpqi/smartpqi.h b/drivers/scsi/smartpqi/smartpqi.h
index f192745ee488d3079f7c50ce6e4c1229cd158017..81ec5fbf570a77ce0e67adce905837c6ed0f6927 100644 (file)
--- a/drivers/scsi/smartpqi/smartpqi.h
+++ b/drivers/scsi/smartpqi/smartpqi.h
@@ -96,12 +96,6 @@ struct pqi_ctrl_registers {
        struct pqi_device_registers pqi_registers;      /* 4000h */
 };
 
-#if ((HZ) < 1000)
-#define PQI_HZ  1000
-#else
-#define PQI_HZ  (HZ)
-#endif
-
 #define PQI_DEVICE_REGISTERS_OFFSET    0x4000
 
 /* shutdown reasons for taking the controller offline */

diff --git a/drivers/scsi/smartpqi/smartpqi_init.c b/drivers/scsi/smartpqi/smartpqi_init.c
index 075e41b5ceaa5d6a7e30d2e9614ef036906702ea..b32a5a5a5c215e552d21d8f23c1ec20edf5c5eed 100644 (file)
--- a/drivers/scsi/smartpqi/smartpqi_init.c
+++ b/drivers/scsi/smartpqi/smartpqi_init.c
@@ -376,7 +376,7 @@ static inline void pqi_ctrl_wait_until_quiesced(struct pqi_ctrl_info *ctrl_info)
 
        displayed_warning = false;
        start_jiffies = jiffies;
-       warning_timeout = (PQI_QUIESCE_WARNING_TIMEOUT_SECS * PQI_HZ) + start_jiffies;
+       warning_timeout = (PQI_QUIESCE_WARNING_TIMEOUT_SECS * HZ) + start_jiffies;
 
        while (atomic_read(&ctrl_info->num_busy_threads) >
                atomic_read(&ctrl_info->num_blocked_threads)) {
@@ -385,7 +385,7 @@ static inline void pqi_ctrl_wait_until_quiesced(struct pqi_ctrl_info *ctrl_info)
                                "waiting %u seconds for driver activity to quiesce\n",
                                jiffies_to_msecs(jiffies - start_jiffies) / 1000);
                        displayed_warning = true;
-                       warning_timeout = (PQI_QUIESCE_WARNING_TIMEOUT_SECS * PQI_HZ) + jiffies;
+                       warning_timeout = (PQI_QUIESCE_WARNING_TIMEOUT_SECS * HZ) + jiffies;
                }
                usleep_range(1000, 2000);
        }
@@ -462,7 +462,7 @@ static inline void pqi_schedule_rescan_worker(struct pqi_ctrl_info *ctrl_info)
        pqi_schedule_rescan_worker_with_delay(ctrl_info, 0);
 }
 
-#define PQI_RESCAN_WORK_DELAY  (10 * PQI_HZ)
+#define PQI_RESCAN_WORK_DELAY  (10 * HZ)
 
 static inline void pqi_schedule_rescan_worker_delayed(struct pqi_ctrl_info *ctrl_info)
 {
@@ -1038,7 +1038,7 @@ static int pqi_write_current_time_to_host_wellness(
        return rc;
 }
 
-#define PQI_UPDATE_TIME_WORK_INTERVAL  (24UL * 60 * 60 * PQI_HZ)
+#define PQI_UPDATE_TIME_WORK_INTERVAL  (24UL * 60 * 60 * HZ)
 
 static void pqi_update_time_worker(struct work_struct *work)
 {
@@ -3045,7 +3045,7 @@ static int pqi_wait_for_pqi_mode_ready(struct pqi_ctrl_info *ctrl_info)
        u8 status;
 
        pqi_registers = ctrl_info->pqi_registers;
-       timeout = (PQI_MODE_READY_TIMEOUT_SECS * PQI_HZ) + jiffies;
+       timeout = (PQI_MODE_READY_TIMEOUT_SECS * HZ) + jiffies;
 
        while (1) {
                signature = readq(&pqi_registers->signature);
@@ -3539,7 +3539,7 @@ static enum pqi_soft_reset_status pqi_poll_for_soft_reset_status(
        u8 status;
        unsigned long timeout;
 
-       timeout = (PQI_SOFT_RESET_STATUS_TIMEOUT_SECS * PQI_HZ) + jiffies;
+       timeout = (PQI_SOFT_RESET_STATUS_TIMEOUT_SECS * HZ) + jiffies;
 
        while (1) {
                status = pqi_read_soft_reset_status(ctrl_info);
@@ -3717,7 +3717,7 @@ out:
        pqi_ctrl_unbusy(ctrl_info);
 }
 
-#define PQI_HEARTBEAT_TIMER_INTERVAL   (10 * PQI_HZ)
+#define PQI_HEARTBEAT_TIMER_INTERVAL   (10 * HZ)
 
 static void pqi_heartbeat_timer_handler(struct timer_list *t)
 {
@@ -4264,7 +4264,7 @@ static int pqi_alloc_admin_queues(struct pqi_ctrl_info *ctrl_info)
        return 0;
 }
 
-#define PQI_ADMIN_QUEUE_CREATE_TIMEOUT_JIFFIES         PQI_HZ
+#define PQI_ADMIN_QUEUE_CREATE_TIMEOUT_JIFFIES         HZ
 #define PQI_ADMIN_QUEUE_CREATE_POLL_INTERVAL_MSECS     1
 
 static int pqi_create_admin_queues(struct pqi_ctrl_info *ctrl_info)
@@ -4358,7 +4358,7 @@ static int pqi_poll_for_admin_response(struct pqi_ctrl_info *ctrl_info,
        admin_queues = &ctrl_info->admin_queues;
        oq_ci = admin_queues->oq_ci_copy;
 
-       timeout = (PQI_ADMIN_REQUEST_TIMEOUT_SECS * PQI_HZ) + jiffies;
+       timeout = (PQI_ADMIN_REQUEST_TIMEOUT_SECS * HZ) + jiffies;
 
        while (1) {
                oq_pi = readl(admin_queues->oq_pi);
@@ -4473,7 +4473,7 @@ static int pqi_wait_for_completion_io(struct pqi_ctrl_info *ctrl_info,
 
        while (1) {
                if (wait_for_completion_io_timeout(wait,
-                       PQI_WAIT_FOR_COMPLETION_IO_TIMEOUT_SECS * PQI_HZ)) {
+                       PQI_WAIT_FOR_COMPLETION_IO_TIMEOUT_SECS * HZ)) {
                        rc = 0;
                        break;
                }
@@ -6065,7 +6065,7 @@ static int pqi_wait_until_inbound_queues_empty(struct pqi_ctrl_info *ctrl_info)
 
        displayed_warning = false;
        start_jiffies = jiffies;
-       warning_timeout = (PQI_INBOUND_QUEUES_NONEMPTY_WARNING_TIMEOUT_SECS * PQI_HZ) + start_jiffies;
+       warning_timeout = (PQI_INBOUND_QUEUES_NONEMPTY_WARNING_TIMEOUT_SECS * HZ) + start_jiffies;
 
        while (1) {
                queued_io_count = pqi_queued_io_count(ctrl_info);
@@ -6080,7 +6080,7 @@ static int pqi_wait_until_inbound_queues_empty(struct pqi_ctrl_info *ctrl_info)
                                "waiting %u seconds for queued I/O to drain (queued I/O count: %u; non-empty inbound queue count: %u)\n",
                                jiffies_to_msecs(jiffies - start_jiffies) / 1000, queued_io_count, nonempty_inbound_queue_count);
                        displayed_warning = true;
-                       warning_timeout = (PQI_INBOUND_QUEUES_NONEMPTY_WARNING_TIMEOUT_SECS * PQI_HZ) + jiffies;
+                       warning_timeout = (PQI_INBOUND_QUEUES_NONEMPTY_WARNING_TIMEOUT_SECS * HZ) + jiffies;
                }
                usleep_range(1000, 2000);
        }
@@ -6148,7 +6148,7 @@ static int pqi_device_wait_for_pending_io(struct pqi_ctrl_info *ctrl_info,
        unsigned long msecs_waiting;
 
        start_jiffies = jiffies;
-       warning_timeout = (PQI_PENDING_IO_WARNING_TIMEOUT_SECS * PQI_HZ) + start_jiffies;
+       warning_timeout = (PQI_PENDING_IO_WARNING_TIMEOUT_SECS * HZ) + start_jiffies;
 
        while ((cmds_outstanding = atomic_read(&device->scsi_cmds_outstanding)) > 0) {
                pqi_check_ctrl_health(ctrl_info);
@@ -6167,7 +6167,7 @@ static int pqi_device_wait_for_pending_io(struct pqi_ctrl_info *ctrl_info,
                                "scsi %d:%d:%d:%d: waiting %lu seconds for %d outstanding command(s)\n",
                                ctrl_info->scsi_host->host_no, device->bus, device->target,
                                device->lun, msecs_waiting / 1000, cmds_outstanding);
-                       warning_timeout = (PQI_PENDING_IO_WARNING_TIMEOUT_SECS * PQI_HZ) + jiffies;
+                       warning_timeout = (PQI_PENDING_IO_WARNING_TIMEOUT_SECS * HZ) + jiffies;
                }
                usleep_range(1000, 2000);
        }
@@ -6196,7 +6196,7 @@ static int pqi_wait_for_lun_reset_completion(struct pqi_ctrl_info *ctrl_info,
 
        while (1) {
                if (wait_for_completion_io_timeout(wait,
-                       PQI_LUN_RESET_POLL_COMPLETION_SECS * PQI_HZ)) {
+                       PQI_LUN_RESET_POLL_COMPLETION_SECS * HZ)) {
                        rc = 0;
                        break;
                }
@@ -7994,7 +7994,7 @@ static int pqi_ctrl_init(struct pqi_ctrl_info *ctrl_info)
                                return rc;
                }
                sis_soft_reset(ctrl_info);
-               msleep(PQI_POST_RESET_DELAY_SECS * PQI_HZ);
+               ssleep(PQI_POST_RESET_DELAY_SECS);
        } else {
                rc = pqi_force_sis_mode(ctrl_info);
                if (rc)

diff --git a/drivers/scsi/smartpqi/smartpqi_sis.c b/drivers/scsi/smartpqi/smartpqi_sis.c
index d66eb8ea161c50a1adb3ee493324ce2da37ff736..e176a1a0534dd4aa4eb9bafa22cdd69afcc3599e 100644 (file)
--- a/drivers/scsi/smartpqi/smartpqi_sis.c
+++ b/drivers/scsi/smartpqi/smartpqi_sis.c
@@ -92,7 +92,7 @@ static int sis_wait_for_ctrl_ready_with_timeout(struct pqi_ctrl_info *ctrl_info,
        unsigned long timeout;
        u32 status;
 
-       timeout = (timeout_secs * PQI_HZ) + jiffies;
+       timeout = (timeout_secs * HZ) + jiffies;
 
        while (1) {
                status = readl(&ctrl_info->registers->sis_firmware_status);
@@ -209,7 +209,7 @@ static int sis_send_sync_cmd(struct pqi_ctrl_info *ctrl_info,
         * the top of the loop in order to give the controller time to start
         * processing the command before we start polling.
         */
-       timeout = (SIS_CMD_COMPLETE_TIMEOUT_SECS * PQI_HZ) + jiffies;
+       timeout = (SIS_CMD_COMPLETE_TIMEOUT_SECS * HZ) + jiffies;
        while (1) {
                msleep(SIS_CMD_COMPLETE_POLL_INTERVAL_MSECS);
                doorbell = readl(&registers->sis_ctrl_to_host_doorbell);
@@ -355,7 +355,7 @@ static int sis_wait_for_doorbell_bit_to_clear(
        u32 doorbell_register;
        unsigned long timeout;
 
-       timeout = (SIS_DOORBELL_BIT_CLEAR_TIMEOUT_SECS * PQI_HZ) + jiffies;
+       timeout = (SIS_DOORBELL_BIT_CLEAR_TIMEOUT_SECS * HZ) + jiffies;
 
        while (1) {
                doorbell_register =
@@ -452,7 +452,7 @@ int sis_wait_for_fw_triage_completion(struct pqi_ctrl_info *ctrl_info)
        enum sis_fw_triage_status status;
        unsigned long timeout;
 
-       timeout = (SIS_FW_TRIAGE_STATUS_TIMEOUT_SECS * PQI_HZ) + jiffies;
+       timeout = (SIS_FW_TRIAGE_STATUS_TIMEOUT_SECS * HZ) + jiffies;
        while (1) {
                status = sis_read_firmware_triage_status(ctrl_info);
                if (status == FW_TRIAGE_COND_INVALID) {