Fixes for 5.10

Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/queue-5.10/bpf-declare-__bpf_free_used_maps-unconditionally.patch b/queue-5.10/bpf-declare-__bpf_free_used_maps-unconditionally.patch
new file mode 100644 (file)
index 0000000..724a7db
--- /dev/null
+++ b/queue-5.10/bpf-declare-__bpf_free_used_maps-unconditionally.patch
@@ -0,0 +1,50 @@
+From 2b7908e2a19b261b8a33c73259e91108bf9524ff Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 11 Jan 2021 23:55:16 -0800
+Subject: bpf: Declare __bpf_free_used_maps() unconditionally
+
+From: Andrii Nakryiko <andrii@kernel.org>
+
+[ Upstream commit 936f8946bdb48239f4292812d4d2e26c6d328c95 ]
+
+__bpf_free_used_maps() is always defined in kernel/bpf/core.c, while
+include/linux/bpf.h is guarding it behind CONFIG_BPF_SYSCALL. Move it out of
+that guard region and fix compiler warning.
+
+Fixes: a2ea07465c8d ("bpf: Fix missing prog untrack in release_maps")
+Reported-by: kernel test robot <lkp@intel.com>
+Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
+Signed-off-by: Alexei Starovoitov <ast@kernel.org>
+Acked-by: Yonghong Song <yhs@fb.com>
+Link: https://lore.kernel.org/bpf/20210112075520.4103414-4-andrii@kernel.org
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ include/linux/bpf.h | 5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/include/linux/bpf.h b/include/linux/bpf.h
+index 642ce03f19c4..76322b6452c8 100644
+--- a/include/linux/bpf.h
++++ b/include/linux/bpf.h
+@@ -1201,8 +1201,6 @@ struct bpf_prog * __must_check bpf_prog_inc_not_zero(struct bpf_prog *prog);
+ void bpf_prog_put(struct bpf_prog *prog);
+ int __bpf_prog_charge(struct user_struct *user, u32 pages);
+ void __bpf_prog_uncharge(struct user_struct *user, u32 pages);
+-void __bpf_free_used_maps(struct bpf_prog_aux *aux,
+-                        struct bpf_map **used_maps, u32 len);
+ 
+ void bpf_prog_free_id(struct bpf_prog *prog, bool do_idr_lock);
+ void bpf_map_free_id(struct bpf_map *map, bool do_idr_lock);
+@@ -1652,6 +1650,9 @@ static inline struct bpf_prog *bpf_prog_get_type(u32 ufd,
+       return bpf_prog_get_type_dev(ufd, type, false);
+ }
+ 
++void __bpf_free_used_maps(struct bpf_prog_aux *aux,
++                        struct bpf_map **used_maps, u32 len);
++
+ bool bpf_prog_get_ok(struct bpf_prog *, enum bpf_prog_type *, bool);
+ 
+ int bpf_prog_offload_compile(struct bpf_prog *prog);
+-- 
+2.30.1
+

diff --git a/queue-5.10/counter-stm32-timer-cnt-report-count-function-when-s.patch b/queue-5.10/counter-stm32-timer-cnt-report-count-function-when-s.patch
new file mode 100644 (file)
index 0000000..acefb65
--- /dev/null
+++ b/queue-5.10/counter-stm32-timer-cnt-report-count-function-when-s.patch
@@ -0,0 +1,139 @@
+From 7b43a4fed2d7ff4298f06629eac3da21720e2ce6 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Fri, 26 Feb 2021 10:29:31 +0900
+Subject: counter: stm32-timer-cnt: Report count function when
+ SLAVE_MODE_DISABLED
+
+From: William Breathitt Gray <vilhelm.gray@gmail.com>
+
+[ Upstream commit fae6f62e6a580b663ecf42c2120a0898deae9137 ]
+
+When in SLAVE_MODE_DISABLED mode, the count still increases if the
+counter is enabled because an internal clock is used. This patch fixes
+the stm32_count_function_get() and stm32_count_function_set() functions
+to properly handle this behavior.
+
+Fixes: ad29937e206f ("counter: Add STM32 Timer quadrature encoder")
+Cc: Fabrice Gasnier <fabrice.gasnier@st.com>
+Cc: Maxime Coquelin <mcoquelin.stm32@gmail.com>
+Cc: Alexandre Torgue <alexandre.torgue@st.com>
+Signed-off-by: William Breathitt Gray <vilhelm.gray@gmail.com>
+Reviewed-by: Fabrice Gasnier <fabrice.gasnier@foss.st.com>
+Link: https://lore.kernel.org/r/20210226012931.161429-1-vilhelm.gray@gmail.com
+Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/counter/stm32-timer-cnt.c | 39 ++++++++++++++++++++-----------
+ 1 file changed, 25 insertions(+), 14 deletions(-)
+
+diff --git a/drivers/counter/stm32-timer-cnt.c b/drivers/counter/stm32-timer-cnt.c
+index ef2a974a2f10..cd50dc12bd02 100644
+--- a/drivers/counter/stm32-timer-cnt.c
++++ b/drivers/counter/stm32-timer-cnt.c
+@@ -44,13 +44,14 @@ struct stm32_timer_cnt {
+  * @STM32_COUNT_ENCODER_MODE_3: counts on both TI1FP1 and TI2FP2 edges
+  */
+ enum stm32_count_function {
+-      STM32_COUNT_SLAVE_MODE_DISABLED = -1,
++      STM32_COUNT_SLAVE_MODE_DISABLED,
+       STM32_COUNT_ENCODER_MODE_1,
+       STM32_COUNT_ENCODER_MODE_2,
+       STM32_COUNT_ENCODER_MODE_3,
+ };
+ 
+ static enum counter_count_function stm32_count_functions[] = {
++      [STM32_COUNT_SLAVE_MODE_DISABLED] = COUNTER_COUNT_FUNCTION_INCREASE,
+       [STM32_COUNT_ENCODER_MODE_1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
+       [STM32_COUNT_ENCODER_MODE_2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
+       [STM32_COUNT_ENCODER_MODE_3] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
+@@ -90,6 +91,9 @@ static int stm32_count_function_get(struct counter_device *counter,
+       regmap_read(priv->regmap, TIM_SMCR, &smcr);
+ 
+       switch (smcr & TIM_SMCR_SMS) {
++      case 0:
++              *function = STM32_COUNT_SLAVE_MODE_DISABLED;
++              return 0;
+       case 1:
+               *function = STM32_COUNT_ENCODER_MODE_1;
+               return 0;
+@@ -99,9 +103,9 @@ static int stm32_count_function_get(struct counter_device *counter,
+       case 3:
+               *function = STM32_COUNT_ENCODER_MODE_3;
+               return 0;
++      default:
++              return -EINVAL;
+       }
+-
+-      return -EINVAL;
+ }
+ 
+ static int stm32_count_function_set(struct counter_device *counter,
+@@ -112,6 +116,9 @@ static int stm32_count_function_set(struct counter_device *counter,
+       u32 cr1, sms;
+ 
+       switch (function) {
++      case STM32_COUNT_SLAVE_MODE_DISABLED:
++              sms = 0;
++              break;
+       case STM32_COUNT_ENCODER_MODE_1:
+               sms = 1;
+               break;
+@@ -122,8 +129,7 @@ static int stm32_count_function_set(struct counter_device *counter,
+               sms = 3;
+               break;
+       default:
+-              sms = 0;
+-              break;
++              return -EINVAL;
+       }
+ 
+       /* Store enable status */
+@@ -274,31 +280,36 @@ static int stm32_action_get(struct counter_device *counter,
+       size_t function;
+       int err;
+ 
+-      /* Default action mode (e.g. STM32_COUNT_SLAVE_MODE_DISABLED) */
+-      *action = STM32_SYNAPSE_ACTION_NONE;
+-
+       err = stm32_count_function_get(counter, count, &function);
+       if (err)
+-              return 0;
++              return err;
+ 
+       switch (function) {
++      case STM32_COUNT_SLAVE_MODE_DISABLED:
++              /* counts on internal clock when CEN=1 */
++              *action = STM32_SYNAPSE_ACTION_NONE;
++              return 0;
+       case STM32_COUNT_ENCODER_MODE_1:
+               /* counts up/down on TI1FP1 edge depending on TI2FP2 level */
+               if (synapse->signal->id == count->synapses[0].signal->id)
+                       *action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
+-              break;
++              else
++                      *action = STM32_SYNAPSE_ACTION_NONE;
++              return 0;
+       case STM32_COUNT_ENCODER_MODE_2:
+               /* counts up/down on TI2FP2 edge depending on TI1FP1 level */
+               if (synapse->signal->id == count->synapses[1].signal->id)
+                       *action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
+-              break;
++              else
++                      *action = STM32_SYNAPSE_ACTION_NONE;
++              return 0;
+       case STM32_COUNT_ENCODER_MODE_3:
+               /* counts up/down on both TI1FP1 and TI2FP2 edges */
+               *action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
+-              break;
++              return 0;
++      default:
++              return -EINVAL;
+       }
+-
+-      return 0;
+ }
+ 
+ static const struct counter_ops stm32_timer_cnt_ops = {
+-- 
+2.30.1
+

diff --git a/queue-5.10/drm-amd-display-turn-dpms-off-on-connector-unplug.patch b/queue-5.10/drm-amd-display-turn-dpms-off-on-connector-unplug.patch
new file mode 100644 (file)
index 0000000..cf9ebe9
--- /dev/null
+++ b/queue-5.10/drm-amd-display-turn-dpms-off-on-connector-unplug.patch
@@ -0,0 +1,116 @@
+From c790cd79dbbba2d581cbc2d9c330da2b5bb13150 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 26 Nov 2020 16:45:59 -0500
+Subject: drm/amd/display: turn DPMS off on connector unplug
+
+From: Aurabindo Pillai <aurabindo.pillai@amd.com>
+
+[ Upstream commit 3c4d55c9b9becedd8d31a7c96783a364533713ab ]
+
+[Why&How]
+
+Set dpms off on the connector that was unplugged, for the side effect of
+releasing some references held through deallocation of MST payload. This is
+the expected behaviour for non MST devices as well.
+
+Signed-off-by: Aurabindo Pillai <aurabindo.pillai@amd.com>
+Signed-off-by: Eryk Brol <eryk.brol@amd.com>
+Reviewed-by: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
+Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ .../gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 32 ++++++++++++++++++-
+ drivers/gpu/drm/amd/display/dc/core/dc.c      | 13 ++++++++
+ drivers/gpu/drm/amd/display/dc/dc_stream.h    |  1 +
+ 3 files changed, 45 insertions(+), 1 deletion(-)
+
+diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
+index ea1ea147f607..c07737c45677 100644
+--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
+@@ -1902,6 +1902,33 @@ static void dm_gpureset_commit_state(struct dc_state *dc_state,
+       return;
+ }
+ 
++static void dm_set_dpms_off(struct dc_link *link)
++{
++      struct dc_stream_state *stream_state;
++      struct amdgpu_dm_connector *aconnector = link->priv;
++      struct amdgpu_device *adev = drm_to_adev(aconnector->base.dev);
++      struct dc_stream_update stream_update;
++      bool dpms_off = true;
++
++      memset(&stream_update, 0, sizeof(stream_update));
++      stream_update.dpms_off = &dpms_off;
++
++      mutex_lock(&adev->dm.dc_lock);
++      stream_state = dc_stream_find_from_link(link);
++
++      if (stream_state == NULL) {
++              DRM_DEBUG_DRIVER("Error finding stream state associated with link!\n");
++              mutex_unlock(&adev->dm.dc_lock);
++              return;
++      }
++
++      stream_update.stream = stream_state;
++      dc_commit_updates_for_stream(stream_state->ctx->dc, NULL, 0,
++                                   stream_state, &stream_update,
++                                   stream_state->ctx->dc->current_state);
++      mutex_unlock(&adev->dm.dc_lock);
++}
++
+ static int dm_resume(void *handle)
+ {
+       struct amdgpu_device *adev = handle;
+@@ -2353,8 +2380,11 @@ static void handle_hpd_irq(void *param)
+                       drm_kms_helper_hotplug_event(dev);
+ 
+       } else if (dc_link_detect(aconnector->dc_link, DETECT_REASON_HPD)) {
+-              amdgpu_dm_update_connector_after_detect(aconnector);
++              if (new_connection_type == dc_connection_none &&
++                  aconnector->dc_link->type == dc_connection_none)
++                      dm_set_dpms_off(aconnector->dc_link);
+ 
++              amdgpu_dm_update_connector_after_detect(aconnector);
+ 
+               drm_modeset_lock_all(dev);
+               dm_restore_drm_connector_state(dev, connector);
+diff --git a/drivers/gpu/drm/amd/display/dc/core/dc.c b/drivers/gpu/drm/amd/display/dc/core/dc.c
+index 45ad05f6e03b..ffb21196bf59 100644
+--- a/drivers/gpu/drm/amd/display/dc/core/dc.c
++++ b/drivers/gpu/drm/amd/display/dc/core/dc.c
+@@ -2767,6 +2767,19 @@ struct dc_stream_state *dc_get_stream_at_index(struct dc *dc, uint8_t i)
+       return NULL;
+ }
+ 
++struct dc_stream_state *dc_stream_find_from_link(const struct dc_link *link)
++{
++      uint8_t i;
++      struct dc_context *ctx = link->ctx;
++
++      for (i = 0; i < ctx->dc->current_state->stream_count; i++) {
++              if (ctx->dc->current_state->streams[i]->link == link)
++                      return ctx->dc->current_state->streams[i];
++      }
++
++      return NULL;
++}
++
+ enum dc_irq_source dc_interrupt_to_irq_source(
+               struct dc *dc,
+               uint32_t src_id,
+diff --git a/drivers/gpu/drm/amd/display/dc/dc_stream.h b/drivers/gpu/drm/amd/display/dc/dc_stream.h
+index c246af7c584b..205bedd1b196 100644
+--- a/drivers/gpu/drm/amd/display/dc/dc_stream.h
++++ b/drivers/gpu/drm/amd/display/dc/dc_stream.h
+@@ -297,6 +297,7 @@ void dc_stream_log(const struct dc *dc, const struct dc_stream_state *stream);
+ 
+ uint8_t dc_get_current_stream_count(struct dc *dc);
+ struct dc_stream_state *dc_get_stream_at_index(struct dc *dc, uint8_t i);
++struct dc_stream_state *dc_stream_find_from_link(const struct dc_link *link);
+ 
+ /*
+  * Return the current frame counter.
+-- 
+2.30.1
+

diff --git a/queue-5.10/drm-amd-pm-fulfill-the-polaris-implementation-for-ge.patch b/queue-5.10/drm-amd-pm-fulfill-the-polaris-implementation-for-ge.patch
new file mode 100644 (file)
index 0000000..bb166e6
--- /dev/null
+++ b/queue-5.10/drm-amd-pm-fulfill-the-polaris-implementation-for-ge.patch
@@ -0,0 +1,108 @@
+From 19683a03e028634b46c90c88aaaf58c1fe2e63e8 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 28 Sep 2020 17:17:56 +0800
+Subject: drm/amd/pm: fulfill the Polaris implementation for
+ get_clock_by_type_with_latency()
+
+From: Evan Quan <evan.quan@amd.com>
+
+[ Upstream commit 690cdc2635849db8b782dbbcabfb1c7519c84fa1 ]
+
+Fulfill Polaris get_clock_by_type_with_latency().
+
+Signed-off-by: Evan Quan <evan.quan@amd.com>
+Acked-by: Alex Deucher <alexander.deucher@amd.com>
+Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ .../drm/amd/pm/powerplay/hwmgr/smu7_hwmgr.c   | 67 +++++++++++++++++++
+ 1 file changed, 67 insertions(+)
+
+diff --git a/drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu7_hwmgr.c b/drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu7_hwmgr.c
+index 35629140fc7a..c5223a9e0d89 100644
+--- a/drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu7_hwmgr.c
++++ b/drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu7_hwmgr.c
+@@ -4771,6 +4771,72 @@ static int smu7_get_clock_by_type(struct pp_hwmgr *hwmgr, enum amd_pp_clock_type
+       return 0;
+ }
+ 
++static int smu7_get_sclks_with_latency(struct pp_hwmgr *hwmgr,
++                                     struct pp_clock_levels_with_latency *clocks)
++{
++      struct phm_ppt_v1_information *table_info =
++                      (struct phm_ppt_v1_information *)hwmgr->pptable;
++      struct phm_ppt_v1_clock_voltage_dependency_table *dep_sclk_table =
++                      table_info->vdd_dep_on_sclk;
++      int i;
++
++      clocks->num_levels = 0;
++      for (i = 0; i < dep_sclk_table->count; i++) {
++              if (dep_sclk_table->entries[i].clk) {
++                      clocks->data[clocks->num_levels].clocks_in_khz =
++                              dep_sclk_table->entries[i].clk * 10;
++                      clocks->num_levels++;
++              }
++      }
++
++      return 0;
++}
++
++static int smu7_get_mclks_with_latency(struct pp_hwmgr *hwmgr,
++                                     struct pp_clock_levels_with_latency *clocks)
++{
++      struct phm_ppt_v1_information *table_info =
++                      (struct phm_ppt_v1_information *)hwmgr->pptable;
++      struct phm_ppt_v1_clock_voltage_dependency_table *dep_mclk_table =
++                      table_info->vdd_dep_on_mclk;
++      int i;
++
++      clocks->num_levels = 0;
++      for (i = 0; i < dep_mclk_table->count; i++) {
++              if (dep_mclk_table->entries[i].clk) {
++                      clocks->data[clocks->num_levels].clocks_in_khz =
++                                      dep_mclk_table->entries[i].clk * 10;
++                      clocks->data[clocks->num_levels].latency_in_us =
++                                      smu7_get_mem_latency(hwmgr, dep_mclk_table->entries[i].clk);
++                      clocks->num_levels++;
++              }
++      }
++
++      return 0;
++}
++
++static int smu7_get_clock_by_type_with_latency(struct pp_hwmgr *hwmgr,
++                                             enum amd_pp_clock_type type,
++                                             struct pp_clock_levels_with_latency *clocks)
++{
++      if (!(hwmgr->chip_id >= CHIP_POLARIS10 &&
++            hwmgr->chip_id <= CHIP_VEGAM))
++              return -EINVAL;
++
++      switch (type) {
++      case amd_pp_sys_clock:
++              smu7_get_sclks_with_latency(hwmgr, clocks);
++              break;
++      case amd_pp_mem_clock:
++              smu7_get_mclks_with_latency(hwmgr, clocks);
++              break;
++      default:
++              return -EINVAL;
++      }
++
++      return 0;
++}
++
+ static int smu7_notify_cac_buffer_info(struct pp_hwmgr *hwmgr,
+                                       uint32_t virtual_addr_low,
+                                       uint32_t virtual_addr_hi,
+@@ -5188,6 +5254,7 @@ static const struct pp_hwmgr_func smu7_hwmgr_funcs = {
+       .get_mclk_od = smu7_get_mclk_od,
+       .set_mclk_od = smu7_set_mclk_od,
+       .get_clock_by_type = smu7_get_clock_by_type,
++      .get_clock_by_type_with_latency = smu7_get_clock_by_type_with_latency,
+       .read_sensor = smu7_read_sensor,
+       .dynamic_state_management_disable = smu7_disable_dpm_tasks,
+       .avfs_control = smu7_avfs_control,
+-- 
+2.30.1
+

diff --git a/queue-5.10/entry-explicitly-flush-pending-rcuog-wakeup-before-l.patch b/queue-5.10/entry-explicitly-flush-pending-rcuog-wakeup-before-l.patch
new file mode 100644 (file)
index 0000000..dc92838
--- /dev/null
+++ b/queue-5.10/entry-explicitly-flush-pending-rcuog-wakeup-before-l.patch
@@ -0,0 +1,79 @@
+From 20ed96c067f883754be413dacb263dd5b3938fe5 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 1 Feb 2021 00:05:47 +0100
+Subject: entry: Explicitly flush pending rcuog wakeup before last rescheduling
+ point
+
+From: Frederic Weisbecker <frederic@kernel.org>
+
+[ Upstream commit 47b8ff194c1fd73d58dc339b597d466fe48c8958 ]
+
+Following the idle loop model, cleanly check for pending rcuog wakeup
+before the last rescheduling point on resuming to user mode. This
+way we can avoid to do it from rcu_user_enter() with the last resort
+self-IPI hack that enforces rescheduling.
+
+Signed-off-by: Frederic Weisbecker <frederic@kernel.org>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+Cc: stable@vger.kernel.org
+Link: https://lkml.kernel.org/r/20210131230548.32970-5-frederic@kernel.org
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ kernel/entry/common.c |  7 +++++++
+ kernel/rcu/tree.c     | 12 +++++++-----
+ 2 files changed, 14 insertions(+), 5 deletions(-)
+
+diff --git a/kernel/entry/common.c b/kernel/entry/common.c
+index e289e6773292..d6587e10bd4c 100644
+--- a/kernel/entry/common.c
++++ b/kernel/entry/common.c
+@@ -174,6 +174,10 @@ static unsigned long exit_to_user_mode_loop(struct pt_regs *regs,
+                * enabled above.
+                */
+               local_irq_disable_exit_to_user();
++
++              /* Check if any of the above work has queued a deferred wakeup */
++              rcu_nocb_flush_deferred_wakeup();
++
+               ti_work = READ_ONCE(current_thread_info()->flags);
+       }
+ 
+@@ -187,6 +191,9 @@ static void exit_to_user_mode_prepare(struct pt_regs *regs)
+ 
+       lockdep_assert_irqs_disabled();
+ 
++      /* Flush pending rcuog wakeup before the last need_resched() check */
++      rcu_nocb_flush_deferred_wakeup();
++
+       if (unlikely(ti_work & EXIT_TO_USER_MODE_WORK))
+               ti_work = exit_to_user_mode_loop(regs, ti_work);
+ 
+diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c
+index f137a599941b..0d8a2e2df221 100644
+--- a/kernel/rcu/tree.c
++++ b/kernel/rcu/tree.c
+@@ -699,13 +699,15 @@ noinstr void rcu_user_enter(void)
+       lockdep_assert_irqs_disabled();
+ 
+       /*
+-       * We may be past the last rescheduling opportunity in the entry code.
+-       * Trigger a self IPI that will fire and reschedule once we resume to
+-       * user/guest mode.
++       * Other than generic entry implementation, we may be past the last
++       * rescheduling opportunity in the entry code. Trigger a self IPI
++       * that will fire and reschedule once we resume in user/guest mode.
+        */
+       instrumentation_begin();
+-      if (do_nocb_deferred_wakeup(rdp) && need_resched())
+-              irq_work_queue(this_cpu_ptr(&late_wakeup_work));
++      if (!IS_ENABLED(CONFIG_GENERIC_ENTRY) || (current->flags & PF_VCPU)) {
++              if (do_nocb_deferred_wakeup(rdp) && need_resched())
++                      irq_work_queue(this_cpu_ptr(&late_wakeup_work));
++      }
+       instrumentation_end();
+ 
+       rcu_eqs_enter(true);
+-- 
+2.30.1
+

diff --git a/queue-5.10/entry-kvm-explicitly-flush-pending-rcuog-wakeup-befo.patch b/queue-5.10/entry-kvm-explicitly-flush-pending-rcuog-wakeup-befo.patch
new file mode 100644 (file)
index 0000000..68a91dd
--- /dev/null
+++ b/queue-5.10/entry-kvm-explicitly-flush-pending-rcuog-wakeup-befo.patch
@@ -0,0 +1,159 @@
+From 2bb2e8c3414e27ff54f2903989be7dba512c3156 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 1 Feb 2021 00:05:48 +0100
+Subject: entry/kvm: Explicitly flush pending rcuog wakeup before last
+ rescheduling point
+
+From: Frederic Weisbecker <frederic@kernel.org>
+
+[ Upstream commit 4ae7dc97f726ea95c58ac58af71cc034ad22d7de ]
+
+Following the idle loop model, cleanly check for pending rcuog wakeup
+before the last rescheduling point upon resuming to guest mode. This
+way we can avoid to do it from rcu_user_enter() with the last resort
+self-IPI hack that enforces rescheduling.
+
+Suggested-by: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Frederic Weisbecker <frederic@kernel.org>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+Cc: stable@vger.kernel.org
+Link: https://lkml.kernel.org/r/20210131230548.32970-6-frederic@kernel.org
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ arch/x86/kvm/x86.c        |  1 +
+ include/linux/entry-kvm.h | 14 +++++++++++++
+ kernel/rcu/tree.c         | 44 ++++++++++++++++++++++++++++++---------
+ kernel/rcu/tree_plugin.h  |  1 +
+ 4 files changed, 50 insertions(+), 10 deletions(-)
+
+diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
+index fa5f059c2b94..08bb14e3bd61 100644
+--- a/arch/x86/kvm/x86.c
++++ b/arch/x86/kvm/x86.c
+@@ -1776,6 +1776,7 @@ EXPORT_SYMBOL_GPL(kvm_emulate_wrmsr);
+ 
+ bool kvm_vcpu_exit_request(struct kvm_vcpu *vcpu)
+ {
++      xfer_to_guest_mode_prepare();
+       return vcpu->mode == EXITING_GUEST_MODE || kvm_request_pending(vcpu) ||
+               xfer_to_guest_mode_work_pending();
+ }
+diff --git a/include/linux/entry-kvm.h b/include/linux/entry-kvm.h
+index 0cef17afb41a..d60ab08f9058 100644
+--- a/include/linux/entry-kvm.h
++++ b/include/linux/entry-kvm.h
+@@ -46,6 +46,20 @@ static inline int arch_xfer_to_guest_mode_handle_work(struct kvm_vcpu *vcpu,
+  */
+ int xfer_to_guest_mode_handle_work(struct kvm_vcpu *vcpu);
+ 
++/**
++ * xfer_to_guest_mode_prepare - Perform last minute preparation work that
++ *                            need to be handled while IRQs are disabled
++ *                            upon entering to guest.
++ *
++ * Has to be invoked with interrupts disabled before the last call
++ * to xfer_to_guest_mode_work_pending().
++ */
++static inline void xfer_to_guest_mode_prepare(void)
++{
++      lockdep_assert_irqs_disabled();
++      rcu_nocb_flush_deferred_wakeup();
++}
++
+ /**
+  * __xfer_to_guest_mode_work_pending - Check if work is pending
+  *
+diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c
+index 0d8a2e2df221..eff2f7359a4c 100644
+--- a/kernel/rcu/tree.c
++++ b/kernel/rcu/tree.c
+@@ -670,9 +670,10 @@ EXPORT_SYMBOL_GPL(rcu_idle_enter);
+ 
+ #ifdef CONFIG_NO_HZ_FULL
+ 
++#if !defined(CONFIG_GENERIC_ENTRY) || !defined(CONFIG_KVM_XFER_TO_GUEST_WORK)
+ /*
+  * An empty function that will trigger a reschedule on
+- * IRQ tail once IRQs get re-enabled on userspace resume.
++ * IRQ tail once IRQs get re-enabled on userspace/guest resume.
+  */
+ static void late_wakeup_func(struct irq_work *work)
+ {
+@@ -681,6 +682,37 @@ static void late_wakeup_func(struct irq_work *work)
+ static DEFINE_PER_CPU(struct irq_work, late_wakeup_work) =
+       IRQ_WORK_INIT(late_wakeup_func);
+ 
++/*
++ * If either:
++ *
++ * 1) the task is about to enter in guest mode and $ARCH doesn't support KVM generic work
++ * 2) the task is about to enter in user mode and $ARCH doesn't support generic entry.
++ *
++ * In these cases the late RCU wake ups aren't supported in the resched loops and our
++ * last resort is to fire a local irq_work that will trigger a reschedule once IRQs
++ * get re-enabled again.
++ */
++noinstr static void rcu_irq_work_resched(void)
++{
++      struct rcu_data *rdp = this_cpu_ptr(&rcu_data);
++
++      if (IS_ENABLED(CONFIG_GENERIC_ENTRY) && !(current->flags & PF_VCPU))
++              return;
++
++      if (IS_ENABLED(CONFIG_KVM_XFER_TO_GUEST_WORK) && (current->flags & PF_VCPU))
++              return;
++
++      instrumentation_begin();
++      if (do_nocb_deferred_wakeup(rdp) && need_resched()) {
++              irq_work_queue(this_cpu_ptr(&late_wakeup_work));
++      }
++      instrumentation_end();
++}
++
++#else
++static inline void rcu_irq_work_resched(void) { }
++#endif
++
+ /**
+  * rcu_user_enter - inform RCU that we are resuming userspace.
+  *
+@@ -694,8 +726,6 @@ static DEFINE_PER_CPU(struct irq_work, late_wakeup_work) =
+  */
+ noinstr void rcu_user_enter(void)
+ {
+-      struct rcu_data *rdp = this_cpu_ptr(&rcu_data);
+-
+       lockdep_assert_irqs_disabled();
+ 
+       /*
+@@ -703,13 +733,7 @@ noinstr void rcu_user_enter(void)
+        * rescheduling opportunity in the entry code. Trigger a self IPI
+        * that will fire and reschedule once we resume in user/guest mode.
+        */
+-      instrumentation_begin();
+-      if (!IS_ENABLED(CONFIG_GENERIC_ENTRY) || (current->flags & PF_VCPU)) {
+-              if (do_nocb_deferred_wakeup(rdp) && need_resched())
+-                      irq_work_queue(this_cpu_ptr(&late_wakeup_work));
+-      }
+-      instrumentation_end();
+-
++      rcu_irq_work_resched();
+       rcu_eqs_enter(true);
+ }
+ 
+diff --git a/kernel/rcu/tree_plugin.h b/kernel/rcu/tree_plugin.h
+index 29a00d9ea286..a9351906e290 100644
+--- a/kernel/rcu/tree_plugin.h
++++ b/kernel/rcu/tree_plugin.h
+@@ -2197,6 +2197,7 @@ void rcu_nocb_flush_deferred_wakeup(void)
+ {
+       do_nocb_deferred_wakeup(this_cpu_ptr(&rcu_data));
+ }
++EXPORT_SYMBOL_GPL(rcu_nocb_flush_deferred_wakeup);
+ 
+ void __init rcu_init_nohz(void)
+ {
+-- 
+2.30.1
+

diff --git a/queue-5.10/gfs2-add-common-helper-for-holding-and-releasing-the.patch b/queue-5.10/gfs2-add-common-helper-for-holding-and-releasing-the.patch
new file mode 100644 (file)
index 0000000..bec61c1
--- /dev/null
+++ b/queue-5.10/gfs2-add-common-helper-for-holding-and-releasing-the.patch
@@ -0,0 +1,241 @@
+From 9b73152b84f204d112c9f2fff4ea3c7943c86ee9 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Tue, 22 Dec 2020 14:43:27 -0600
+Subject: gfs2: Add common helper for holding and releasing the freeze glock
+
+From: Bob Peterson <rpeterso@redhat.com>
+
+[ Upstream commit c77b52c0a137994ad796f44544c802b0b766e496 ]
+
+Many places in the gfs2 code queued and dequeued the freeze glock.
+Almost all of them acquire it in SHARED mode, and need to specify the
+same LM_FLAG_NOEXP and GL_EXACT flags.
+
+This patch adds common helper functions gfs2_freeze_lock and gfs2_freeze_unlock
+to make the code more readable, and to prepare for the next patch.
+
+Signed-off-by: Bob Peterson <rpeterso@redhat.com>
+Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ fs/gfs2/ops_fstype.c |  6 ++----
+ fs/gfs2/recovery.c   |  8 +++-----
+ fs/gfs2/super.c      | 42 ++++++++++++++----------------------------
+ fs/gfs2/util.c       | 25 +++++++++++++++++++++++++
+ fs/gfs2/util.h       |  3 +++
+ 5 files changed, 47 insertions(+), 37 deletions(-)
+
+diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
+index 61fce59cb4d3..4ee56f5e93cb 100644
+--- a/fs/gfs2/ops_fstype.c
++++ b/fs/gfs2/ops_fstype.c
+@@ -1198,14 +1198,12 @@ static int gfs2_fill_super(struct super_block *sb, struct fs_context *fc)
+       if (sb_rdonly(sb)) {
+               struct gfs2_holder freeze_gh;
+ 
+-              error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED,
+-                                         LM_FLAG_NOEXP | GL_EXACT,
+-                                         &freeze_gh);
++              error = gfs2_freeze_lock(sdp, &freeze_gh, 0);
+               if (error) {
+                       fs_err(sdp, "can't make FS RO: %d\n", error);
+                       goto fail_per_node;
+               }
+-              gfs2_glock_dq_uninit(&freeze_gh);
++              gfs2_freeze_unlock(&freeze_gh);
+       } else {
+               error = gfs2_make_fs_rw(sdp);
+               if (error) {
+diff --git a/fs/gfs2/recovery.c b/fs/gfs2/recovery.c
+index a3c1911862f0..8f9c6480a5df 100644
+--- a/fs/gfs2/recovery.c
++++ b/fs/gfs2/recovery.c
+@@ -470,9 +470,7 @@ void gfs2_recover_func(struct work_struct *work)
+ 
+               /* Acquire a shared hold on the freeze lock */
+ 
+-              error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED,
+-                                         LM_FLAG_NOEXP | LM_FLAG_PRIORITY |
+-                                         GL_EXACT, &thaw_gh);
++              error = gfs2_freeze_lock(sdp, &thaw_gh, LM_FLAG_PRIORITY);
+               if (error)
+                       goto fail_gunlock_ji;
+ 
+@@ -524,7 +522,7 @@ void gfs2_recover_func(struct work_struct *work)
+               clean_journal(jd, &head);
+               up_read(&sdp->sd_log_flush_lock);
+ 
+-              gfs2_glock_dq_uninit(&thaw_gh);
++              gfs2_freeze_unlock(&thaw_gh);
+               t_rep = ktime_get();
+               fs_info(sdp, "jid=%u: Journal replayed in %lldms [jlck:%lldms, "
+                       "jhead:%lldms, tlck:%lldms, replay:%lldms]\n",
+@@ -546,7 +544,7 @@ void gfs2_recover_func(struct work_struct *work)
+       goto done;
+ 
+ fail_gunlock_thaw:
+-      gfs2_glock_dq_uninit(&thaw_gh);
++      gfs2_freeze_unlock(&thaw_gh);
+ fail_gunlock_ji:
+       if (jlocked) {
+               gfs2_glock_dq_uninit(&ji_gh);
+diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
+index b3d951ab8068..6b0e8c0bb110 100644
+--- a/fs/gfs2/super.c
++++ b/fs/gfs2/super.c
+@@ -173,9 +173,7 @@ int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
+       if (error)
+               return error;
+ 
+-      error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED,
+-                                 LM_FLAG_NOEXP | GL_EXACT,
+-                                 &freeze_gh);
++      error = gfs2_freeze_lock(sdp, &freeze_gh, 0);
+       if (error)
+               goto fail_threads;
+ 
+@@ -205,12 +203,12 @@ int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
+ 
+       set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
+ 
+-      gfs2_glock_dq_uninit(&freeze_gh);
++      gfs2_freeze_unlock(&freeze_gh);
+ 
+       return 0;
+ 
+ fail:
+-      gfs2_glock_dq_uninit(&freeze_gh);
++      gfs2_freeze_unlock(&freeze_gh);
+ fail_threads:
+       if (sdp->sd_quotad_process)
+               kthread_stop(sdp->sd_quotad_process);
+@@ -454,7 +452,7 @@ static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp)
+       }
+ 
+       if (error)
+-              gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);
++              gfs2_freeze_unlock(&sdp->sd_freeze_gh);
+ 
+ out:
+       while (!list_empty(&list)) {
+@@ -618,21 +616,12 @@ int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
+       gfs2_holder_mark_uninitialized(&freeze_gh);
+       if (sdp->sd_freeze_gl &&
+           !gfs2_glock_is_locked_by_me(sdp->sd_freeze_gl)) {
+-              if (!log_write_allowed) {
+-                      error = gfs2_glock_nq_init(sdp->sd_freeze_gl,
+-                                                 LM_ST_SHARED, LM_FLAG_TRY |
+-                                                 LM_FLAG_NOEXP | GL_EXACT,
+-                                                 &freeze_gh);
+-                      if (error == GLR_TRYFAILED)
+-                              error = 0;
+-              } else {
+-                      error = gfs2_glock_nq_init(sdp->sd_freeze_gl,
+-                                                 LM_ST_SHARED,
+-                                                 LM_FLAG_NOEXP | GL_EXACT,
+-                                                 &freeze_gh);
+-                      if (error && !gfs2_withdrawn(sdp))
+-                              return error;
+-              }
++              error = gfs2_freeze_lock(sdp, &freeze_gh,
++                                       log_write_allowed ? 0 : LM_FLAG_TRY);
++              if (error == GLR_TRYFAILED)
++                      error = 0;
++              if (error && !gfs2_withdrawn(sdp))
++                      return error;
+       }
+ 
+       gfs2_flush_delete_work(sdp);
+@@ -663,8 +652,7 @@ int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
+                                  atomic_read(&sdp->sd_reserving_log) == 0,
+                                  HZ * 5);
+       }
+-      if (gfs2_holder_initialized(&freeze_gh))
+-              gfs2_glock_dq_uninit(&freeze_gh);
++      gfs2_freeze_unlock(&freeze_gh);
+ 
+       gfs2_quota_cleanup(sdp);
+ 
+@@ -774,10 +762,8 @@ void gfs2_freeze_func(struct work_struct *work)
+       struct super_block *sb = sdp->sd_vfs;
+ 
+       atomic_inc(&sb->s_active);
+-      error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED,
+-                                 LM_FLAG_NOEXP | GL_EXACT, &freeze_gh);
++      error = gfs2_freeze_lock(sdp, &freeze_gh, 0);
+       if (error) {
+-              fs_info(sdp, "GFS2: couldn't get freeze lock : %d\n", error);
+               gfs2_assert_withdraw(sdp, 0);
+       } else {
+               atomic_set(&sdp->sd_freeze_state, SFS_UNFROZEN);
+@@ -787,7 +773,7 @@ void gfs2_freeze_func(struct work_struct *work)
+                               error);
+                       gfs2_assert_withdraw(sdp, 0);
+               }
+-              gfs2_glock_dq_uninit(&freeze_gh);
++              gfs2_freeze_unlock(&freeze_gh);
+       }
+       deactivate_super(sb);
+       clear_bit_unlock(SDF_FS_FROZEN, &sdp->sd_flags);
+@@ -855,7 +841,7 @@ static int gfs2_unfreeze(struct super_block *sb)
+                 return 0;
+       }
+ 
+-      gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);
++      gfs2_freeze_unlock(&sdp->sd_freeze_gh);
+       mutex_unlock(&sdp->sd_freeze_mutex);
+       return wait_on_bit(&sdp->sd_flags, SDF_FS_FROZEN, TASK_INTERRUPTIBLE);
+ }
+diff --git a/fs/gfs2/util.c b/fs/gfs2/util.c
+index b7d4e4550880..c8d55055e495 100644
+--- a/fs/gfs2/util.c
++++ b/fs/gfs2/util.c
+@@ -91,6 +91,31 @@ int check_journal_clean(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
+       return error;
+ }
+ 
++/**
++ * gfs2_freeze_lock - hold the freeze glock
++ * @sdp: the superblock
++ * @freeze_gh: pointer to the requested holder
++ * @caller_flags: any additional flags needed by the caller
++ */
++int gfs2_freeze_lock(struct gfs2_sbd *sdp, struct gfs2_holder *freeze_gh,
++                   int caller_flags)
++{
++      int flags = LM_FLAG_NOEXP | GL_EXACT | caller_flags;
++      int error;
++
++      error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, flags,
++                                 freeze_gh);
++      if (error && error != GLR_TRYFAILED)
++              fs_err(sdp, "can't lock the freeze lock: %d\n", error);
++      return error;
++}
++
++void gfs2_freeze_unlock(struct gfs2_holder *freeze_gh)
++{
++      if (gfs2_holder_initialized(freeze_gh))
++              gfs2_glock_dq_uninit(freeze_gh);
++}
++
+ static void signal_our_withdraw(struct gfs2_sbd *sdp)
+ {
+       struct gfs2_glock *live_gl = sdp->sd_live_gh.gh_gl;
+diff --git a/fs/gfs2/util.h b/fs/gfs2/util.h
+index d7562981b3a0..aa3771281aca 100644
+--- a/fs/gfs2/util.h
++++ b/fs/gfs2/util.h
+@@ -149,6 +149,9 @@ int gfs2_io_error_i(struct gfs2_sbd *sdp, const char *function,
+ 
+ extern int check_journal_clean(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
+                              bool verbose);
++extern int gfs2_freeze_lock(struct gfs2_sbd *sdp,
++                          struct gfs2_holder *freeze_gh, int caller_flags);
++extern void gfs2_freeze_unlock(struct gfs2_holder *freeze_gh);
+ 
+ #define gfs2_io_error(sdp) \
+ gfs2_io_error_i((sdp), __func__, __FILE__, __LINE__);
+-- 
+2.30.1
+

diff --git a/queue-5.10/gfs2-bypass-signal_our_withdraw-if-no-journal.patch b/queue-5.10/gfs2-bypass-signal_our_withdraw-if-no-journal.patch
new file mode 100644 (file)
index 0000000..ea7862d
--- /dev/null
+++ b/queue-5.10/gfs2-bypass-signal_our_withdraw-if-no-journal.patch
@@ -0,0 +1,64 @@
+From 458f4704b01ac51f715c121c814a6443677e4c8f Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Fri, 12 Mar 2021 07:58:54 -0500
+Subject: gfs2: bypass signal_our_withdraw if no journal
+
+From: Bob Peterson <rpeterso@redhat.com>
+
+[ Upstream commit d5bf630f355d8c532bef2347cf90e8ae60a5f1bd ]
+
+Before this patch, function signal_our_withdraw referenced the journal
+inode immediately. But corrupt file systems may have some invalid
+journals, in which case our attempt to read it in will withdraw and the
+resulting signal_our_withdraw would dereference the NULL value.
+
+This patch adds a check to signal_our_withdraw so that if the journal
+has not yet been initialized, it simply returns and does the old-style
+withdraw.
+
+Thanks, Andy Price, for his analysis.
+
+Reported-by: syzbot+50a8a9cf8127f2c6f5df@syzkaller.appspotmail.com
+Fixes: 601ef0d52e96 ("gfs2: Force withdraw to replay journals and wait for it to finish")
+Signed-off-by: Bob Peterson <rpeterso@redhat.com>
+Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ fs/gfs2/util.c | 15 ++++++++++-----
+ 1 file changed, 10 insertions(+), 5 deletions(-)
+
+diff --git a/fs/gfs2/util.c b/fs/gfs2/util.c
+index a1ecb2b48250..3ece99e6490c 100644
+--- a/fs/gfs2/util.c
++++ b/fs/gfs2/util.c
+@@ -119,17 +119,22 @@ void gfs2_freeze_unlock(struct gfs2_holder *freeze_gh)
+ static void signal_our_withdraw(struct gfs2_sbd *sdp)
+ {
+       struct gfs2_glock *live_gl = sdp->sd_live_gh.gh_gl;
+-      struct inode *inode = sdp->sd_jdesc->jd_inode;
+-      struct gfs2_inode *ip = GFS2_I(inode);
+-      struct gfs2_glock *i_gl = ip->i_gl;
+-      u64 no_formal_ino = ip->i_no_formal_ino;
++      struct inode *inode;
++      struct gfs2_inode *ip;
++      struct gfs2_glock *i_gl;
++      u64 no_formal_ino;
+       int log_write_allowed = test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
+       int ret = 0;
+       int tries;
+ 
+-      if (test_bit(SDF_NORECOVERY, &sdp->sd_flags))
++      if (test_bit(SDF_NORECOVERY, &sdp->sd_flags) || !sdp->sd_jdesc)
+               return;
+ 
++      inode = sdp->sd_jdesc->jd_inode;
++      ip = GFS2_I(inode);
++      i_gl = ip->i_gl;
++      no_formal_ino = ip->i_no_formal_ino;
++
+       /* Prevent any glock dq until withdraw recovery is complete */
+       set_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags);
+       /*
+-- 
+2.30.1
+

diff --git a/queue-5.10/gfs2-move-freeze-glock-outside-the-make_fs_rw-and-_r.patch b/queue-5.10/gfs2-move-freeze-glock-outside-the-make_fs_rw-and-_r.patch
new file mode 100644 (file)
index 0000000..b75836e
--- /dev/null
+++ b/queue-5.10/gfs2-move-freeze-glock-outside-the-make_fs_rw-and-_r.patch
@@ -0,0 +1,216 @@
+From 49d031b4e9f53c34b19fde0ac530c15fbd1de157 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Tue, 22 Dec 2020 14:43:28 -0600
+Subject: gfs2: move freeze glock outside the make_fs_rw and _ro functions
+
+From: Bob Peterson <rpeterso@redhat.com>
+
+[ Upstream commit 96b1454f2e8ede4c619fde405a1bb4e9ba8d218e ]
+
+Before this patch, sister functions gfs2_make_fs_rw and gfs2_make_fs_ro locked
+(held) the freeze glock by calling gfs2_freeze_lock and gfs2_freeze_unlock.
+The problem is, not all the callers of gfs2_make_fs_ro should be doing this.
+The three callers of gfs2_make_fs_ro are: remount (gfs2_reconfigure),
+signal_our_withdraw, and unmount (gfs2_put_super). But when unmounting the
+file system we can get into the following circular lock dependency:
+
+deactivate_super
+   down_write(&s->s_umount); <-------------------------------------- s_umount
+   deactivate_locked_super
+      gfs2_kill_sb
+         kill_block_super
+            generic_shutdown_super
+               gfs2_put_super
+                  gfs2_make_fs_ro
+                     gfs2_glock_nq_init sd_freeze_gl
+                        freeze_go_sync
+                           if (freeze glock in SH)
+                              freeze_super (vfs)
+                                 down_write(&sb->s_umount); <------- s_umount
+
+This patch moves the hold of the freeze glock outside the two sister rw/ro
+functions to their callers, but it doesn't request the glock from
+gfs2_put_super, thus eliminating the circular dependency.
+
+Signed-off-by: Bob Peterson <rpeterso@redhat.com>
+Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ fs/gfs2/ops_fstype.c | 31 +++++++++++++++++--------------
+ fs/gfs2/super.c      | 23 -----------------------
+ fs/gfs2/util.c       | 18 ++++++++++++++++--
+ 3 files changed, 33 insertions(+), 39 deletions(-)
+
+diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
+index 4ee56f5e93cb..f2c6bbe5cdb8 100644
+--- a/fs/gfs2/ops_fstype.c
++++ b/fs/gfs2/ops_fstype.c
+@@ -1084,6 +1084,7 @@ static int gfs2_fill_super(struct super_block *sb, struct fs_context *fc)
+       int silent = fc->sb_flags & SB_SILENT;
+       struct gfs2_sbd *sdp;
+       struct gfs2_holder mount_gh;
++      struct gfs2_holder freeze_gh;
+       int error;
+ 
+       sdp = init_sbd(sb);
+@@ -1195,23 +1196,18 @@ static int gfs2_fill_super(struct super_block *sb, struct fs_context *fc)
+               goto fail_per_node;
+       }
+ 
+-      if (sb_rdonly(sb)) {
+-              struct gfs2_holder freeze_gh;
++      error = gfs2_freeze_lock(sdp, &freeze_gh, 0);
++      if (error)
++              goto fail_per_node;
+ 
+-              error = gfs2_freeze_lock(sdp, &freeze_gh, 0);
+-              if (error) {
+-                      fs_err(sdp, "can't make FS RO: %d\n", error);
+-                      goto fail_per_node;
+-              }
+-              gfs2_freeze_unlock(&freeze_gh);
+-      } else {
++      if (!sb_rdonly(sb))
+               error = gfs2_make_fs_rw(sdp);
+-              if (error) {
+-                      fs_err(sdp, "can't make FS RW: %d\n", error);
+-                      goto fail_per_node;
+-              }
+-      }
+ 
++      gfs2_freeze_unlock(&freeze_gh);
++      if (error) {
++              fs_err(sdp, "can't make FS RW: %d\n", error);
++              goto fail_per_node;
++      }
+       gfs2_glock_dq_uninit(&mount_gh);
+       gfs2_online_uevent(sdp);
+       return 0;
+@@ -1512,6 +1508,12 @@ static int gfs2_reconfigure(struct fs_context *fc)
+               fc->sb_flags |= SB_RDONLY;
+ 
+       if ((sb->s_flags ^ fc->sb_flags) & SB_RDONLY) {
++              struct gfs2_holder freeze_gh;
++
++              error = gfs2_freeze_lock(sdp, &freeze_gh, 0);
++              if (error)
++                      return -EINVAL;
++
+               if (fc->sb_flags & SB_RDONLY) {
+                       error = gfs2_make_fs_ro(sdp);
+                       if (error)
+@@ -1521,6 +1523,7 @@ static int gfs2_reconfigure(struct fs_context *fc)
+                       if (error)
+                               errorfc(fc, "unable to remount read-write");
+               }
++              gfs2_freeze_unlock(&freeze_gh);
+       }
+       sdp->sd_args = *newargs;
+ 
+diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
+index 6b0e8c0bb110..ddd40c96f7a2 100644
+--- a/fs/gfs2/super.c
++++ b/fs/gfs2/super.c
+@@ -165,7 +165,6 @@ int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
+ {
+       struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
+       struct gfs2_glock *j_gl = ip->i_gl;
+-      struct gfs2_holder freeze_gh;
+       struct gfs2_log_header_host head;
+       int error;
+ 
+@@ -173,10 +172,6 @@ int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
+       if (error)
+               return error;
+ 
+-      error = gfs2_freeze_lock(sdp, &freeze_gh, 0);
+-      if (error)
+-              goto fail_threads;
+-
+       j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
+       if (gfs2_withdrawn(sdp)) {
+               error = -EIO;
+@@ -203,13 +198,9 @@ int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
+ 
+       set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
+ 
+-      gfs2_freeze_unlock(&freeze_gh);
+-
+       return 0;
+ 
+ fail:
+-      gfs2_freeze_unlock(&freeze_gh);
+-fail_threads:
+       if (sdp->sd_quotad_process)
+               kthread_stop(sdp->sd_quotad_process);
+       sdp->sd_quotad_process = NULL;
+@@ -609,21 +600,9 @@ static void gfs2_dirty_inode(struct inode *inode, int flags)
+ 
+ int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
+ {
+-      struct gfs2_holder freeze_gh;
+       int error = 0;
+       int log_write_allowed = test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
+ 
+-      gfs2_holder_mark_uninitialized(&freeze_gh);
+-      if (sdp->sd_freeze_gl &&
+-          !gfs2_glock_is_locked_by_me(sdp->sd_freeze_gl)) {
+-              error = gfs2_freeze_lock(sdp, &freeze_gh,
+-                                       log_write_allowed ? 0 : LM_FLAG_TRY);
+-              if (error == GLR_TRYFAILED)
+-                      error = 0;
+-              if (error && !gfs2_withdrawn(sdp))
+-                      return error;
+-      }
+-
+       gfs2_flush_delete_work(sdp);
+       if (!log_write_allowed && current == sdp->sd_quotad_process)
+               fs_warn(sdp, "The quotad daemon is withdrawing.\n");
+@@ -652,8 +631,6 @@ int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
+                                  atomic_read(&sdp->sd_reserving_log) == 0,
+                                  HZ * 5);
+       }
+-      gfs2_freeze_unlock(&freeze_gh);
+-
+       gfs2_quota_cleanup(sdp);
+ 
+       if (!log_write_allowed)
+diff --git a/fs/gfs2/util.c b/fs/gfs2/util.c
+index c8d55055e495..a1ecb2b48250 100644
+--- a/fs/gfs2/util.c
++++ b/fs/gfs2/util.c
+@@ -123,6 +123,7 @@ static void signal_our_withdraw(struct gfs2_sbd *sdp)
+       struct gfs2_inode *ip = GFS2_I(inode);
+       struct gfs2_glock *i_gl = ip->i_gl;
+       u64 no_formal_ino = ip->i_no_formal_ino;
++      int log_write_allowed = test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
+       int ret = 0;
+       int tries;
+ 
+@@ -143,8 +144,21 @@ static void signal_our_withdraw(struct gfs2_sbd *sdp)
+        * therefore we need to clear SDF_JOURNAL_LIVE manually.
+        */
+       clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
+-      if (!sb_rdonly(sdp->sd_vfs))
+-              ret = gfs2_make_fs_ro(sdp);
++      if (!sb_rdonly(sdp->sd_vfs)) {
++              struct gfs2_holder freeze_gh;
++
++              gfs2_holder_mark_uninitialized(&freeze_gh);
++              if (sdp->sd_freeze_gl &&
++                  !gfs2_glock_is_locked_by_me(sdp->sd_freeze_gl)) {
++                      ret = gfs2_freeze_lock(sdp, &freeze_gh,
++                                     log_write_allowed ? 0 : LM_FLAG_TRY);
++                      if (ret == GLR_TRYFAILED)
++                              ret = 0;
++              }
++              if (!ret)
++                      ret = gfs2_make_fs_ro(sdp);
++              gfs2_freeze_unlock(&freeze_gh);
++      }
+ 
+       if (sdp->sd_lockstruct.ls_ops->lm_lock == NULL) { /* lock_nolock */
+               if (!ret)
+-- 
+2.30.1
+

diff --git a/queue-5.10/gpiolib-assign-fwnode-to-parent-s-if-no-primary-one-.patch b/queue-5.10/gpiolib-assign-fwnode-to-parent-s-if-no-primary-one-.patch
new file mode 100644 (file)
index 0000000..26b1b0c
--- /dev/null
+++ b/queue-5.10/gpiolib-assign-fwnode-to-parent-s-if-no-primary-one-.patch
@@ -0,0 +1,54 @@
+From 57488b514660c6ab97f4771d653c9f5ac25680a8 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 15 Mar 2021 20:44:30 +0200
+Subject: gpiolib: Assign fwnode to parent's if no primary one provided
+
+From: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
+
+[ Upstream commit 6cb59afe9e5b45a035bd6b97da6593743feefc72 ]
+
+In case when the properties are supplied in the secondary fwnode
+(for example, built-in device properties) the fwnode pointer left
+unassigned. This makes unable to retrieve them.
+
+Assign fwnode to parent's if no primary one provided.
+
+Fixes: 7cba1a4d5e16 ("gpiolib: generalize devprop_gpiochip_set_names() for device properties")
+Fixes: 2afa97e9868f ("gpiolib: Read "gpio-line-names" from a firmware node")
+Reported-by: Bartosz Golaszewski <bgolaszewski@baylibre.com>
+Tested-by: Bartosz Golaszewski <bgolaszewski@baylibre.com>
+Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
+Signed-off-by: Bartosz Golaszewski <bgolaszewski@baylibre.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/gpio/gpiolib.c | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
+index 7f557ea90542..0a2c4adcd833 100644
+--- a/drivers/gpio/gpiolib.c
++++ b/drivers/gpio/gpiolib.c
+@@ -572,6 +572,7 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
+                              struct lock_class_key *lock_key,
+                              struct lock_class_key *request_key)
+ {
++      struct fwnode_handle *fwnode = gc->parent ? dev_fwnode(gc->parent) : NULL;
+       unsigned long   flags;
+       int             ret = 0;
+       unsigned        i;
+@@ -601,6 +602,12 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
+               gc->of_node = gdev->dev.of_node;
+ #endif
+ 
++      /*
++       * Assign fwnode depending on the result of the previous calls,
++       * if none of them succeed, assign it to the parent's one.
++       */
++      gdev->dev.fwnode = dev_fwnode(&gdev->dev) ?: fwnode;
++
+       gdev->id = ida_alloc(&gpio_ida, GFP_KERNEL);
+       if (gdev->id < 0) {
+               ret = gdev->id;
+-- 
+2.30.1
+

diff --git a/queue-5.10/gpiolib-read-gpio-line-names-from-a-firmware-node.patch b/queue-5.10/gpiolib-read-gpio-line-names-from-a-firmware-node.patch
new file mode 100644 (file)
index 0000000..2b4b695
--- /dev/null
+++ b/queue-5.10/gpiolib-read-gpio-line-names-from-a-firmware-node.patch
@@ -0,0 +1,82 @@
+From 03ea7cbc5235d6ace2724c64d54bac3f72697003 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Fri, 5 Mar 2021 14:02:40 +0200
+Subject: gpiolib: Read "gpio-line-names" from a firmware node
+
+From: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
+
+[ Upstream commit b41ba2ec54a70908067034f139aa23d0dd2985ce ]
+
+On STM32MP1, the GPIO banks are subnodes of pin-controller@50002000,
+see arch/arm/boot/dts/stm32mp151.dtsi. The driver for
+pin-controller@50002000 is in drivers/pinctrl/stm32/pinctrl-stm32.c
+and iterates over all of its DT subnodes when registering each GPIO
+bank gpiochip. Each gpiochip has:
+
+  - gpio_chip.parent = dev,
+    where dev is the device node of the pin controller
+  - gpio_chip.of_node = np,
+    which is the OF node of the GPIO bank
+
+Therefore, dev_fwnode(chip->parent) != of_fwnode_handle(chip.of_node),
+i.e. pin-controller@50002000 != pin-controller@50002000/gpio@5000*000.
+
+The original code behaved correctly, as it extracted the "gpio-line-names"
+from of_fwnode_handle(chip.of_node) = pin-controller@50002000/gpio@5000*000.
+
+To achieve the same behaviour, read property from the firmware node.
+
+Fixes: 7cba1a4d5e162 ("gpiolib: generalize devprop_gpiochip_set_names() for device properties")
+Reported-by: Marek Vasut <marex@denx.de>
+Reported-by: Roman Guskov <rguskov@dh-electronics.com>
+Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
+Tested-by: Marek Vasut <marex@denx.de>
+Reviewed-by: Marek Vasut <marex@denx.de>
+Signed-off-by: Bartosz Golaszewski <bgolaszewski@baylibre.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/gpio/gpiolib.c | 12 ++++--------
+ 1 file changed, 4 insertions(+), 8 deletions(-)
+
+diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
+index 0a2c4adcd833..af5bb8fedfea 100644
+--- a/drivers/gpio/gpiolib.c
++++ b/drivers/gpio/gpiolib.c
+@@ -364,22 +364,18 @@ static int gpiochip_set_desc_names(struct gpio_chip *gc)
+  *
+  * Looks for device property "gpio-line-names" and if it exists assigns
+  * GPIO line names for the chip. The memory allocated for the assigned
+- * names belong to the underlying software node and should not be released
++ * names belong to the underlying firmware node and should not be released
+  * by the caller.
+  */
+ static int devprop_gpiochip_set_names(struct gpio_chip *chip)
+ {
+       struct gpio_device *gdev = chip->gpiodev;
+-      struct device *dev = chip->parent;
++      struct fwnode_handle *fwnode = dev_fwnode(&gdev->dev);
+       const char **names;
+       int ret, i;
+       int count;
+ 
+-      /* GPIO chip may not have a parent device whose properties we inspect. */
+-      if (!dev)
+-              return 0;
+-
+-      count = device_property_string_array_count(dev, "gpio-line-names");
++      count = fwnode_property_string_array_count(fwnode, "gpio-line-names");
+       if (count < 0)
+               return 0;
+ 
+@@ -393,7 +389,7 @@ static int devprop_gpiochip_set_names(struct gpio_chip *chip)
+       if (!names)
+               return -ENOMEM;
+ 
+-      ret = device_property_read_string_array(dev, "gpio-line-names",
++      ret = fwnode_property_read_string_array(fwnode, "gpio-line-names",
+                                               names, count);
+       if (ret < 0) {
+               dev_warn(&gdev->dev, "failed to read GPIO line names\n");
+-- 
+2.30.1
+

diff --git a/queue-5.10/i40e-fix-endianness-conversions.patch b/queue-5.10/i40e-fix-endianness-conversions.patch
new file mode 100644 (file)
index 0000000..b757ba2
--- /dev/null
+++ b/queue-5.10/i40e-fix-endianness-conversions.patch
@@ -0,0 +1,96 @@
+From 4646992b8ad9c97fa8921f561fab2d6d080ef405 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Fri, 5 Feb 2021 08:48:52 +0000
+Subject: i40e: Fix endianness conversions
+
+From: Norbert Ciosek <norbertx.ciosek@intel.com>
+
+[ Upstream commit b32cddd2247cf730731f93f1967d0147a40682c7 ]
+
+Fixes the following sparse warnings:
+i40e_main.c:5953:32: warning: cast from restricted __le16
+i40e_main.c:8008:29: warning: incorrect type in assignment (different base types)
+i40e_main.c:8008:29:    expected unsigned int [assigned] [usertype] ipa
+i40e_main.c:8008:29:    got restricted __le32 [usertype]
+i40e_main.c:8008:29: warning: incorrect type in assignment (different base types)
+i40e_main.c:8008:29:    expected unsigned int [assigned] [usertype] ipa
+i40e_main.c:8008:29:    got restricted __le32 [usertype]
+i40e_txrx.c:1950:59: warning: incorrect type in initializer (different base types)
+i40e_txrx.c:1950:59:    expected unsigned short [usertype] vlan_tag
+i40e_txrx.c:1950:59:    got restricted __le16 [usertype] l2tag1
+i40e_txrx.c:1953:40: warning: cast to restricted __le16
+i40e_xsk.c:448:38: warning: invalid assignment: |=
+i40e_xsk.c:448:38:    left side has type restricted __le64
+i40e_xsk.c:448:38:    right side has type int
+
+Fixes: 2f4b411a3d67 ("i40e: Enable cloud filters via tc-flower")
+Fixes: 2a508c64ad27 ("i40e: fix VLAN.TCI == 0 RX HW offload")
+Fixes: 3106c580fb7c ("i40e: Use batched xsk Tx interfaces to increase performance")
+Fixes: 8f88b3034db3 ("i40e: Add infrastructure for queue channel support")
+Signed-off-by: Norbert Ciosek <norbertx.ciosek@intel.com>
+Tested-by: Tony Brelinski <tonyx.brelinski@intel.com>
+Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/net/ethernet/intel/i40e/i40e_main.c | 12 ++++++------
+ drivers/net/ethernet/intel/i40e/i40e_txrx.c |  2 +-
+ 2 files changed, 7 insertions(+), 7 deletions(-)
+
+diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
+index 3e4a4d6f0419..4a2d03cada01 100644
+--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
++++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
+@@ -5920,7 +5920,7 @@ static int i40e_add_channel(struct i40e_pf *pf, u16 uplink_seid,
+       ch->enabled_tc = !i40e_is_channel_macvlan(ch) && enabled_tc;
+       ch->seid = ctxt.seid;
+       ch->vsi_number = ctxt.vsi_number;
+-      ch->stat_counter_idx = cpu_to_le16(ctxt.info.stat_counter_idx);
++      ch->stat_counter_idx = le16_to_cpu(ctxt.info.stat_counter_idx);
+ 
+       /* copy just the sections touched not the entire info
+        * since not all sections are valid as returned by
+@@ -7599,8 +7599,8 @@ static inline void
+ i40e_set_cld_element(struct i40e_cloud_filter *filter,
+                    struct i40e_aqc_cloud_filters_element_data *cld)
+ {
+-      int i, j;
+       u32 ipa;
++      int i;
+ 
+       memset(cld, 0, sizeof(*cld));
+       ether_addr_copy(cld->outer_mac, filter->dst_mac);
+@@ -7611,14 +7611,14 @@ i40e_set_cld_element(struct i40e_cloud_filter *filter,
+ 
+       if (filter->n_proto == ETH_P_IPV6) {
+ #define IPV6_MAX_INDEX        (ARRAY_SIZE(filter->dst_ipv6) - 1)
+-              for (i = 0, j = 0; i < ARRAY_SIZE(filter->dst_ipv6);
+-                   i++, j += 2) {
++              for (i = 0; i < ARRAY_SIZE(filter->dst_ipv6); i++) {
+                       ipa = be32_to_cpu(filter->dst_ipv6[IPV6_MAX_INDEX - i]);
+-                      ipa = cpu_to_le32(ipa);
+-                      memcpy(&cld->ipaddr.raw_v6.data[j], &ipa, sizeof(ipa));
++
++                      *(__le32 *)&cld->ipaddr.raw_v6.data[i * 2] = cpu_to_le32(ipa);
+               }
+       } else {
+               ipa = be32_to_cpu(filter->dst_ipv4);
++
+               memcpy(&cld->ipaddr.v4.data, &ipa, sizeof(ipa));
+       }
+ 
+diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.c b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
+index 38dec49ac64d..899714243af7 100644
+--- a/drivers/net/ethernet/intel/i40e/i40e_txrx.c
++++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
+@@ -1782,7 +1782,7 @@ void i40e_process_skb_fields(struct i40e_ring *rx_ring,
+       skb_record_rx_queue(skb, rx_ring->queue_index);
+ 
+       if (qword & BIT(I40E_RX_DESC_STATUS_L2TAG1P_SHIFT)) {
+-              u16 vlan_tag = rx_desc->wb.qword0.lo_dword.l2tag1;
++              __le16 vlan_tag = rx_desc->wb.qword0.lo_dword.l2tag1;
+ 
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
+                                      le16_to_cpu(vlan_tag));
+-- 
+2.30.1
+

diff --git a/queue-5.10/ibmvnic-add-some-debugs.patch b/queue-5.10/ibmvnic-add-some-debugs.patch
new file mode 100644 (file)
index 0000000..8aba1fb
--- /dev/null
+++ b/queue-5.10/ibmvnic-add-some-debugs.patch
@@ -0,0 +1,111 @@
+From ce4b6b4681159e4f9922ebadfde7a9984b8dc659 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Fri, 4 Dec 2020 18:22:35 -0800
+Subject: ibmvnic: add some debugs
+
+From: Sukadev Bhattiprolu <sukadev@linux.ibm.com>
+
+[ Upstream commit 38bd5cec76e2282986b1bf2f8e7d2d05ffe68b22 ]
+
+We sometimes run into situations where a soft/hard reset of the adapter
+takes a long time or fails to complete. Having additional messages that
+include important adapter state info will hopefully help understand what
+is happening, reduce the guess work and minimize requests to reproduce
+problems with debug patches.
+
+Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.ibm.com>
+Link: https://lore.kernel.org/r/20201205022235.2414110-1-sukadev@linux.ibm.com
+Signed-off-by: Jakub Kicinski <kuba@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/net/ethernet/ibm/ibmvnic.c | 25 ++++++++++++++++++++++---
+ 1 file changed, 22 insertions(+), 3 deletions(-)
+
+diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c
+index f184f4a79cc3..1207007d8e46 100644
+--- a/drivers/net/ethernet/ibm/ibmvnic.c
++++ b/drivers/net/ethernet/ibm/ibmvnic.c
+@@ -409,6 +409,8 @@ static void replenish_pools(struct ibmvnic_adapter *adapter)
+               if (adapter->rx_pool[i].active)
+                       replenish_rx_pool(adapter, &adapter->rx_pool[i]);
+       }
++
++      netdev_dbg(adapter->netdev, "Replenished %d pools\n", i);
+ }
+ 
+ static void release_stats_buffers(struct ibmvnic_adapter *adapter)
+@@ -914,6 +916,7 @@ static int ibmvnic_login(struct net_device *netdev)
+ 
+       __ibmvnic_set_mac(netdev, adapter->mac_addr);
+ 
++      netdev_dbg(netdev, "[S:%d] Login succeeded\n", adapter->state);
+       return 0;
+ }
+ 
+@@ -1343,6 +1346,10 @@ static int ibmvnic_close(struct net_device *netdev)
+       struct ibmvnic_adapter *adapter = netdev_priv(netdev);
+       int rc;
+ 
++      netdev_dbg(netdev, "[S:%d FOP:%d FRR:%d] Closing\n",
++                 adapter->state, adapter->failover_pending,
++                 adapter->force_reset_recovery);
++
+       /* If device failover is pending, just set device state and return.
+        * Device operation will be handled by reset routine.
+        */
+@@ -1937,8 +1944,10 @@ static int do_reset(struct ibmvnic_adapter *adapter,
+       struct net_device *netdev = adapter->netdev;
+       int i, rc;
+ 
+-      netdev_dbg(adapter->netdev, "Re-setting driver (%d)\n",
+-                 rwi->reset_reason);
++      netdev_dbg(adapter->netdev,
++                 "[S:%d FOP:%d] Reset reason %d, reset_state %d\n",
++                 adapter->state, adapter->failover_pending,
++                 rwi->reset_reason, reset_state);
+ 
+       rtnl_lock();
+       /*
+@@ -2097,6 +2106,8 @@ static int do_reset(struct ibmvnic_adapter *adapter,
+               adapter->state = reset_state;
+       rtnl_unlock();
+ 
++      netdev_dbg(adapter->netdev, "[S:%d FOP:%d] Reset done, rc %d\n",
++                 adapter->state, adapter->failover_pending, rc);
+       return rc;
+ }
+ 
+@@ -2166,6 +2177,8 @@ static int do_hard_reset(struct ibmvnic_adapter *adapter,
+       /* restore adapter state if reset failed */
+       if (rc)
+               adapter->state = reset_state;
++      netdev_dbg(adapter->netdev, "[S:%d FOP:%d] Hard reset done, rc %d\n",
++                 adapter->state, adapter->failover_pending, rc);
+       return rc;
+ }
+ 
+@@ -2275,6 +2288,11 @@ static void __ibmvnic_reset(struct work_struct *work)
+       }
+ 
+       clear_bit_unlock(0, &adapter->resetting);
++
++      netdev_dbg(adapter->netdev,
++                 "[S:%d FRR:%d WFR:%d] Done processing resets\n",
++                 adapter->state, adapter->force_reset_recovery,
++                 adapter->wait_for_reset);
+ }
+ 
+ static void __ibmvnic_delayed_reset(struct work_struct *work)
+@@ -2320,7 +2338,8 @@ static int ibmvnic_reset(struct ibmvnic_adapter *adapter,
+       list_for_each(entry, &adapter->rwi_list) {
+               tmp = list_entry(entry, struct ibmvnic_rwi, list);
+               if (tmp->reset_reason == reason) {
+-                      netdev_dbg(netdev, "Skipping matching reset\n");
++                      netdev_dbg(netdev, "Skipping matching reset, reason=%d\n",
++                                 reason);
+                       spin_unlock_irqrestore(&adapter->rwi_lock, flags);
+                       ret = EBUSY;
+                       goto err;
+-- 
+2.30.1
+

diff --git a/queue-5.10/ibmvnic-remove-excessive-irqsave.patch b/queue-5.10/ibmvnic-remove-excessive-irqsave.patch
new file mode 100644 (file)
index 0000000..95c7e40
--- /dev/null
+++ b/queue-5.10/ibmvnic-remove-excessive-irqsave.patch
@@ -0,0 +1,53 @@
+From 60f94fa5e92bfed6ab8b309e3ad29555994ec525 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Fri, 5 Mar 2021 16:48:39 +0800
+Subject: ibmvnic: remove excessive irqsave
+
+From: Junlin Yang <yangjunlin@yulong.com>
+
+[ Upstream commit 69cdb7947adb816fc9325b4ec02a6dddd5070b82 ]
+
+ibmvnic_remove locks multiple spinlocks while disabling interrupts:
+spin_lock_irqsave(&adapter->state_lock, flags);
+spin_lock_irqsave(&adapter->rwi_lock, flags);
+
+As reported by coccinelle, the second _irqsave() overwrites the value
+saved in 'flags' by the first _irqsave(),   therefore when the second
+_irqrestore() comes,the value in 'flags' is not valid,the value saved
+by the first _irqsave() has been lost.
+This likely leads to IRQs remaining disabled. So remove the second
+_irqsave():
+spin_lock_irqsave(&adapter->state_lock, flags);
+spin_lock(&adapter->rwi_lock);
+
+Generated by: ./scripts/coccinelle/locks/flags.cocci
+./drivers/net/ethernet/ibm/ibmvnic.c:5413:1-18:
+ERROR: nested lock+irqsave that reuses flags from line 5404.
+
+Fixes: 4a41c421f367 ("ibmvnic: serialize access to work queue on remove")
+Signed-off-by: Junlin Yang <yangjunlin@yulong.com>
+Signed-off-by: David S. Miller <davem@davemloft.net>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/net/ethernet/ibm/ibmvnic.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c
+index 2aee81496ffa..4a4cb62b7332 100644
+--- a/drivers/net/ethernet/ibm/ibmvnic.c
++++ b/drivers/net/ethernet/ibm/ibmvnic.c
+@@ -5388,9 +5388,9 @@ static int ibmvnic_remove(struct vio_dev *dev)
+        * after setting state, so __ibmvnic_reset() which is called
+        * from the flush_work() below, can make progress.
+        */
+-      spin_lock_irqsave(&adapter->rwi_lock, flags);
++      spin_lock(&adapter->rwi_lock);
+       adapter->state = VNIC_REMOVING;
+-      spin_unlock_irqrestore(&adapter->rwi_lock, flags);
++      spin_unlock(&adapter->rwi_lock);
+ 
+       spin_unlock_irqrestore(&adapter->state_lock, flags);
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/ibmvnic-serialize-access-to-work-queue-on-remove.patch b/queue-5.10/ibmvnic-serialize-access-to-work-queue-on-remove.patch
new file mode 100644 (file)
index 0000000..02b3429
--- /dev/null
+++ b/queue-5.10/ibmvnic-serialize-access-to-work-queue-on-remove.patch
@@ -0,0 +1,135 @@
+From 30473df01b96834c92e1ffbd806ac0046befa1f1 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Fri, 12 Feb 2021 20:42:50 -0800
+Subject: ibmvnic: serialize access to work queue on remove
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+From: Sukadev Bhattiprolu <sukadev@linux.ibm.com>
+
+[ Upstream commit 4a41c421f3676fdeea91733cf434dcf319c4c351 ]
+
+The work queue is used to queue reset requests like CHANGE-PARAM or
+FAILOVER resets for the worker thread. When the adapter is being removed
+the adapter state is set to VNIC_REMOVING and the work queue is flushed
+so no new work is added. However the check for adapter being removed is
+racy in that the adapter can go into REMOVING state just after we check
+and we might end up adding work just as it is being flushed (or after).
+
+The ->rwi_lock is already being used to serialize queue/dequeue work.
+Extend its usage ensure there is no race when scheduling/flushing work.
+
+Fixes: 6954a9e4192b ("ibmvnic: Flush existing work items before device removal")
+Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.ibm.com>
+Cc:Uwe Kleine-König <uwe@kleine-koenig.org>
+Cc:Saeed Mahameed <saeed@kernel.org>
+Reviewed-by: Dany Madden <drt@linux.ibm.com>
+Signed-off-by: David S. Miller <davem@davemloft.net>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/net/ethernet/ibm/ibmvnic.c | 27 ++++++++++++++++++++-------
+ drivers/net/ethernet/ibm/ibmvnic.h |  5 ++++-
+ 2 files changed, 24 insertions(+), 8 deletions(-)
+
+diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c
+index 1207007d8e46..2aee81496ffa 100644
+--- a/drivers/net/ethernet/ibm/ibmvnic.c
++++ b/drivers/net/ethernet/ibm/ibmvnic.c
+@@ -2313,6 +2313,8 @@ static int ibmvnic_reset(struct ibmvnic_adapter *adapter,
+       unsigned long flags;
+       int ret;
+ 
++      spin_lock_irqsave(&adapter->rwi_lock, flags);
++
+       /*
+        * If failover is pending don't schedule any other reset.
+        * Instead let the failover complete. If there is already a
+@@ -2333,14 +2335,11 @@ static int ibmvnic_reset(struct ibmvnic_adapter *adapter,
+               goto err;
+       }
+ 
+-      spin_lock_irqsave(&adapter->rwi_lock, flags);
+-
+       list_for_each(entry, &adapter->rwi_list) {
+               tmp = list_entry(entry, struct ibmvnic_rwi, list);
+               if (tmp->reset_reason == reason) {
+                       netdev_dbg(netdev, "Skipping matching reset, reason=%d\n",
+                                  reason);
+-                      spin_unlock_irqrestore(&adapter->rwi_lock, flags);
+                       ret = EBUSY;
+                       goto err;
+               }
+@@ -2348,8 +2347,6 @@ static int ibmvnic_reset(struct ibmvnic_adapter *adapter,
+ 
+       rwi = kzalloc(sizeof(*rwi), GFP_ATOMIC);
+       if (!rwi) {
+-              spin_unlock_irqrestore(&adapter->rwi_lock, flags);
+-              ibmvnic_close(netdev);
+               ret = ENOMEM;
+               goto err;
+       }
+@@ -2362,12 +2359,17 @@ static int ibmvnic_reset(struct ibmvnic_adapter *adapter,
+       }
+       rwi->reset_reason = reason;
+       list_add_tail(&rwi->list, &adapter->rwi_list);
+-      spin_unlock_irqrestore(&adapter->rwi_lock, flags);
+       netdev_dbg(adapter->netdev, "Scheduling reset (reason %d)\n", reason);
+       schedule_work(&adapter->ibmvnic_reset);
+ 
+-      return 0;
++      ret = 0;
+ err:
++      /* ibmvnic_close() below can block, so drop the lock first */
++      spin_unlock_irqrestore(&adapter->rwi_lock, flags);
++
++      if (ret == ENOMEM)
++              ibmvnic_close(netdev);
++
+       return -ret;
+ }
+ 
+@@ -5378,7 +5380,18 @@ static int ibmvnic_remove(struct vio_dev *dev)
+       unsigned long flags;
+ 
+       spin_lock_irqsave(&adapter->state_lock, flags);
++
++      /* If ibmvnic_reset() is scheduling a reset, wait for it to
++       * finish. Then, set the state to REMOVING to prevent it from
++       * scheduling any more work and to have reset functions ignore
++       * any resets that have already been scheduled. Drop the lock
++       * after setting state, so __ibmvnic_reset() which is called
++       * from the flush_work() below, can make progress.
++       */
++      spin_lock_irqsave(&adapter->rwi_lock, flags);
+       adapter->state = VNIC_REMOVING;
++      spin_unlock_irqrestore(&adapter->rwi_lock, flags);
++
+       spin_unlock_irqrestore(&adapter->state_lock, flags);
+ 
+       flush_work(&adapter->ibmvnic_reset);
+diff --git a/drivers/net/ethernet/ibm/ibmvnic.h b/drivers/net/ethernet/ibm/ibmvnic.h
+index 21e7ea858cda..b27211063c64 100644
+--- a/drivers/net/ethernet/ibm/ibmvnic.h
++++ b/drivers/net/ethernet/ibm/ibmvnic.h
+@@ -1080,6 +1080,7 @@ struct ibmvnic_adapter {
+       struct tasklet_struct tasklet;
+       enum vnic_state state;
+       enum ibmvnic_reset_reason reset_reason;
++      /* when taking both state and rwi locks, take state lock first */
+       spinlock_t rwi_lock;
+       struct list_head rwi_list;
+       struct work_struct ibmvnic_reset;
+@@ -1096,6 +1097,8 @@ struct ibmvnic_adapter {
+       struct ibmvnic_tunables desired;
+       struct ibmvnic_tunables fallback;
+ 
+-      /* Used for serializatin of state field */
++      /* Used for serialization of state field. When taking both state
++       * and rwi locks, take state lock first.
++       */
+       spinlock_t state_lock;
+ };
+-- 
+2.30.1
+

diff --git a/queue-5.10/io_uring-clear-iocb_waitq-for-non-eiocbqueued-return.patch b/queue-5.10/io_uring-clear-iocb_waitq-for-non-eiocbqueued-return.patch
new file mode 100644 (file)
index 0000000..4c71ddb
--- /dev/null
+++ b/queue-5.10/io_uring-clear-iocb_waitq-for-non-eiocbqueued-return.patch
@@ -0,0 +1,36 @@
+From 76864744af7c31edc3b75da9096560e502a315a1 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 4 Mar 2021 21:02:58 -0700
+Subject: io_uring: clear IOCB_WAITQ for non -EIOCBQUEUED return
+
+From: Jens Axboe <axboe@kernel.dk>
+
+[ Upstream commit b5b0ecb736f1ce1e68eb50613c0cfecff10198eb ]
+
+The callback can only be armed, if we get -EIOCBQUEUED returned. It's
+important that we clear the WAITQ bit for other cases, otherwise we can
+queue for async retry and filemap will assume that we're armed and
+return -EAGAIN instead of just blocking for the IO.
+
+Cc: stable@vger.kernel.org # 5.9+
+Signed-off-by: Jens Axboe <axboe@kernel.dk>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ fs/io_uring.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/fs/io_uring.c b/fs/io_uring.c
+index 7625b3e2db2c..06e9c2181995 100644
+--- a/fs/io_uring.c
++++ b/fs/io_uring.c
+@@ -3501,6 +3501,7 @@ static int io_read(struct io_kiocb *req, bool force_nonblock,
+               goto out_free;
+       } else if (ret > 0 && ret < io_size) {
+               /* we got some bytes, but not all. retry. */
++              kiocb->ki_flags &= ~IOCB_WAITQ;
+               goto retry;
+       }
+ done:
+-- 
+2.30.1
+

diff --git a/queue-5.10/io_uring-don-t-attempt-io-reissue-from-the-ring-exit.patch b/queue-5.10/io_uring-don-t-attempt-io-reissue-from-the-ring-exit.patch
new file mode 100644 (file)
index 0000000..7e9afbf
--- /dev/null
+++ b/queue-5.10/io_uring-don-t-attempt-io-reissue-from-the-ring-exit.patch
@@ -0,0 +1,40 @@
+From 420abb264b3a384425b20bcb00d97e82e89b60ab Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Tue, 23 Feb 2021 19:17:35 -0700
+Subject: io_uring: don't attempt IO reissue from the ring exit path
+
+From: Jens Axboe <axboe@kernel.dk>
+
+[ Upstream commit 7c977a58dc83366e488c217fd88b1469d242bee5 ]
+
+If we're exiting the ring, just let the IO fail with -EAGAIN as nobody
+will care anyway. It's not the right context to reissue from.
+
+Cc: stable@vger.kernel.org
+Signed-off-by: Jens Axboe <axboe@kernel.dk>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ fs/io_uring.c | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/fs/io_uring.c b/fs/io_uring.c
+index 5746998799ab..7625b3e2db2c 100644
+--- a/fs/io_uring.c
++++ b/fs/io_uring.c
+@@ -2617,6 +2617,13 @@ static bool io_rw_reissue(struct io_kiocb *req, long res)
+               return false;
+       if ((res != -EAGAIN && res != -EOPNOTSUPP) || io_wq_current_is_worker())
+               return false;
++      /*
++       * If ref is dying, we might be running poll reap from the exit work.
++       * Don't attempt to reissue from that path, just let it fail with
++       * -EAGAIN.
++       */
++      if (percpu_ref_is_dying(&req->ctx->refs))
++              return false;
+ 
+       ret = io_sq_thread_acquire_mm(req->ctx, req);
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/io_uring-fix-inconsistent-lock-state.patch b/queue-5.10/io_uring-fix-inconsistent-lock-state.patch
new file mode 100644 (file)
index 0000000..af29935
--- /dev/null
+++ b/queue-5.10/io_uring-fix-inconsistent-lock-state.patch
@@ -0,0 +1,102 @@
+From 7c34f23de988c1d29008f31059467d05d04d82cd Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Wed, 10 Mar 2021 11:30:37 +0000
+Subject: io_uring: fix inconsistent lock state
+
+From: Pavel Begunkov <asml.silence@gmail.com>
+
+[ Upstream commit 9ae1f8dd372e0e4c020b345cf9e09f519265e981 ]
+
+WARNING: inconsistent lock state
+
+inconsistent {HARDIRQ-ON-W} -> {IN-HARDIRQ-W} usage.
+syz-executor217/8450 [HC1[1]:SC0[0]:HE0:SE1] takes:
+ffff888023d6e620 (&fs->lock){?.+.}-{2:2}, at: spin_lock include/linux/spinlock.h:354 [inline]
+ffff888023d6e620 (&fs->lock){?.+.}-{2:2}, at: io_req_clean_work fs/io_uring.c:1398 [inline]
+ffff888023d6e620 (&fs->lock){?.+.}-{2:2}, at: io_dismantle_req+0x66f/0xf60 fs/io_uring.c:2029
+
+other info that might help us debug this:
+ Possible unsafe locking scenario:
+
+       CPU0
+       ----
+  lock(&fs->lock);
+  <Interrupt>
+    lock(&fs->lock);
+
+ *** DEADLOCK ***
+
+1 lock held by syz-executor217/8450:
+ #0: ffff88802417c3e8 (&ctx->uring_lock){+.+.}-{3:3}, at: __do_sys_io_uring_enter+0x1071/0x1f30 fs/io_uring.c:9442
+
+stack backtrace:
+CPU: 1 PID: 8450 Comm: syz-executor217 Not tainted 5.11.0-rc5-next-20210129-syzkaller #0
+Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/01/2011
+Call Trace:
+ <IRQ>
+[...]
+ _raw_spin_lock+0x2a/0x40 kernel/locking/spinlock.c:151
+ spin_lock include/linux/spinlock.h:354 [inline]
+ io_req_clean_work fs/io_uring.c:1398 [inline]
+ io_dismantle_req+0x66f/0xf60 fs/io_uring.c:2029
+ __io_free_req+0x3d/0x2e0 fs/io_uring.c:2046
+ io_free_req fs/io_uring.c:2269 [inline]
+ io_double_put_req fs/io_uring.c:2392 [inline]
+ io_put_req+0xf9/0x570 fs/io_uring.c:2388
+ io_link_timeout_fn+0x30c/0x480 fs/io_uring.c:6497
+ __run_hrtimer kernel/time/hrtimer.c:1519 [inline]
+ __hrtimer_run_queues+0x609/0xe40 kernel/time/hrtimer.c:1583
+ hrtimer_interrupt+0x334/0x940 kernel/time/hrtimer.c:1645
+ local_apic_timer_interrupt arch/x86/kernel/apic/apic.c:1085 [inline]
+ __sysvec_apic_timer_interrupt+0x146/0x540 arch/x86/kernel/apic/apic.c:1102
+ asm_call_irq_on_stack+0xf/0x20
+ </IRQ>
+ __run_sysvec_on_irqstack arch/x86/include/asm/irq_stack.h:37 [inline]
+ run_sysvec_on_irqstack_cond arch/x86/include/asm/irq_stack.h:89 [inline]
+ sysvec_apic_timer_interrupt+0xbd/0x100 arch/x86/kernel/apic/apic.c:1096
+ asm_sysvec_apic_timer_interrupt+0x12/0x20 arch/x86/include/asm/idtentry.h:629
+RIP: 0010:__raw_spin_unlock_irq include/linux/spinlock_api_smp.h:169 [inline]
+RIP: 0010:_raw_spin_unlock_irq+0x25/0x40 kernel/locking/spinlock.c:199
+ spin_unlock_irq include/linux/spinlock.h:404 [inline]
+ io_queue_linked_timeout+0x194/0x1f0 fs/io_uring.c:6525
+ __io_queue_sqe+0x328/0x1290 fs/io_uring.c:6594
+ io_queue_sqe+0x631/0x10d0 fs/io_uring.c:6639
+ io_queue_link_head fs/io_uring.c:6650 [inline]
+ io_submit_sqe fs/io_uring.c:6697 [inline]
+ io_submit_sqes+0x19b5/0x2720 fs/io_uring.c:6960
+ __do_sys_io_uring_enter+0x107d/0x1f30 fs/io_uring.c:9443
+ do_syscall_64+0x2d/0x70 arch/x86/entry/common.c:46
+ entry_SYSCALL_64_after_hwframe+0x44/0xa9
+
+Don't free requests from under hrtimer context (softirq) as it may sleep
+or take spinlocks improperly (e.g. non-irq versions).
+
+Cc: stable@vger.kernel.org # 5.6+
+Reported-by: syzbot+81d17233a2b02eafba33@syzkaller.appspotmail.com
+Signed-off-by: Pavel Begunkov <asml.silence@gmail.com>
+Signed-off-by: Jens Axboe <axboe@kernel.dk>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ fs/io_uring.c | 5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/fs/io_uring.c b/fs/io_uring.c
+index dcc77af5320e..5746998799ab 100644
+--- a/fs/io_uring.c
++++ b/fs/io_uring.c
+@@ -6234,9 +6234,10 @@ static enum hrtimer_restart io_link_timeout_fn(struct hrtimer *timer)
+       if (prev) {
+               req_set_fail_links(prev);
+               io_async_find_and_cancel(ctx, req, prev->user_data, -ETIME);
+-              io_put_req(prev);
++              io_put_req_deferred(prev, 1);
+       } else {
+-              io_req_complete(req, -ETIME);
++              io_cqring_add_event(req, -ETIME, 0);
++              io_put_req_deferred(req, 1);
+       }
+       return HRTIMER_NORESTART;
+ }
+-- 
+2.30.1
+

diff --git a/queue-5.10/iwlwifi-add-a-new-card-for-ma-family.patch b/queue-5.10/iwlwifi-add-a-new-card-for-ma-family.patch
new file mode 100644 (file)
index 0000000..6ff3f45
--- /dev/null
+++ b/queue-5.10/iwlwifi-add-a-new-card-for-ma-family.patch
@@ -0,0 +1,102 @@
+From 81eaae5dd85d99b3c2ed219e8dcf62edd17497c8 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Wed, 9 Dec 2020 23:16:45 +0200
+Subject: iwlwifi: Add a new card for MA family
+
+From: Matti Gottlieb <matti.gottlieb@intel.com>
+
+[ Upstream commit ac1a98e1e924e7e8d7c7e5b1ca8ddc522e10ddd0 ]
+
+Add a PCI ID for snj with mr in AX family.
+
+Signed-off-by: Matti Gottlieb <matti.gottlieb@intel.com>
+Signed-off-by: Luca Coelho <luciano.coelho@intel.com>
+Link: https://lore.kernel.org/r/iwlwifi.20201209231352.101ac3058c04.Idd28706b122cdc8103956f8e72bb062fe4adb54e@changeid
+Signed-off-by: Luca Coelho <luciano.coelho@intel.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/net/wireless/intel/iwlwifi/cfg/22000.c  | 11 +++++++++++
+ drivers/net/wireless/intel/iwlwifi/iwl-config.h |  2 ++
+ drivers/net/wireless/intel/iwlwifi/pcie/drv.c   |  6 ++++++
+ 3 files changed, 19 insertions(+)
+
+diff --git a/drivers/net/wireless/intel/iwlwifi/cfg/22000.c b/drivers/net/wireless/intel/iwlwifi/cfg/22000.c
+index 92c50efd48fc..39842bdef4b4 100644
+--- a/drivers/net/wireless/intel/iwlwifi/cfg/22000.c
++++ b/drivers/net/wireless/intel/iwlwifi/cfg/22000.c
+@@ -92,6 +92,7 @@
+ #define IWL_SNJ_A_HR_B_FW_PRE         "iwlwifi-SoSnj-a0-hr-b0-"
+ #define IWL_MA_A_GF_A_FW_PRE          "iwlwifi-ma-a0-gf-a0-"
+ #define IWL_MA_A_MR_A_FW_PRE          "iwlwifi-ma-a0-mr-a0-"
++#define IWL_SNJ_A_MR_A_FW_PRE         "iwlwifi-SoSnj-a0-mr-a0-"
+ 
+ #define IWL_QU_B_HR_B_MODULE_FIRMWARE(api) \
+       IWL_QU_B_HR_B_FW_PRE __stringify(api) ".ucode"
+@@ -127,6 +128,8 @@
+       IWL_MA_A_GF_A_FW_PRE __stringify(api) ".ucode"
+ #define IWL_MA_A_MR_A_FW_MODULE_FIRMWARE(api) \
+       IWL_MA_A_MR_A_FW_PRE __stringify(api) ".ucode"
++#define IWL_SNJ_A_MR_A_MODULE_FIRMWARE(api) \
++      IWL_SNJ_A_MR_A_FW_PRE __stringify(api) ".ucode"
+ 
+ static const struct iwl_base_params iwl_22000_base_params = {
+       .eeprom_size = OTP_LOW_IMAGE_SIZE_32K,
+@@ -672,6 +675,13 @@ const struct iwl_cfg iwl_cfg_ma_a0_mr_a0 = {
+       .num_rbds = IWL_NUM_RBDS_AX210_HE,
+ };
+ 
++const struct iwl_cfg iwl_cfg_snj_a0_mr_a0 = {
++      .fw_name_pre = IWL_SNJ_A_MR_A_FW_PRE,
++      .uhb_supported = true,
++      IWL_DEVICE_AX210,
++      .num_rbds = IWL_NUM_RBDS_AX210_HE,
++};
++
+ MODULE_FIRMWARE(IWL_QU_B_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
+ MODULE_FIRMWARE(IWL_QNJ_B_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
+ MODULE_FIRMWARE(IWL_QU_C_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
+@@ -689,3 +699,4 @@ MODULE_FIRMWARE(IWL_SNJ_A_GF_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
+ MODULE_FIRMWARE(IWL_SNJ_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
+ MODULE_FIRMWARE(IWL_MA_A_GF_A_FW_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
+ MODULE_FIRMWARE(IWL_MA_A_MR_A_FW_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
++MODULE_FIRMWARE(IWL_SNJ_A_MR_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
+diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-config.h b/drivers/net/wireless/intel/iwlwifi/iwl-config.h
+index 9b91aa9b2e7f..bd04e4fbbb8a 100644
+--- a/drivers/net/wireless/intel/iwlwifi/iwl-config.h
++++ b/drivers/net/wireless/intel/iwlwifi/iwl-config.h
+@@ -472,6 +472,7 @@ struct iwl_cfg {
+ #define IWL_CFG_MAC_TYPE_QU           0x33
+ #define IWL_CFG_MAC_TYPE_QUZ          0x35
+ #define IWL_CFG_MAC_TYPE_QNJ          0x36
++#define IWL_CFG_MAC_TYPE_SNJ          0x42
+ #define IWL_CFG_MAC_TYPE_MA           0x44
+ 
+ #define IWL_CFG_RF_TYPE_TH            0x105
+@@ -656,6 +657,7 @@ extern const struct iwl_cfg iwlax211_cfg_snj_gf_a0;
+ extern const struct iwl_cfg iwlax201_cfg_snj_hr_b0;
+ extern const struct iwl_cfg iwl_cfg_ma_a0_gf_a0;
+ extern const struct iwl_cfg iwl_cfg_ma_a0_mr_a0;
++extern const struct iwl_cfg iwl_cfg_snj_a0_mr_a0;
+ #endif /* CONFIG_IWLMVM */
+ 
+ #endif /* __IWL_CONFIG_H__ */
+diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
+index 2823a1e81656..fa32f9045c0c 100644
+--- a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
++++ b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
+@@ -1002,6 +1002,12 @@ static const struct iwl_dev_info iwl_dev_info_table[] = {
+                     IWL_CFG_RF_TYPE_MR, IWL_CFG_ANY,
+                     IWL_CFG_ANY, IWL_CFG_ANY,
+                     iwl_cfg_ma_a0_mr_a0, iwl_ma_name),
++      _IWL_DEV_INFO(IWL_CFG_ANY, IWL_CFG_ANY,
++                    IWL_CFG_MAC_TYPE_SNJ, IWL_CFG_ANY,
++                    IWL_CFG_RF_TYPE_MR, IWL_CFG_ANY,
++                    IWL_CFG_ANY, IWL_CFG_ANY,
++                    iwl_cfg_snj_a0_mr_a0, iwl_ma_name),
++
+ 
+ #endif /* CONFIG_IWLMVM */
+ };
+-- 
+2.30.1
+

diff --git a/queue-5.10/media-cedrus-h264-support-profile-controls.patch b/queue-5.10/media-cedrus-h264-support-profile-controls.patch
new file mode 100644 (file)
index 0000000..8fa0d53
--- /dev/null
+++ b/queue-5.10/media-cedrus-h264-support-profile-controls.patch
@@ -0,0 +1,59 @@
+From 6333098a9fb147ef52cbb0fadfe958731cb9c346 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 26 Nov 2020 10:36:08 +0100
+Subject: media: cedrus: h264: Support profile controls
+
+From: Ezequiel Garcia <ezequiel@collabora.com>
+
+[ Upstream commit c8363ff21b5168f2252aa8b8447173ce48ff0149 ]
+
+Cedrus supports H.264 profiles from Baseline to High,
+except for the Extended profile
+
+Expose the V4L2_CID_MPEG_VIDEO_H264_PROFILE so that
+userspace can query the driver for the supported
+profiles and levels.
+
+Signed-off-by: Ezequiel Garcia <ezequiel@collabora.com>
+Reviewed-by: Jernej Skrabec <jernej.skrabec@siol.net>
+Tested-by: Jernej Skrabec <jernej.skrabec@siol.net>
+Signed-off-by: Hans Verkuil <hverkuil-cisco@xs4all.nl>
+Signed-off-by: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/staging/media/sunxi/cedrus/cedrus.c | 19 +++++++++++++++++++
+ 1 file changed, 19 insertions(+)
+
+diff --git a/drivers/staging/media/sunxi/cedrus/cedrus.c b/drivers/staging/media/sunxi/cedrus/cedrus.c
+index e0e35502e34a..1dd833757c4e 100644
+--- a/drivers/staging/media/sunxi/cedrus/cedrus.c
++++ b/drivers/staging/media/sunxi/cedrus/cedrus.c
+@@ -103,6 +103,25 @@ static const struct cedrus_control cedrus_controls[] = {
+               .codec          = CEDRUS_CODEC_H264,
+               .required       = false,
+       },
++      /*
++       * We only expose supported profiles information,
++       * and not levels as it's not clear what is supported
++       * for each hardware/core version.
++       * In any case, TRY/S_FMT will clamp the format resolution
++       * to the maximum supported.
++       */
++      {
++              .cfg = {
++                      .id     = V4L2_CID_MPEG_VIDEO_H264_PROFILE,
++                      .min    = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
++                      .def    = V4L2_MPEG_VIDEO_H264_PROFILE_MAIN,
++                      .max    = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
++                      .menu_skip_mask =
++                              BIT(V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED),
++              },
++              .codec          = CEDRUS_CODEC_H264,
++              .required       = false,
++      },
+       {
+               .cfg = {
+                       .id     = V4L2_CID_MPEG_VIDEO_HEVC_SPS,
+-- 
+2.30.1
+

diff --git a/queue-5.10/mips-compressed-fix-build-with-enabled-ubsan.patch b/queue-5.10/mips-compressed-fix-build-with-enabled-ubsan.patch
new file mode 100644 (file)
index 0000000..6334c9d
--- /dev/null
+++ b/queue-5.10/mips-compressed-fix-build-with-enabled-ubsan.patch
@@ -0,0 +1,54 @@
+From 542109b14c7db464e75eb0e768afc13456a1738a Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 8 Feb 2021 12:37:42 +0000
+Subject: MIPS: compressed: fix build with enabled UBSAN
+
+From: Alexander Lobakin <alobakin@pm.me>
+
+[ Upstream commit fc4cac4cfc437659ce445c3c47b807e1cc625b66 ]
+
+Commit 1e35918ad9d1 ("MIPS: Enable Undefined Behavior Sanitizer
+UBSAN") added a possibility to build the entire kernel with UBSAN
+instrumentation for MIPS, with the exception for VDSO.
+However, self-extracting head wasn't been added to exceptions, so
+this occurs:
+
+mips-alpine-linux-musl-ld: arch/mips/boot/compressed/decompress.o:
+in function `FSE_buildDTable_wksp':
+decompress.c:(.text.FSE_buildDTable_wksp+0x278): undefined reference
+to `__ubsan_handle_shift_out_of_bounds'
+mips-alpine-linux-musl-ld: decompress.c:(.text.FSE_buildDTable_wksp+0x2a8):
+undefined reference to `__ubsan_handle_shift_out_of_bounds'
+mips-alpine-linux-musl-ld: decompress.c:(.text.FSE_buildDTable_wksp+0x2c4):
+undefined reference to `__ubsan_handle_shift_out_of_bounds'
+mips-alpine-linux-musl-ld: arch/mips/boot/compressed/decompress.o:
+decompress.c:(.text.FSE_buildDTable_raw+0x9c): more undefined references
+to `__ubsan_handle_shift_out_of_bounds' follow
+
+Add UBSAN_SANITIZE := n to mips/boot/compressed/Makefile to exclude
+it from instrumentation scope and fix this issue.
+
+Fixes: 1e35918ad9d1 ("MIPS: Enable Undefined Behavior Sanitizer UBSAN")
+Cc: stable@vger.kernel.org # 5.0+
+Signed-off-by: Alexander Lobakin <alobakin@pm.me>
+Signed-off-by: Thomas Bogendoerfer <tsbogend@alpha.franken.de>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ arch/mips/boot/compressed/Makefile | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/arch/mips/boot/compressed/Makefile b/arch/mips/boot/compressed/Makefile
+index d66511825fe1..337ab1d18cc1 100644
+--- a/arch/mips/boot/compressed/Makefile
++++ b/arch/mips/boot/compressed/Makefile
+@@ -36,6 +36,7 @@ KBUILD_AFLAGS := $(KBUILD_AFLAGS) -D__ASSEMBLY__ \
+ 
+ # Prevents link failures: __sanitizer_cov_trace_pc() is not linked in.
+ KCOV_INSTRUMENT               := n
++UBSAN_SANITIZE := n
+ 
+ # decompressor objects (linked with vmlinuz)
+ vmlinuzobjs-y := $(obj)/head.o $(obj)/decompress.o $(obj)/string.o
+-- 
+2.30.1
+

diff --git a/queue-5.10/mips-kernel-reserve-exception-base-early-to-prevent-.patch b/queue-5.10/mips-kernel-reserve-exception-base-early-to-prevent-.patch
new file mode 100644 (file)
index 0000000..4ed93cd
--- /dev/null
+++ b/queue-5.10/mips-kernel-reserve-exception-base-early-to-prevent-.patch
@@ -0,0 +1,163 @@
+From 0a3116dd14ed2b3e7d9071669cf22c2d9a9695e5 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 8 Mar 2021 10:24:47 +0100
+Subject: MIPS: kernel: Reserve exception base early to prevent corruption
+
+From: Thomas Bogendoerfer <tsbogend@alpha.franken.de>
+
+[ Upstream commit bd67b711bfaa02cf19e88aa2d9edae5c1c1d2739 ]
+
+BMIPS is one of the few platforms that do change the exception base.
+After commit 2dcb39645441 ("memblock: do not start bottom-up allocations
+with kernel_end") we started seeing BMIPS boards fail to boot with the
+built-in FDT being corrupted.
+
+Before the cited commit, early allocations would be in the [kernel_end,
+RAM_END] range, but after commit they would be within [RAM_START +
+PAGE_SIZE, RAM_END].
+
+The custom exception base handler that is installed by
+bmips_ebase_setup() done for BMIPS5000 CPUs ends-up trampling on the
+memory region allocated by unflatten_and_copy_device_tree() thus
+corrupting the FDT used by the kernel.
+
+To fix this, we need to perform an early reservation of the custom
+exception space. Additional we reserve the first 4k (1k for R3k) for
+either normal exception vector space (legacy CPUs) or special vectors
+like cache exceptions.
+
+Huge thanks to Serge for analysing and proposing a solution to this
+issue.
+
+Fixes: 2dcb39645441 ("memblock: do not start bottom-up allocations with kernel_end")
+Reported-by: Kamal Dasu <kdasu.kdev@gmail.com>
+Debugged-by: Serge Semin <Sergey.Semin@baikalelectronics.ru>
+Acked-by: Mike Rapoport <rppt@linux.ibm.com>
+Tested-by: Florian Fainelli <f.fainelli@gmail.com>
+Reviewed-by: Serge Semin <fancer.lancer@gmail.com>
+Signed-off-by: Thomas Bogendoerfer <tsbogend@alpha.franken.de>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ arch/mips/include/asm/traps.h    |  3 +++
+ arch/mips/kernel/cpu-probe.c     |  6 ++++++
+ arch/mips/kernel/cpu-r3k-probe.c |  3 +++
+ arch/mips/kernel/traps.c         | 10 +++++-----
+ 4 files changed, 17 insertions(+), 5 deletions(-)
+
+diff --git a/arch/mips/include/asm/traps.h b/arch/mips/include/asm/traps.h
+index 6a0864bb604d..9038b91e2d8c 100644
+--- a/arch/mips/include/asm/traps.h
++++ b/arch/mips/include/asm/traps.h
+@@ -24,6 +24,9 @@ extern void (*board_ebase_setup)(void);
+ extern void (*board_cache_error_setup)(void);
+ 
+ extern int register_nmi_notifier(struct notifier_block *nb);
++extern void reserve_exception_space(phys_addr_t addr, unsigned long size);
++
++#define VECTORSPACING 0x100   /* for EI/VI mode */
+ 
+ #define nmi_notifier(fn, pri)                                         \
+ ({                                                                    \
+diff --git a/arch/mips/kernel/cpu-probe.c b/arch/mips/kernel/cpu-probe.c
+index 31cb9199197c..21794db53c05 100644
+--- a/arch/mips/kernel/cpu-probe.c
++++ b/arch/mips/kernel/cpu-probe.c
+@@ -26,6 +26,7 @@
+ #include <asm/elf.h>
+ #include <asm/pgtable-bits.h>
+ #include <asm/spram.h>
++#include <asm/traps.h>
+ #include <linux/uaccess.h>
+ 
+ #include "fpu-probe.h"
+@@ -1619,6 +1620,7 @@ static inline void cpu_probe_broadcom(struct cpuinfo_mips *c, unsigned int cpu)
+               c->cputype = CPU_BMIPS3300;
+               __cpu_name[cpu] = "Broadcom BMIPS3300";
+               set_elf_platform(cpu, "bmips3300");
++              reserve_exception_space(0x400, VECTORSPACING * 64);
+               break;
+       case PRID_IMP_BMIPS43XX: {
+               int rev = c->processor_id & PRID_REV_MASK;
+@@ -1629,6 +1631,7 @@ static inline void cpu_probe_broadcom(struct cpuinfo_mips *c, unsigned int cpu)
+                       __cpu_name[cpu] = "Broadcom BMIPS4380";
+                       set_elf_platform(cpu, "bmips4380");
+                       c->options |= MIPS_CPU_RIXI;
++                      reserve_exception_space(0x400, VECTORSPACING * 64);
+               } else {
+                       c->cputype = CPU_BMIPS4350;
+                       __cpu_name[cpu] = "Broadcom BMIPS4350";
+@@ -1645,6 +1648,7 @@ static inline void cpu_probe_broadcom(struct cpuinfo_mips *c, unsigned int cpu)
+                       __cpu_name[cpu] = "Broadcom BMIPS5000";
+               set_elf_platform(cpu, "bmips5000");
+               c->options |= MIPS_CPU_ULRI | MIPS_CPU_RIXI;
++              reserve_exception_space(0x1000, VECTORSPACING * 64);
+               break;
+       }
+ }
+@@ -2124,6 +2128,8 @@ void cpu_probe(void)
+       if (cpu == 0)
+               __ua_limit = ~((1ull << cpu_vmbits) - 1);
+ #endif
++
++      reserve_exception_space(0, 0x1000);
+ }
+ 
+ void cpu_report(void)
+diff --git a/arch/mips/kernel/cpu-r3k-probe.c b/arch/mips/kernel/cpu-r3k-probe.c
+index abdbbe8c5a43..af654771918c 100644
+--- a/arch/mips/kernel/cpu-r3k-probe.c
++++ b/arch/mips/kernel/cpu-r3k-probe.c
+@@ -21,6 +21,7 @@
+ #include <asm/fpu.h>
+ #include <asm/mipsregs.h>
+ #include <asm/elf.h>
++#include <asm/traps.h>
+ 
+ #include "fpu-probe.h"
+ 
+@@ -158,6 +159,8 @@ void cpu_probe(void)
+               cpu_set_fpu_opts(c);
+       else
+               cpu_set_nofpu_opts(c);
++
++      reserve_exception_space(0, 0x400);
+ }
+ 
+ void cpu_report(void)
+diff --git a/arch/mips/kernel/traps.c b/arch/mips/kernel/traps.c
+index e0352958e2f7..808b8b61ded1 100644
+--- a/arch/mips/kernel/traps.c
++++ b/arch/mips/kernel/traps.c
+@@ -2009,13 +2009,16 @@ void __noreturn nmi_exception_handler(struct pt_regs *regs)
+       nmi_exit();
+ }
+ 
+-#define VECTORSPACING 0x100   /* for EI/VI mode */
+-
+ unsigned long ebase;
+ EXPORT_SYMBOL_GPL(ebase);
+ unsigned long exception_handlers[32];
+ unsigned long vi_handlers[64];
+ 
++void reserve_exception_space(phys_addr_t addr, unsigned long size)
++{
++      memblock_reserve(addr, size);
++}
++
+ void __init *set_except_vector(int n, void *addr)
+ {
+       unsigned long handler = (unsigned long) addr;
+@@ -2367,10 +2370,7 @@ void __init trap_init(void)
+ 
+       if (!cpu_has_mips_r2_r6) {
+               ebase = CAC_BASE;
+-              ebase_pa = virt_to_phys((void *)ebase);
+               vec_size = 0x400;
+-
+-              memblock_reserve(ebase_pa, vec_size);
+       } else {
+               if (cpu_has_veic || cpu_has_vint)
+                       vec_size = 0x200 + VECTORSPACING*64;
+-- 
+2.30.1
+

diff --git a/queue-5.10/module-avoid-goto-s-in-module_sig_check.patch b/queue-5.10/module-avoid-goto-s-in-module_sig_check.patch
new file mode 100644 (file)
index 0000000..83a7ffb
--- /dev/null
+++ b/queue-5.10/module-avoid-goto-s-in-module_sig_check.patch
@@ -0,0 +1,66 @@
+From c5d4af31cebd2d83fdb7bb7b7d11cbc086c18a4a Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Sat, 31 Oct 2020 23:09:31 +0300
+Subject: module: avoid *goto*s in module_sig_check()
+
+From: Sergey Shtylyov <s.shtylyov@omprussia.ru>
+
+[ Upstream commit 10ccd1abb808599a6dc7c9389560016ea3568085 ]
+
+Let's move the common handling of the non-fatal errors after the *switch*
+statement -- this avoids *goto*s inside that *switch*...
+
+Suggested-by: Joe Perches <joe@perches.com>
+Reviewed-by: Miroslav Benes <mbenes@suse.cz>
+Signed-off-by: Sergey Shtylyov <s.shtylyov@omprussia.ru>
+Signed-off-by: Jessica Yu <jeyu@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ kernel/module.c | 20 ++++++++++----------
+ 1 file changed, 10 insertions(+), 10 deletions(-)
+
+diff --git a/kernel/module.c b/kernel/module.c
+index 3b6dd8200d3d..f1be6b6a3a3d 100644
+--- a/kernel/module.c
++++ b/kernel/module.c
+@@ -2923,20 +2923,13 @@ static int module_sig_check(struct load_info *info, int flags)
+                */
+       case -ENODATA:
+               reason = "unsigned module";
+-              goto decide;
++              break;
+       case -ENOPKG:
+               reason = "module with unsupported crypto";
+-              goto decide;
++              break;
+       case -ENOKEY:
+               reason = "module with unavailable key";
+-      decide:
+-              if (is_module_sig_enforced()) {
+-                      pr_notice("%s: loading of %s is rejected\n",
+-                                info->name, reason);
+-                      return -EKEYREJECTED;
+-              }
+-
+-              return security_locked_down(LOCKDOWN_MODULE_SIGNATURE);
++              break;
+ 
+               /* All other errors are fatal, including nomem, unparseable
+                * signatures and signature check failures - even if signatures
+@@ -2945,6 +2938,13 @@ static int module_sig_check(struct load_info *info, int flags)
+       default:
+               return err;
+       }
++
++      if (is_module_sig_enforced()) {
++              pr_notice("%s: loading of %s is rejected\n", info->name, reason);
++              return -EKEYREJECTED;
++      }
++
++      return security_locked_down(LOCKDOWN_MODULE_SIGNATURE);
+ }
+ #else /* !CONFIG_MODULE_SIG */
+ static int module_sig_check(struct load_info *info, int flags)
+-- 
+2.30.1
+

diff --git a/queue-5.10/module-harden-elf-info-handling.patch b/queue-5.10/module-harden-elf-info-handling.patch
new file mode 100644 (file)
index 0000000..635912d
--- /dev/null
+++ b/queue-5.10/module-harden-elf-info-handling.patch
@@ -0,0 +1,297 @@
+From 945b3a59594d673e661159700a5c799dc2b0ea01 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 14 Jan 2021 22:21:46 +0000
+Subject: module: harden ELF info handling
+
+From: Frank van der Linden <fllinden@amazon.com>
+
+[ Upstream commit ec2a29593c83ed71a7f16e3243941ebfcf75fdf6 ]
+
+5fdc7db644 ("module: setup load info before module_sig_check()")
+moved the ELF setup, so that it was done before the signature
+check. This made the module name available to signature error
+messages.
+
+However, the checks for ELF correctness in setup_load_info
+are not sufficient to prevent bad memory references due to
+corrupted offset fields, indices, etc.
+
+So, there's a regression in behavior here: a corrupt and unsigned
+(or badly signed) module, which might previously have been rejected
+immediately, can now cause an oops/crash.
+
+Harden ELF handling for module loading by doing the following:
+
+- Move the signature check back up so that it comes before ELF
+  initialization. It's best to do the signature check to see
+  if we can trust the module, before using the ELF structures
+  inside it. This also makes checks against info->len
+  more accurate again, as this field will be reduced by the
+  length of the signature in mod_check_sig().
+
+  The module name is now once again not available for error
+  messages during the signature check, but that seems like
+  a fair tradeoff.
+
+- Check if sections have offset / size fields that at least don't
+  exceed the length of the module.
+
+- Check if sections have section name offsets that don't fall
+  outside the section name table.
+
+- Add a few other sanity checks against invalid section indices,
+  etc.
+
+This is not an exhaustive consistency check, but the idea is to
+at least get through the signature and blacklist checks without
+crashing because of corrupted ELF info, and to error out gracefully
+for most issues that would have caused problems later on.
+
+Fixes: 5fdc7db6448a ("module: setup load info before module_sig_check()")
+Signed-off-by: Frank van der Linden <fllinden@amazon.com>
+Signed-off-by: Jessica Yu <jeyu@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ kernel/module.c           | 143 +++++++++++++++++++++++++++++++++-----
+ kernel/module_signature.c |   2 +-
+ kernel/module_signing.c   |   2 +-
+ 3 files changed, 126 insertions(+), 21 deletions(-)
+
+diff --git a/kernel/module.c b/kernel/module.c
+index f1be6b6a3a3d..908d46abe165 100644
+--- a/kernel/module.c
++++ b/kernel/module.c
+@@ -2940,7 +2940,7 @@ static int module_sig_check(struct load_info *info, int flags)
+       }
+ 
+       if (is_module_sig_enforced()) {
+-              pr_notice("%s: loading of %s is rejected\n", info->name, reason);
++              pr_notice("Loading of %s is rejected\n", reason);
+               return -EKEYREJECTED;
+       }
+ 
+@@ -2953,9 +2953,33 @@ static int module_sig_check(struct load_info *info, int flags)
+ }
+ #endif /* !CONFIG_MODULE_SIG */
+ 
+-/* Sanity checks against invalid binaries, wrong arch, weird elf version. */
+-static int elf_header_check(struct load_info *info)
++static int validate_section_offset(struct load_info *info, Elf_Shdr *shdr)
+ {
++      unsigned long secend;
++
++      /*
++       * Check for both overflow and offset/size being
++       * too large.
++       */
++      secend = shdr->sh_offset + shdr->sh_size;
++      if (secend < shdr->sh_offset || secend > info->len)
++              return -ENOEXEC;
++
++      return 0;
++}
++
++/*
++ * Sanity checks against invalid binaries, wrong arch, weird elf version.
++ *
++ * Also do basic validity checks against section offsets and sizes, the
++ * section name string table, and the indices used for it (sh_name).
++ */
++static int elf_validity_check(struct load_info *info)
++{
++      unsigned int i;
++      Elf_Shdr *shdr, *strhdr;
++      int err;
++
+       if (info->len < sizeof(*(info->hdr)))
+               return -ENOEXEC;
+ 
+@@ -2965,11 +2989,78 @@ static int elf_header_check(struct load_info *info)
+           || info->hdr->e_shentsize != sizeof(Elf_Shdr))
+               return -ENOEXEC;
+ 
++      /*
++       * e_shnum is 16 bits, and sizeof(Elf_Shdr) is
++       * known and small. So e_shnum * sizeof(Elf_Shdr)
++       * will not overflow unsigned long on any platform.
++       */
+       if (info->hdr->e_shoff >= info->len
+           || (info->hdr->e_shnum * sizeof(Elf_Shdr) >
+               info->len - info->hdr->e_shoff))
+               return -ENOEXEC;
+ 
++      info->sechdrs = (void *)info->hdr + info->hdr->e_shoff;
++
++      /*
++       * Verify if the section name table index is valid.
++       */
++      if (info->hdr->e_shstrndx == SHN_UNDEF
++          || info->hdr->e_shstrndx >= info->hdr->e_shnum)
++              return -ENOEXEC;
++
++      strhdr = &info->sechdrs[info->hdr->e_shstrndx];
++      err = validate_section_offset(info, strhdr);
++      if (err < 0)
++              return err;
++
++      /*
++       * The section name table must be NUL-terminated, as required
++       * by the spec. This makes strcmp and pr_* calls that access
++       * strings in the section safe.
++       */
++      info->secstrings = (void *)info->hdr + strhdr->sh_offset;
++      if (info->secstrings[strhdr->sh_size - 1] != '\0')
++              return -ENOEXEC;
++
++      /*
++       * The code assumes that section 0 has a length of zero and
++       * an addr of zero, so check for it.
++       */
++      if (info->sechdrs[0].sh_type != SHT_NULL
++          || info->sechdrs[0].sh_size != 0
++          || info->sechdrs[0].sh_addr != 0)
++              return -ENOEXEC;
++
++      for (i = 1; i < info->hdr->e_shnum; i++) {
++              shdr = &info->sechdrs[i];
++              switch (shdr->sh_type) {
++              case SHT_NULL:
++              case SHT_NOBITS:
++                      continue;
++              case SHT_SYMTAB:
++                      if (shdr->sh_link == SHN_UNDEF
++                          || shdr->sh_link >= info->hdr->e_shnum)
++                              return -ENOEXEC;
++                      fallthrough;
++              default:
++                      err = validate_section_offset(info, shdr);
++                      if (err < 0) {
++                              pr_err("Invalid ELF section in module (section %u type %u)\n",
++                                      i, shdr->sh_type);
++                              return err;
++                      }
++
++                      if (shdr->sh_flags & SHF_ALLOC) {
++                              if (shdr->sh_name >= strhdr->sh_size) {
++                                      pr_err("Invalid ELF section name in module (section %u type %u)\n",
++                                             i, shdr->sh_type);
++                                      return -ENOEXEC;
++                              }
++                      }
++                      break;
++              }
++      }
++
+       return 0;
+ }
+ 
+@@ -3071,11 +3162,6 @@ static int rewrite_section_headers(struct load_info *info, int flags)
+ 
+       for (i = 1; i < info->hdr->e_shnum; i++) {
+               Elf_Shdr *shdr = &info->sechdrs[i];
+-              if (shdr->sh_type != SHT_NOBITS
+-                  && info->len < shdr->sh_offset + shdr->sh_size) {
+-                      pr_err("Module len %lu truncated\n", info->len);
+-                      return -ENOEXEC;
+-              }
+ 
+               /* Mark all sections sh_addr with their address in the
+                  temporary image. */
+@@ -3107,11 +3193,6 @@ static int setup_load_info(struct load_info *info, int flags)
+ {
+       unsigned int i;
+ 
+-      /* Set up the convenience variables */
+-      info->sechdrs = (void *)info->hdr + info->hdr->e_shoff;
+-      info->secstrings = (void *)info->hdr
+-              + info->sechdrs[info->hdr->e_shstrndx].sh_offset;
+-
+       /* Try to find a name early so we can log errors with a module name */
+       info->index.info = find_sec(info, ".modinfo");
+       if (info->index.info)
+@@ -3855,26 +3936,50 @@ static int load_module(struct load_info *info, const char __user *uargs,
+       long err = 0;
+       char *after_dashes;
+ 
+-      err = elf_header_check(info);
++      /*
++       * Do the signature check (if any) first. All that
++       * the signature check needs is info->len, it does
++       * not need any of the section info. That can be
++       * set up later. This will minimize the chances
++       * of a corrupt module causing problems before
++       * we even get to the signature check.
++       *
++       * The check will also adjust info->len by stripping
++       * off the sig length at the end of the module, making
++       * checks against info->len more correct.
++       */
++      err = module_sig_check(info, flags);
++      if (err)
++              goto free_copy;
++
++      /*
++       * Do basic sanity checks against the ELF header and
++       * sections.
++       */
++      err = elf_validity_check(info);
+       if (err) {
+-              pr_err("Module has invalid ELF header\n");
++              pr_err("Module has invalid ELF structures\n");
+               goto free_copy;
+       }
+ 
++      /*
++       * Everything checks out, so set up the section info
++       * in the info structure.
++       */
+       err = setup_load_info(info, flags);
+       if (err)
+               goto free_copy;
+ 
++      /*
++       * Now that we know we have the correct module name, check
++       * if it's blacklisted.
++       */
+       if (blacklisted(info->name)) {
+               err = -EPERM;
+               pr_err("Module %s is blacklisted\n", info->name);
+               goto free_copy;
+       }
+ 
+-      err = module_sig_check(info, flags);
+-      if (err)
+-              goto free_copy;
+-
+       err = rewrite_section_headers(info, flags);
+       if (err)
+               goto free_copy;
+diff --git a/kernel/module_signature.c b/kernel/module_signature.c
+index 4224a1086b7d..00132d12487c 100644
+--- a/kernel/module_signature.c
++++ b/kernel/module_signature.c
+@@ -25,7 +25,7 @@ int mod_check_sig(const struct module_signature *ms, size_t file_len,
+               return -EBADMSG;
+ 
+       if (ms->id_type != PKEY_ID_PKCS7) {
+-              pr_err("%s: Module is not signed with expected PKCS#7 message\n",
++              pr_err("%s: not signed with expected PKCS#7 message\n",
+                      name);
+               return -ENOPKG;
+       }
+diff --git a/kernel/module_signing.c b/kernel/module_signing.c
+index 9d9fc678c91d..8723ae70ea1f 100644
+--- a/kernel/module_signing.c
++++ b/kernel/module_signing.c
+@@ -30,7 +30,7 @@ int mod_verify_sig(const void *mod, struct load_info *info)
+ 
+       memcpy(&ms, mod + (modlen - sizeof(ms)), sizeof(ms));
+ 
+-      ret = mod_check_sig(&ms, modlen, info->name);
++      ret = mod_check_sig(&ms, modlen, "module");
+       if (ret)
+               return ret;
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/module-merge-repetitive-strings-in-module_sig_check.patch b/queue-5.10/module-merge-repetitive-strings-in-module_sig_check.patch
new file mode 100644 (file)
index 0000000..8d2563e
--- /dev/null
+++ b/queue-5.10/module-merge-repetitive-strings-in-module_sig_check.patch
@@ -0,0 +1,52 @@
+From dd8dfb1bde1ec60845b6e32d1150814d8d98b396 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Sat, 31 Oct 2020 23:06:45 +0300
+Subject: module: merge repetitive strings in module_sig_check()
+
+From: Sergey Shtylyov <s.shtylyov@omprussia.ru>
+
+[ Upstream commit 705e9195187d85249fbb0eaa844b1604a98fbc9a ]
+
+The 'reason' variable in module_sig_check() points to 3 strings across
+the *switch* statement, all needlessly starting with the same text.
+Let's put the starting text into the pr_notice() call -- it saves 21
+bytes of the object code (x86 gcc 10.2.1).
+
+Suggested-by: Joe Perches <joe@perches.com>
+Reviewed-by: Miroslav Benes <mbenes@suse.cz>
+Signed-off-by: Sergey Shtylyov <s.shtylyov@omprussia.ru>
+Signed-off-by: Jessica Yu <jeyu@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ kernel/module.c | 9 +++++----
+ 1 file changed, 5 insertions(+), 4 deletions(-)
+
+diff --git a/kernel/module.c b/kernel/module.c
+index 94f926473e35..3b6dd8200d3d 100644
+--- a/kernel/module.c
++++ b/kernel/module.c
+@@ -2922,16 +2922,17 @@ static int module_sig_check(struct load_info *info, int flags)
+                * enforcing, certain errors are non-fatal.
+                */
+       case -ENODATA:
+-              reason = "Loading of unsigned module";
++              reason = "unsigned module";
+               goto decide;
+       case -ENOPKG:
+-              reason = "Loading of module with unsupported crypto";
++              reason = "module with unsupported crypto";
+               goto decide;
+       case -ENOKEY:
+-              reason = "Loading of module with unavailable key";
++              reason = "module with unavailable key";
+       decide:
+               if (is_module_sig_enforced()) {
+-                      pr_notice("%s: %s is rejected\n", info->name, reason);
++                      pr_notice("%s: loading of %s is rejected\n",
++                                info->name, reason);
+                       return -EKEYREJECTED;
+               }
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/mptcp-put-subflow-sock-on-connect-error.patch b/queue-5.10/mptcp-put-subflow-sock-on-connect-error.patch
new file mode 100644 (file)
index 0000000..b7f3353
--- /dev/null
+++ b/queue-5.10/mptcp-put-subflow-sock-on-connect-error.patch
@@ -0,0 +1,49 @@
+From b3cc8605c6bacaef72b8f38f2bd2cfe82b9d2c85 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 4 Mar 2021 13:32:09 -0800
+Subject: mptcp: put subflow sock on connect error
+
+From: Florian Westphal <fw@strlen.de>
+
+[ Upstream commit f07157792c633b528de5fc1dbe2e4ea54f8e09d4 ]
+
+mptcp_add_pending_subflow() performs a sock_hold() on the subflow,
+then adds the subflow to the join list.
+
+Without a sock_put the subflow sk won't be freed in case connect() fails.
+
+unreferenced object 0xffff88810c03b100 (size 3000):
+[..]
+    sk_prot_alloc.isra.0+0x2f/0x110
+    sk_alloc+0x5d/0xc20
+    inet6_create+0x2b7/0xd30
+    __sock_create+0x17f/0x410
+    mptcp_subflow_create_socket+0xff/0x9c0
+    __mptcp_subflow_connect+0x1da/0xaf0
+    mptcp_pm_nl_work+0x6e0/0x1120
+    mptcp_worker+0x508/0x9a0
+
+Fixes: 5b950ff4331ddda ("mptcp: link MPC subflow into msk only after accept")
+Signed-off-by: Florian Westphal <fw@strlen.de>
+Signed-off-by: Mat Martineau <mathew.j.martineau@linux.intel.com>
+Signed-off-by: David S. Miller <davem@davemloft.net>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ net/mptcp/subflow.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/net/mptcp/subflow.c b/net/mptcp/subflow.c
+index 16adba172fb9..591546d0953f 100644
+--- a/net/mptcp/subflow.c
++++ b/net/mptcp/subflow.c
+@@ -1133,6 +1133,7 @@ int __mptcp_subflow_connect(struct sock *sk, const struct mptcp_addr_info *loc,
+       spin_lock_bh(&msk->join_list_lock);
+       list_add_tail(&subflow->node, &msk->join_list);
+       spin_unlock_bh(&msk->join_list_lock);
++      sock_put(mptcp_subflow_tcp_sock(subflow));
+ 
+       return err;
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/mptcp-reduce-the-arguments-of-mptcp_sendmsg_frag.patch b/queue-5.10/mptcp-reduce-the-arguments-of-mptcp_sendmsg_frag.patch
new file mode 100644 (file)
index 0000000..c75a7d5
--- /dev/null
+++ b/queue-5.10/mptcp-reduce-the-arguments-of-mptcp_sendmsg_frag.patch
@@ -0,0 +1,176 @@
+From 325a0840329a4b04c35fe3ebf13d977cbd33dd91 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 16 Nov 2020 10:48:06 +0100
+Subject: mptcp: reduce the arguments of mptcp_sendmsg_frag
+
+From: Paolo Abeni <pabeni@redhat.com>
+
+[ Upstream commit caf971df01b86f33f151bcfa61b4385cf5e43822 ]
+
+The current argument list is pretty long and quite unreadable,
+move many of them into a specific struct. Later patches
+will add more stuff to such struct.
+
+Additionally drop the 'timeo' argument, now unused.
+
+Signed-off-by: Paolo Abeni <pabeni@redhat.com>
+Signed-off-by: Jakub Kicinski <kuba@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ net/mptcp/protocol.c | 53 ++++++++++++++++++++++++--------------------
+ 1 file changed, 29 insertions(+), 24 deletions(-)
+
+diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c
+index 0504a5f13c2a..888eb6a86dad 100644
+--- a/net/mptcp/protocol.c
++++ b/net/mptcp/protocol.c
+@@ -886,12 +886,16 @@ mptcp_carve_data_frag(const struct mptcp_sock *msk, struct page_frag *pfrag,
+       return dfrag;
+ }
+ 
++struct mptcp_sendmsg_info {
++      int mss_now;
++      int size_goal;
++};
++
+ static int mptcp_sendmsg_frag(struct sock *sk, struct sock *ssk,
+                             struct msghdr *msg, struct mptcp_data_frag *dfrag,
+-                            long *timeo, int *pmss_now,
+-                            int *ps_goal)
++                            struct mptcp_sendmsg_info *info)
+ {
+-      int mss_now, avail_size, size_goal, offset, ret, frag_truesize = 0;
++      int avail_size, offset, ret, frag_truesize = 0;
+       bool dfrag_collapsed, can_collapse = false;
+       struct mptcp_sock *msk = mptcp_sk(sk);
+       struct mptcp_ext *mpext = NULL;
+@@ -917,10 +921,8 @@ static int mptcp_sendmsg_frag(struct sock *sk, struct sock *ssk,
+       }
+ 
+       /* compute copy limit */
+-      mss_now = tcp_send_mss(ssk, &size_goal, msg->msg_flags);
+-      *pmss_now = mss_now;
+-      *ps_goal = size_goal;
+-      avail_size = size_goal;
++      info->mss_now = tcp_send_mss(ssk, &info->size_goal, msg->msg_flags);
++      avail_size = info->size_goal;
+       skb = tcp_write_queue_tail(ssk);
+       if (skb) {
+               mpext = skb_ext_find(skb, SKB_EXT_MPTCP);
+@@ -931,12 +933,12 @@ static int mptcp_sendmsg_frag(struct sock *sk, struct sock *ssk,
+                * queue management operation, to avoid breaking the ext <->
+                * SSN association set here
+                */
+-              can_collapse = (size_goal - skb->len > 0) &&
++              can_collapse = (info->size_goal - skb->len > 0) &&
+                             mptcp_skb_can_collapse_to(*write_seq, skb, mpext);
+               if (!can_collapse)
+                       TCP_SKB_CB(skb)->eor = 1;
+               else
+-                      avail_size = size_goal - skb->len;
++                      avail_size = info->size_goal - skb->len;
+       }
+ 
+       if (!retransmission) {
+@@ -1168,11 +1170,15 @@ static void ssk_check_wmem(struct mptcp_sock *msk)
+ 
+ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
+ {
+-      int mss_now = 0, size_goal = 0, ret = 0;
+       struct mptcp_sock *msk = mptcp_sk(sk);
++      struct mptcp_sendmsg_info info = {
++              .mss_now = 0,
++              .size_goal = 0,
++      };
+       struct page_frag *pfrag;
+       size_t copied = 0;
+       struct sock *ssk;
++      int ret = 0;
+       u32 sndbuf;
+       bool tx_ok;
+       long timeo;
+@@ -1241,8 +1247,7 @@ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
+       lock_sock(ssk);
+       tx_ok = msg_data_left(msg);
+       while (tx_ok) {
+-              ret = mptcp_sendmsg_frag(sk, ssk, msg, NULL, &timeo, &mss_now,
+-                                       &size_goal);
++              ret = mptcp_sendmsg_frag(sk, ssk, msg, NULL, &info);
+               if (ret < 0) {
+                       if (ret == -EAGAIN && timeo > 0) {
+                               mptcp_set_timeout(sk, ssk);
+@@ -1265,8 +1270,8 @@ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
+               if (!sk_stream_memory_free(ssk) ||
+                   !mptcp_page_frag_refill(ssk, pfrag) ||
+                   !mptcp_ext_cache_refill(msk)) {
+-                      tcp_push(ssk, msg->msg_flags, mss_now,
+-                               tcp_sk(ssk)->nonagle, size_goal);
++                      tcp_push(ssk, msg->msg_flags, info.mss_now,
++                               tcp_sk(ssk)->nonagle, info.size_goal);
+                       mptcp_set_timeout(sk, ssk);
+                       release_sock(ssk);
+                       goto restart;
+@@ -1286,8 +1291,8 @@ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
+                * limits before we send more data.
+                */
+               if (unlikely(!sk_stream_memory_free(sk))) {
+-                      tcp_push(ssk, msg->msg_flags, mss_now,
+-                               tcp_sk(ssk)->nonagle, size_goal);
++                      tcp_push(ssk, msg->msg_flags, info.mss_now,
++                               tcp_sk(ssk)->nonagle, info.size_goal);
+                       mptcp_clean_una(sk);
+                       if (!sk_stream_memory_free(sk)) {
+                               /* can't send more for now, need to wait for
+@@ -1304,8 +1309,8 @@ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
+ 
+       mptcp_set_timeout(sk, ssk);
+       if (copied) {
+-              tcp_push(ssk, msg->msg_flags, mss_now, tcp_sk(ssk)->nonagle,
+-                       size_goal);
++              tcp_push(ssk, msg->msg_flags, info.mss_now,
++                       tcp_sk(ssk)->nonagle, info.size_goal);
+ 
+               /* start the timer, if it's not pending */
+               if (!mptcp_timer_pending(sk))
+@@ -1747,14 +1752,15 @@ static void mptcp_worker(struct work_struct *work)
+ {
+       struct mptcp_sock *msk = container_of(work, struct mptcp_sock, work);
+       struct sock *ssk, *sk = &msk->sk.icsk_inet.sk;
+-      int orig_len, orig_offset, mss_now = 0, size_goal = 0;
++      struct mptcp_sendmsg_info info = {};
+       struct mptcp_data_frag *dfrag;
++      int orig_len, orig_offset;
+       u64 orig_write_seq;
+       size_t copied = 0;
+       struct msghdr msg = {
+               .msg_flags = MSG_DONTWAIT,
+       };
+-      long timeo = 0;
++      int ret;
+ 
+       lock_sock(sk);
+       mptcp_clean_una_wakeup(sk);
+@@ -1793,8 +1799,7 @@ static void mptcp_worker(struct work_struct *work)
+       orig_offset = dfrag->offset;
+       orig_write_seq = dfrag->data_seq;
+       while (dfrag->data_len > 0) {
+-              int ret = mptcp_sendmsg_frag(sk, ssk, &msg, dfrag, &timeo,
+-                                           &mss_now, &size_goal);
++              ret = mptcp_sendmsg_frag(sk, ssk, &msg, dfrag, &info);
+               if (ret < 0)
+                       break;
+ 
+@@ -1807,8 +1812,8 @@ static void mptcp_worker(struct work_struct *work)
+                       break;
+       }
+       if (copied)
+-              tcp_push(ssk, msg.msg_flags, mss_now, tcp_sk(ssk)->nonagle,
+-                       size_goal);
++              tcp_push(ssk, 0, info.mss_now, tcp_sk(ssk)->nonagle,
++                       info.size_goal);
+ 
+       dfrag->data_seq = orig_write_seq;
+       dfrag->offset = orig_offset;
+-- 
+2.30.1
+

diff --git a/queue-5.10/mptcp-split-mptcp_clean_una-function.patch b/queue-5.10/mptcp-split-mptcp_clean_una-function.patch
new file mode 100644 (file)
index 0000000..7cfc2bb
--- /dev/null
+++ b/queue-5.10/mptcp-split-mptcp_clean_una-function.patch
@@ -0,0 +1,74 @@
+From 83cc045e23160c921284e98fe71b19ca08ebbe2a Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Tue, 3 Nov 2020 11:05:06 -0800
+Subject: mptcp: split mptcp_clean_una function
+
+From: Florian Westphal <fw@strlen.de>
+
+[ Upstream commit 95ed690ebc72ad6c89068f08197b51fe4d3c3b48 ]
+
+mptcp_clean_una() will wake writers in case memory could be reclaimed.
+When called from mptcp_sendmsg the wakeup code isn't needed.
+
+Move the wakeup to a new helper and then use that from the mptcp worker.
+
+Signed-off-by: Florian Westphal <fw@strlen.de>
+Signed-off-by: Mat Martineau <mathew.j.martineau@linux.intel.com>
+Signed-off-by: Jakub Kicinski <kuba@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ net/mptcp/protocol.c | 28 +++++++++++++++++-----------
+ 1 file changed, 17 insertions(+), 11 deletions(-)
+
+diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c
+index f56b2e331bb6..0504a5f13c2a 100644
+--- a/net/mptcp/protocol.c
++++ b/net/mptcp/protocol.c
+@@ -833,19 +833,25 @@ static void mptcp_clean_una(struct sock *sk)
+       }
+ 
+ out:
+-      if (cleaned) {
++      if (cleaned)
+               sk_mem_reclaim_partial(sk);
++}
+ 
+-              /* Only wake up writers if a subflow is ready */
+-              if (mptcp_is_writeable(msk)) {
+-                      set_bit(MPTCP_SEND_SPACE, &mptcp_sk(sk)->flags);
+-                      smp_mb__after_atomic();
++static void mptcp_clean_una_wakeup(struct sock *sk)
++{
++      struct mptcp_sock *msk = mptcp_sk(sk);
+ 
+-                      /* set SEND_SPACE before sk_stream_write_space clears
+-                       * NOSPACE
+-                       */
+-                      sk_stream_write_space(sk);
+-              }
++      mptcp_clean_una(sk);
++
++      /* Only wake up writers if a subflow is ready */
++      if (mptcp_is_writeable(msk)) {
++              set_bit(MPTCP_SEND_SPACE, &msk->flags);
++              smp_mb__after_atomic();
++
++              /* set SEND_SPACE before sk_stream_write_space clears
++               * NOSPACE
++               */
++              sk_stream_write_space(sk);
+       }
+ }
+ 
+@@ -1751,7 +1757,7 @@ static void mptcp_worker(struct work_struct *work)
+       long timeo = 0;
+ 
+       lock_sock(sk);
+-      mptcp_clean_una(sk);
++      mptcp_clean_una_wakeup(sk);
+       mptcp_check_data_fin_ack(sk);
+       __mptcp_flush_join_list(msk);
+       if (test_and_clear_bit(MPTCP_WORK_CLOSE_SUBFLOW, &msk->flags))
+-- 
+2.30.1
+

diff --git a/queue-5.10/net-bonding-fix-error-return-code-of-bond_neigh_init.patch b/queue-5.10/net-bonding-fix-error-return-code-of-bond_neigh_init.patch
new file mode 100644 (file)
index 0000000..473fd46
--- /dev/null
+++ b/queue-5.10/net-bonding-fix-error-return-code-of-bond_neigh_init.patch
@@ -0,0 +1,47 @@
+From cfd20b4a247c4294e2e352aeaefd705663b84fe9 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Sun, 7 Mar 2021 19:11:02 -0800
+Subject: net: bonding: fix error return code of bond_neigh_init()
+
+From: Jia-Ju Bai <baijiaju1990@gmail.com>
+
+[ Upstream commit 2055a99da8a253a357bdfd359b3338ef3375a26c ]
+
+When slave is NULL or slave_ops->ndo_neigh_setup is NULL, no error
+return code of bond_neigh_init() is assigned.
+To fix this bug, ret is assigned with -EINVAL in these cases.
+
+Fixes: 9e99bfefdbce ("bonding: fix bond_neigh_init()")
+Reported-by: TOTE Robot <oslab@tsinghua.edu.cn>
+Signed-off-by: Jia-Ju Bai <baijiaju1990@gmail.com>
+Signed-off-by: David S. Miller <davem@davemloft.net>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/net/bonding/bond_main.c | 8 ++++++--
+ 1 file changed, 6 insertions(+), 2 deletions(-)
+
+diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
+index 47afc5938c26..6d5a39af1097 100644
+--- a/drivers/net/bonding/bond_main.c
++++ b/drivers/net/bonding/bond_main.c
+@@ -3918,11 +3918,15 @@ static int bond_neigh_init(struct neighbour *n)
+ 
+       rcu_read_lock();
+       slave = bond_first_slave_rcu(bond);
+-      if (!slave)
++      if (!slave) {
++              ret = -EINVAL;
+               goto out;
++      }
+       slave_ops = slave->dev->netdev_ops;
+-      if (!slave_ops->ndo_neigh_setup)
++      if (!slave_ops->ndo_neigh_setup) {
++              ret = -EINVAL;
+               goto out;
++      }
+ 
+       /* TODO: find another way [1] to implement this.
+        * Passing a zeroed structure is fragile,
+-- 
+2.30.1
+

diff --git a/queue-5.10/net-phy-micrel-set-soft_reset-callback-to-genphy_sof.patch b/queue-5.10/net-phy-micrel-set-soft_reset-callback-to-genphy_sof.patch
new file mode 100644 (file)
index 0000000..00dda64
--- /dev/null
+++ b/queue-5.10/net-phy-micrel-set-soft_reset-callback-to-genphy_sof.patch
@@ -0,0 +1,48 @@
+From 35619b89465f3182d211802030fc900286936b07 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Wed, 24 Feb 2021 21:55:36 +0100
+Subject: net: phy: micrel: set soft_reset callback to genphy_soft_reset for
+ KSZ8081
+
+From: Christian Melki <christian.melki@t2data.com>
+
+[ Upstream commit 764d31cacfe48440745c4bbb55a62ac9471c9f19 ]
+
+Following a similar reinstate for the KSZ9031.
+
+Older kernels would use the genphy_soft_reset if the PHY did not implement
+a .soft_reset.
+
+Bluntly removing that default may expose a lot of situations where various
+PHYs/board implementations won't recover on various changes.
+Like with this implementation during a 4.9.x to 5.4.x LTS transition.
+I think it's a good thing to remove unwanted soft resets but wonder if it
+did open a can of worms?
+
+Atleast this fixes one iMX6 FEC/RMII/8081 combo.
+
+Fixes: 6e2d85ec0559 ("net: phy: Stop with excessive soft reset")
+Signed-off-by: Christian Melki <christian.melki@t2data.com>
+Reviewed-by: Andrew Lunn <andrew@lunn.ch>
+Link: https://lore.kernel.org/r/20210224205536.9349-1-christian.melki@t2data.com
+Signed-off-by: Jakub Kicinski <kuba@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/net/phy/micrel.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/drivers/net/phy/micrel.c b/drivers/net/phy/micrel.c
+index a7f74b3b97af..47ae1d1723c5 100644
+--- a/drivers/net/phy/micrel.c
++++ b/drivers/net/phy/micrel.c
+@@ -1263,6 +1263,7 @@ static struct phy_driver ksphy_driver[] = {
+       .probe          = kszphy_probe,
+       .config_init    = ksz8081_config_init,
+       .ack_interrupt  = kszphy_ack_interrupt,
++      .soft_reset     = genphy_soft_reset,
+       .config_intr    = kszphy_config_intr,
+       .get_sset_count = kszphy_get_sset_count,
+       .get_strings    = kszphy_get_strings,
+-- 
+2.30.1
+

diff --git a/queue-5.10/nvme-rdma-fix-possible-hang-when-failing-to-set-io-q.patch b/queue-5.10/nvme-rdma-fix-possible-hang-when-failing-to-set-io-q.patch
new file mode 100644 (file)
index 0000000..d52ffcf
--- /dev/null
+++ b/queue-5.10/nvme-rdma-fix-possible-hang-when-failing-to-set-io-q.patch
@@ -0,0 +1,46 @@
+From 775812c250a7384c7d5cc473f1259663e5d3b173 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 15 Mar 2021 14:04:27 -0700
+Subject: nvme-rdma: fix possible hang when failing to set io queues
+
+From: Sagi Grimberg <sagi@grimberg.me>
+
+[ Upstream commit c4c6df5fc84659690d4391d1fba155cd94185295 ]
+
+We only setup io queues for nvme controllers, and it makes absolutely no
+sense to allow a controller (re)connect without any I/O queues.  If we
+happen to fail setting the queue count for any reason, we should not allow
+this to be a successful reconnect as I/O has no chance in going through.
+Instead just fail and schedule another reconnect.
+
+Reported-by: Chao Leng <lengchao@huawei.com>
+Fixes: 711023071960 ("nvme-rdma: add a NVMe over Fabrics RDMA host driver")
+Signed-off-by: Sagi Grimberg <sagi@grimberg.me>
+Reviewed-by: Chao Leng <lengchao@huawei.com>
+Signed-off-by: Christoph Hellwig <hch@lst.de>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/nvme/host/rdma.c | 7 +++++--
+ 1 file changed, 5 insertions(+), 2 deletions(-)
+
+diff --git a/drivers/nvme/host/rdma.c b/drivers/nvme/host/rdma.c
+index 195703013272..8b326508a480 100644
+--- a/drivers/nvme/host/rdma.c
++++ b/drivers/nvme/host/rdma.c
+@@ -736,8 +736,11 @@ static int nvme_rdma_alloc_io_queues(struct nvme_rdma_ctrl *ctrl)
+               return ret;
+ 
+       ctrl->ctrl.queue_count = nr_io_queues + 1;
+-      if (ctrl->ctrl.queue_count < 2)
+-              return 0;
++      if (ctrl->ctrl.queue_count < 2) {
++              dev_err(ctrl->ctrl.device,
++                      "unable to set any I/O queues\n");
++              return -ENOMEM;
++      }
+ 
+       dev_info(ctrl->ctrl.device,
+               "creating %d I/O queues.\n", nr_io_queues);
+-- 
+2.30.1
+

diff --git a/queue-5.10/powerpc-sstep-fix-darn-emulation.patch b/queue-5.10/powerpc-sstep-fix-darn-emulation.patch
new file mode 100644 (file)
index 0000000..1d680e4
--- /dev/null
+++ b/queue-5.10/powerpc-sstep-fix-darn-emulation.patch
@@ -0,0 +1,39 @@
+From c2423cdd0b8bbec3fb4ad55d734707328bfd863b Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 4 Feb 2021 13:37:44 +0530
+Subject: powerpc/sstep: Fix darn emulation
+
+From: Sandipan Das <sandipan@linux.ibm.com>
+
+[ Upstream commit 22b89ba178dd0a66a26699ead014a3e73ff8e044 ]
+
+Commit 8813ff49607e ("powerpc/sstep: Check instruction validity
+against ISA version before emulation") introduced a proper way to skip
+unknown instructions. This makes sure that the same is used for the
+darn instruction when the range selection bits have a reserved value.
+
+Fixes: a23987ef267a ("powerpc: sstep: Add support for darn instruction")
+Signed-off-by: Sandipan Das <sandipan@linux.ibm.com>
+Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
+Link: https://lore.kernel.org/r/20210204080744.135785-2-sandipan@linux.ibm.com
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ arch/powerpc/lib/sstep.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/arch/powerpc/lib/sstep.c b/arch/powerpc/lib/sstep.c
+index 0f228ee11ca4..a2e067f68dee 100644
+--- a/arch/powerpc/lib/sstep.c
++++ b/arch/powerpc/lib/sstep.c
+@@ -1853,7 +1853,7 @@ int analyse_instr(struct instruction_op *op, const struct pt_regs *regs,
+                               goto compute_done;
+                       }
+ 
+-                      return -1;
++                      goto unknown_opcode;
+ #ifdef __powerpc64__
+               case 777:       /* modsd */
+                       if (!cpu_has_feature(CPU_FTR_ARCH_300))
+-- 
+2.30.1
+

diff --git a/queue-5.10/powerpc-sstep-fix-load-store-and-update-emulation.patch b/queue-5.10/powerpc-sstep-fix-load-store-and-update-emulation.patch
new file mode 100644 (file)
index 0000000..f7d8246
--- /dev/null
+++ b/queue-5.10/powerpc-sstep-fix-load-store-and-update-emulation.patch
@@ -0,0 +1,101 @@
+From aab9a3f3d3b5c67d6c66ad5beca52bb951f23886 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 4 Feb 2021 13:37:43 +0530
+Subject: powerpc/sstep: Fix load-store and update emulation
+
+From: Sandipan Das <sandipan@linux.ibm.com>
+
+[ Upstream commit bbda4b6c7d7c7f79da71f95c92a5d76be22c3efd ]
+
+The Power ISA says that the fixed-point load and update instructions
+must neither use R0 for the base address (RA) nor have the
+destination (RT) and the base address (RA) as the same register.
+Similarly, for fixed-point stores and floating-point loads and stores,
+the instruction is invalid when R0 is used as the base address (RA).
+
+This is applicable to the following instructions.
+  * Load Byte and Zero with Update (lbzu)
+  * Load Byte and Zero with Update Indexed (lbzux)
+  * Load Halfword and Zero with Update (lhzu)
+  * Load Halfword and Zero with Update Indexed (lhzux)
+  * Load Halfword Algebraic with Update (lhau)
+  * Load Halfword Algebraic with Update Indexed (lhaux)
+  * Load Word and Zero with Update (lwzu)
+  * Load Word and Zero with Update Indexed (lwzux)
+  * Load Word Algebraic with Update Indexed (lwaux)
+  * Load Doubleword with Update (ldu)
+  * Load Doubleword with Update Indexed (ldux)
+  * Load Floating Single with Update (lfsu)
+  * Load Floating Single with Update Indexed (lfsux)
+  * Load Floating Double with Update (lfdu)
+  * Load Floating Double with Update Indexed (lfdux)
+  * Store Byte with Update (stbu)
+  * Store Byte with Update Indexed (stbux)
+  * Store Halfword with Update (sthu)
+  * Store Halfword with Update Indexed (sthux)
+  * Store Word with Update (stwu)
+  * Store Word with Update Indexed (stwux)
+  * Store Doubleword with Update (stdu)
+  * Store Doubleword with Update Indexed (stdux)
+  * Store Floating Single with Update (stfsu)
+  * Store Floating Single with Update Indexed (stfsux)
+  * Store Floating Double with Update (stfdu)
+  * Store Floating Double with Update Indexed (stfdux)
+
+E.g. the following behaviour is observed for an invalid load and
+update instruction having RA = RT.
+
+While a userspace program having an instruction word like 0xe9ce0001,
+i.e. ldu r14, 0(r14), runs without getting receiving a SIGILL on a
+Power system (observed on P8 and P9), the outcome of executing that
+instruction word varies and its behaviour can be considered to be
+undefined.
+
+Attaching an uprobe at that instruction's address results in emulation
+which currently performs the load as well as writes the effective
+address back to the base register. This might not match the outcome
+from hardware.
+
+To remove any inconsistencies, this adds additional checks for the
+aforementioned instructions to make sure that the emulation
+infrastructure treats them as unknown. The kernel can then fallback to
+executing such instructions on hardware.
+
+Fixes: 0016a4cf5582 ("powerpc: Emulate most Book I instructions in emulate_step()")
+Signed-off-by: Sandipan Das <sandipan@linux.ibm.com>
+Reviewed-by: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
+Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
+Link: https://lore.kernel.org/r/20210204080744.135785-1-sandipan@linux.ibm.com
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ arch/powerpc/lib/sstep.c | 14 ++++++++++++++
+ 1 file changed, 14 insertions(+)
+
+diff --git a/arch/powerpc/lib/sstep.c b/arch/powerpc/lib/sstep.c
+index 242bdd8281e0..0f228ee11ca4 100644
+--- a/arch/powerpc/lib/sstep.c
++++ b/arch/powerpc/lib/sstep.c
+@@ -2909,6 +2909,20 @@ int analyse_instr(struct instruction_op *op, const struct pt_regs *regs,
+ 
+       }
+ 
++      if (OP_IS_LOAD_STORE(op->type) && (op->type & UPDATE)) {
++              switch (GETTYPE(op->type)) {
++              case LOAD:
++                      if (ra == rd)
++                              goto unknown_opcode;
++                      fallthrough;
++              case STORE:
++              case LOAD_FP:
++              case STORE_FP:
++                      if (ra == 0)
++                              goto unknown_opcode;
++              }
++      }
++
+ #ifdef CONFIG_VSX
+       if ((GETTYPE(op->type) == LOAD_VSX ||
+            GETTYPE(op->type) == STORE_VSX) &&
+-- 
+2.30.1
+

diff --git a/queue-5.10/rcu-nocb-trigger-self-ipi-on-late-deferred-wake-up-b.patch b/queue-5.10/rcu-nocb-trigger-self-ipi-on-late-deferred-wake-up-b.patch
new file mode 100644 (file)
index 0000000..3b44d9e
--- /dev/null
+++ b/queue-5.10/rcu-nocb-trigger-self-ipi-on-late-deferred-wake-up-b.patch
@@ -0,0 +1,184 @@
+From 06e8c88dca93588e77c0cff0eb3f808e59ebb231 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 1 Feb 2021 00:05:46 +0100
+Subject: rcu/nocb: Trigger self-IPI on late deferred wake up before user
+ resume
+
+From: Frederic Weisbecker <frederic@kernel.org>
+
+[ Upstream commit f8bb5cae9616224a39cbb399de382d36ac41df10 ]
+
+Entering RCU idle mode may cause a deferred wake up of an RCU NOCB_GP
+kthread (rcuog) to be serviced.
+
+Unfortunately the call to rcu_user_enter() is already past the last
+rescheduling opportunity before we resume to userspace or to guest mode.
+We may escape there with the woken task ignored.
+
+The ultimate resort to fix every callsites is to trigger a self-IPI
+(nohz_full depends on arch to implement arch_irq_work_raise()) that will
+trigger a reschedule on IRQ tail or guest exit.
+
+Eventually every site that want a saner treatment will need to carefully
+place a call to rcu_nocb_flush_deferred_wakeup() before the last explicit
+need_resched() check upon resume.
+
+Fixes: 96d3fd0d315a (rcu: Break call_rcu() deadlock involving scheduler and perf)
+Reported-by: Paul E. McKenney <paulmck@kernel.org>
+Signed-off-by: Frederic Weisbecker <frederic@kernel.org>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+Cc: stable@vger.kernel.org
+Link: https://lkml.kernel.org/r/20210131230548.32970-4-frederic@kernel.org
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ kernel/rcu/tree.c        | 21 ++++++++++++++++++++-
+ kernel/rcu/tree.h        |  2 +-
+ kernel/rcu/tree_plugin.h | 25 ++++++++++++++++---------
+ 3 files changed, 37 insertions(+), 11 deletions(-)
+
+diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c
+index 5dc36c6e80fd..f137a599941b 100644
+--- a/kernel/rcu/tree.c
++++ b/kernel/rcu/tree.c
+@@ -669,6 +669,18 @@ void rcu_idle_enter(void)
+ EXPORT_SYMBOL_GPL(rcu_idle_enter);
+ 
+ #ifdef CONFIG_NO_HZ_FULL
++
++/*
++ * An empty function that will trigger a reschedule on
++ * IRQ tail once IRQs get re-enabled on userspace resume.
++ */
++static void late_wakeup_func(struct irq_work *work)
++{
++}
++
++static DEFINE_PER_CPU(struct irq_work, late_wakeup_work) =
++      IRQ_WORK_INIT(late_wakeup_func);
++
+ /**
+  * rcu_user_enter - inform RCU that we are resuming userspace.
+  *
+@@ -686,12 +698,19 @@ noinstr void rcu_user_enter(void)
+ 
+       lockdep_assert_irqs_disabled();
+ 
++      /*
++       * We may be past the last rescheduling opportunity in the entry code.
++       * Trigger a self IPI that will fire and reschedule once we resume to
++       * user/guest mode.
++       */
+       instrumentation_begin();
+-      do_nocb_deferred_wakeup(rdp);
++      if (do_nocb_deferred_wakeup(rdp) && need_resched())
++              irq_work_queue(this_cpu_ptr(&late_wakeup_work));
+       instrumentation_end();
+ 
+       rcu_eqs_enter(true);
+ }
++
+ #endif /* CONFIG_NO_HZ_FULL */
+ 
+ /**
+diff --git a/kernel/rcu/tree.h b/kernel/rcu/tree.h
+index e4f66b8f7c47..0ec2b1f66b13 100644
+--- a/kernel/rcu/tree.h
++++ b/kernel/rcu/tree.h
+@@ -431,7 +431,7 @@ static bool rcu_nocb_try_bypass(struct rcu_data *rdp, struct rcu_head *rhp,
+ static void __call_rcu_nocb_wake(struct rcu_data *rdp, bool was_empty,
+                                unsigned long flags);
+ static int rcu_nocb_need_deferred_wakeup(struct rcu_data *rdp);
+-static void do_nocb_deferred_wakeup(struct rcu_data *rdp);
++static bool do_nocb_deferred_wakeup(struct rcu_data *rdp);
+ static void rcu_boot_init_nocb_percpu_data(struct rcu_data *rdp);
+ static void rcu_spawn_cpu_nocb_kthread(int cpu);
+ static void __init rcu_spawn_nocb_kthreads(void);
+diff --git a/kernel/rcu/tree_plugin.h b/kernel/rcu/tree_plugin.h
+index 7d4f78bf4057..29a00d9ea286 100644
+--- a/kernel/rcu/tree_plugin.h
++++ b/kernel/rcu/tree_plugin.h
+@@ -1631,8 +1631,8 @@ bool rcu_is_nocb_cpu(int cpu)
+  * Kick the GP kthread for this NOCB group.  Caller holds ->nocb_lock
+  * and this function releases it.
+  */
+-static void wake_nocb_gp(struct rcu_data *rdp, bool force,
+-                         unsigned long flags)
++static bool wake_nocb_gp(struct rcu_data *rdp, bool force,
++                       unsigned long flags)
+       __releases(rdp->nocb_lock)
+ {
+       bool needwake = false;
+@@ -1643,7 +1643,7 @@ static void wake_nocb_gp(struct rcu_data *rdp, bool force,
+               trace_rcu_nocb_wake(rcu_state.name, rdp->cpu,
+                                   TPS("AlreadyAwake"));
+               rcu_nocb_unlock_irqrestore(rdp, flags);
+-              return;
++              return false;
+       }
+       del_timer(&rdp->nocb_timer);
+       rcu_nocb_unlock_irqrestore(rdp, flags);
+@@ -1656,6 +1656,8 @@ static void wake_nocb_gp(struct rcu_data *rdp, bool force,
+       raw_spin_unlock_irqrestore(&rdp_gp->nocb_gp_lock, flags);
+       if (needwake)
+               wake_up_process(rdp_gp->nocb_gp_kthread);
++
++      return needwake;
+ }
+ 
+ /*
+@@ -2152,20 +2154,23 @@ static int rcu_nocb_need_deferred_wakeup(struct rcu_data *rdp)
+ }
+ 
+ /* Do a deferred wakeup of rcu_nocb_kthread(). */
+-static void do_nocb_deferred_wakeup_common(struct rcu_data *rdp)
++static bool do_nocb_deferred_wakeup_common(struct rcu_data *rdp)
+ {
+       unsigned long flags;
+       int ndw;
++      int ret;
+ 
+       rcu_nocb_lock_irqsave(rdp, flags);
+       if (!rcu_nocb_need_deferred_wakeup(rdp)) {
+               rcu_nocb_unlock_irqrestore(rdp, flags);
+-              return;
++              return false;
+       }
+       ndw = READ_ONCE(rdp->nocb_defer_wakeup);
+       WRITE_ONCE(rdp->nocb_defer_wakeup, RCU_NOCB_WAKE_NOT);
+-      wake_nocb_gp(rdp, ndw == RCU_NOCB_WAKE_FORCE, flags);
++      ret = wake_nocb_gp(rdp, ndw == RCU_NOCB_WAKE_FORCE, flags);
+       trace_rcu_nocb_wake(rcu_state.name, rdp->cpu, TPS("DeferredWake"));
++
++      return ret;
+ }
+ 
+ /* Do a deferred wakeup of rcu_nocb_kthread() from a timer handler. */
+@@ -2181,10 +2186,11 @@ static void do_nocb_deferred_wakeup_timer(struct timer_list *t)
+  * This means we do an inexact common-case check.  Note that if
+  * we miss, ->nocb_timer will eventually clean things up.
+  */
+-static void do_nocb_deferred_wakeup(struct rcu_data *rdp)
++static bool do_nocb_deferred_wakeup(struct rcu_data *rdp)
+ {
+       if (rcu_nocb_need_deferred_wakeup(rdp))
+-              do_nocb_deferred_wakeup_common(rdp);
++              return do_nocb_deferred_wakeup_common(rdp);
++      return false;
+ }
+ 
+ void rcu_nocb_flush_deferred_wakeup(void)
+@@ -2523,8 +2529,9 @@ static int rcu_nocb_need_deferred_wakeup(struct rcu_data *rdp)
+       return false;
+ }
+ 
+-static void do_nocb_deferred_wakeup(struct rcu_data *rdp)
++static bool do_nocb_deferred_wakeup(struct rcu_data *rdp)
+ {
++      return false;
+ }
+ 
+ static void rcu_spawn_cpu_nocb_kthread(int cpu)
+-- 
+2.30.1
+

diff --git a/queue-5.10/rdma-mlx5-allow-creating-all-qps-even-when-non-rdma-.patch b/queue-5.10/rdma-mlx5-allow-creating-all-qps-even-when-non-rdma-.patch
new file mode 100644 (file)
index 0000000..90915c3
--- /dev/null
+++ b/queue-5.10/rdma-mlx5-allow-creating-all-qps-even-when-non-rdma-.patch
@@ -0,0 +1,91 @@
+From 248b360cd1842d7d3e4c259c9547603b974b7d18 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 25 Jan 2021 14:07:09 +0200
+Subject: RDMA/mlx5: Allow creating all QPs even when non RDMA profile is used
+
+From: Mark Bloch <mbloch@nvidia.com>
+
+[ Upstream commit 2614488d1f3cd5989375042286b11424208e20c8 ]
+
+The cited commit disallowed creating any QP which isn't raw ethernet, reg
+umr or the special UD qp for testing WC, this proved too strict.
+
+While modify can't be done (no GIDS/GID table for example) just creating a
+QP is okay.
+
+This patch partially reverts the bellow mentioned commit and places the
+restriction at the modify QP stage and not at the creation.  DEVX commands
+should be used to manipulate such QPs.
+
+Fixes: 42caf9cb5937 ("RDMA/mlx5: Allow only raw Ethernet QPs when RoCE isn't enabled")
+Link: https://lore.kernel.org/r/20210125120709.836718-1-leon@kernel.org
+Signed-off-by: Mark Bloch <mbloch@nvidia.com>
+Reviewed-by: Maor Gottlieb <maorg@mellanox.com>
+Signed-off-by: Leon Romanovsky <leonro@nvidia.com>
+Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/infiniband/hw/mlx5/qp.c | 26 ++++++++++++++++++++------
+ 1 file changed, 20 insertions(+), 6 deletions(-)
+
+diff --git a/drivers/infiniband/hw/mlx5/qp.c b/drivers/infiniband/hw/mlx5/qp.c
+index 600e056798c0..75caeec378bd 100644
+--- a/drivers/infiniband/hw/mlx5/qp.c
++++ b/drivers/infiniband/hw/mlx5/qp.c
+@@ -2458,8 +2458,6 @@ static int check_qp_type(struct mlx5_ib_dev *dev, struct ib_qp_init_attr *attr,
+       case MLX5_IB_QPT_HW_GSI:
+       case IB_QPT_DRIVER:
+       case IB_QPT_GSI:
+-              if (dev->profile == &raw_eth_profile)
+-                      goto out;
+       case IB_QPT_RAW_PACKET:
+       case IB_QPT_UD:
+       case MLX5_IB_QPT_REG_UMR:
+@@ -2654,10 +2652,6 @@ static int process_create_flags(struct mlx5_ib_dev *dev, struct mlx5_ib_qp *qp,
+       int create_flags = attr->create_flags;
+       bool cond;
+ 
+-      if (qp->type == IB_QPT_UD && dev->profile == &raw_eth_profile)
+-              if (create_flags & ~MLX5_IB_QP_CREATE_WC_TEST)
+-                      return -EINVAL;
+-
+       if (qp_type == MLX5_IB_QPT_DCT)
+               return (create_flags) ? -EINVAL : 0;
+ 
+@@ -4235,6 +4229,23 @@ static int mlx5_ib_modify_dct(struct ib_qp *ibqp, struct ib_qp_attr *attr,
+       return 0;
+ }
+ 
++static bool mlx5_ib_modify_qp_allowed(struct mlx5_ib_dev *dev,
++                                    struct mlx5_ib_qp *qp,
++                                    enum ib_qp_type qp_type)
++{
++      if (dev->profile != &raw_eth_profile)
++              return true;
++
++      if (qp_type == IB_QPT_RAW_PACKET || qp_type == MLX5_IB_QPT_REG_UMR)
++              return true;
++
++      /* Internal QP used for wc testing, with NOPs in wq */
++      if (qp->flags & MLX5_IB_QP_CREATE_WC_TEST)
++              return true;
++
++      return false;
++}
++
+ int mlx5_ib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
+                     int attr_mask, struct ib_udata *udata)
+ {
+@@ -4247,6 +4258,9 @@ int mlx5_ib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
+       int err = -EINVAL;
+       int port;
+ 
++      if (!mlx5_ib_modify_qp_allowed(dev, qp, ibqp->qp_type))
++              return -EOPNOTSUPP;
++
+       if (ibqp->rwq_ind_tbl)
+               return -ENOSYS;
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/rdma-rtrs-fix-kasan-stack-out-of-bounds-bug.patch b/queue-5.10/rdma-rtrs-fix-kasan-stack-out-of-bounds-bug.patch
new file mode 100644 (file)
index 0000000..2c17975
--- /dev/null
+++ b/queue-5.10/rdma-rtrs-fix-kasan-stack-out-of-bounds-bug.patch
@@ -0,0 +1,102 @@
+From 617463c082a6e94e5d50a65f4ff5de9e5ee23206 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 17 Dec 2020 15:19:15 +0100
+Subject: RDMA/rtrs: Fix KASAN: stack-out-of-bounds bug
+
+From: Jack Wang <jinpu.wang@cloud.ionos.com>
+
+[ Upstream commit 7fbc3c373eefc291ff96d48496106c106b7f81c6 ]
+
+When KASAN is enabled, we notice warning below:
+[  483.436975] ==================================================================
+[  483.437234] BUG: KASAN: stack-out-of-bounds in _mlx5_ib_post_send+0x188a/0x2560 [mlx5_ib]
+[  483.437430] Read of size 4 at addr ffff88a195fd7d30 by task kworker/1:3/6954
+
+[  483.437731] CPU: 1 PID: 6954 Comm: kworker/1:3 Kdump: loaded Tainted: G           O      5.4.82-pserver #5.4.82-1+feature+linux+5.4.y+dbg+20201210.1532+987e7a6~deb10
+[  483.437976] Hardware name: Supermicro Super Server/X11DDW-L, BIOS 3.3 02/21/2020
+[  483.438168] Workqueue: rtrs_server_wq hb_work [rtrs_core]
+[  483.438323] Call Trace:
+[  483.438486]  dump_stack+0x96/0xe0
+[  483.438646]  ? _mlx5_ib_post_send+0x188a/0x2560 [mlx5_ib]
+[  483.438802]  print_address_description.constprop.6+0x1b/0x220
+[  483.438966]  ? _mlx5_ib_post_send+0x188a/0x2560 [mlx5_ib]
+[  483.439133]  ? _mlx5_ib_post_send+0x188a/0x2560 [mlx5_ib]
+[  483.439285]  __kasan_report.cold.9+0x1a/0x32
+[  483.439444]  ? _mlx5_ib_post_send+0x188a/0x2560 [mlx5_ib]
+[  483.439597]  kasan_report+0x10/0x20
+[  483.439752]  _mlx5_ib_post_send+0x188a/0x2560 [mlx5_ib]
+[  483.439910]  ? update_sd_lb_stats+0xfb1/0xfc0
+[  483.440073]  ? set_reg_wr+0x520/0x520 [mlx5_ib]
+[  483.440222]  ? update_group_capacity+0x340/0x340
+[  483.440377]  ? find_busiest_group+0x314/0x870
+[  483.440526]  ? update_sd_lb_stats+0xfc0/0xfc0
+[  483.440683]  ? __bitmap_and+0x6f/0x100
+[  483.440832]  ? __lock_acquire+0xa2/0x2150
+[  483.440979]  ? __lock_acquire+0xa2/0x2150
+[  483.441128]  ? __lock_acquire+0xa2/0x2150
+[  483.441279]  ? debug_lockdep_rcu_enabled+0x23/0x60
+[  483.441430]  ? lock_downgrade+0x390/0x390
+[  483.441582]  ? __lock_acquire+0xa2/0x2150
+[  483.441729]  ? __lock_acquire+0xa2/0x2150
+[  483.441876]  ? newidle_balance+0x425/0x8f0
+[  483.442024]  ? __lock_acquire+0xa2/0x2150
+[  483.442172]  ? debug_lockdep_rcu_enabled+0x23/0x60
+[  483.442330]  hb_work+0x15d/0x1d0 [rtrs_core]
+[  483.442479]  ? schedule_hb+0x50/0x50 [rtrs_core]
+[  483.442627]  ? lock_downgrade+0x390/0x390
+[  483.442781]  ? process_one_work+0x40d/0xa50
+[  483.442931]  process_one_work+0x4ee/0xa50
+[  483.443082]  ? pwq_dec_nr_in_flight+0x110/0x110
+[  483.443231]  ? do_raw_spin_lock+0x119/0x1d0
+[  483.443383]  worker_thread+0x65/0x5c0
+[  483.443532]  ? process_one_work+0xa50/0xa50
+[  483.451839]  kthread+0x1e2/0x200
+[  483.451983]  ? kthread_create_on_node+0xc0/0xc0
+[  483.452139]  ret_from_fork+0x3a/0x50
+
+The problem is we use wrong type when send wr, hw driver expect the type
+of IB_WR_RDMA_WRITE_WITH_IMM wr should be ib_rdma_wr, and doing
+container_of to access member. The fix is simple use ib_rdma_wr instread
+of ib_send_wr.
+
+Fixes: c0894b3ea69d ("RDMA/rtrs: core: lib functions shared between client and server modules")
+Link: https://lore.kernel.org/r/20201217141915.56989-20-jinpu.wang@cloud.ionos.com
+Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
+Reviewed-by: Gioh Kim <gi-oh.kim@cloud.ionos.com>
+Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/infiniband/ulp/rtrs/rtrs.c | 14 +++++++-------
+ 1 file changed, 7 insertions(+), 7 deletions(-)
+
+diff --git a/drivers/infiniband/ulp/rtrs/rtrs.c b/drivers/infiniband/ulp/rtrs/rtrs.c
+index 97af8f0bb806..d13aff0aa816 100644
+--- a/drivers/infiniband/ulp/rtrs/rtrs.c
++++ b/drivers/infiniband/ulp/rtrs/rtrs.c
+@@ -182,16 +182,16 @@ int rtrs_post_rdma_write_imm_empty(struct rtrs_con *con, struct ib_cqe *cqe,
+                                   u32 imm_data, enum ib_send_flags flags,
+                                   struct ib_send_wr *head)
+ {
+-      struct ib_send_wr wr;
++      struct ib_rdma_wr wr;
+ 
+-      wr = (struct ib_send_wr) {
+-              .wr_cqe = cqe,
+-              .send_flags     = flags,
+-              .opcode = IB_WR_RDMA_WRITE_WITH_IMM,
+-              .ex.imm_data    = cpu_to_be32(imm_data),
++      wr = (struct ib_rdma_wr) {
++              .wr.wr_cqe      = cqe,
++              .wr.send_flags  = flags,
++              .wr.opcode      = IB_WR_RDMA_WRITE_WITH_IMM,
++              .wr.ex.imm_data = cpu_to_be32(imm_data),
+       };
+ 
+-      return rtrs_post_send(con->qp, head, &wr);
++      return rtrs_post_send(con->qp, head, &wr.wr);
+ }
+ EXPORT_SYMBOL_GPL(rtrs_post_rdma_write_imm_empty);
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/rdma-rtrs-introduce-rtrs_post_send.patch b/queue-5.10/rdma-rtrs-introduce-rtrs_post_send.patch
new file mode 100644 (file)
index 0000000..9c3e3ff
--- /dev/null
+++ b/queue-5.10/rdma-rtrs-introduce-rtrs_post_send.patch
@@ -0,0 +1,108 @@
+From b81daa604b041a4ad7d67d672a40a8ec4bb5258a Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Fri, 23 Oct 2020 09:43:52 +0200
+Subject: RDMA/rtrs: Introduce rtrs_post_send
+
+From: Guoqing Jiang <guoqing.jiang@cloud.ionos.com>
+
+[ Upstream commit e6ab8cf50fa1c38652feba3e4921c60538236f30 ]
+
+Since the three functions share the similar logic, let's introduce one
+common function for it.
+
+Link: https://lore.kernel.org/r/20201023074353.21946-12-jinpu.wang@cloud.ionos.com
+Signed-off-by: Guoqing Jiang <guoqing.jiang@cloud.ionos.com>
+Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
+Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/infiniband/ulp/rtrs/rtrs.c | 52 +++++++++++-------------------
+ 1 file changed, 19 insertions(+), 33 deletions(-)
+
+diff --git a/drivers/infiniband/ulp/rtrs/rtrs.c b/drivers/infiniband/ulp/rtrs/rtrs.c
+index 8321e8a52045..97af8f0bb806 100644
+--- a/drivers/infiniband/ulp/rtrs/rtrs.c
++++ b/drivers/infiniband/ulp/rtrs/rtrs.c
+@@ -104,6 +104,22 @@ int rtrs_post_recv_empty(struct rtrs_con *con, struct ib_cqe *cqe)
+ }
+ EXPORT_SYMBOL_GPL(rtrs_post_recv_empty);
+ 
++static int rtrs_post_send(struct ib_qp *qp, struct ib_send_wr *head,
++                           struct ib_send_wr *wr)
++{
++      if (head) {
++              struct ib_send_wr *tail = head;
++
++              while (tail->next)
++                      tail = tail->next;
++              tail->next = wr;
++      } else {
++              head = wr;
++      }
++
++      return ib_post_send(qp, head, NULL);
++}
++
+ int rtrs_iu_post_send(struct rtrs_con *con, struct rtrs_iu *iu, size_t size,
+                      struct ib_send_wr *head)
+ {
+@@ -126,17 +142,7 @@ int rtrs_iu_post_send(struct rtrs_con *con, struct rtrs_iu *iu, size_t size,
+               .send_flags = IB_SEND_SIGNALED,
+       };
+ 
+-      if (head) {
+-              struct ib_send_wr *tail = head;
+-
+-              while (tail->next)
+-                      tail = tail->next;
+-              tail->next = &wr;
+-      } else {
+-              head = &wr;
+-      }
+-
+-      return ib_post_send(con->qp, head, NULL);
++      return rtrs_post_send(con->qp, head, &wr);
+ }
+ EXPORT_SYMBOL_GPL(rtrs_iu_post_send);
+ 
+@@ -168,17 +174,7 @@ int rtrs_iu_post_rdma_write_imm(struct rtrs_con *con, struct rtrs_iu *iu,
+               if (WARN_ON(sge[i].length == 0))
+                       return -EINVAL;
+ 
+-      if (head) {
+-              struct ib_send_wr *tail = head;
+-
+-              while (tail->next)
+-                      tail = tail->next;
+-              tail->next = &wr.wr;
+-      } else {
+-              head = &wr.wr;
+-      }
+-
+-      return ib_post_send(con->qp, head, NULL);
++      return rtrs_post_send(con->qp, head, &wr.wr);
+ }
+ EXPORT_SYMBOL_GPL(rtrs_iu_post_rdma_write_imm);
+ 
+@@ -195,17 +191,7 @@ int rtrs_post_rdma_write_imm_empty(struct rtrs_con *con, struct ib_cqe *cqe,
+               .ex.imm_data    = cpu_to_be32(imm_data),
+       };
+ 
+-      if (head) {
+-              struct ib_send_wr *tail = head;
+-
+-              while (tail->next)
+-                      tail = tail->next;
+-              tail->next = &wr;
+-      } else {
+-              head = &wr;
+-      }
+-
+-      return ib_post_send(con->qp, head, NULL);
++      return rtrs_post_send(con->qp, head, &wr);
+ }
+ EXPORT_SYMBOL_GPL(rtrs_post_rdma_write_imm_empty);
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/rdma-rtrs-remove-unnecessary-argument-dir-of-rtrs_iu.patch b/queue-5.10/rdma-rtrs-remove-unnecessary-argument-dir-of-rtrs_iu.patch
new file mode 100644 (file)
index 0000000..24f5141
--- /dev/null
+++ b/queue-5.10/rdma-rtrs-remove-unnecessary-argument-dir-of-rtrs_iu.patch
@@ -0,0 +1,195 @@
+From 424902fe4749f0f5c2dc1a6555af47bdd2393043 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Fri, 23 Oct 2020 09:43:48 +0200
+Subject: RDMA/rtrs: Remove unnecessary argument dir of rtrs_iu_free
+
+From: Gioh Kim <gi-oh.kim@cloud.ionos.com>
+
+[ Upstream commit 8bd372ace32ec88fe3ad1421929ae1604f2a2c2c ]
+
+The direction of DMA operation is already in the rtrs_iu
+
+Link: https://lore.kernel.org/r/20201023074353.21946-8-jinpu.wang@cloud.ionos.com
+Signed-off-by: Gioh Kim <gi-oh.kim@cloud.ionos.com>
+Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
+Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/infiniband/ulp/rtrs/rtrs-clt.c | 14 ++++++--------
+ drivers/infiniband/ulp/rtrs/rtrs-pri.h |  3 +--
+ drivers/infiniband/ulp/rtrs/rtrs-srv.c | 14 ++++++--------
+ drivers/infiniband/ulp/rtrs/rtrs.c     |  9 ++++-----
+ 4 files changed, 17 insertions(+), 23 deletions(-)
+
+diff --git a/drivers/infiniband/ulp/rtrs/rtrs-clt.c b/drivers/infiniband/ulp/rtrs/rtrs-clt.c
+index 5c2107ce7f6e..6eb95e3c4c8a 100644
+--- a/drivers/infiniband/ulp/rtrs/rtrs-clt.c
++++ b/drivers/infiniband/ulp/rtrs/rtrs-clt.c
+@@ -1237,8 +1237,7 @@ static void free_sess_reqs(struct rtrs_clt_sess *sess)
+               if (req->mr)
+                       ib_dereg_mr(req->mr);
+               kfree(req->sge);
+-              rtrs_iu_free(req->iu, DMA_TO_DEVICE,
+-                            sess->s.dev->ib_dev, 1);
++              rtrs_iu_free(req->iu, sess->s.dev->ib_dev, 1);
+       }
+       kfree(sess->reqs);
+       sess->reqs = NULL;
+@@ -1611,8 +1610,7 @@ static void destroy_con_cq_qp(struct rtrs_clt_con *con)
+ 
+       rtrs_cq_qp_destroy(&con->c);
+       if (con->rsp_ius) {
+-              rtrs_iu_free(con->rsp_ius, DMA_FROM_DEVICE,
+-                            sess->s.dev->ib_dev, con->queue_size);
++              rtrs_iu_free(con->rsp_ius, sess->s.dev->ib_dev, con->queue_size);
+               con->rsp_ius = NULL;
+               con->queue_size = 0;
+       }
+@@ -2252,7 +2250,7 @@ static void rtrs_clt_info_req_done(struct ib_cq *cq, struct ib_wc *wc)
+       struct rtrs_iu *iu;
+ 
+       iu = container_of(wc->wr_cqe, struct rtrs_iu, cqe);
+-      rtrs_iu_free(iu, DMA_TO_DEVICE, sess->s.dev->ib_dev, 1);
++      rtrs_iu_free(iu, sess->s.dev->ib_dev, 1);
+ 
+       if (unlikely(wc->status != IB_WC_SUCCESS)) {
+               rtrs_err(sess->clt, "Sess info request send failed: %s\n",
+@@ -2381,7 +2379,7 @@ static void rtrs_clt_info_rsp_done(struct ib_cq *cq, struct ib_wc *wc)
+ 
+ out:
+       rtrs_clt_update_wc_stats(con);
+-      rtrs_iu_free(iu, DMA_FROM_DEVICE, sess->s.dev->ib_dev, 1);
++      rtrs_iu_free(iu, sess->s.dev->ib_dev, 1);
+       rtrs_clt_change_state(sess, state);
+ }
+ 
+@@ -2443,9 +2441,9 @@ static int rtrs_send_sess_info(struct rtrs_clt_sess *sess)
+ 
+ out:
+       if (tx_iu)
+-              rtrs_iu_free(tx_iu, DMA_TO_DEVICE, sess->s.dev->ib_dev, 1);
++              rtrs_iu_free(tx_iu, sess->s.dev->ib_dev, 1);
+       if (rx_iu)
+-              rtrs_iu_free(rx_iu, DMA_FROM_DEVICE, sess->s.dev->ib_dev, 1);
++              rtrs_iu_free(rx_iu, sess->s.dev->ib_dev, 1);
+       if (unlikely(err))
+               /* If we've never taken async path because of malloc problems */
+               rtrs_clt_change_state(sess, RTRS_CLT_CONNECTING_ERR);
+diff --git a/drivers/infiniband/ulp/rtrs/rtrs-pri.h b/drivers/infiniband/ulp/rtrs/rtrs-pri.h
+index 2e1d2f7e372a..8caad0a2322b 100644
+--- a/drivers/infiniband/ulp/rtrs/rtrs-pri.h
++++ b/drivers/infiniband/ulp/rtrs/rtrs-pri.h
+@@ -289,8 +289,7 @@ struct rtrs_msg_rdma_hdr {
+ struct rtrs_iu *rtrs_iu_alloc(u32 queue_size, size_t size, gfp_t t,
+                             struct ib_device *dev, enum dma_data_direction,
+                             void (*done)(struct ib_cq *cq, struct ib_wc *wc));
+-void rtrs_iu_free(struct rtrs_iu *iu, enum dma_data_direction dir,
+-                struct ib_device *dev, u32 queue_size);
++void rtrs_iu_free(struct rtrs_iu *iu, struct ib_device *dev, u32 queue_size);
+ int rtrs_iu_post_recv(struct rtrs_con *con, struct rtrs_iu *iu);
+ int rtrs_iu_post_send(struct rtrs_con *con, struct rtrs_iu *iu, size_t size,
+                     struct ib_send_wr *head);
+diff --git a/drivers/infiniband/ulp/rtrs/rtrs-srv.c b/drivers/infiniband/ulp/rtrs/rtrs-srv.c
+index b690a3b8f94d..0fd2a7f8f9f2 100644
+--- a/drivers/infiniband/ulp/rtrs/rtrs-srv.c
++++ b/drivers/infiniband/ulp/rtrs/rtrs-srv.c
+@@ -584,8 +584,7 @@ static void unmap_cont_bufs(struct rtrs_srv_sess *sess)
+               struct rtrs_srv_mr *srv_mr;
+ 
+               srv_mr = &sess->mrs[i];
+-              rtrs_iu_free(srv_mr->iu, DMA_TO_DEVICE,
+-                            sess->s.dev->ib_dev, 1);
++              rtrs_iu_free(srv_mr->iu, sess->s.dev->ib_dev, 1);
+               ib_dereg_mr(srv_mr->mr);
+               ib_dma_unmap_sg(sess->s.dev->ib_dev, srv_mr->sgt.sgl,
+                               srv_mr->sgt.nents, DMA_BIDIRECTIONAL);
+@@ -689,8 +688,7 @@ static int map_cont_bufs(struct rtrs_srv_sess *sess)
+                       sgt = &srv_mr->sgt;
+                       mr = srv_mr->mr;
+ free_iu:
+-                      rtrs_iu_free(srv_mr->iu, DMA_TO_DEVICE,
+-                                    sess->s.dev->ib_dev, 1);
++                      rtrs_iu_free(srv_mr->iu, sess->s.dev->ib_dev, 1);
+ dereg_mr:
+                       ib_dereg_mr(mr);
+ unmap_sg:
+@@ -742,7 +740,7 @@ static void rtrs_srv_info_rsp_done(struct ib_cq *cq, struct ib_wc *wc)
+       struct rtrs_iu *iu;
+ 
+       iu = container_of(wc->wr_cqe, struct rtrs_iu, cqe);
+-      rtrs_iu_free(iu, DMA_TO_DEVICE, sess->s.dev->ib_dev, 1);
++      rtrs_iu_free(iu, sess->s.dev->ib_dev, 1);
+ 
+       if (unlikely(wc->status != IB_WC_SUCCESS)) {
+               rtrs_err(s, "Sess info response send failed: %s\n",
+@@ -868,7 +866,7 @@ static int process_info_req(struct rtrs_srv_con *con,
+       if (unlikely(err)) {
+               rtrs_err(s, "rtrs_iu_post_send(), err: %d\n", err);
+ iu_free:
+-              rtrs_iu_free(tx_iu, DMA_TO_DEVICE, sess->s.dev->ib_dev, 1);
++              rtrs_iu_free(tx_iu, sess->s.dev->ib_dev, 1);
+       }
+ rwr_free:
+       kfree(rwr);
+@@ -913,7 +911,7 @@ static void rtrs_srv_info_req_done(struct ib_cq *cq, struct ib_wc *wc)
+               goto close;
+ 
+ out:
+-      rtrs_iu_free(iu, DMA_FROM_DEVICE, sess->s.dev->ib_dev, 1);
++      rtrs_iu_free(iu, sess->s.dev->ib_dev, 1);
+       return;
+ close:
+       close_sess(sess);
+@@ -936,7 +934,7 @@ static int post_recv_info_req(struct rtrs_srv_con *con)
+       err = rtrs_iu_post_recv(&con->c, rx_iu);
+       if (unlikely(err)) {
+               rtrs_err(s, "rtrs_iu_post_recv(), err: %d\n", err);
+-              rtrs_iu_free(rx_iu, DMA_FROM_DEVICE, sess->s.dev->ib_dev, 1);
++              rtrs_iu_free(rx_iu, sess->s.dev->ib_dev, 1);
+               return err;
+       }
+ 
+diff --git a/drivers/infiniband/ulp/rtrs/rtrs.c b/drivers/infiniband/ulp/rtrs/rtrs.c
+index a3e1a027f808..8321e8a52045 100644
+--- a/drivers/infiniband/ulp/rtrs/rtrs.c
++++ b/drivers/infiniband/ulp/rtrs/rtrs.c
+@@ -31,6 +31,7 @@ struct rtrs_iu *rtrs_iu_alloc(u32 queue_size, size_t size, gfp_t gfp_mask,
+               return NULL;
+       for (i = 0; i < queue_size; i++) {
+               iu = &ius[i];
++              iu->direction = dir;
+               iu->buf = kzalloc(size, gfp_mask);
+               if (!iu->buf)
+                       goto err;
+@@ -41,17 +42,15 @@ struct rtrs_iu *rtrs_iu_alloc(u32 queue_size, size_t size, gfp_t gfp_mask,
+ 
+               iu->cqe.done  = done;
+               iu->size      = size;
+-              iu->direction = dir;
+       }
+       return ius;
+ err:
+-      rtrs_iu_free(ius, dir, dma_dev, i);
++      rtrs_iu_free(ius, dma_dev, i);
+       return NULL;
+ }
+ EXPORT_SYMBOL_GPL(rtrs_iu_alloc);
+ 
+-void rtrs_iu_free(struct rtrs_iu *ius, enum dma_data_direction dir,
+-                 struct ib_device *ibdev, u32 queue_size)
++void rtrs_iu_free(struct rtrs_iu *ius, struct ib_device *ibdev, u32 queue_size)
+ {
+       struct rtrs_iu *iu;
+       int i;
+@@ -61,7 +60,7 @@ void rtrs_iu_free(struct rtrs_iu *ius, enum dma_data_direction dir,
+ 
+       for (i = 0; i < queue_size; i++) {
+               iu = &ius[i];
+-              ib_dma_unmap_single(ibdev, iu->dma_addr, iu->size, dir);
++              ib_dma_unmap_single(ibdev, iu->dma_addr, iu->size, iu->direction);
+               kfree(iu->buf);
+       }
+       kfree(ius);
+-- 
+2.30.1
+

diff --git a/queue-5.10/rdma-rtrs-srv-jump-to-dereg_mr-label-if-allocate-iu-.patch b/queue-5.10/rdma-rtrs-srv-jump-to-dereg_mr-label-if-allocate-iu-.patch
new file mode 100644 (file)
index 0000000..dbbe2e0
--- /dev/null
+++ b/queue-5.10/rdma-rtrs-srv-jump-to-dereg_mr-label-if-allocate-iu-.patch
@@ -0,0 +1,47 @@
+From 6eaf566b0792666568e22b653c924f6953092d3d Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 17 Dec 2020 15:19:02 +0100
+Subject: RDMA/rtrs-srv: Jump to dereg_mr label if allocate iu fails
+
+From: Guoqing Jiang <guoqing.jiang@cloud.ionos.com>
+
+[ Upstream commit f77c4839ee8f4612dcb6601602329096030bd813 ]
+
+The rtrs_iu_free is called in rtrs_iu_alloc if memory is limited, so we
+don't need to free the same iu again.
+
+Fixes: 9cb837480424 ("RDMA/rtrs: server: main functionality")
+Link: https://lore.kernel.org/r/20201217141915.56989-7-jinpu.wang@cloud.ionos.com
+Signed-off-by: Guoqing Jiang <guoqing.jiang@cloud.ionos.com>
+Reviewed-by: Gioh Kim <gi-oh.kim@cloud.ionos.com>
+Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
+Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/infiniband/ulp/rtrs/rtrs-srv.c | 3 +--
+ 1 file changed, 1 insertion(+), 2 deletions(-)
+
+diff --git a/drivers/infiniband/ulp/rtrs/rtrs-srv.c b/drivers/infiniband/ulp/rtrs/rtrs-srv.c
+index 0fd2a7f8f9f2..43806180f85e 100644
+--- a/drivers/infiniband/ulp/rtrs/rtrs-srv.c
++++ b/drivers/infiniband/ulp/rtrs/rtrs-srv.c
+@@ -671,7 +671,7 @@ static int map_cont_bufs(struct rtrs_srv_sess *sess)
+                       if (!srv_mr->iu) {
+                               err = -ENOMEM;
+                               rtrs_err(ss, "rtrs_iu_alloc(), err: %d\n", err);
+-                              goto free_iu;
++                              goto dereg_mr;
+                       }
+               }
+               /* Eventually dma addr for each chunk can be cached */
+@@ -687,7 +687,6 @@ static int map_cont_bufs(struct rtrs_srv_sess *sess)
+                       srv_mr = &sess->mrs[mri];
+                       sgt = &srv_mr->sgt;
+                       mr = srv_mr->mr;
+-free_iu:
+                       rtrs_iu_free(srv_mr->iu, sess->s.dev->ib_dev, 1);
+ dereg_mr:
+                       ib_dereg_mr(mr);
+-- 
+2.30.1
+

diff --git a/queue-5.10/regulator-pca9450-add-sd_vsel-gpio-for-ldo5.patch b/queue-5.10/regulator-pca9450-add-sd_vsel-gpio-for-ldo5.patch
new file mode 100644 (file)
index 0000000..a0b9e66
--- /dev/null
+++ b/queue-5.10/regulator-pca9450-add-sd_vsel-gpio-for-ldo5.patch
@@ -0,0 +1,69 @@
+From 9a7a0f3c4132dfdd6a77382cd9973cdfdfaad0f4 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 11 Feb 2021 11:55:28 +0100
+Subject: regulator: pca9450: Add SD_VSEL GPIO for LDO5
+
+From: Frieder Schrempf <frieder.schrempf@kontron.de>
+
+[ Upstream commit 8c67a11bae889f51fe5054364c3c789dfae3ad73 ]
+
+LDO5 has two separate control registers. LDO5CTRL_L is used if the
+input signal SD_VSEL is low and LDO5CTRL_H if it is high.
+The current driver implementation only uses LDO5CTRL_H. To make this
+work on boards that have SD_VSEL connected to a GPIO, we add support
+for specifying an optional GPIO and setting it to high at probe time.
+
+In the future we might also want to add support for boards that have
+SD_VSEL set to a fixed low level. In this case we need to change the
+driver to be able to use the LDO5CTRL_L register.
+
+Signed-off-by: Frieder Schrempf <frieder.schrempf@kontron.de>
+Link: https://lore.kernel.org/r/20210211105534.38972-1-frieder.schrempf@kontron.de
+Signed-off-by: Mark Brown <broonie@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/regulator/pca9450-regulator.c | 14 ++++++++++++++
+ 1 file changed, 14 insertions(+)
+
+diff --git a/drivers/regulator/pca9450-regulator.c b/drivers/regulator/pca9450-regulator.c
+index cb29421d745a..1bba8fdcb7b7 100644
+--- a/drivers/regulator/pca9450-regulator.c
++++ b/drivers/regulator/pca9450-regulator.c
+@@ -5,6 +5,7 @@
+  */
+ 
+ #include <linux/err.h>
++#include <linux/gpio/consumer.h>
+ #include <linux/i2c.h>
+ #include <linux/interrupt.h>
+ #include <linux/kernel.h>
+@@ -32,6 +33,7 @@ struct pca9450_regulator_desc {
+ struct pca9450 {
+       struct device *dev;
+       struct regmap *regmap;
++      struct gpio_desc *sd_vsel_gpio;
+       enum pca9450_chip_type type;
+       unsigned int rcnt;
+       int irq;
+@@ -795,6 +797,18 @@ static int pca9450_i2c_probe(struct i2c_client *i2c,
+               return ret;
+       }
+ 
++      /*
++       * The driver uses the LDO5CTRL_H register to control the LDO5 regulator.
++       * This is only valid if the SD_VSEL input of the PMIC is high. Let's
++       * check if the pin is available as GPIO and set it to high.
++       */
++      pca9450->sd_vsel_gpio = gpiod_get_optional(pca9450->dev, "sd-vsel", GPIOD_OUT_HIGH);
++
++      if (IS_ERR(pca9450->sd_vsel_gpio)) {
++              dev_err(&i2c->dev, "Failed to get SD_VSEL GPIO\n");
++              return ret;
++      }
++
+       dev_info(&i2c->dev, "%s probed.\n",
+               type == PCA9450_TYPE_PCA9450A ? "pca9450a" : "pca9450bc");
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/regulator-pca9450-clear-preset_en-bit-to-fix-buck1-2.patch b/queue-5.10/regulator-pca9450-clear-preset_en-bit-to-fix-buck1-2.patch
new file mode 100644 (file)
index 0000000..2848217
--- /dev/null
+++ b/queue-5.10/regulator-pca9450-clear-preset_en-bit-to-fix-buck1-2.patch
@@ -0,0 +1,64 @@
+From f4417d557a01247822c005dcaa940f36f2025ee4 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 22 Feb 2021 12:52:20 +0100
+Subject: regulator: pca9450: Clear PRESET_EN bit to fix BUCK1/2/3 voltage
+ setting
+
+From: Frieder Schrempf <frieder.schrempf@kontron.de>
+
+[ Upstream commit 98b94b6e38ca0c4eeb29949c656f6a315000c23e ]
+
+The driver uses the DVS registers PCA9450_REG_BUCKxOUT_DVS0 to set the
+voltage for the buck regulators 1, 2 and 3. This has no effect as the
+PRESET_EN bit is set by default and therefore the preset values are used
+instead, which are set to 850 mV.
+
+To fix this we clear the PRESET_EN bit at time of initialization.
+
+Fixes: 0935ff5f1f0a ("regulator: pca9450: add pca9450 pmic driver")
+Cc: <stable@vger.kernel.org>
+Signed-off-by: Frieder Schrempf <frieder.schrempf@kontron.de>
+Link: https://lore.kernel.org/r/20210222115229.166620-1-frieder.schrempf@kontron.de
+Signed-off-by: Mark Brown <broonie@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/regulator/pca9450-regulator.c | 8 ++++++++
+ include/linux/regulator/pca9450.h     | 3 +++
+ 2 files changed, 11 insertions(+)
+
+diff --git a/drivers/regulator/pca9450-regulator.c b/drivers/regulator/pca9450-regulator.c
+index 833d398c6aa2..d38109cc3a01 100644
+--- a/drivers/regulator/pca9450-regulator.c
++++ b/drivers/regulator/pca9450-regulator.c
+@@ -797,6 +797,14 @@ static int pca9450_i2c_probe(struct i2c_client *i2c,
+               return ret;
+       }
+ 
++      /* Clear PRESET_EN bit in BUCK123_DVS to use DVS registers */
++      ret = regmap_clear_bits(pca9450->regmap, PCA9450_REG_BUCK123_DVS,
++                              BUCK123_PRESET_EN);
++      if (ret) {
++              dev_err(&i2c->dev, "Failed to clear PRESET_EN bit: %d\n", ret);
++              return ret;
++      }
++
+       /* Set reset behavior on assertion of WDOG_B signal */
+       ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_RESET_CTRL,
+                               WDOG_B_CFG_MASK, WDOG_B_CFG_COLD_LDO12);
+diff --git a/include/linux/regulator/pca9450.h b/include/linux/regulator/pca9450.h
+index ccdb5320a240..71902f41c919 100644
+--- a/include/linux/regulator/pca9450.h
++++ b/include/linux/regulator/pca9450.h
+@@ -147,6 +147,9 @@ enum {
+ #define BUCK6_FPWM                    0x04
+ #define BUCK6_ENMODE_MASK             0x03
+ 
++/* PCA9450_REG_BUCK123_PRESET_EN bit */
++#define BUCK123_PRESET_EN             0x80
++
+ /* PCA9450_BUCK1OUT_DVS0 bits */
+ #define BUCK1OUT_DVS0_MASK            0x7F
+ #define BUCK1OUT_DVS0_DEFAULT         0x14
+-- 
+2.30.1
+

diff --git a/queue-5.10/regulator-pca9450-enable-system-reset-on-wdog_b-asse.patch b/queue-5.10/regulator-pca9450-enable-system-reset-on-wdog_b-asse.patch
new file mode 100644 (file)
index 0000000..d2d380d
--- /dev/null
+++ b/queue-5.10/regulator-pca9450-enable-system-reset-on-wdog_b-asse.patch
@@ -0,0 +1,64 @@
+From a051a420ff523367df79465e71bce33af1a138d7 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 11 Feb 2021 11:55:30 +0100
+Subject: regulator: pca9450: Enable system reset on WDOG_B assertion
+
+From: Frieder Schrempf <frieder.schrempf@kontron.de>
+
+[ Upstream commit f7684f5a048febd2a7bc98ee81d6dce52f7268b8 ]
+
+By default the PCA9450 doesn't handle the assertion of the WDOG_B
+signal, but this is required to guarantee that things like software
+resets triggered by the watchdog work reliably.
+
+As we don't want to rely on the bootloader to enable this, we tell
+the PMIC to issue a cold reset in case the WDOG_B signal is
+asserted (WDOG_B_CFG = 10), just as the NXP U-Boot code does.
+
+Signed-off-by: Frieder Schrempf <frieder.schrempf@kontron.de>
+Link: https://lore.kernel.org/r/20210211105534.38972-3-frieder.schrempf@kontron.de
+Signed-off-by: Mark Brown <broonie@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/regulator/pca9450-regulator.c | 8 ++++++++
+ include/linux/regulator/pca9450.h     | 7 +++++++
+ 2 files changed, 15 insertions(+)
+
+diff --git a/drivers/regulator/pca9450-regulator.c b/drivers/regulator/pca9450-regulator.c
+index 1bba8fdcb7b7..833d398c6aa2 100644
+--- a/drivers/regulator/pca9450-regulator.c
++++ b/drivers/regulator/pca9450-regulator.c
+@@ -797,6 +797,14 @@ static int pca9450_i2c_probe(struct i2c_client *i2c,
+               return ret;
+       }
+ 
++      /* Set reset behavior on assertion of WDOG_B signal */
++      ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_RESET_CTRL,
++                              WDOG_B_CFG_MASK, WDOG_B_CFG_COLD_LDO12);
++      if (ret) {
++              dev_err(&i2c->dev, "Failed to set WDOG_B reset behavior\n");
++              return ret;
++      }
++
+       /*
+        * The driver uses the LDO5CTRL_H register to control the LDO5 regulator.
+        * This is only valid if the SD_VSEL input of the PMIC is high. Let's
+diff --git a/include/linux/regulator/pca9450.h b/include/linux/regulator/pca9450.h
+index 1bbd3014f906..ccdb5320a240 100644
+--- a/include/linux/regulator/pca9450.h
++++ b/include/linux/regulator/pca9450.h
+@@ -216,4 +216,11 @@ enum {
+ #define IRQ_THERM_105                 0x02
+ #define IRQ_THERM_125                 0x01
+ 
++/* PCA9450_REG_RESET_CTRL bits */
++#define WDOG_B_CFG_MASK                       0xC0
++#define WDOG_B_CFG_NONE                       0x00
++#define WDOG_B_CFG_WARM                       0x40
++#define WDOG_B_CFG_COLD_LDO12         0x80
++#define WDOG_B_CFG_COLD                       0xC0
++
+ #endif /* __LINUX_REG_PCA9450_H__ */
+-- 
+2.30.1
+

diff --git a/queue-5.10/s390-qeth-schedule-tx-napi-on-qaob-completion.patch b/queue-5.10/s390-qeth-schedule-tx-napi-on-qaob-completion.patch
new file mode 100644 (file)
index 0000000..9aba0aa
--- /dev/null
+++ b/queue-5.10/s390-qeth-schedule-tx-napi-on-qaob-completion.patch
@@ -0,0 +1,99 @@
+From 9c6cd898e1a28572c2dfd4423d1a417c5549e8fc Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Tue, 9 Mar 2021 17:52:20 +0100
+Subject: s390/qeth: schedule TX NAPI on QAOB completion
+
+From: Julian Wiedmann <jwi@linux.ibm.com>
+
+[ Upstream commit 3e83d467a08e25b27c44c885f511624a71c84f7c ]
+
+When a QAOB notifies us that a pending TX buffer has been delivered, the
+actual TX completion processing by qeth_tx_complete_pending_bufs()
+is done within the context of a TX NAPI instance. We shouldn't rely on
+this instance being scheduled by some other TX event, but just do it
+ourselves.
+
+qeth_qdio_handle_aob() is called from qeth_poll(), ie. our main NAPI
+instance. To avoid touching the TX queue's NAPI instance
+before/after it is (un-)registered, reorder the code in qeth_open()
+and qeth_stop() accordingly.
+
+Fixes: 0da9581ddb0f ("qeth: exploit asynchronous delivery of storage blocks")
+Signed-off-by: Julian Wiedmann <jwi@linux.ibm.com>
+Signed-off-by: David S. Miller <davem@davemloft.net>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/s390/net/qeth_core_main.c | 18 ++++++++++++------
+ 1 file changed, 12 insertions(+), 6 deletions(-)
+
+diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c
+index 03f96177e58e..4d51c4ace8ea 100644
+--- a/drivers/s390/net/qeth_core_main.c
++++ b/drivers/s390/net/qeth_core_main.c
+@@ -470,6 +470,7 @@ static void qeth_qdio_handle_aob(struct qeth_card *card,
+       struct qaob *aob;
+       struct qeth_qdio_out_buffer *buffer;
+       enum iucv_tx_notify notification;
++      struct qeth_qdio_out_q *queue;
+       unsigned int i;
+ 
+       aob = (struct qaob *) phys_to_virt(phys_aob_addr);
+@@ -511,7 +512,9 @@ static void qeth_qdio_handle_aob(struct qeth_card *card,
+                               kmem_cache_free(qeth_core_header_cache, data);
+               }
+ 
++              queue = buffer->q;
+               atomic_set(&buffer->state, QETH_QDIO_BUF_EMPTY);
++              napi_schedule(&queue->napi);
+               break;
+       default:
+               WARN_ON_ONCE(1);
+@@ -7013,9 +7016,7 @@ int qeth_open(struct net_device *dev)
+       card->data.state = CH_STATE_UP;
+       netif_tx_start_all_queues(dev);
+ 
+-      napi_enable(&card->napi);
+       local_bh_disable();
+-      napi_schedule(&card->napi);
+       if (IS_IQD(card)) {
+               struct qeth_qdio_out_q *queue;
+               unsigned int i;
+@@ -7027,8 +7028,12 @@ int qeth_open(struct net_device *dev)
+                       napi_schedule(&queue->napi);
+               }
+       }
++
++      napi_enable(&card->napi);
++      napi_schedule(&card->napi);
+       /* kick-start the NAPI softirq: */
+       local_bh_enable();
++
+       return 0;
+ }
+ EXPORT_SYMBOL_GPL(qeth_open);
+@@ -7038,6 +7043,11 @@ int qeth_stop(struct net_device *dev)
+       struct qeth_card *card = dev->ml_priv;
+ 
+       QETH_CARD_TEXT(card, 4, "qethstop");
++
++      napi_disable(&card->napi);
++      cancel_delayed_work_sync(&card->buffer_reclaim_work);
++      qdio_stop_irq(CARD_DDEV(card));
++
+       if (IS_IQD(card)) {
+               struct qeth_qdio_out_q *queue;
+               unsigned int i;
+@@ -7058,10 +7068,6 @@ int qeth_stop(struct net_device *dev)
+               netif_tx_disable(dev);
+       }
+ 
+-      napi_disable(&card->napi);
+-      cancel_delayed_work_sync(&card->buffer_reclaim_work);
+-      qdio_stop_irq(CARD_DDEV(card));
+-
+       return 0;
+ }
+ EXPORT_SYMBOL_GPL(qeth_stop);
+-- 
+2.30.1
+

diff --git a/queue-5.10/scsi-isci-pass-gfp_t-flags-in-isci_port_bc_change_re.patch b/queue-5.10/scsi-isci-pass-gfp_t-flags-in-isci_port_bc_change_re.patch
new file mode 100644 (file)
index 0000000..339133c
--- /dev/null
+++ b/queue-5.10/scsi-isci-pass-gfp_t-flags-in-isci_port_bc_change_re.patch
@@ -0,0 +1,196 @@
+From c3cd58820245d78335d813ca1477827447c74e9d Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 18 Jan 2021 11:09:43 +0100
+Subject: scsi: isci: Pass gfp_t flags in isci_port_bc_change_received()
+
+From: Ahmed S. Darwish <a.darwish@linutronix.de>
+
+[ Upstream commit 71dca5539fcf977aead0c9ea1962e70e78484b8e ]
+
+Use the new libsas event notifiers API, which requires callers to
+explicitly pass the gfp_t memory allocation flags.
+
+libsas sas_notify_port_event() is called from
+isci_port_bc_change_received(). Below is the context analysis for all of
+its call chains:
+
+host.c: sci_controller_error_handler(): atomic, irq handler     (*)
+OR host.c: sci_controller_completion_handler(), atomic, tasklet (*)
+  -> sci_controller_process_completions()
+    -> sci_controller_event_completion()
+      -> phy.c: sci_phy_event_handler()
+        -> port.c: sci_port_broadcast_change_received()
+          -> isci_port_bc_change_received()
+
+host.c: isci_host_init()                                        (@)
+spin_lock_irq(isci_host::scic_lock)
+  -> sci_controller_initialize(), atomic                        (*)
+    -> port_config.c: sci_port_configuration_agent_initialize()
+      -> sci_mpc_agent_validate_phy_configuration()
+        -> port.c: sci_port_add_phy()
+          -> sci_port_set_phy()
+            -> phy.c: sci_phy_set_port()
+              -> port.c: sci_port_broadcast_change_received()
+                -> isci_port_bc_change_received()
+
+port_config.c: apc_agent_timeout(), atomic, timer callback      (*)
+  -> sci_apc_agent_configure_ports()
+    -> port.c: sci_port_add_phy()
+      -> sci_port_set_phy()
+        -> phy.c: sci_phy_set_port()
+          -> port.c: sci_port_broadcast_change_received()
+            -> isci_port_bc_change_received()
+
+phy.c: enter SCI state: *SCI_PHY_STOPPED*                       # Cont. from [1]
+  -> sci_phy_stopped_state_enter()
+    -> host.c: sci_controller_link_down()
+      -> ->link_down_handler()
+      == port_config.c: sci_apc_agent_link_down()
+        -> port.c: sci_port_remove_phy()
+          -> sci_port_clear_phy()
+            -> phy.c: sci_phy_set_port()
+              -> port.c: sci_port_broadcast_change_received()
+                -> isci_port_bc_change_received()
+
+phy.c: enter SCI state: *SCI_PHY_STARTING*                      # Cont. from [2]
+  -> sci_phy_starting_state_enter()
+    -> host.c: sci_controller_link_down()
+      -> ->link_down_handler()
+      == port_config.c: sci_apc_agent_link_down()
+        -> port.c: sci_port_remove_phy()
+          -> sci_port_clear_phy()
+            -> phy.c: sci_phy_set_port()
+              -> port.c: sci_port_broadcast_change_received()
+                -> isci_port_bc_change_received()
+
+[1] Call chains for entering state: *SCI_PHY_STOPPED*
+-----------------------------------------------------
+
+host.c: isci_host_init()                                        (@)
+spin_lock_irq(isci_host::scic_lock)
+  -> sci_controller_initialize(), atomic                        (*)
+      -> phy.c: sci_phy_initialize()
+        -> phy.c: sci_phy_link_layer_initialization()
+          -> phy.c: sci_change_state(SCI_PHY_STOPPED)
+
+init.c: PCI ->remove() || PM_OPS ->suspend,  process context    (+)
+  -> host.c: isci_host_deinit()
+    -> sci_controller_stop_phys()
+      -> phy.c: sci_phy_stop()
+       -> sci_change_state(SCI_PHY_STOPPED)
+
+phy.c: isci_phy_control()
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> sci_phy_stop(), atomic                                     (*)
+    -> sci_change_state(SCI_PHY_STOPPED)
+
+[2] Call chains for entering state: *SCI_PHY_STARTING*
+------------------------------------------------------
+
+phy.c: phy_sata_timeout(), atimer, timer callback               (*)
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> sci_change_state(SCI_PHY_STARTING)
+
+host.c: phy_startup_timeout(), atomic, timer callback           (*)
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> sci_controller_start_next_phy()
+    -> sci_phy_start()
+      -> sci_change_state(SCI_PHY_STARTING)
+
+host.c: isci_host_start()                                       (@)
+spin_lock_irq(isci_host::scic_lock)
+  -> sci_controller_start(), atomic                             (*)
+    -> sci_controller_start_next_phy()
+      -> sci_phy_start()
+        -> sci_change_state(SCI_PHY_STARTING)
+
+phy.c: Enter SCI state *SCI_PHY_SUB_FINAL*                      # Cont. from [2A]
+  -> sci_change_state(SCI_PHY_SUB_FINAL)
+    -> sci_phy_starting_final_substate_enter()
+      -> sci_change_state(SCI_PHY_READY)
+        -> Enter SCI state: *SCI_PHY_READY*
+          -> sci_phy_ready_state_enter()
+            -> host.c: sci_controller_link_up()
+              -> sci_controller_start_next_phy()
+                -> sci_phy_start()
+                  -> sci_change_state(SCI_PHY_STARTING)
+
+phy.c: sci_phy_event_handler(), atomic, discussed earlier       (*)
+  -> sci_change_state(SCI_PHY_STARTING), 11 instances
+
+port.c: isci_port_perform_hard_reset()
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> port.c: sci_port_hard_reset(), atomic                      (*)
+    -> phy.c: sci_phy_reset()
+      -> sci_change_state(SCI_PHY_RESETTING)
+        -> enter SCI PHY state: *SCI_PHY_RESETTING*
+          -> sci_phy_resetting_state_enter()
+            -> sci_change_state(SCI_PHY_STARTING)
+
+[2A] Call chains for entering SCI state: *SCI_PHY_SUB_FINAL*
+------------------------------------------------------------
+
+host.c: power_control_timeout(), atomic, timer callback         (*)
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> phy.c: sci_phy_consume_power_handler()
+    -> phy.c: sci_change_state(SCI_PHY_SUB_FINAL)
+
+host.c: sci_controller_error_handler(): atomic, irq handler     (*)
+OR host.c: sci_controller_completion_handler(), atomic, tasklet (*)
+  -> sci_controller_process_completions()
+    -> sci_controller_unsolicited_frame()
+      -> phy.c: sci_phy_frame_handler()
+        -> sci_change_state(SCI_PHY_SUB_AWAIT_SAS_POWER)
+          -> sci_phy_starting_await_sas_power_substate_enter()
+            -> host.c: sci_controller_power_control_queue_insert()
+              -> phy.c: sci_phy_consume_power_handler()
+                -> sci_change_state(SCI_PHY_SUB_FINAL)
+        -> sci_change_state(SCI_PHY_SUB_FINAL)
+    -> sci_controller_event_completion()
+      -> phy.c: sci_phy_event_handler()
+        -> sci_phy_start_sata_link_training()
+          -> sci_change_state(SCI_PHY_SUB_AWAIT_SATA_POWER)
+            -> sci_phy_starting_await_sata_power_substate_enter
+              -> host.c: sci_controller_power_control_queue_insert()
+                -> phy.c: sci_phy_consume_power_handler()
+                  -> sci_change_state(SCI_PHY_SUB_FINAL)
+
+As can be seen from the "(*)" markers above, almost all the call-chains are
+atomic. The only exception, marked with "(+)", is a PCI ->remove() and
+PM_OPS ->suspend() cold path. Thus, pass GFP_ATOMIC to the libsas port
+event notifier.
+
+Note, the now-replaced libsas APIs used in_interrupt() to implicitly decide
+which memory allocation type to use.  This was only partially correct, as
+it fails to choose the correct GFP flags when just preemption or interrupts
+are disabled. Such buggy code paths are marked with "(@)" in the call
+chains above.
+
+Link: https://lore.kernel.org/r/20210118100955.1761652-8-a.darwish@linutronix.de
+Fixes: 1c393b970e0f ("scsi: libsas: Use dynamic alloced work to avoid sas event lost")
+Cc: Artur Paszkiewicz <artur.paszkiewicz@intel.com>
+Reviewed-by: John Garry <john.garry@huawei.com>
+Signed-off-by: Ahmed S. Darwish <a.darwish@linutronix.de>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/scsi/isci/port.c | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+diff --git a/drivers/scsi/isci/port.c b/drivers/scsi/isci/port.c
+index 10136ae466e2..e50c3b0deeb3 100644
+--- a/drivers/scsi/isci/port.c
++++ b/drivers/scsi/isci/port.c
+@@ -164,7 +164,8 @@ static void isci_port_bc_change_received(struct isci_host *ihost,
+               "%s: isci_phy = %p, sas_phy = %p\n",
+               __func__, iphy, &iphy->sas_phy);
+ 
+-      sas_notify_port_event(&iphy->sas_phy, PORTE_BROADCAST_RCVD);
++      sas_notify_port_event_gfp(&iphy->sas_phy,
++                                PORTE_BROADCAST_RCVD, GFP_ATOMIC);
+       sci_port_bcn_enable(iport);
+ }
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/scsi-isci-pass-gfp_t-flags-in-isci_port_link_down.patch b/queue-5.10/scsi-isci-pass-gfp_t-flags-in-isci_port_link_down.patch
new file mode 100644 (file)
index 0000000..eda2cc2
--- /dev/null
+++ b/queue-5.10/scsi-isci-pass-gfp_t-flags-in-isci_port_link_down.patch
@@ -0,0 +1,248 @@
+From 7ca2619c69ee55ce3ff01c5b2dde8e994ee753c8 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 18 Jan 2021 11:09:41 +0100
+Subject: scsi: isci: Pass gfp_t flags in isci_port_link_down()
+
+From: Ahmed S. Darwish <a.darwish@linutronix.de>
+
+[ Upstream commit 885ab3b8926fdf9cdd7163dfad99deb9b0662b39 ]
+
+Use the new libsas event notifiers API, which requires callers to
+explicitly pass the gfp_t memory allocation flags.
+
+sas_notify_phy_event() is exclusively called by isci_port_link_down().
+Below is the context analysis for all of its call chains:
+
+port.c: port_timeout(), atomic, timer callback                  (*)
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> port_state_machine_change(..., SCI_PORT_FAILED)
+    -> enter SCI port state: *SCI_PORT_FAILED*
+      -> sci_port_failed_state_enter()
+        -> isci_port_hard_reset_complete()
+          -> isci_port_link_down()
+
+port.c: isci_port_perform_hard_reset()
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> port.c: sci_port_hard_reset(), atomic                      (*)
+    -> phy.c: sci_phy_reset()
+      -> sci_change_state(SCI_PHY_RESETTING)
+        -> enter SCI PHY state: *SCI_PHY_RESETTING*
+          -> sci_phy_resetting_state_enter()
+            -> port.c: sci_port_deactivate_phy()
+             -> isci_port_link_down()
+
+port.c: enter SCI port state: *SCI_PORT_READY*                  # Cont. from [1]
+  -> sci_port_ready_state_enter()
+    -> isci_port_hard_reset_complete()
+      -> isci_port_link_down()
+
+phy.c: enter SCI state: *SCI_PHY_STOPPED*                       # Cont. from [2]
+  -> sci_phy_stopped_state_enter()
+    -> host.c: sci_controller_link_down()
+      -> ->link_down_handler()
+      == port_config.c: sci_apc_agent_link_down()
+        -> port.c: sci_port_remove_phy()
+          -> sci_port_deactivate_phy()
+            -> isci_port_link_down()
+      == port_config.c: sci_mpc_agent_link_down()
+        -> port.c: sci_port_link_down()
+          -> sci_port_deactivate_phy()
+            -> isci_port_link_down()
+
+phy.c: enter SCI state: *SCI_PHY_STARTING*                      # Cont. from [3]
+  -> sci_phy_starting_state_enter()
+    -> host.c: sci_controller_link_down()
+      -> ->link_down_handler()
+      == port_config.c: sci_apc_agent_link_down()
+        -> port.c: sci_port_remove_phy()
+          -> isci_port_link_down()
+      == port_config.c: sci_mpc_agent_link_down()
+        -> port.c: sci_port_link_down()
+          -> sci_port_deactivate_phy()
+            -> isci_port_link_down()
+
+[1] Call chains for 'enter SCI port state: *SCI_PORT_READY*'
+------------------------------------------------------------
+
+host.c: isci_host_init()                                        (@)
+spin_lock_irq(isci_host::scic_lock)
+  -> sci_controller_initialize(), atomic                        (*)
+    -> port_config.c: sci_port_configuration_agent_initialize()
+      -> sci_mpc_agent_validate_phy_configuration()
+        -> port.c: sci_port_add_phy()
+          -> sci_port_general_link_up_handler()
+            -> port_state_machine_change(, SCI_PORT_READY)
+              -> enter port state *SCI_PORT_READY*
+
+host.c: isci_host_start()                                       (@)
+spin_lock_irq(isci_host::scic_lock)
+  -> host.c: sci_controller_start(), atomic                     (*)
+    -> host.c: sci_port_start()
+      -> port.c: port_state_machine_change(, SCI_PORT_READY)
+        -> enter port state *SCI_PORT_READY*
+
+port_config.c: apc_agent_timeout(), atomic, timer callback      (*)
+  -> sci_apc_agent_configure_ports()
+    -> port.c: sci_port_add_phy()
+      -> sci_port_general_link_up_handler()
+        -> port_state_machine_change(, SCI_PORT_READY)
+          -> enter port state *SCI_PORT_READY*
+
+port_config.c: mpc_agent_timeout(), atomic, timer callback      (*)
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> ->link_up_handler()
+  == port.c: sci_apc_agent_link_up()
+    -> sci_port_general_link_up_handler()
+      -> port_state_machine_change(, SCI_PORT_READY)
+        -> enter port state *SCI_PORT_READY*
+  == port.c: sci_mpc_agent_link_up()
+    -> port.c: sci_port_link_up()
+      -> sci_port_general_link_up_handler()
+        -> port_state_machine_change(, SCI_PORT_READY)
+          -> enter port state *SCI_PORT_READY*
+
+phy.c: enter SCI state: SCI_PHY_SUB_FINAL                       # Cont. from [1A]
+  -> sci_phy_starting_final_substate_enter()
+    -> sci_change_state(SCI_PHY_READY)
+      -> enter SCI state: *SCI_PHY_READY*
+        -> sci_phy_ready_state_enter()
+          -> host.c: sci_controller_link_up()
+            -> port_agent.link_up_handler()
+            == port_config.c: sci_apc_agent_link_up()
+              -> port.c: sci_port_link_up()
+                -> sci_port_general_link_up_handler()
+                  -> port_state_machine_change(, SCI_PORT_READY)
+                    -> enter port state *SCI_PORT_READY*
+            == port_config.c: sci_mpc_agent_link_up()
+              -> port.c: sci_port_link_up()
+                -> sci_port_general_link_up_handler()
+                  -> port_state_machine_change(, SCI_PORT_READY)
+                    -> enter port state *SCI_PORT_READY*
+
+[1A] Call chains for entering SCI state: *SCI_PHY_SUB_FINAL*
+------------------------------------------------------------
+
+host.c: power_control_timeout(), atomic, timer callback         (*)
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> phy.c: sci_phy_consume_power_handler()
+    -> phy.c: sci_change_state(SCI_PHY_SUB_FINAL)
+
+host.c: sci_controller_error_handler(): atomic, irq handler     (*)
+OR host.c: sci_controller_completion_handler(), atomic, tasklet (*)
+  -> sci_controller_process_completions()
+    -> sci_controller_unsolicited_frame()
+      -> phy.c: sci_phy_frame_handler()
+        -> sci_change_state(SCI_PHY_SUB_AWAIT_SAS_POWER)
+          -> sci_phy_starting_await_sas_power_substate_enter()
+            -> host.c: sci_controller_power_control_queue_insert()
+              -> phy.c: sci_phy_consume_power_handler()
+                -> sci_change_state(SCI_PHY_SUB_FINAL)
+        -> sci_change_state(SCI_PHY_SUB_FINAL)
+    -> sci_controller_event_completion()
+      -> phy.c: sci_phy_event_handler()
+        -> sci_phy_start_sata_link_training()
+          -> sci_change_state(SCI_PHY_SUB_AWAIT_SATA_POWER)
+            -> sci_phy_starting_await_sata_power_substate_enter
+              -> host.c: sci_controller_power_control_queue_insert()
+                -> phy.c: sci_phy_consume_power_handler()
+                  -> sci_change_state(SCI_PHY_SUB_FINAL)
+
+[2] Call chains for entering state: *SCI_PHY_STOPPED*
+-----------------------------------------------------
+
+host.c: isci_host_init()                                        (@)
+spin_lock_irq(isci_host::scic_lock)
+  -> sci_controller_initialize(), atomic                        (*)
+      -> phy.c: sci_phy_initialize()
+        -> phy.c: sci_phy_link_layer_initialization()
+          -> phy.c: sci_change_state(SCI_PHY_STOPPED)
+
+init.c: PCI ->remove() || PM_OPS ->suspend,  process context    (+)
+  -> host.c: isci_host_deinit()
+    -> sci_controller_stop_phys()
+      -> phy.c: sci_phy_stop()
+       -> sci_change_state(SCI_PHY_STOPPED)
+
+phy.c: isci_phy_control()
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> sci_phy_stop(), atomic                                     (*)
+    -> sci_change_state(SCI_PHY_STOPPED)
+
+[3] Call chains for entering state: *SCI_PHY_STARTING*
+------------------------------------------------------
+
+phy.c: phy_sata_timeout(), atimer, timer callback               (*)
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> sci_change_state(SCI_PHY_STARTING)
+
+host.c: phy_startup_timeout(), atomic, timer callback           (*)
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> sci_controller_start_next_phy()
+    -> sci_phy_start()
+      -> sci_change_state(SCI_PHY_STARTING)
+
+host.c: isci_host_start()                                       (@)
+spin_lock_irq(isci_host::scic_lock)
+  -> sci_controller_start(), atomic                             (*)
+    -> sci_controller_start_next_phy()
+      -> sci_phy_start()
+        -> sci_change_state(SCI_PHY_STARTING)
+
+phy.c: Enter SCI state *SCI_PHY_SUB_FINAL*, atomic, check above (*)
+  -> sci_change_state(SCI_PHY_SUB_FINAL)
+    -> sci_phy_starting_final_substate_enter()
+      -> sci_change_state(SCI_PHY_READY)
+        -> Enter SCI state: *SCI_PHY_READY*
+          -> sci_phy_ready_state_enter()
+            -> host.c: sci_controller_link_up()
+              -> sci_controller_start_next_phy()
+                -> sci_phy_start()
+                  -> sci_change_state(SCI_PHY_STARTING)
+
+phy.c: sci_phy_event_handler(), atomic, discussed earlier       (*)
+  -> sci_change_state(SCI_PHY_STARTING), 11 instances
+
+phy.c: enter SCI state: *SCI_PHY_RESETTING*, atomic, discussed  (*)
+  -> sci_phy_resetting_state_enter()
+    -> sci_change_state(SCI_PHY_STARTING)
+
+As can be seen from the "(*)" markers above, almost all the call-chains are
+atomic. The only exception, marked with "(+)", is a PCI ->remove() and
+PM_OPS ->suspend() cold path. Thus, pass GFP_ATOMIC to the libsas phy event
+notifier.
+
+Note, The now-replaced libsas APIs used in_interrupt() to implicitly decide
+which memory allocation type to use.  This was only partially correct, as
+it fails to choose the correct GFP flags when just preemption or interrupts
+are disabled. Such buggy code paths are marked with "(@)" in the call
+chains above.
+
+Link: https://lore.kernel.org/r/20210118100955.1761652-6-a.darwish@linutronix.de
+Fixes: 1c393b970e0f ("scsi: libsas: Use dynamic alloced work to avoid sas event lost")
+Cc: Artur Paszkiewicz <artur.paszkiewicz@intel.com>
+Reviewed-by: John Garry <john.garry@huawei.com>
+Signed-off-by: Ahmed S. Darwish <a.darwish@linutronix.de>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/scsi/isci/port.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/drivers/scsi/isci/port.c b/drivers/scsi/isci/port.c
+index 8d9349738067..a3c58718c260 100644
+--- a/drivers/scsi/isci/port.c
++++ b/drivers/scsi/isci/port.c
+@@ -269,8 +269,8 @@ static void isci_port_link_down(struct isci_host *isci_host,
+        * isci_port_deformed and isci_dev_gone functions.
+        */
+       sas_phy_disconnected(&isci_phy->sas_phy);
+-      sas_notify_phy_event(&isci_phy->sas_phy,
+-                                         PHYE_LOSS_OF_SIGNAL);
++      sas_notify_phy_event_gfp(&isci_phy->sas_phy,
++                               PHYE_LOSS_OF_SIGNAL, GFP_ATOMIC);
+ 
+       dev_dbg(&isci_host->pdev->dev,
+               "%s: isci_port = %p - Done\n", __func__, isci_port);
+-- 
+2.30.1
+

diff --git a/queue-5.10/scsi-isci-pass-gfp_t-flags-in-isci_port_link_up.patch b/queue-5.10/scsi-isci-pass-gfp_t-flags-in-isci_port_link_up.patch
new file mode 100644 (file)
index 0000000..e036c7c
--- /dev/null
+++ b/queue-5.10/scsi-isci-pass-gfp_t-flags-in-isci_port_link_up.patch
@@ -0,0 +1,128 @@
+From e35b9aa62ff55033a4b933839081aba440c03d10 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 18 Jan 2021 11:09:42 +0100
+Subject: scsi: isci: Pass gfp_t flags in isci_port_link_up()
+
+From: Ahmed S. Darwish <a.darwish@linutronix.de>
+
+[ Upstream commit 5ce7902902adb8d154d67ba494f06daa29360ef0 ]
+
+Use the new libsas event notifiers API, which requires callers to
+explicitly pass the gfp_t memory allocation flags.
+
+libsas sas_notify_port_event() is called from isci_port_link_up().  Below
+is the context analysis for all of its call chains:
+
+host.c: isci_host_init()                                        (@)
+spin_lock_irq(isci_host::scic_lock)
+  -> sci_controller_initialize(), atomic                        (*)
+    -> port_config.c: sci_port_configuration_agent_initialize()
+      -> sci_mpc_agent_validate_phy_configuration()
+        -> port.c: sci_port_add_phy()
+          -> sci_port_general_link_up_handler()
+            -> sci_port_activate_phy()
+              -> isci_port_link_up()
+
+port_config.c: apc_agent_timeout(), atomic, timer callback      (*)
+  -> sci_apc_agent_configure_ports()
+    -> port.c: sci_port_add_phy()
+      -> sci_port_general_link_up_handler()
+        -> sci_port_activate_phy()
+          -> isci_port_link_up()
+
+phy.c: enter SCI state: *SCI_PHY_SUB_FINAL*                     # Cont. from [1]
+  -> phy.c: sci_phy_starting_final_substate_enter()
+    -> phy.c: sci_change_state(SCI_PHY_READY)
+      -> enter SCI state: *SCI_PHY_READY*
+        -> phy.c: sci_phy_ready_state_enter()
+          -> host.c: sci_controller_link_up()
+            -> .link_up_handler()
+            == port_config.c: sci_apc_agent_link_up()
+              -> port.c: sci_port_link_up()
+                -> (continue at [A])
+            == port_config.c: sci_mpc_agent_link_up()
+             -> port.c: sci_port_link_up()
+                -> (continue at [A])
+
+port_config.c: mpc_agent_timeout(), atomic, timer callback      (*)
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> ->link_up_handler()
+  == port_config.c: sci_apc_agent_link_up()
+    -> port.c: sci_port_link_up()
+      -> (continue at [A])
+  == port_config.c: sci_mpc_agent_link_up()
+    -> port.c: sci_port_link_up()
+      -> (continue at [A])
+
+[A] port.c: sci_port_link_up()
+  -> sci_port_activate_phy()
+    -> isci_port_link_up()
+  -> sci_port_general_link_up_handler()
+    -> sci_port_activate_phy()
+      -> isci_port_link_up()
+
+[1] Call chains for entering SCI state: *SCI_PHY_SUB_FINAL*
+-----------------------------------------------------------
+
+host.c: power_control_timeout(), atomic, timer callback         (*)
+spin_lock_irqsave(isci_host::scic_lock, )
+  -> phy.c: sci_phy_consume_power_handler()
+    -> phy.c: sci_change_state(SCI_PHY_SUB_FINAL)
+
+host.c: sci_controller_error_handler(): atomic, irq handler     (*)
+OR host.c: sci_controller_completion_handler(), atomic, tasklet (*)
+  -> sci_controller_process_completions()
+    -> sci_controller_unsolicited_frame()
+      -> phy.c: sci_phy_frame_handler()
+        -> sci_change_state(SCI_PHY_SUB_AWAIT_SAS_POWER)
+          -> sci_phy_starting_await_sas_power_substate_enter()
+            -> host.c: sci_controller_power_control_queue_insert()
+              -> phy.c: sci_phy_consume_power_handler()
+                -> sci_change_state(SCI_PHY_SUB_FINAL)
+        -> sci_change_state(SCI_PHY_SUB_FINAL)
+    -> sci_controller_event_completion()
+      -> phy.c: sci_phy_event_handler()
+        -> sci_phy_start_sata_link_training()
+          -> sci_change_state(SCI_PHY_SUB_AWAIT_SATA_POWER)
+            -> sci_phy_starting_await_sata_power_substate_enter
+              -> host.c: sci_controller_power_control_queue_insert()
+                -> phy.c: sci_phy_consume_power_handler()
+                  -> sci_change_state(SCI_PHY_SUB_FINAL)
+
+As can be seen from the "(*)" markers above, all the call-chains are
+atomic.  Pass GFP_ATOMIC to libsas port event notifier.
+
+Note, the now-replaced libsas APIs used in_interrupt() to implicitly decide
+which memory allocation type to use.  This was only partially correct, as
+it fails to choose the correct GFP flags when just preemption or interrupts
+are disabled. Such buggy code paths are marked with "(@)" in the call
+chains above.
+
+Link: https://lore.kernel.org/r/20210118100955.1761652-7-a.darwish@linutronix.de
+Fixes: 1c393b970e0f ("scsi: libsas: Use dynamic alloced work to avoid sas event lost")
+Cc: Artur Paszkiewicz <artur.paszkiewicz@intel.com>
+Reviewed-by: John Garry <john.garry@huawei.com>
+Signed-off-by: Ahmed S. Darwish <a.darwish@linutronix.de>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/scsi/isci/port.c | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+diff --git a/drivers/scsi/isci/port.c b/drivers/scsi/isci/port.c
+index a3c58718c260..10136ae466e2 100644
+--- a/drivers/scsi/isci/port.c
++++ b/drivers/scsi/isci/port.c
+@@ -223,7 +223,8 @@ static void isci_port_link_up(struct isci_host *isci_host,
+       /* Notify libsas that we have an address frame, if indeed
+        * we've found an SSP, SMP, or STP target */
+       if (success)
+-              sas_notify_port_event(&iphy->sas_phy, PORTE_BYTES_DMAED);
++              sas_notify_port_event_gfp(&iphy->sas_phy,
++                                        PORTE_BYTES_DMAED, GFP_ATOMIC);
+ }
+ 
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/scsi-libsas-introduce-a-_gfp-variant-of-event-notifi.patch b/queue-5.10/scsi-libsas-introduce-a-_gfp-variant-of-event-notifi.patch
new file mode 100644 (file)
index 0000000..e836953
--- /dev/null
+++ b/queue-5.10/scsi-libsas-introduce-a-_gfp-variant-of-event-notifi.patch
@@ -0,0 +1,262 @@
+From cc5a45d9c6b7579aba2b0a89c7363ba2349e0e92 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 18 Jan 2021 11:09:39 +0100
+Subject: scsi: libsas: Introduce a _gfp() variant of event notifiers
+
+From: Ahmed S. Darwish <a.darwish@linutronix.de>
+
+[ Upstream commit c2d0f1a65ab9fbabebb463bf36f50ea8f4633386 ]
+
+sas_alloc_event() uses in_interrupt() to decide which allocation should be
+used.
+
+The usage of in_interrupt() in drivers is phased out and Linus clearly
+requested that code which changes behaviour depending on context should
+either be separated or the context be conveyed in an argument passed by the
+caller, which usually knows the context.
+
+The in_interrupt() check is also only partially correct, because it fails
+to choose the correct code path when just preemption or interrupts are
+disabled. For example, as in the following call chain:
+
+  mvsas/mv_sas.c: mvs_work_queue() [process context]
+  spin_lock_irqsave(mvs_info::lock, )
+    -> libsas/sas_event.c: sas_notify_phy_event()
+      -> sas_alloc_event()
+        -> in_interrupt() = false
+          -> invalid GFP_KERNEL allocation
+    -> libsas/sas_event.c: sas_notify_port_event()
+      -> sas_alloc_event()
+        -> in_interrupt() = false
+          -> invalid GFP_KERNEL allocation
+
+Introduce sas_alloc_event_gfp(), sas_notify_port_event_gfp(), and
+sas_notify_phy_event_gfp(), which all behave like the non _gfp() variants
+but use a caller-passed GFP mask for allocations.
+
+For bisectability, all callers will be modified first to pass GFP context,
+then the non _gfp() libsas API variants will be modified to take a gfp_t by
+default.
+
+Link: https://lore.kernel.org/r/20210118100955.1761652-4-a.darwish@linutronix.de
+Fixes: 1c393b970e0f ("scsi: libsas: Use dynamic alloced work to avoid sas event lost")
+Cc: Jason Yan <yanaijie@huawei.com>
+Reviewed-by: John Garry <john.garry@huawei.com>
+Signed-off-by: Ahmed S. Darwish <a.darwish@linutronix.de>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ Documentation/scsi/libsas.rst      |  2 +
+ drivers/scsi/libsas/sas_event.c    | 65 ++++++++++++++++++++++++------
+ drivers/scsi/libsas/sas_init.c     | 21 +++++++---
+ drivers/scsi/libsas/sas_internal.h |  4 ++
+ include/scsi/libsas.h              |  4 ++
+ 5 files changed, 79 insertions(+), 17 deletions(-)
+
+diff --git a/Documentation/scsi/libsas.rst b/Documentation/scsi/libsas.rst
+index 6722e352444b..ea63ab3a9216 100644
+--- a/Documentation/scsi/libsas.rst
++++ b/Documentation/scsi/libsas.rst
+@@ -191,6 +191,8 @@ The event interface::
+       /* LLDD calls these to notify the class of an event. */
+       void sas_notify_port_event(struct sas_phy *, enum port_event);
+       void sas_notify_phy_event(struct sas_phy *, enum phy_event);
++      void sas_notify_port_event_gfp(struct sas_phy *, enum port_event, gfp_t);
++      void sas_notify_phy_event_gfp(struct sas_phy *, enum phy_event, gfp_t);
+ 
+ The port notification::
+ 
+diff --git a/drivers/scsi/libsas/sas_event.c b/drivers/scsi/libsas/sas_event.c
+index 112a1b76f63b..ba266a17250a 100644
+--- a/drivers/scsi/libsas/sas_event.c
++++ b/drivers/scsi/libsas/sas_event.c
+@@ -131,18 +131,15 @@ static void sas_phy_event_worker(struct work_struct *work)
+       sas_free_event(ev);
+ }
+ 
+-int sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event)
++static int __sas_notify_port_event(struct asd_sas_phy *phy,
++                                 enum port_event event,
++                                 struct asd_sas_event *ev)
+ {
+-      struct asd_sas_event *ev;
+       struct sas_ha_struct *ha = phy->ha;
+       int ret;
+ 
+       BUG_ON(event >= PORT_NUM_EVENTS);
+ 
+-      ev = sas_alloc_event(phy);
+-      if (!ev)
+-              return -ENOMEM;
+-
+       INIT_SAS_EVENT(ev, sas_port_event_worker, phy, event);
+ 
+       ret = sas_queue_event(event, &ev->work, ha);
+@@ -151,20 +148,41 @@ int sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event)
+ 
+       return ret;
+ }
+-EXPORT_SYMBOL_GPL(sas_notify_port_event);
+ 
+-int sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event)
++int sas_notify_port_event_gfp(struct asd_sas_phy *phy, enum port_event event,
++                            gfp_t gfp_flags)
+ {
+       struct asd_sas_event *ev;
+-      struct sas_ha_struct *ha = phy->ha;
+-      int ret;
+ 
+-      BUG_ON(event >= PHY_NUM_EVENTS);
++      ev = sas_alloc_event_gfp(phy, gfp_flags);
++      if (!ev)
++              return -ENOMEM;
++
++      return __sas_notify_port_event(phy, event, ev);
++}
++EXPORT_SYMBOL_GPL(sas_notify_port_event_gfp);
++
++int sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event)
++{
++      struct asd_sas_event *ev;
+ 
+       ev = sas_alloc_event(phy);
+       if (!ev)
+               return -ENOMEM;
+ 
++      return __sas_notify_port_event(phy, event, ev);
++}
++EXPORT_SYMBOL_GPL(sas_notify_port_event);
++
++static inline int __sas_notify_phy_event(struct asd_sas_phy *phy,
++                                       enum phy_event event,
++                                       struct asd_sas_event *ev)
++{
++      struct sas_ha_struct *ha = phy->ha;
++      int ret;
++
++      BUG_ON(event >= PHY_NUM_EVENTS);
++
+       INIT_SAS_EVENT(ev, sas_phy_event_worker, phy, event);
+ 
+       ret = sas_queue_event(event, &ev->work, ha);
+@@ -173,5 +191,28 @@ int sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event)
+ 
+       return ret;
+ }
+-EXPORT_SYMBOL_GPL(sas_notify_phy_event);
+ 
++int sas_notify_phy_event_gfp(struct asd_sas_phy *phy, enum phy_event event,
++                           gfp_t gfp_flags)
++{
++      struct asd_sas_event *ev;
++
++      ev = sas_alloc_event_gfp(phy, gfp_flags);
++      if (!ev)
++              return -ENOMEM;
++
++      return __sas_notify_phy_event(phy, event, ev);
++}
++EXPORT_SYMBOL_GPL(sas_notify_phy_event_gfp);
++
++int sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event)
++{
++      struct asd_sas_event *ev;
++
++      ev = sas_alloc_event(phy);
++      if (!ev)
++              return -ENOMEM;
++
++      return __sas_notify_phy_event(phy, event, ev);
++}
++EXPORT_SYMBOL_GPL(sas_notify_phy_event);
+diff --git a/drivers/scsi/libsas/sas_init.c b/drivers/scsi/libsas/sas_init.c
+index 6dc2505d36af..f8ae1f0f17d3 100644
+--- a/drivers/scsi/libsas/sas_init.c
++++ b/drivers/scsi/libsas/sas_init.c
+@@ -584,16 +584,15 @@ sas_domain_attach_transport(struct sas_domain_function_template *dft)
+ }
+ EXPORT_SYMBOL_GPL(sas_domain_attach_transport);
+ 
+-
+-struct asd_sas_event *sas_alloc_event(struct asd_sas_phy *phy)
++static struct asd_sas_event *__sas_alloc_event(struct asd_sas_phy *phy,
++                                             gfp_t gfp_flags)
+ {
+       struct asd_sas_event *event;
+-      gfp_t flags = in_interrupt() ? GFP_ATOMIC : GFP_KERNEL;
+       struct sas_ha_struct *sas_ha = phy->ha;
+       struct sas_internal *i =
+               to_sas_internal(sas_ha->core.shost->transportt);
+ 
+-      event = kmem_cache_zalloc(sas_event_cache, flags);
++      event = kmem_cache_zalloc(sas_event_cache, gfp_flags);
+       if (!event)
+               return NULL;
+ 
+@@ -604,7 +603,8 @@ struct asd_sas_event *sas_alloc_event(struct asd_sas_phy *phy)
+                       if (cmpxchg(&phy->in_shutdown, 0, 1) == 0) {
+                               pr_notice("The phy%d bursting events, shut it down.\n",
+                                         phy->id);
+-                              sas_notify_phy_event(phy, PHYE_SHUTDOWN);
++                              sas_notify_phy_event_gfp(phy, PHYE_SHUTDOWN,
++                                                       gfp_flags);
+                       }
+               } else {
+                       /* Do not support PHY control, stop allocating events */
+@@ -618,6 +618,17 @@ struct asd_sas_event *sas_alloc_event(struct asd_sas_phy *phy)
+       return event;
+ }
+ 
++struct asd_sas_event *sas_alloc_event(struct asd_sas_phy *phy)
++{
++      return __sas_alloc_event(phy, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
++}
++
++struct asd_sas_event *sas_alloc_event_gfp(struct asd_sas_phy *phy,
++                                        gfp_t gfp_flags)
++{
++      return __sas_alloc_event(phy, gfp_flags);
++}
++
+ void sas_free_event(struct asd_sas_event *event)
+ {
+       struct asd_sas_phy *phy = event->phy;
+diff --git a/drivers/scsi/libsas/sas_internal.h b/drivers/scsi/libsas/sas_internal.h
+index 53ea32ed17a7..52e09c3e2b50 100644
+--- a/drivers/scsi/libsas/sas_internal.h
++++ b/drivers/scsi/libsas/sas_internal.h
+@@ -49,6 +49,8 @@ int  sas_register_phys(struct sas_ha_struct *sas_ha);
+ void sas_unregister_phys(struct sas_ha_struct *sas_ha);
+ 
+ struct asd_sas_event *sas_alloc_event(struct asd_sas_phy *phy);
++struct asd_sas_event *sas_alloc_event_gfp(struct asd_sas_phy *phy,
++                                        gfp_t gfp_flags);
+ void sas_free_event(struct asd_sas_event *event);
+ 
+ int  sas_register_ports(struct sas_ha_struct *sas_ha);
+@@ -77,6 +79,8 @@ int sas_smp_phy_control(struct domain_device *dev, int phy_id,
+ int sas_smp_get_phy_events(struct sas_phy *phy);
+ 
+ int sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event);
++int sas_notify_phy_event_gfp(struct asd_sas_phy *phy, enum phy_event event,
++                           gfp_t flags);
+ void sas_device_set_phy(struct domain_device *dev, struct sas_port *port);
+ struct domain_device *sas_find_dev_by_rphy(struct sas_rphy *rphy);
+ struct domain_device *sas_ex_to_ata(struct domain_device *ex_dev, int phy_id);
+diff --git a/include/scsi/libsas.h b/include/scsi/libsas.h
+index 3387149502e9..e6a43163ab5b 100644
+--- a/include/scsi/libsas.h
++++ b/include/scsi/libsas.h
+@@ -704,5 +704,9 @@ int sas_request_addr(struct Scsi_Host *shost, u8 *addr);
+ 
+ int sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event);
+ int sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event);
++int sas_notify_port_event_gfp(struct asd_sas_phy *phy, enum port_event event,
++                            gfp_t gfp_flags);
++int sas_notify_phy_event_gfp(struct asd_sas_phy *phy, enum phy_event event,
++                           gfp_t gfp_flags);
+ 
+ #endif /* _SASLIB_H_ */
+-- 
+2.30.1
+

diff --git a/queue-5.10/scsi-libsas-remove-notifier-indirection.patch b/queue-5.10/scsi-libsas-remove-notifier-indirection.patch
new file mode 100644 (file)
index 0000000..a0f7348
--- /dev/null
+++ b/queue-5.10/scsi-libsas-remove-notifier-indirection.patch
@@ -0,0 +1,837 @@
+From 52ab3b4a8786cc0d5de93d6517fa584faf698674 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 18 Jan 2021 11:09:38 +0100
+Subject: scsi: libsas: Remove notifier indirection
+
+From: John Garry <john.garry@huawei.com>
+
+[ Upstream commit 121181f3f839c29d8dd9fdc3cc9babbdc74227f8 ]
+
+LLDDs report events to libsas with .notify_port_event and .notify_phy_event
+callbacks.
+
+These callbacks are fixed and so there is no reason why the functions
+cannot be called directly, so do that.
+
+This neatens the code slightly, makes it more obvious, and reduces function
+pointer usage, which is generally a good thing. Downside is that there are
+2x more symbol exports.
+
+[a.darwish@linutronix.de: Remove the now unused "sas_ha" local variables]
+
+Link: https://lore.kernel.org/r/20210118100955.1761652-3-a.darwish@linutronix.de
+Reviewed-by: Christoph Hellwig <hch@lst.de>
+Reviewed-by: Jack Wang <jinpu.wang@cloud.ionos.com>
+Signed-off-by: John Garry <john.garry@huawei.com>
+Signed-off-by: Ahmed S. Darwish <a.darwish@linutronix.de>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ Documentation/scsi/libsas.rst          |  8 ++----
+ drivers/scsi/aic94xx/aic94xx_scb.c     | 20 ++++++-------
+ drivers/scsi/hisi_sas/hisi_sas_main.c  | 12 +++-----
+ drivers/scsi/hisi_sas/hisi_sas_v1_hw.c |  3 +-
+ drivers/scsi/hisi_sas/hisi_sas_v2_hw.c |  3 +-
+ drivers/scsi/hisi_sas/hisi_sas_v3_hw.c |  3 +-
+ drivers/scsi/isci/port.c               |  7 ++---
+ drivers/scsi/libsas/sas_event.c        | 13 +++------
+ drivers/scsi/libsas/sas_init.c         |  6 ----
+ drivers/scsi/libsas/sas_internal.h     |  1 -
+ drivers/scsi/mvsas/mv_sas.c            | 14 ++++-----
+ drivers/scsi/pm8001/pm8001_hwi.c       | 40 ++++++++++++--------------
+ drivers/scsi/pm8001/pm8001_sas.c       |  7 ++---
+ drivers/scsi/pm8001/pm80xx_hwi.c       | 35 ++++++++++------------
+ include/scsi/libsas.h                  |  7 ++---
+ 15 files changed, 69 insertions(+), 110 deletions(-)
+
+diff --git a/Documentation/scsi/libsas.rst b/Documentation/scsi/libsas.rst
+index f9b77c7879db..6722e352444b 100644
+--- a/Documentation/scsi/libsas.rst
++++ b/Documentation/scsi/libsas.rst
+@@ -189,12 +189,8 @@ num_phys
+ The event interface::
+ 
+       /* LLDD calls these to notify the class of an event. */
+-      void (*notify_port_event)(struct sas_phy *, enum port_event);
+-      void (*notify_phy_event)(struct sas_phy *, enum phy_event);
+-
+-When sas_register_ha() returns, those are set and can be
+-called by the LLDD to notify the SAS layer of such events
+-the SAS layer.
++      void sas_notify_port_event(struct sas_phy *, enum port_event);
++      void sas_notify_phy_event(struct sas_phy *, enum phy_event);
+ 
+ The port notification::
+ 
+diff --git a/drivers/scsi/aic94xx/aic94xx_scb.c b/drivers/scsi/aic94xx/aic94xx_scb.c
+index e2d880a5f391..7b0566f6a97f 100644
+--- a/drivers/scsi/aic94xx/aic94xx_scb.c
++++ b/drivers/scsi/aic94xx/aic94xx_scb.c
+@@ -68,7 +68,6 @@ static void asd_phy_event_tasklet(struct asd_ascb *ascb,
+                                        struct done_list_struct *dl)
+ {
+       struct asd_ha_struct *asd_ha = ascb->ha;
+-      struct sas_ha_struct *sas_ha = &asd_ha->sas_ha;
+       int phy_id = dl->status_block[0] & DL_PHY_MASK;
+       struct asd_phy *phy = &asd_ha->phys[phy_id];
+ 
+@@ -81,7 +80,7 @@ static void asd_phy_event_tasklet(struct asd_ascb *ascb,
+               ASD_DPRINTK("phy%d: device unplugged\n", phy_id);
+               asd_turn_led(asd_ha, phy_id, 0);
+               sas_phy_disconnected(&phy->sas_phy);
+-              sas_ha->notify_phy_event(&phy->sas_phy, PHYE_LOSS_OF_SIGNAL);
++              sas_notify_phy_event(&phy->sas_phy, PHYE_LOSS_OF_SIGNAL);
+               break;
+       case CURRENT_OOB_DONE:
+               /* hot plugged device */
+@@ -89,12 +88,12 @@ static void asd_phy_event_tasklet(struct asd_ascb *ascb,
+               get_lrate_mode(phy, oob_mode);
+               ASD_DPRINTK("phy%d device plugged: lrate:0x%x, proto:0x%x\n",
+                           phy_id, phy->sas_phy.linkrate, phy->sas_phy.iproto);
+-              sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
++              sas_notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
+               break;
+       case CURRENT_SPINUP_HOLD:
+               /* hot plug SATA, no COMWAKE sent */
+               asd_turn_led(asd_ha, phy_id, 1);
+-              sas_ha->notify_phy_event(&phy->sas_phy, PHYE_SPINUP_HOLD);
++              sas_notify_phy_event(&phy->sas_phy, PHYE_SPINUP_HOLD);
+               break;
+       case CURRENT_GTO_TIMEOUT:
+       case CURRENT_OOB_ERROR:
+@@ -102,7 +101,7 @@ static void asd_phy_event_tasklet(struct asd_ascb *ascb,
+                           dl->status_block[1]);
+               asd_turn_led(asd_ha, phy_id, 0);
+               sas_phy_disconnected(&phy->sas_phy);
+-              sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_ERROR);
++              sas_notify_phy_event(&phy->sas_phy, PHYE_OOB_ERROR);
+               break;
+       }
+ }
+@@ -222,7 +221,6 @@ static void asd_bytes_dmaed_tasklet(struct asd_ascb *ascb,
+       int edb_el = edb_id + ascb->edb_index;
+       struct asd_dma_tok *edb = ascb->ha->seq.edb_arr[edb_el];
+       struct asd_phy *phy = &ascb->ha->phys[phy_id];
+-      struct sas_ha_struct *sas_ha = phy->sas_phy.ha;
+       u16 size = ((dl->status_block[3] & 7) << 8) | dl->status_block[2];
+ 
+       size = min(size, (u16) sizeof(phy->frame_rcvd));
+@@ -234,7 +232,7 @@ static void asd_bytes_dmaed_tasklet(struct asd_ascb *ascb,
+       spin_unlock_irqrestore(&phy->sas_phy.frame_rcvd_lock, flags);
+       asd_dump_frame_rcvd(phy, dl);
+       asd_form_port(ascb->ha, phy);
+-      sas_ha->notify_port_event(&phy->sas_phy, PORTE_BYTES_DMAED);
++      sas_notify_port_event(&phy->sas_phy, PORTE_BYTES_DMAED);
+ }
+ 
+ static void asd_link_reset_err_tasklet(struct asd_ascb *ascb,
+@@ -270,7 +268,7 @@ static void asd_link_reset_err_tasklet(struct asd_ascb *ascb,
+       asd_turn_led(asd_ha, phy_id, 0);
+       sas_phy_disconnected(sas_phy);
+       asd_deform_port(asd_ha, phy);
+-      sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++      sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+ 
+       if (retries_left == 0) {
+               int num = 1;
+@@ -315,7 +313,7 @@ static void asd_primitive_rcvd_tasklet(struct asd_ascb *ascb,
+                       spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+                       sas_phy->sas_prim = ffs(cont);
+                       spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+-                      sas_ha->notify_port_event(sas_phy,PORTE_BROADCAST_RCVD);
++                      sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+                       break;
+ 
+               case LmUNKNOWNP:
+@@ -336,7 +334,7 @@ static void asd_primitive_rcvd_tasklet(struct asd_ascb *ascb,
+                       /* The sequencer disables all phys on that port.
+                        * We have to re-enable the phys ourselves. */
+                       asd_deform_port(asd_ha, phy);
+-                      sas_ha->notify_port_event(sas_phy, PORTE_HARD_RESET);
++                      sas_notify_port_event(sas_phy, PORTE_HARD_RESET);
+                       break;
+ 
+               default:
+@@ -567,7 +565,7 @@ static void escb_tasklet_complete(struct asd_ascb *ascb,
+               /* the device is gone */
+               sas_phy_disconnected(sas_phy);
+               asd_deform_port(asd_ha, phy);
+-              sas_ha->notify_port_event(sas_phy, PORTE_TIMER_EVENT);
++              sas_notify_port_event(sas_phy, PORTE_TIMER_EVENT);
+               break;
+       default:
+               ASD_DPRINTK("%s: phy%d: unknown event:0x%x\n", __func__,
+diff --git a/drivers/scsi/hisi_sas/hisi_sas_main.c b/drivers/scsi/hisi_sas/hisi_sas_main.c
+index 274ccf18ce2d..1feca45384c7 100644
+--- a/drivers/scsi/hisi_sas/hisi_sas_main.c
++++ b/drivers/scsi/hisi_sas/hisi_sas_main.c
+@@ -622,7 +622,6 @@ static void hisi_sas_bytes_dmaed(struct hisi_hba *hisi_hba, int phy_no)
+ {
+       struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
+       struct asd_sas_phy *sas_phy = &phy->sas_phy;
+-      struct sas_ha_struct *sas_ha;
+ 
+       if (!phy->phy_attached)
+               return;
+@@ -633,8 +632,7 @@ static void hisi_sas_bytes_dmaed(struct hisi_hba *hisi_hba, int phy_no)
+               return;
+       }
+ 
+-      sas_ha = &hisi_hba->sha;
+-      sas_ha->notify_phy_event(sas_phy, PHYE_OOB_DONE);
++      sas_notify_phy_event(sas_phy, PHYE_OOB_DONE);
+ 
+       if (sas_phy->phy) {
+               struct sas_phy *sphy = sas_phy->phy;
+@@ -662,7 +660,7 @@ static void hisi_sas_bytes_dmaed(struct hisi_hba *hisi_hba, int phy_no)
+       }
+ 
+       sas_phy->frame_rcvd_size = phy->frame_rcvd_size;
+-      sas_ha->notify_port_event(sas_phy, PORTE_BYTES_DMAED);
++      sas_notify_port_event(sas_phy, PORTE_BYTES_DMAED);
+ }
+ 
+ static struct hisi_sas_device *hisi_sas_alloc_dev(struct domain_device *device)
+@@ -1417,7 +1415,6 @@ static void hisi_sas_refresh_port_id(struct hisi_hba *hisi_hba)
+ 
+ static void hisi_sas_rescan_topology(struct hisi_hba *hisi_hba, u32 state)
+ {
+-      struct sas_ha_struct *sas_ha = &hisi_hba->sha;
+       struct asd_sas_port *_sas_port = NULL;
+       int phy_no;
+ 
+@@ -1438,7 +1435,7 @@ static void hisi_sas_rescan_topology(struct hisi_hba *hisi_hba, u32 state)
+                               _sas_port = sas_port;
+ 
+                               if (dev_is_expander(dev->dev_type))
+-                                      sas_ha->notify_port_event(sas_phy,
++                                      sas_notify_port_event(sas_phy,
+                                                       PORTE_BROADCAST_RCVD);
+                       }
+               } else {
+@@ -2200,7 +2197,6 @@ void hisi_sas_phy_down(struct hisi_hba *hisi_hba, int phy_no, int rdy)
+ {
+       struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
+       struct asd_sas_phy *sas_phy = &phy->sas_phy;
+-      struct sas_ha_struct *sas_ha = &hisi_hba->sha;
+       struct device *dev = hisi_hba->dev;
+ 
+       if (rdy) {
+@@ -2216,7 +2212,7 @@ void hisi_sas_phy_down(struct hisi_hba *hisi_hba, int phy_no, int rdy)
+                       return;
+               }
+               /* Phy down and not ready */
+-              sas_ha->notify_phy_event(sas_phy, PHYE_LOSS_OF_SIGNAL);
++              sas_notify_phy_event(sas_phy, PHYE_LOSS_OF_SIGNAL);
+               sas_phy_disconnected(sas_phy);
+ 
+               if (port) {
+diff --git a/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c
+index 45e866cb9164..22eecc89d41b 100644
+--- a/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c
++++ b/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c
+@@ -1408,7 +1408,6 @@ static irqreturn_t int_bcast_v1_hw(int irq, void *p)
+       struct hisi_sas_phy *phy = p;
+       struct hisi_hba *hisi_hba = phy->hisi_hba;
+       struct asd_sas_phy *sas_phy = &phy->sas_phy;
+-      struct sas_ha_struct *sha = &hisi_hba->sha;
+       struct device *dev = hisi_hba->dev;
+       int phy_no = sas_phy->id;
+       u32 irq_value;
+@@ -1424,7 +1423,7 @@ static irqreturn_t int_bcast_v1_hw(int irq, void *p)
+       }
+ 
+       if (!test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags))
+-              sha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
++              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+ 
+ end:
+       hisi_sas_phy_write32(hisi_hba, phy_no, CHL_INT2,
+diff --git a/drivers/scsi/hisi_sas/hisi_sas_v2_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v2_hw.c
+index b57177b52fac..6ef8730c61a6 100644
+--- a/drivers/scsi/hisi_sas/hisi_sas_v2_hw.c
++++ b/drivers/scsi/hisi_sas/hisi_sas_v2_hw.c
+@@ -2818,14 +2818,13 @@ static void phy_bcast_v2_hw(int phy_no, struct hisi_hba *hisi_hba)
+ {
+       struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
+       struct asd_sas_phy *sas_phy = &phy->sas_phy;
+-      struct sas_ha_struct *sas_ha = &hisi_hba->sha;
+       u32 bcast_status;
+ 
+       hisi_sas_phy_write32(hisi_hba, phy_no, SL_RX_BCAST_CHK_MSK, 1);
+       bcast_status = hisi_sas_phy_read32(hisi_hba, phy_no, RX_PRIMS_STATUS);
+       if ((bcast_status & RX_BCAST_CHG_MSK) &&
+           !test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags))
+-              sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
++              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+       hisi_sas_phy_write32(hisi_hba, phy_no, CHL_INT0,
+                            CHL_INT0_SL_RX_BCST_ACK_MSK);
+       hisi_sas_phy_write32(hisi_hba, phy_no, SL_RX_BCAST_CHK_MSK, 0);
+diff --git a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
+index 2cbd8a524eda..19170c7ac336 100644
+--- a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
++++ b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
+@@ -1598,14 +1598,13 @@ static irqreturn_t phy_bcast_v3_hw(int phy_no, struct hisi_hba *hisi_hba)
+ {
+       struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
+       struct asd_sas_phy *sas_phy = &phy->sas_phy;
+-      struct sas_ha_struct *sas_ha = &hisi_hba->sha;
+       u32 bcast_status;
+ 
+       hisi_sas_phy_write32(hisi_hba, phy_no, SL_RX_BCAST_CHK_MSK, 1);
+       bcast_status = hisi_sas_phy_read32(hisi_hba, phy_no, RX_PRIMS_STATUS);
+       if ((bcast_status & RX_BCAST_CHG_MSK) &&
+           !test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags))
+-              sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
++              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+       hisi_sas_phy_write32(hisi_hba, phy_no, CHL_INT0,
+                            CHL_INT0_SL_RX_BCST_ACK_MSK);
+       hisi_sas_phy_write32(hisi_hba, phy_no, SL_RX_BCAST_CHK_MSK, 0);
+diff --git a/drivers/scsi/isci/port.c b/drivers/scsi/isci/port.c
+index 1df45f028ea7..8d9349738067 100644
+--- a/drivers/scsi/isci/port.c
++++ b/drivers/scsi/isci/port.c
+@@ -164,7 +164,7 @@ static void isci_port_bc_change_received(struct isci_host *ihost,
+               "%s: isci_phy = %p, sas_phy = %p\n",
+               __func__, iphy, &iphy->sas_phy);
+ 
+-      ihost->sas_ha.notify_port_event(&iphy->sas_phy, PORTE_BROADCAST_RCVD);
++      sas_notify_port_event(&iphy->sas_phy, PORTE_BROADCAST_RCVD);
+       sci_port_bcn_enable(iport);
+ }
+ 
+@@ -223,8 +223,7 @@ static void isci_port_link_up(struct isci_host *isci_host,
+       /* Notify libsas that we have an address frame, if indeed
+        * we've found an SSP, SMP, or STP target */
+       if (success)
+-              isci_host->sas_ha.notify_port_event(&iphy->sas_phy,
+-                                                  PORTE_BYTES_DMAED);
++              sas_notify_port_event(&iphy->sas_phy, PORTE_BYTES_DMAED);
+ }
+ 
+ 
+@@ -270,7 +269,7 @@ static void isci_port_link_down(struct isci_host *isci_host,
+        * isci_port_deformed and isci_dev_gone functions.
+        */
+       sas_phy_disconnected(&isci_phy->sas_phy);
+-      isci_host->sas_ha.notify_phy_event(&isci_phy->sas_phy,
++      sas_notify_phy_event(&isci_phy->sas_phy,
+                                          PHYE_LOSS_OF_SIGNAL);
+ 
+       dev_dbg(&isci_host->pdev->dev,
+diff --git a/drivers/scsi/libsas/sas_event.c b/drivers/scsi/libsas/sas_event.c
+index a1852f6c042b..112a1b76f63b 100644
+--- a/drivers/scsi/libsas/sas_event.c
++++ b/drivers/scsi/libsas/sas_event.c
+@@ -109,7 +109,7 @@ void sas_enable_revalidation(struct sas_ha_struct *ha)
+ 
+               sas_phy = container_of(port->phy_list.next, struct asd_sas_phy,
+                               port_phy_el);
+-              ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
++              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+       }
+       mutex_unlock(&ha->disco_mutex);
+ }
+@@ -131,7 +131,7 @@ static void sas_phy_event_worker(struct work_struct *work)
+       sas_free_event(ev);
+ }
+ 
+-static int sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event)
++int sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event)
+ {
+       struct asd_sas_event *ev;
+       struct sas_ha_struct *ha = phy->ha;
+@@ -151,6 +151,7 @@ static int sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event)
+ 
+       return ret;
+ }
++EXPORT_SYMBOL_GPL(sas_notify_port_event);
+ 
+ int sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event)
+ {
+@@ -172,11 +173,5 @@ int sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event)
+ 
+       return ret;
+ }
++EXPORT_SYMBOL_GPL(sas_notify_phy_event);
+ 
+-int sas_init_events(struct sas_ha_struct *sas_ha)
+-{
+-      sas_ha->notify_port_event = sas_notify_port_event;
+-      sas_ha->notify_phy_event = sas_notify_phy_event;
+-
+-      return 0;
+-}
+diff --git a/drivers/scsi/libsas/sas_init.c b/drivers/scsi/libsas/sas_init.c
+index 21c43b18d5d5..6dc2505d36af 100644
+--- a/drivers/scsi/libsas/sas_init.c
++++ b/drivers/scsi/libsas/sas_init.c
+@@ -123,12 +123,6 @@ int sas_register_ha(struct sas_ha_struct *sas_ha)
+               goto Undo_phys;
+       }
+ 
+-      error = sas_init_events(sas_ha);
+-      if (error) {
+-              pr_notice("couldn't start event thread:%d\n", error);
+-              goto Undo_ports;
+-      }
+-
+       error = -ENOMEM;
+       snprintf(name, sizeof(name), "%s_event_q", dev_name(sas_ha->dev));
+       sas_ha->event_q = create_singlethread_workqueue(name);
+diff --git a/drivers/scsi/libsas/sas_internal.h b/drivers/scsi/libsas/sas_internal.h
+index 1f1d01901978..53ea32ed17a7 100644
+--- a/drivers/scsi/libsas/sas_internal.h
++++ b/drivers/scsi/libsas/sas_internal.h
+@@ -54,7 +54,6 @@ void sas_free_event(struct asd_sas_event *event);
+ int  sas_register_ports(struct sas_ha_struct *sas_ha);
+ void sas_unregister_ports(struct sas_ha_struct *sas_ha);
+ 
+-int  sas_init_events(struct sas_ha_struct *sas_ha);
+ void sas_disable_revalidation(struct sas_ha_struct *ha);
+ void sas_enable_revalidation(struct sas_ha_struct *ha);
+ void __sas_drain_work(struct sas_ha_struct *ha);
+diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c
+index a920eced92ec..e5e3e95f78b0 100644
+--- a/drivers/scsi/mvsas/mv_sas.c
++++ b/drivers/scsi/mvsas/mv_sas.c
+@@ -220,7 +220,7 @@ static void mvs_bytes_dmaed(struct mvs_info *mvi, int i)
+ {
+       struct mvs_phy *phy = &mvi->phy[i];
+       struct asd_sas_phy *sas_phy = &phy->sas_phy;
+-      struct sas_ha_struct *sas_ha;
++
+       if (!phy->phy_attached)
+               return;
+ 
+@@ -229,8 +229,7 @@ static void mvs_bytes_dmaed(struct mvs_info *mvi, int i)
+               return;
+       }
+ 
+-      sas_ha = mvi->sas;
+-      sas_ha->notify_phy_event(sas_phy, PHYE_OOB_DONE);
++      sas_notify_phy_event(sas_phy, PHYE_OOB_DONE);
+ 
+       if (sas_phy->phy) {
+               struct sas_phy *sphy = sas_phy->phy;
+@@ -262,8 +261,7 @@ static void mvs_bytes_dmaed(struct mvs_info *mvi, int i)
+ 
+       sas_phy->frame_rcvd_size = phy->frame_rcvd_size;
+ 
+-      mvi->sas->notify_port_event(sas_phy,
+-                                 PORTE_BYTES_DMAED);
++      sas_notify_port_event(sas_phy, PORTE_BYTES_DMAED);
+ }
+ 
+ void mvs_scan_start(struct Scsi_Host *shost)
+@@ -1880,7 +1878,6 @@ static void mvs_work_queue(struct work_struct *work)
+       struct mvs_info *mvi = mwq->mvi;
+       unsigned long flags;
+       u32 phy_no = (unsigned long) mwq->data;
+-      struct sas_ha_struct *sas_ha = mvi->sas;
+       struct mvs_phy *phy = &mvi->phy[phy_no];
+       struct asd_sas_phy *sas_phy = &phy->sas_phy;
+ 
+@@ -1895,7 +1892,7 @@ static void mvs_work_queue(struct work_struct *work)
+                       if (!(tmp & PHY_READY_MASK)) {
+                               sas_phy_disconnected(sas_phy);
+                               mvs_phy_disconnected(phy);
+-                              sas_ha->notify_phy_event(sas_phy,
++                              sas_notify_phy_event(sas_phy,
+                                       PHYE_LOSS_OF_SIGNAL);
+                               mv_dprintk("phy%d Removed Device\n", phy_no);
+                       } else {
+@@ -1908,8 +1905,7 @@ static void mvs_work_queue(struct work_struct *work)
+               }
+       } else if (mwq->handler & EXP_BRCT_CHG) {
+               phy->phy_event &= ~EXP_BRCT_CHG;
+-              sas_ha->notify_port_event(sas_phy,
+-                              PORTE_BROADCAST_RCVD);
++              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               mv_dprintk("phy%d Got Broadcast Change\n", phy_no);
+       }
+       list_del(&mwq->entry);
+diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
+index b72c0074b0e9..95ba1bd16db9 100644
+--- a/drivers/scsi/pm8001/pm8001_hwi.c
++++ b/drivers/scsi/pm8001/pm8001_hwi.c
+@@ -3179,7 +3179,7 @@ void pm8001_bytes_dmaed(struct pm8001_hba_info *pm8001_ha, int i)
+       pm8001_dbg(pm8001_ha, MSG, "phy %d byte dmaded.\n", i);
+ 
+       sas_phy->frame_rcvd_size = phy->frame_rcvd_size;
+-      pm8001_ha->sas->notify_port_event(sas_phy, PORTE_BYTES_DMAED);
++      sas_notify_port_event(sas_phy, PORTE_BYTES_DMAED);
+ }
+ 
+ /* Get the link rate speed  */
+@@ -3293,7 +3293,6 @@ hw_event_sas_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       u32 npip_portstate = le32_to_cpu(pPayload->npip_portstate);
+       u8 portstate = (u8)(npip_portstate & 0x0000000F);
+       struct pm8001_port *port = &pm8001_ha->port[port_id];
+-      struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+       struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+       unsigned long flags;
+       u8 deviceType = pPayload->sas_identify.dev_type;
+@@ -3337,7 +3336,7 @@ hw_event_sas_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       else if (phy->identify.device_type != SAS_PHY_UNUSED)
+               phy->identify.target_port_protocols = SAS_PROTOCOL_SMP;
+       phy->sas_phy.oob_mode = SAS_OOB_MODE;
+-      sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
++      sas_notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
+       spin_lock_irqsave(&phy->sas_phy.frame_rcvd_lock, flags);
+       memcpy(phy->frame_rcvd, &pPayload->sas_identify,
+               sizeof(struct sas_identify_frame)-4);
+@@ -3369,7 +3368,6 @@ hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       u32 npip_portstate = le32_to_cpu(pPayload->npip_portstate);
+       u8 portstate = (u8)(npip_portstate & 0x0000000F);
+       struct pm8001_port *port = &pm8001_ha->port[port_id];
+-      struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+       struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+       unsigned long flags;
+       pm8001_dbg(pm8001_ha, DEVIO, "HW_EVENT_SATA_PHY_UP port id = %d, phy id = %d\n",
+@@ -3381,7 +3379,7 @@ hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       phy->phy_type |= PORT_TYPE_SATA;
+       phy->phy_attached = 1;
+       phy->sas_phy.oob_mode = SATA_OOB_MODE;
+-      sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
++      sas_notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
+       spin_lock_irqsave(&phy->sas_phy.frame_rcvd_lock, flags);
+       memcpy(phy->frame_rcvd, ((u8 *)&pPayload->sata_fis - 4),
+               sizeof(struct dev_to_host_fis));
+@@ -3728,11 +3726,11 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               break;
+       case HW_EVENT_SATA_SPINUP_HOLD:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_SATA_SPINUP_HOLD\n");
+-              sas_ha->notify_phy_event(&phy->sas_phy, PHYE_SPINUP_HOLD);
++              sas_notify_phy_event(&phy->sas_phy, PHYE_SPINUP_HOLD);
+               break;
+       case HW_EVENT_PHY_DOWN:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_DOWN\n");
+-              sas_ha->notify_phy_event(&phy->sas_phy, PHYE_LOSS_OF_SIGNAL);
++              sas_notify_phy_event(&phy->sas_phy, PHYE_LOSS_OF_SIGNAL);
+               phy->phy_attached = 0;
+               phy->phy_state = 0;
+               hw_event_phy_down(pm8001_ha, piomb);
+@@ -3741,7 +3739,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_INVALID\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       /* the broadcast change primitive received, tell the LIBSAS this event
+       to revalidate the sas domain*/
+@@ -3752,20 +3750,20 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+               sas_phy->sas_prim = HW_EVENT_BROADCAST_CHANGE;
+               spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+-              sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
++              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_PHY_ERROR:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_ERROR\n");
+               sas_phy_disconnected(&phy->sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_ERROR);
++              sas_notify_phy_event(&phy->sas_phy, PHYE_OOB_ERROR);
+               break;
+       case HW_EVENT_BROADCAST_EXP:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_BROADCAST_EXP\n");
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+               sas_phy->sas_prim = HW_EVENT_BROADCAST_EXP;
+               spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+-              sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
++              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_LINK_ERR_INVALID_DWORD:
+               pm8001_dbg(pm8001_ha, MSG,
+@@ -3774,7 +3772,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+                       HW_EVENT_LINK_ERR_INVALID_DWORD, port_id, phy_id, 0, 0);
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_LINK_ERR_DISPARITY_ERROR:
+               pm8001_dbg(pm8001_ha, MSG,
+@@ -3784,7 +3782,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+                       port_id, phy_id, 0, 0);
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_LINK_ERR_CODE_VIOLATION:
+               pm8001_dbg(pm8001_ha, MSG,
+@@ -3794,7 +3792,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+                       port_id, phy_id, 0, 0);
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH:
+               pm8001_dbg(pm8001_ha, MSG,
+@@ -3804,7 +3802,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+                       port_id, phy_id, 0, 0);
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_MALFUNCTION:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_MALFUNCTION\n");
+@@ -3814,7 +3812,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+               sas_phy->sas_prim = HW_EVENT_BROADCAST_SES;
+               spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+-              sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
++              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_INBOUND_CRC_ERROR:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_INBOUND_CRC_ERROR\n");
+@@ -3824,13 +3822,13 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               break;
+       case HW_EVENT_HARD_RESET_RECEIVED:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_HARD_RESET_RECEIVED\n");
+-              sas_ha->notify_port_event(sas_phy, PORTE_HARD_RESET);
++              sas_notify_port_event(sas_phy, PORTE_HARD_RESET);
+               break;
+       case HW_EVENT_ID_FRAME_TIMEOUT:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_ID_FRAME_TIMEOUT\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_LINK_ERR_PHY_RESET_FAILED:
+               pm8001_dbg(pm8001_ha, MSG,
+@@ -3840,20 +3838,20 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+                       port_id, phy_id, 0, 0);
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_PORT_RESET_TIMER_TMO:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_RESET_TIMER_TMO\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_PORT_RECOVERY_TIMER_TMO:
+               pm8001_dbg(pm8001_ha, MSG,
+                          "HW_EVENT_PORT_RECOVERY_TIMER_TMO\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_PORT_RECOVER:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_RECOVER\n");
+diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
+index 7a6d34267585..474468df2a78 100644
+--- a/drivers/scsi/pm8001/pm8001_sas.c
++++ b/drivers/scsi/pm8001/pm8001_sas.c
+@@ -158,7 +158,6 @@ int pm8001_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
+       int rc = 0, phy_id = sas_phy->id;
+       struct pm8001_hba_info *pm8001_ha = NULL;
+       struct sas_phy_linkrates *rates;
+-      struct sas_ha_struct *sas_ha;
+       struct pm8001_phy *phy;
+       DECLARE_COMPLETION_ONSTACK(completion);
+       unsigned long flags;
+@@ -207,18 +206,16 @@ int pm8001_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
+               if (pm8001_ha->chip_id != chip_8001) {
+                       if (pm8001_ha->phy[phy_id].phy_state ==
+                               PHY_STATE_LINK_UP_SPCV) {
+-                              sas_ha = pm8001_ha->sas;
+                               sas_phy_disconnected(&phy->sas_phy);
+-                              sas_ha->notify_phy_event(&phy->sas_phy,
++                              sas_notify_phy_event(&phy->sas_phy,
+                                       PHYE_LOSS_OF_SIGNAL);
+                               phy->phy_attached = 0;
+                       }
+               } else {
+                       if (pm8001_ha->phy[phy_id].phy_state ==
+                               PHY_STATE_LINK_UP_SPC) {
+-                              sas_ha = pm8001_ha->sas;
+                               sas_phy_disconnected(&phy->sas_phy);
+-                              sas_ha->notify_phy_event(&phy->sas_phy,
++                              sas_notify_phy_event(&phy->sas_phy,
+                                       PHYE_LOSS_OF_SIGNAL);
+                               phy->phy_attached = 0;
+                       }
+diff --git a/drivers/scsi/pm8001/pm80xx_hwi.c b/drivers/scsi/pm8001/pm80xx_hwi.c
+index 990501be47e7..055f7649676e 100644
+--- a/drivers/scsi/pm8001/pm80xx_hwi.c
++++ b/drivers/scsi/pm8001/pm80xx_hwi.c
+@@ -3242,7 +3242,6 @@ hw_event_sas_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       u8 portstate = (u8)(phyid_npip_portstate & 0x0000000F);
+ 
+       struct pm8001_port *port = &pm8001_ha->port[port_id];
+-      struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+       struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+       unsigned long flags;
+       u8 deviceType = pPayload->sas_identify.dev_type;
+@@ -3287,7 +3286,7 @@ hw_event_sas_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       else if (phy->identify.device_type != SAS_PHY_UNUSED)
+               phy->identify.target_port_protocols = SAS_PROTOCOL_SMP;
+       phy->sas_phy.oob_mode = SAS_OOB_MODE;
+-      sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
++      sas_notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
+       spin_lock_irqsave(&phy->sas_phy.frame_rcvd_lock, flags);
+       memcpy(phy->frame_rcvd, &pPayload->sas_identify,
+               sizeof(struct sas_identify_frame)-4);
+@@ -3321,7 +3320,6 @@ hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       u8 portstate = (u8)(phyid_npip_portstate & 0x0000000F);
+ 
+       struct pm8001_port *port = &pm8001_ha->port[port_id];
+-      struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+       struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+       unsigned long flags;
+       pm8001_dbg(pm8001_ha, DEVIO,
+@@ -3335,7 +3333,7 @@ hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       phy->phy_type |= PORT_TYPE_SATA;
+       phy->phy_attached = 1;
+       phy->sas_phy.oob_mode = SATA_OOB_MODE;
+-      sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
++      sas_notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
+       spin_lock_irqsave(&phy->sas_phy.frame_rcvd_lock, flags);
+       memcpy(phy->frame_rcvd, ((u8 *)&pPayload->sata_fis - 4),
+               sizeof(struct dev_to_host_fis));
+@@ -3417,11 +3415,8 @@ hw_event_phy_down(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               break;
+ 
+       }
+-      if (port_sata && (portstate != PORT_IN_RESET)) {
+-              struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+-
+-              sas_ha->notify_phy_event(&phy->sas_phy, PHYE_LOSS_OF_SIGNAL);
+-      }
++      if (port_sata && (portstate != PORT_IN_RESET))
++              sas_notify_phy_event(&phy->sas_phy, PHYE_LOSS_OF_SIGNAL);
+ }
+ 
+ static int mpi_phy_start_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+@@ -3519,7 +3514,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               break;
+       case HW_EVENT_SATA_SPINUP_HOLD:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_SATA_SPINUP_HOLD\n");
+-              sas_ha->notify_phy_event(&phy->sas_phy, PHYE_SPINUP_HOLD);
++              sas_notify_phy_event(&phy->sas_phy, PHYE_SPINUP_HOLD);
+               break;
+       case HW_EVENT_PHY_DOWN:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_DOWN\n");
+@@ -3535,7 +3530,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_INVALID\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       /* the broadcast change primitive received, tell the LIBSAS this event
+       to revalidate the sas domain*/
+@@ -3546,20 +3541,20 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+               sas_phy->sas_prim = HW_EVENT_BROADCAST_CHANGE;
+               spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+-              sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
++              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_PHY_ERROR:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_ERROR\n");
+               sas_phy_disconnected(&phy->sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_ERROR);
++              sas_notify_phy_event(&phy->sas_phy, PHYE_OOB_ERROR);
+               break;
+       case HW_EVENT_BROADCAST_EXP:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_BROADCAST_EXP\n");
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+               sas_phy->sas_prim = HW_EVENT_BROADCAST_EXP;
+               spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+-              sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
++              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_LINK_ERR_INVALID_DWORD:
+               pm8001_dbg(pm8001_ha, MSG,
+@@ -3596,7 +3591,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+               sas_phy->sas_prim = HW_EVENT_BROADCAST_SES;
+               spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+-              sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
++              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_INBOUND_CRC_ERROR:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_INBOUND_CRC_ERROR\n");
+@@ -3606,13 +3601,13 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               break;
+       case HW_EVENT_HARD_RESET_RECEIVED:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_HARD_RESET_RECEIVED\n");
+-              sas_ha->notify_port_event(sas_phy, PORTE_HARD_RESET);
++              sas_notify_port_event(sas_phy, PORTE_HARD_RESET);
+               break;
+       case HW_EVENT_ID_FRAME_TIMEOUT:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_ID_FRAME_TIMEOUT\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_LINK_ERR_PHY_RESET_FAILED:
+               pm8001_dbg(pm8001_ha, MSG,
+@@ -3622,7 +3617,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       port_id, phy_id, 0, 0);
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_PORT_RESET_TIMER_TMO:
+               pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_RESET_TIMER_TMO\n");
+@@ -3630,7 +3625,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       port_id, phy_id, 0, 0);
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+-              sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
++              sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               if (pm8001_ha->phy[phy_id].reset_completion) {
+                       pm8001_ha->phy[phy_id].port_reset_status =
+                                       PORT_RESET_TMO;
+@@ -3647,7 +3642,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               for (i = 0; i < pm8001_ha->chip->n_phy; i++) {
+                       if (port->wide_port_phymap & (1 << i)) {
+                               phy = &pm8001_ha->phy[i];
+-                              sas_ha->notify_phy_event(&phy->sas_phy,
++                              sas_notify_phy_event(&phy->sas_phy,
+                                               PHYE_LOSS_OF_SIGNAL);
+                               port->wide_port_phymap &= ~(1 << i);
+                       }
+diff --git a/include/scsi/libsas.h b/include/scsi/libsas.h
+index 4e2d61e8fb1e..3387149502e9 100644
+--- a/include/scsi/libsas.h
++++ b/include/scsi/libsas.h
+@@ -391,10 +391,6 @@ struct sas_ha_struct {
+       int strict_wide_ports; /* both sas_addr and attached_sas_addr must match
+                               * their siblings when forming wide ports */
+ 
+-      /* LLDD calls these to notify the class of an event. */
+-      int (*notify_port_event)(struct asd_sas_phy *, enum port_event);
+-      int (*notify_phy_event)(struct asd_sas_phy *, enum phy_event);
+-
+       void *lldd_ha;            /* not touched by sas class code */
+ 
+       struct list_head eh_done_q;  /* complete via scsi_eh_flush_done_q */
+@@ -706,4 +702,7 @@ struct sas_phy *sas_get_local_phy(struct domain_device *dev);
+ 
+ int sas_request_addr(struct Scsi_Host *shost, u8 *addr);
+ 
++int sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event);
++int sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event);
++
+ #endif /* _SASLIB_H_ */
+-- 
+2.30.1
+

diff --git a/queue-5.10/scsi-mvsas-pass-gfp_t-flags-to-libsas-event-notifier.patch b/queue-5.10/scsi-mvsas-pass-gfp_t-flags-to-libsas-event-notifier.patch
new file mode 100644 (file)
index 0000000..1c28309
--- /dev/null
+++ b/queue-5.10/scsi-mvsas-pass-gfp_t-flags-to-libsas-event-notifier.patch
@@ -0,0 +1,142 @@
+From b45dcd8b2549e8341246bb2d802e3ca400ba1e8a Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 18 Jan 2021 11:09:40 +0100
+Subject: scsi: mvsas: Pass gfp_t flags to libsas event notifiers
+
+From: Ahmed S. Darwish <a.darwish@linutronix.de>
+
+[ Upstream commit feb18e900f0048001ff375dca639eaa327ab3c1b ]
+
+mvsas calls the non _gfp version of the libsas event notifiers API, leading
+to the buggy call chains below:
+
+  mvsas/mv_sas.c: mvs_work_queue() [process context]
+  spin_lock_irqsave(mvs_info::lock, )
+    -> libsas/sas_event.c: sas_notify_phy_event()
+      -> sas_alloc_event()
+        -> in_interrupt() = false
+          -> invalid GFP_KERNEL allocation
+    -> libsas/sas_event.c: sas_notify_port_event()
+      -> sas_alloc_event()
+        -> in_interrupt() = false
+          -> invalid GFP_KERNEL allocation
+
+Use the new event notifiers API instead, which requires callers to
+explicitly pass the gfp_t memory allocation flags.
+
+Below are context analysis for the modified functions:
+
+=> mvs_bytes_dmaed():
+
+Since it is invoked from both process and atomic contexts, let its callers
+pass the gfp_t flags. Call chains:
+
+  scsi_scan.c: do_scsi_scan_host() [has msleep()]
+    -> shost->hostt->scan_start()
+    -> [mvsas/mv_init.c: Scsi_Host::scsi_host_template .scan_start = mvs_scan_start()]
+    -> mvsas/mv_sas.c: mvs_scan_start()
+      -> mvs_bytes_dmaed(..., GFP_KERNEL)
+
+  mvsas/mv_sas.c: mvs_work_queue()
+  spin_lock_irqsave(mvs_info::lock,)
+    -> mvs_bytes_dmaed(..., GFP_ATOMIC)
+
+  mvsas/mv_64xx.c: mvs_64xx_isr() || mvsas/mv_94xx.c: mvs_94xx_isr()
+    -> mvsas/mv_chips.h: mvs_int_full()
+      -> mvsas/mv_sas.c: mvs_int_port()
+        -> mvs_bytes_dmaed(..., GFP_ATOMIC);
+
+=> mvs_work_queue():
+
+Invoked from process context, but it calls all the libsas event notifier
+APIs under a spin_lock_irqsave(). Pass GFP_ATOMIC.
+
+Link: https://lore.kernel.org/r/20210118100955.1761652-5-a.darwish@linutronix.de
+Fixes: 1c393b970e0f ("scsi: libsas: Use dynamic alloced work to avoid sas event lost")
+Cc: Jason Yan <yanaijie@huawei.com>
+Reviewed-by: John Garry <john.garry@huawei.com>
+Signed-off-by: Ahmed S. Darwish <a.darwish@linutronix.de>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/scsi/mvsas/mv_sas.c | 19 ++++++++++---------
+ 1 file changed, 10 insertions(+), 9 deletions(-)
+
+diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c
+index e5e3e95f78b0..484e01428da2 100644
+--- a/drivers/scsi/mvsas/mv_sas.c
++++ b/drivers/scsi/mvsas/mv_sas.c
+@@ -216,7 +216,7 @@ void mvs_set_sas_addr(struct mvs_info *mvi, int port_id, u32 off_lo,
+       MVS_CHIP_DISP->write_port_cfg_data(mvi, port_id, hi);
+ }
+ 
+-static void mvs_bytes_dmaed(struct mvs_info *mvi, int i)
++static void mvs_bytes_dmaed(struct mvs_info *mvi, int i, gfp_t gfp_flags)
+ {
+       struct mvs_phy *phy = &mvi->phy[i];
+       struct asd_sas_phy *sas_phy = &phy->sas_phy;
+@@ -229,7 +229,7 @@ static void mvs_bytes_dmaed(struct mvs_info *mvi, int i)
+               return;
+       }
+ 
+-      sas_notify_phy_event(sas_phy, PHYE_OOB_DONE);
++      sas_notify_phy_event_gfp(sas_phy, PHYE_OOB_DONE, gfp_flags);
+ 
+       if (sas_phy->phy) {
+               struct sas_phy *sphy = sas_phy->phy;
+@@ -261,7 +261,7 @@ static void mvs_bytes_dmaed(struct mvs_info *mvi, int i)
+ 
+       sas_phy->frame_rcvd_size = phy->frame_rcvd_size;
+ 
+-      sas_notify_port_event(sas_phy, PORTE_BYTES_DMAED);
++      sas_notify_port_event_gfp(sas_phy, PORTE_BYTES_DMAED, gfp_flags);
+ }
+ 
+ void mvs_scan_start(struct Scsi_Host *shost)
+@@ -277,7 +277,7 @@ void mvs_scan_start(struct Scsi_Host *shost)
+       for (j = 0; j < core_nr; j++) {
+               mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[j];
+               for (i = 0; i < mvi->chip->n_phy; ++i)
+-                      mvs_bytes_dmaed(mvi, i);
++                      mvs_bytes_dmaed(mvi, i, GFP_KERNEL);
+       }
+       mvs_prv->scan_finished = 1;
+ }
+@@ -1892,20 +1892,21 @@ static void mvs_work_queue(struct work_struct *work)
+                       if (!(tmp & PHY_READY_MASK)) {
+                               sas_phy_disconnected(sas_phy);
+                               mvs_phy_disconnected(phy);
+-                              sas_notify_phy_event(sas_phy,
+-                                      PHYE_LOSS_OF_SIGNAL);
++                              sas_notify_phy_event_gfp(sas_phy,
++                                      PHYE_LOSS_OF_SIGNAL, GFP_ATOMIC);
+                               mv_dprintk("phy%d Removed Device\n", phy_no);
+                       } else {
+                               MVS_CHIP_DISP->detect_porttype(mvi, phy_no);
+                               mvs_update_phyinfo(mvi, phy_no, 1);
+-                              mvs_bytes_dmaed(mvi, phy_no);
++                              mvs_bytes_dmaed(mvi, phy_no, GFP_ATOMIC);
+                               mvs_port_notify_formed(sas_phy, 0);
+                               mv_dprintk("phy%d Attached Device\n", phy_no);
+                       }
+               }
+       } else if (mwq->handler & EXP_BRCT_CHG) {
+               phy->phy_event &= ~EXP_BRCT_CHG;
+-              sas_notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
++              sas_notify_port_event_gfp(sas_phy,
++                              PORTE_BROADCAST_RCVD, GFP_ATOMIC);
+               mv_dprintk("phy%d Got Broadcast Change\n", phy_no);
+       }
+       list_del(&mwq->entry);
+@@ -2022,7 +2023,7 @@ void mvs_int_port(struct mvs_info *mvi, int phy_no, u32 events)
+                               mdelay(10);
+                       }
+ 
+-                      mvs_bytes_dmaed(mvi, phy_no);
++                      mvs_bytes_dmaed(mvi, phy_no, GFP_ATOMIC);
+                       /* whether driver is going to handle hot plug */
+                       if (phy->phy_event & PHY_PLUG_OUT) {
+                               mvs_port_notify_formed(&phy->sas_phy, 0);
+-- 
+2.30.1
+

diff --git a/queue-5.10/scsi-pm8001-neaten-debug-logging-macros-and-uses.patch b/queue-5.10/scsi-pm8001-neaten-debug-logging-macros-and-uses.patch
new file mode 100644 (file)
index 0000000..eae958f
--- /dev/null
+++ b/queue-5.10/scsi-pm8001-neaten-debug-logging-macros-and-uses.patch
@@ -0,0 +1,7032 @@
+From 0a95816ac190527c8d62f8d1914e65fba0a7a3e4 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Fri, 20 Nov 2020 15:16:09 -0800
+Subject: scsi: pm8001: Neaten debug logging macros and uses
+
+From: Joe Perches <joe@perches.com>
+
+[ Upstream commit 1b5d2793283dcb97b401b3b2c02b8a94eee29af1 ]
+
+Every PM8001_<FOO>_DBG macro uses an internal call to pm8001_printk.
+
+Convert all uses of:
+
+       PM8001_<FOO>_DBG(hba, pm8001_printk(fmt, ...))
+to
+       pm8001_dbg(hba, <FOO>, fmt, ...)
+
+so the visual complexity of each macro is reduced.
+
+The repetitive macro definitions are converted to a single pm8001_dbg and
+the level is concatenated using PM8001_##level##_LOGGING for the specific
+level test.
+
+Done with coccinelle, checkpatch and a little typing of the new macro
+definition.
+
+Miscellanea:
+
+ - Coalesce formats
+
+ - Realign arguments
+
+ - Add missing terminating newlines to formats
+
+ - Remove trailing spaces from formats
+
+ - Change defective loop with printk(KERN_INFO... to emit a 16 byte hex
+   block to %p16h
+
+Link: https://lore.kernel.org/r/49f36a93af7752b613d03c89a87078243567fd9a.1605914030.git.joe@perches.com
+Reported-by: kernel test robot <lkp@intel.com>
+Acked-by: Jack Wang <jinpu.wang@cloud.ionos.com>
+Signed-off-by: Joe Perches <joe@perches.com>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/scsi/pm8001/pm8001_ctl.c  |    7 +-
+ drivers/scsi/pm8001/pm8001_hwi.c  | 1370 ++++++++++---------------
+ drivers/scsi/pm8001/pm8001_init.c |   91 +-
+ drivers/scsi/pm8001/pm8001_sas.c  |  132 +--
+ drivers/scsi/pm8001/pm8001_sas.h  |   45 +-
+ drivers/scsi/pm8001/pm80xx_hwi.c  | 1596 ++++++++++++-----------------
+ 6 files changed, 1354 insertions(+), 1887 deletions(-)
+
+diff --git a/drivers/scsi/pm8001/pm8001_ctl.c b/drivers/scsi/pm8001/pm8001_ctl.c
+index 3587f7c8a428..12035baf0997 100644
+--- a/drivers/scsi/pm8001/pm8001_ctl.c
++++ b/drivers/scsi/pm8001/pm8001_ctl.c
+@@ -841,10 +841,9 @@ static ssize_t pm8001_store_update_fw(struct device *cdev,
+                              pm8001_ha->dev);
+ 
+       if (ret) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk(
+-                      "Failed to load firmware image file %s, error %d\n",
+-                      filename_ptr, ret));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "Failed to load firmware image file %s, error %d\n",
++                         filename_ptr, ret);
+               pm8001_ha->fw_status = FAIL_OPEN_BIOS_FILE;
+               goto out;
+       }
+diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
+index 2054c2b03d92..b72c0074b0e9 100644
+--- a/drivers/scsi/pm8001/pm8001_hwi.c
++++ b/drivers/scsi/pm8001/pm8001_hwi.c
+@@ -400,9 +400,9 @@ int pm8001_bar4_shift(struct pm8001_hba_info *pm8001_ha, u32 shiftValue)
+       } while ((regVal != shiftValue) && time_before(jiffies, start));
+ 
+       if (regVal != shiftValue) {
+-              PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("TIMEOUT:SPC_IBW_AXI_TRANSLATION_LOW"
+-                      " = 0x%x\n", regVal));
++              pm8001_dbg(pm8001_ha, INIT,
++                         "TIMEOUT:SPC_IBW_AXI_TRANSLATION_LOW = 0x%x\n",
++                         regVal);
+               return -1;
+       }
+       return 0;
+@@ -623,12 +623,10 @@ static void init_pci_device_addresses(struct pm8001_hba_info *pm8001_ha)
+ 
+       value = pm8001_cr32(pm8001_ha, 0, 0x44);
+       offset = value & 0x03FFFFFF;
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("Scratchpad 0 Offset: %x\n", offset));
++      pm8001_dbg(pm8001_ha, INIT, "Scratchpad 0 Offset: %x\n", offset);
+       pcilogic = (value & 0xFC000000) >> 26;
+       pcibar = get_pci_bar_index(pcilogic);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("Scratchpad 0 PCI BAR: %d\n", pcibar));
++      pm8001_dbg(pm8001_ha, INIT, "Scratchpad 0 PCI BAR: %d\n", pcibar);
+       pm8001_ha->main_cfg_tbl_addr = base_addr =
+               pm8001_ha->io_mem[pcibar].memvirtaddr + offset;
+       pm8001_ha->general_stat_tbl_addr =
+@@ -652,16 +650,15 @@ static int pm8001_chip_init(struct pm8001_hba_info *pm8001_ha)
+       * as this is shared with BIOS data */
+       if (deviceid == 0x8081 || deviceid == 0x0042) {
+               if (-1 == pm8001_bar4_shift(pm8001_ha, GSM_SM_BASE)) {
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("Shift Bar4 to 0x%x failed\n",
+-                                      GSM_SM_BASE));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "Shift Bar4 to 0x%x failed\n",
++                                 GSM_SM_BASE);
+                       return -1;
+               }
+       }
+       /* check the firmware status */
+       if (-1 == check_fw_ready(pm8001_ha)) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Firmware is not ready!\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "Firmware is not ready!\n");
+               return -EBUSY;
+       }
+ 
+@@ -686,8 +683,7 @@ static int pm8001_chip_init(struct pm8001_hba_info *pm8001_ha)
+       }
+       /* notify firmware update finished and check initialization status */
+       if (0 == mpi_init_check(pm8001_ha)) {
+-              PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("MPI initialize successful!\n"));
++              pm8001_dbg(pm8001_ha, INIT, "MPI initialize successful!\n");
+       } else
+               return -EBUSY;
+       /*This register is a 16-bit timer with a resolution of 1us. This is the
+@@ -709,9 +705,9 @@ static int mpi_uninit_check(struct pm8001_hba_info *pm8001_ha)
+       pci_read_config_word(pm8001_ha->pdev, PCI_DEVICE_ID, &deviceid);
+       if (deviceid == 0x8081 || deviceid == 0x0042) {
+               if (-1 == pm8001_bar4_shift(pm8001_ha, GSM_SM_BASE)) {
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("Shift Bar4 to 0x%x failed\n",
+-                                      GSM_SM_BASE));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "Shift Bar4 to 0x%x failed\n",
++                                 GSM_SM_BASE);
+                       return -1;
+               }
+       }
+@@ -729,8 +725,8 @@ static int mpi_uninit_check(struct pm8001_hba_info *pm8001_ha)
+       } while ((value != 0) && (--max_wait_count));
+ 
+       if (!max_wait_count) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("TIMEOUT:IBDB value/=0x%x\n", value));
++              pm8001_dbg(pm8001_ha, FAIL, "TIMEOUT:IBDB value/=0x%x\n",
++                         value);
+               return -1;
+       }
+ 
+@@ -747,9 +743,8 @@ static int mpi_uninit_check(struct pm8001_hba_info *pm8001_ha)
+                       break;
+       } while (--max_wait_count);
+       if (!max_wait_count) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk(" TIME OUT MPI State = 0x%x\n",
+-                              gst_len_mpistate & GST_MPI_STATE_MASK));
++              pm8001_dbg(pm8001_ha, FAIL, " TIME OUT MPI State = 0x%x\n",
++                         gst_len_mpistate & GST_MPI_STATE_MASK);
+               return -1;
+       }
+       return 0;
+@@ -763,25 +758,23 @@ static u32 soft_reset_ready_check(struct pm8001_hba_info *pm8001_ha)
+ {
+       u32 regVal, regVal1, regVal2;
+       if (mpi_uninit_check(pm8001_ha) != 0) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("MPI state is not ready\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "MPI state is not ready\n");
+               return -1;
+       }
+       /* read the scratch pad 2 register bit 2 */
+       regVal = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2)
+               & SCRATCH_PAD2_FWRDY_RST;
+       if (regVal == SCRATCH_PAD2_FWRDY_RST) {
+-              PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("Firmware is ready for reset .\n"));
++              pm8001_dbg(pm8001_ha, INIT, "Firmware is ready for reset.\n");
+       } else {
+               unsigned long flags;
+               /* Trigger NMI twice via RB6 */
+               spin_lock_irqsave(&pm8001_ha->lock, flags);
+               if (-1 == pm8001_bar4_shift(pm8001_ha, RB6_ACCESS_REG)) {
+                       spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("Shift Bar4 to 0x%x failed\n",
+-                                      RB6_ACCESS_REG));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "Shift Bar4 to 0x%x failed\n",
++                                 RB6_ACCESS_REG);
+                       return -1;
+               }
+               pm8001_cw32(pm8001_ha, 2, SPC_RB6_OFFSET,
+@@ -794,16 +787,14 @@ static u32 soft_reset_ready_check(struct pm8001_hba_info *pm8001_ha)
+               if (regVal != SCRATCH_PAD2_FWRDY_RST) {
+                       regVal1 = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
+                       regVal2 = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2);
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("TIMEOUT:MSGU_SCRATCH_PAD1"
+-                              "=0x%x, MSGU_SCRATCH_PAD2=0x%x\n",
+-                              regVal1, regVal2));
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("SCRATCH_PAD0 value = 0x%x\n",
+-                              pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_0)));
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("SCRATCH_PAD3 value = 0x%x\n",
+-                              pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_3)));
++                      pm8001_dbg(pm8001_ha, FAIL, "TIMEOUT:MSGU_SCRATCH_PAD1=0x%x, MSGU_SCRATCH_PAD2=0x%x\n",
++                                 regVal1, regVal2);
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "SCRATCH_PAD0 value = 0x%x\n",
++                                 pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_0));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "SCRATCH_PAD3 value = 0x%x\n",
++                                 pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_3));
+                       spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                       return -1;
+               }
+@@ -828,7 +819,7 @@ pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+ 
+       /* step1: Check FW is ready for soft reset */
+       if (soft_reset_ready_check(pm8001_ha) != 0) {
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("FW is not ready\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "FW is not ready\n");
+               return -1;
+       }
+ 
+@@ -838,46 +829,43 @@ pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+       spin_lock_irqsave(&pm8001_ha->lock, flags);
+       if (-1 == pm8001_bar4_shift(pm8001_ha, MBIC_AAP1_ADDR_BASE)) {
+               spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Shift Bar4 to 0x%x failed\n",
+-                      MBIC_AAP1_ADDR_BASE));
++              pm8001_dbg(pm8001_ha, FAIL, "Shift Bar4 to 0x%x failed\n",
++                         MBIC_AAP1_ADDR_BASE);
+               return -1;
+       }
+       regVal = pm8001_cr32(pm8001_ha, 2, MBIC_NMI_ENABLE_VPE0_IOP);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("MBIC - NMI Enable VPE0 (IOP)= 0x%x\n", regVal));
++      pm8001_dbg(pm8001_ha, INIT, "MBIC - NMI Enable VPE0 (IOP)= 0x%x\n",
++                 regVal);
+       pm8001_cw32(pm8001_ha, 2, MBIC_NMI_ENABLE_VPE0_IOP, 0x0);
+       /* map 0x70000 to BAR4(0x20), BAR2(win) */
+       if (-1 == pm8001_bar4_shift(pm8001_ha, MBIC_IOP_ADDR_BASE)) {
+               spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Shift Bar4 to 0x%x failed\n",
+-                      MBIC_IOP_ADDR_BASE));
++              pm8001_dbg(pm8001_ha, FAIL, "Shift Bar4 to 0x%x failed\n",
++                         MBIC_IOP_ADDR_BASE);
+               return -1;
+       }
+       regVal = pm8001_cr32(pm8001_ha, 2, MBIC_NMI_ENABLE_VPE0_AAP1);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("MBIC - NMI Enable VPE0 (AAP1)= 0x%x\n", regVal));
++      pm8001_dbg(pm8001_ha, INIT, "MBIC - NMI Enable VPE0 (AAP1)= 0x%x\n",
++                 regVal);
+       pm8001_cw32(pm8001_ha, 2, MBIC_NMI_ENABLE_VPE0_AAP1, 0x0);
+ 
+       regVal = pm8001_cr32(pm8001_ha, 1, PCIE_EVENT_INTERRUPT_ENABLE);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("PCIE -Event Interrupt Enable = 0x%x\n", regVal));
++      pm8001_dbg(pm8001_ha, INIT, "PCIE -Event Interrupt Enable = 0x%x\n",
++                 regVal);
+       pm8001_cw32(pm8001_ha, 1, PCIE_EVENT_INTERRUPT_ENABLE, 0x0);
+ 
+       regVal = pm8001_cr32(pm8001_ha, 1, PCIE_EVENT_INTERRUPT);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("PCIE - Event Interrupt  = 0x%x\n", regVal));
++      pm8001_dbg(pm8001_ha, INIT, "PCIE - Event Interrupt  = 0x%x\n",
++                 regVal);
+       pm8001_cw32(pm8001_ha, 1, PCIE_EVENT_INTERRUPT, regVal);
+ 
+       regVal = pm8001_cr32(pm8001_ha, 1, PCIE_ERROR_INTERRUPT_ENABLE);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("PCIE -Error Interrupt Enable = 0x%x\n", regVal));
++      pm8001_dbg(pm8001_ha, INIT, "PCIE -Error Interrupt Enable = 0x%x\n",
++                 regVal);
+       pm8001_cw32(pm8001_ha, 1, PCIE_ERROR_INTERRUPT_ENABLE, 0x0);
+ 
+       regVal = pm8001_cr32(pm8001_ha, 1, PCIE_ERROR_INTERRUPT);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("PCIE - Error Interrupt = 0x%x\n", regVal));
++      pm8001_dbg(pm8001_ha, INIT, "PCIE - Error Interrupt = 0x%x\n", regVal);
+       pm8001_cw32(pm8001_ha, 1, PCIE_ERROR_INTERRUPT, regVal);
+ 
+       /* read the scratch pad 1 register bit 2 */
+@@ -893,15 +881,13 @@ pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+       /* map 0x0700000 to BAR4(0x20), BAR2(win) */
+       if (-1 == pm8001_bar4_shift(pm8001_ha, GSM_ADDR_BASE)) {
+               spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Shift Bar4 to 0x%x failed\n",
+-                      GSM_ADDR_BASE));
++              pm8001_dbg(pm8001_ha, FAIL, "Shift Bar4 to 0x%x failed\n",
++                         GSM_ADDR_BASE);
+               return -1;
+       }
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x0(0x00007b88)-GSM Configuration and"
+-              " Reset = 0x%x\n",
+-              pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET)));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "GSM 0x0(0x00007b88)-GSM Configuration and Reset = 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET));
+ 
+       /* step 3: host read GSM Configuration and Reset register */
+       regVal = pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET);
+@@ -916,59 +902,52 @@ pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+       regVal &= ~(0x00003b00);
+       /* host write GSM Configuration and Reset register */
+       pm8001_cw32(pm8001_ha, 2, GSM_CONFIG_RESET, regVal);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x0 (0x00007b88 ==> 0x00004088) - GSM "
+-              "Configuration and Reset is set to = 0x%x\n",
+-              pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET)));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "GSM 0x0 (0x00007b88 ==> 0x00004088) - GSM Configuration and Reset is set to = 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET));
+ 
+       /* step 4: */
+       /* disable GSM - Read Address Parity Check */
+       regVal1 = pm8001_cr32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x700038 - Read Address Parity Check "
+-              "Enable = 0x%x\n", regVal1));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "GSM 0x700038 - Read Address Parity Check Enable = 0x%x\n",
++                 regVal1);
+       pm8001_cw32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK, 0x0);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x700038 - Read Address Parity Check Enable"
+-              "is set to = 0x%x\n",
+-              pm8001_cr32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK)));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "GSM 0x700038 - Read Address Parity Check Enable is set to = 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK));
+ 
+       /* disable GSM - Write Address Parity Check */
+       regVal2 = pm8001_cr32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x700040 - Write Address Parity Check"
+-              " Enable = 0x%x\n", regVal2));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "GSM 0x700040 - Write Address Parity Check Enable = 0x%x\n",
++                 regVal2);
+       pm8001_cw32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK, 0x0);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x700040 - Write Address Parity Check "
+-              "Enable is set to = 0x%x\n",
+-              pm8001_cr32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK)));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "GSM 0x700040 - Write Address Parity Check Enable is set to = 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK));
+ 
+       /* disable GSM - Write Data Parity Check */
+       regVal3 = pm8001_cr32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x300048 - Write Data Parity Check"
+-              " Enable = 0x%x\n", regVal3));
++      pm8001_dbg(pm8001_ha, INIT, "GSM 0x300048 - Write Data Parity Check Enable = 0x%x\n",
++                 regVal3);
+       pm8001_cw32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK, 0x0);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x300048 - Write Data Parity Check Enable"
+-              "is set to = 0x%x\n",
+-      pm8001_cr32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK)));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "GSM 0x300048 - Write Data Parity Check Enable is set to = 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK));
+ 
+       /* step 5: delay 10 usec */
+       udelay(10);
+       /* step 5-b: set GPIO-0 output control to tristate anyway */
+       if (-1 == pm8001_bar4_shift(pm8001_ha, GPIO_ADDR_BASE)) {
+               spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+-              PM8001_INIT_DBG(pm8001_ha,
+-                              pm8001_printk("Shift Bar4 to 0x%x failed\n",
+-                              GPIO_ADDR_BASE));
++              pm8001_dbg(pm8001_ha, INIT, "Shift Bar4 to 0x%x failed\n",
++                         GPIO_ADDR_BASE);
+               return -1;
+       }
+       regVal = pm8001_cr32(pm8001_ha, 2, GPIO_GPIO_0_0UTPUT_CTL_OFFSET);
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("GPIO Output Control Register:"
+-                      " = 0x%x\n", regVal));
++      pm8001_dbg(pm8001_ha, INIT, "GPIO Output Control Register: = 0x%x\n",
++                 regVal);
+       /* set GPIO-0 output control to tri-state */
+       regVal &= 0xFFFFFFFC;
+       pm8001_cw32(pm8001_ha, 2, GPIO_GPIO_0_0UTPUT_CTL_OFFSET, regVal);
+@@ -977,23 +956,20 @@ pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+       /* map 0x00000 to BAR4(0x20), BAR2(win) */
+       if (-1 == pm8001_bar4_shift(pm8001_ha, SPC_TOP_LEVEL_ADDR_BASE)) {
+               spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("SPC Shift Bar4 to 0x%x failed\n",
+-                      SPC_TOP_LEVEL_ADDR_BASE));
++              pm8001_dbg(pm8001_ha, FAIL, "SPC Shift Bar4 to 0x%x failed\n",
++                         SPC_TOP_LEVEL_ADDR_BASE);
+               return -1;
+       }
+       regVal = pm8001_cr32(pm8001_ha, 2, SPC_REG_RESET);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("Top Register before resetting IOP/AAP1"
+-              ":= 0x%x\n", regVal));
++      pm8001_dbg(pm8001_ha, INIT, "Top Register before resetting IOP/AAP1:= 0x%x\n",
++                 regVal);
+       regVal &= ~(SPC_REG_RESET_PCS_IOP_SS | SPC_REG_RESET_PCS_AAP1_SS);
+       pm8001_cw32(pm8001_ha, 2, SPC_REG_RESET, regVal);
+ 
+       /* step 7: Reset the BDMA/OSSP */
+       regVal = pm8001_cr32(pm8001_ha, 2, SPC_REG_RESET);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("Top Register before resetting BDMA/OSSP"
+-              ": = 0x%x\n", regVal));
++      pm8001_dbg(pm8001_ha, INIT, "Top Register before resetting BDMA/OSSP: = 0x%x\n",
++                 regVal);
+       regVal &= ~(SPC_REG_RESET_BDMA_CORE | SPC_REG_RESET_OSSP);
+       pm8001_cw32(pm8001_ha, 2, SPC_REG_RESET, regVal);
+ 
+@@ -1002,9 +978,9 @@ pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+ 
+       /* step 9: bring the BDMA and OSSP out of reset */
+       regVal = pm8001_cr32(pm8001_ha, 2, SPC_REG_RESET);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("Top Register before bringing up BDMA/OSSP"
+-              ":= 0x%x\n", regVal));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "Top Register before bringing up BDMA/OSSP:= 0x%x\n",
++                 regVal);
+       regVal |= (SPC_REG_RESET_BDMA_CORE | SPC_REG_RESET_OSSP);
+       pm8001_cw32(pm8001_ha, 2, SPC_REG_RESET, regVal);
+ 
+@@ -1015,14 +991,13 @@ pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+       /* map 0x0700000 to BAR4(0x20), BAR2(win) */
+       if (-1 == pm8001_bar4_shift(pm8001_ha, GSM_ADDR_BASE)) {
+               spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("SPC Shift Bar4 to 0x%x failed\n",
+-                      GSM_ADDR_BASE));
++              pm8001_dbg(pm8001_ha, FAIL, "SPC Shift Bar4 to 0x%x failed\n",
++                         GSM_ADDR_BASE);
+               return -1;
+       }
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x0 (0x00007b88)-GSM Configuration and "
+-              "Reset = 0x%x\n", pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET)));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "GSM 0x0 (0x00007b88)-GSM Configuration and Reset = 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET));
+       regVal = pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET);
+       /* Put those bits to high */
+       /* GSM XCBI offset = 0x70 0000
+@@ -1034,44 +1009,37 @@ pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+       */
+       regVal |= (GSM_CONFIG_RESET_VALUE);
+       pm8001_cw32(pm8001_ha, 2, GSM_CONFIG_RESET, regVal);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM (0x00004088 ==> 0x00007b88) - GSM"
+-              " Configuration and Reset is set to = 0x%x\n",
+-              pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET)));
++      pm8001_dbg(pm8001_ha, INIT, "GSM (0x00004088 ==> 0x00007b88) - GSM Configuration and Reset is set to = 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET));
+ 
+       /* step 12: Restore GSM - Read Address Parity Check */
+       regVal = pm8001_cr32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK);
+       /* just for debugging */
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x700038 - Read Address Parity Check Enable"
+-              " = 0x%x\n", regVal));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "GSM 0x700038 - Read Address Parity Check Enable = 0x%x\n",
++                 regVal);
+       pm8001_cw32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK, regVal1);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x700038 - Read Address Parity"
+-              " Check Enable is set to = 0x%x\n",
+-              pm8001_cr32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK)));
++      pm8001_dbg(pm8001_ha, INIT, "GSM 0x700038 - Read Address Parity Check Enable is set to = 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK));
+       /* Restore GSM - Write Address Parity Check */
+       regVal = pm8001_cr32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK);
+       pm8001_cw32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK, regVal2);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x700040 - Write Address Parity Check"
+-              " Enable is set to = 0x%x\n",
+-              pm8001_cr32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK)));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "GSM 0x700040 - Write Address Parity Check Enable is set to = 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK));
+       /* Restore GSM - Write Data Parity Check */
+       regVal = pm8001_cr32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK);
+       pm8001_cw32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK, regVal3);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("GSM 0x700048 - Write Data Parity Check Enable"
+-              "is set to = 0x%x\n",
+-              pm8001_cr32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK)));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "GSM 0x700048 - Write Data Parity Check Enableis set to = 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK));
+ 
+       /* step 13: bring the IOP and AAP1 out of reset */
+       /* map 0x00000 to BAR4(0x20), BAR2(win) */
+       if (-1 == pm8001_bar4_shift(pm8001_ha, SPC_TOP_LEVEL_ADDR_BASE)) {
+               spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Shift Bar4 to 0x%x failed\n",
+-                      SPC_TOP_LEVEL_ADDR_BASE));
++              pm8001_dbg(pm8001_ha, FAIL, "Shift Bar4 to 0x%x failed\n",
++                         SPC_TOP_LEVEL_ADDR_BASE);
+               return -1;
+       }
+       regVal = pm8001_cr32(pm8001_ha, 2, SPC_REG_RESET);
+@@ -1094,22 +1062,20 @@ pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+               if (!max_wait_count) {
+                       regVal = pm8001_cr32(pm8001_ha, 0,
+                               MSGU_SCRATCH_PAD_1);
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("TIMEOUT : ToggleVal 0x%x,"
+-                              "MSGU_SCRATCH_PAD1 = 0x%x\n",
+-                              toggleVal, regVal));
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("SCRATCH_PAD0 value = 0x%x\n",
+-                              pm8001_cr32(pm8001_ha, 0,
+-                              MSGU_SCRATCH_PAD_0)));
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("SCRATCH_PAD2 value = 0x%x\n",
+-                              pm8001_cr32(pm8001_ha, 0,
+-                              MSGU_SCRATCH_PAD_2)));
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("SCRATCH_PAD3 value = 0x%x\n",
+-                              pm8001_cr32(pm8001_ha, 0,
+-                              MSGU_SCRATCH_PAD_3)));
++                      pm8001_dbg(pm8001_ha, FAIL, "TIMEOUT : ToggleVal 0x%x,MSGU_SCRATCH_PAD1 = 0x%x\n",
++                                 toggleVal, regVal);
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "SCRATCH_PAD0 value = 0x%x\n",
++                                 pm8001_cr32(pm8001_ha, 0,
++                                             MSGU_SCRATCH_PAD_0));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "SCRATCH_PAD2 value = 0x%x\n",
++                                 pm8001_cr32(pm8001_ha, 0,
++                                             MSGU_SCRATCH_PAD_2));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "SCRATCH_PAD3 value = 0x%x\n",
++                                 pm8001_cr32(pm8001_ha, 0,
++                                             MSGU_SCRATCH_PAD_3));
+                       spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                       return -1;
+               }
+@@ -1124,22 +1090,22 @@ pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+               if (check_fw_ready(pm8001_ha) == -1) {
+                       regVal = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
+                       /* return error if MPI Configuration Table not ready */
+-                      PM8001_INIT_DBG(pm8001_ha,
+-                              pm8001_printk("FW not ready SCRATCH_PAD1"
+-                              " = 0x%x\n", regVal));
++                      pm8001_dbg(pm8001_ha, INIT,
++                                 "FW not ready SCRATCH_PAD1 = 0x%x\n",
++                                 regVal);
+                       regVal = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2);
+                       /* return error if MPI Configuration Table not ready */
+-                      PM8001_INIT_DBG(pm8001_ha,
+-                              pm8001_printk("FW not ready SCRATCH_PAD2"
+-                              " = 0x%x\n", regVal));
+-                      PM8001_INIT_DBG(pm8001_ha,
+-                              pm8001_printk("SCRATCH_PAD0 value = 0x%x\n",
+-                              pm8001_cr32(pm8001_ha, 0,
+-                              MSGU_SCRATCH_PAD_0)));
+-                      PM8001_INIT_DBG(pm8001_ha,
+-                              pm8001_printk("SCRATCH_PAD3 value = 0x%x\n",
+-                              pm8001_cr32(pm8001_ha, 0,
+-                              MSGU_SCRATCH_PAD_3)));
++                      pm8001_dbg(pm8001_ha, INIT,
++                                 "FW not ready SCRATCH_PAD2 = 0x%x\n",
++                                 regVal);
++                      pm8001_dbg(pm8001_ha, INIT,
++                                 "SCRATCH_PAD0 value = 0x%x\n",
++                                 pm8001_cr32(pm8001_ha, 0,
++                                             MSGU_SCRATCH_PAD_0));
++                      pm8001_dbg(pm8001_ha, INIT,
++                                 "SCRATCH_PAD3 value = 0x%x\n",
++                                 pm8001_cr32(pm8001_ha, 0,
++                                             MSGU_SCRATCH_PAD_3));
+                       spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                       return -1;
+               }
+@@ -1147,8 +1113,7 @@ pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+       pm8001_bar4_shift(pm8001_ha, 0);
+       spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+ 
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("SPC soft reset Complete\n"));
++      pm8001_dbg(pm8001_ha, INIT, "SPC soft reset Complete\n");
+       return 0;
+ }
+ 
+@@ -1156,8 +1121,7 @@ static void pm8001_hw_chip_rst(struct pm8001_hba_info *pm8001_ha)
+ {
+       u32 i;
+       u32 regVal;
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("chip reset start\n"));
++      pm8001_dbg(pm8001_ha, INIT, "chip reset start\n");
+ 
+       /* do SPC chip reset. */
+       regVal = pm8001_cr32(pm8001_ha, 1, SPC_REG_RESET);
+@@ -1181,8 +1145,7 @@ static void pm8001_hw_chip_rst(struct pm8001_hba_info *pm8001_ha)
+               mdelay(1);
+       } while ((--i) != 0);
+ 
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("chip reset finished\n"));
++      pm8001_dbg(pm8001_ha, INIT, "chip reset finished\n");
+ }
+ 
+ /**
+@@ -1365,8 +1328,7 @@ int pm8001_mpi_build_cmd(struct pm8001_hba_info *pm8001_ha,
+       rv = pm8001_mpi_msg_free_get(circularQ, pm8001_ha->iomb_size,
+                       &pMessage);
+       if (rv < 0) {
+-              PM8001_IO_DBG(pm8001_ha,
+-                            pm8001_printk("No free mpi buffer\n"));
++              pm8001_dbg(pm8001_ha, IO, "No free mpi buffer\n");
+               rv = -ENOMEM;
+               goto done;
+       }
+@@ -1387,10 +1349,10 @@ int pm8001_mpi_build_cmd(struct pm8001_hba_info *pm8001_ha,
+       /*Update the PI to the firmware*/
+       pm8001_cw32(pm8001_ha, circularQ->pi_pci_bar,
+               circularQ->pi_offset, circularQ->producer_idx);
+-      PM8001_DEVIO_DBG(pm8001_ha,
+-              pm8001_printk("INB Q %x OPCODE:%x , UPDATED PI=%d CI=%d\n",
+-                      responseQueue, opCode, circularQ->producer_idx,
+-                      circularQ->consumer_index));
++      pm8001_dbg(pm8001_ha, DEVIO,
++                 "INB Q %x OPCODE:%x , UPDATED PI=%d CI=%d\n",
++                 responseQueue, opCode, circularQ->producer_idx,
++                 circularQ->consumer_index);
+ done:
+       spin_unlock_irqrestore(&circularQ->iq_lock, flags);
+       return rv;
+@@ -1407,17 +1369,17 @@ u32 pm8001_mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha, void *pMsg,
+       pOutBoundMsgHeader = (struct mpi_msg_hdr *)(circularQ->base_virt +
+                               circularQ->consumer_idx * pm8001_ha->iomb_size);
+       if (pOutBoundMsgHeader != msgHeader) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("consumer_idx = %d msgHeader = %p\n",
+-                      circularQ->consumer_idx, msgHeader));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "consumer_idx = %d msgHeader = %p\n",
++                         circularQ->consumer_idx, msgHeader);
+ 
+               /* Update the producer index from SPC */
+               producer_index = pm8001_read_32(circularQ->pi_virt);
+               circularQ->producer_index = cpu_to_le32(producer_index);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("consumer_idx = %d producer_index = %d"
+-                      "msgHeader = %p\n", circularQ->consumer_idx,
+-                      circularQ->producer_index, msgHeader));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "consumer_idx = %d producer_index = %dmsgHeader = %p\n",
++                         circularQ->consumer_idx,
++                         circularQ->producer_index, msgHeader);
+               return 0;
+       }
+       /* free the circular queue buffer elements associated with the message*/
+@@ -1429,9 +1391,8 @@ u32 pm8001_mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha, void *pMsg,
+       /* Update the producer index from SPC*/
+       producer_index = pm8001_read_32(circularQ->pi_virt);
+       circularQ->producer_index = cpu_to_le32(producer_index);
+-      PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk(" CI=%d PI=%d\n", circularQ->consumer_idx,
+-              circularQ->producer_index));
++      pm8001_dbg(pm8001_ha, IO, " CI=%d PI=%d\n",
++                 circularQ->consumer_idx, circularQ->producer_index);
+       return 0;
+ }
+ 
+@@ -1461,10 +1422,10 @@ u32 pm8001_mpi_msg_consume(struct pm8001_hba_info *pm8001_ha,
+                       /* read header */
+                       header_tmp = pm8001_read_32(msgHeader);
+                       msgHeader_tmp = cpu_to_le32(header_tmp);
+-                      PM8001_DEVIO_DBG(pm8001_ha, pm8001_printk(
+-                              "outbound opcode msgheader:%x ci=%d pi=%d\n",
+-                              msgHeader_tmp, circularQ->consumer_idx,
+-                              circularQ->producer_index));
++                      pm8001_dbg(pm8001_ha, DEVIO,
++                                 "outbound opcode msgheader:%x ci=%d pi=%d\n",
++                                 msgHeader_tmp, circularQ->consumer_idx,
++                                 circularQ->producer_index);
+                       if (0 != (le32_to_cpu(msgHeader_tmp) & 0x80000000)) {
+                               if (OPC_OUB_SKIP_ENTRY !=
+                                       (le32_to_cpu(msgHeader_tmp) & 0xfff)) {
+@@ -1473,12 +1434,11 @@ u32 pm8001_mpi_msg_consume(struct pm8001_hba_info *pm8001_ha,
+                                               sizeof(struct mpi_msg_hdr);
+                                       *pBC = (u8)((le32_to_cpu(msgHeader_tmp)
+                                               >> 24) & 0x1f);
+-                                      PM8001_IO_DBG(pm8001_ha,
+-                                              pm8001_printk(": CI=%d PI=%d "
+-                                              "msgHeader=%x\n",
+-                                              circularQ->consumer_idx,
+-                                              circularQ->producer_index,
+-                                              msgHeader_tmp));
++                                      pm8001_dbg(pm8001_ha, IO,
++                                                 ": CI=%d PI=%d msgHeader=%x\n",
++                                                 circularQ->consumer_idx,
++                                                 circularQ->producer_index,
++                                                 msgHeader_tmp);
+                                       return MPI_IO_STATUS_SUCCESS;
+                               } else {
+                                       circularQ->consumer_idx =
+@@ -1594,10 +1554,8 @@ void pm8001_work_fn(struct work_struct *work)
+               t->task_state_flags |= SAS_TASK_STATE_DONE;
+               if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+                       spin_unlock_irqrestore(&t->task_state_lock, flags1);
+-                      PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("task 0x%p"
+-                              " done with event 0x%x resp 0x%x stat 0x%x but"
+-                              " aborted by upper layer!\n",
+-                              t, pw->handler, ts->resp, ts->stat));
++                      pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
++                                 t, pw->handler, ts->resp, ts->stat);
+                       pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                       spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+               } else {
+@@ -1617,26 +1575,16 @@ void pm8001_work_fn(struct work_struct *work)
+               unsigned long flags, flags1;
+               int i, ret = 0;
+ 
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_OPEN_RETRY_TIMEOUT\n");
+ 
+               ret = pm8001_query_task(t);
+ 
+-              PM8001_IO_DBG(pm8001_ha,
+-                      switch (ret) {
+-                      case TMF_RESP_FUNC_SUCC:
+-                              pm8001_printk("...Task on lu\n");
+-                              break;
+-
+-                      case TMF_RESP_FUNC_COMPLETE:
+-                              pm8001_printk("...Task NOT on lu\n");
+-                              break;
+-
+-                      default:
+-                              PM8001_DEVIO_DBG(pm8001_ha, pm8001_printk(
+-                                      "...query task failed!!!\n"));
+-                              break;
+-                      });
++              if (ret == TMF_RESP_FUNC_SUCC)
++                      pm8001_dbg(pm8001_ha, IO, "...Task on lu\n");
++              else if (ret == TMF_RESP_FUNC_COMPLETE)
++                      pm8001_dbg(pm8001_ha, IO, "...Task NOT on lu\n");
++              else
++                      pm8001_dbg(pm8001_ha, DEVIO, "...query task failed!!!\n");
+ 
+               spin_lock_irqsave(&pm8001_ha->lock, flags);
+ 
+@@ -1681,8 +1629,7 @@ void pm8001_work_fn(struct work_struct *work)
+                               break;
+                       default: /* device misbehavior */
+                               ret = TMF_RESP_FUNC_FAILED;
+-                              PM8001_IO_DBG(pm8001_ha,
+-                                      pm8001_printk("...Reset phy\n"));
++                              pm8001_dbg(pm8001_ha, IO, "...Reset phy\n");
+                               pm8001_I_T_nexus_reset(dev);
+                               break;
+                       }
+@@ -1696,15 +1643,14 @@ void pm8001_work_fn(struct work_struct *work)
+               default: /* device misbehavior */
+                       spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                       ret = TMF_RESP_FUNC_FAILED;
+-                      PM8001_IO_DBG(pm8001_ha,
+-                              pm8001_printk("...Reset phy\n"));
++                      pm8001_dbg(pm8001_ha, IO, "...Reset phy\n");
+                       pm8001_I_T_nexus_reset(dev);
+               }
+ 
+               if (ret == TMF_RESP_FUNC_FAILED)
+                       t = NULL;
+               pm8001_open_reject_retry(pm8001_ha, t, pm8001_dev);
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("...Complete\n"));
++              pm8001_dbg(pm8001_ha, IO, "...Complete\n");
+       }       break;
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+               dev = pm8001_dev->sas_device;
+@@ -1758,15 +1704,14 @@ static void pm8001_send_abort_all(struct pm8001_hba_info *pm8001_ha,
+       int ret;
+ 
+       if (!pm8001_ha_dev) {
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("dev is null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "dev is null\n");
+               return;
+       }
+ 
+       task = sas_alloc_slow_task(GFP_ATOMIC);
+ 
+       if (!task) {
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("cannot "
+-                                              "allocate task\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task\n");
+               return;
+       }
+ 
+@@ -1811,8 +1756,7 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
+       task = sas_alloc_slow_task(GFP_ATOMIC);
+ 
+       if (!task) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("cannot allocate task !!!\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task !!!\n");
+               return;
+       }
+       task->task_done = pm8001_task_done;
+@@ -1820,8 +1764,7 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
+       res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
+       if (res) {
+               sas_free_task(task);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("cannot allocate tag !!!\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "cannot allocate tag !!!\n");
+               return;
+       }
+ 
+@@ -1832,8 +1775,8 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
+       if (!dev) {
+               sas_free_task(task);
+               pm8001_tag_free(pm8001_ha, ccb_tag);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Domain device cannot be allocated\n"));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "Domain device cannot be allocated\n");
+               return;
+       }
+       task->dev = dev;
+@@ -1910,27 +1853,25 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       t = ccb->task;
+ 
+       if (status && status != IO_UNDERFLOW)
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("sas IO status 0x%x\n", status));
++              pm8001_dbg(pm8001_ha, FAIL, "sas IO status 0x%x\n", status);
+       if (unlikely(!t || !t->lldd_task || !t->dev))
+               return;
+       ts = &t->task_status;
+       /* Print sas address of IO failed device */
+       if ((status != IO_SUCCESS) && (status != IO_OVERFLOW) &&
+               (status != IO_UNDERFLOW))
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("SAS Address of IO Failure Drive:"
+-                      "%016llx", SAS_ADDR(t->dev->sas_addr)));
++              pm8001_dbg(pm8001_ha, FAIL, "SAS Address of IO Failure Drive:%016llx\n",
++                         SAS_ADDR(t->dev->sas_addr));
+ 
+       if (status)
+-              PM8001_IOERR_DBG(pm8001_ha, pm8001_printk(
+-                      "status:0x%x, tag:0x%x, task:0x%p\n",
+-                      status, tag, t));
++              pm8001_dbg(pm8001_ha, IOERR,
++                         "status:0x%x, tag:0x%x, task:0x%p\n",
++                         status, tag, t);
+ 
+       switch (status) {
+       case IO_SUCCESS:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS"
+-                      ",param = %d\n", param));
++              pm8001_dbg(pm8001_ha, IO, "IO_SUCCESS,param = %d\n",
++                         param);
+               if (param == 0) {
+                       ts->resp = SAS_TASK_COMPLETE;
+                       ts->stat = SAM_STAT_GOOD;
+@@ -1945,15 +1886,14 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_ABORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_ABORTED IOMB Tag\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_ABORTED IOMB Tag\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               break;
+       case IO_UNDERFLOW:
+               /* SSP Completion with error */
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW"
+-                      ",param = %d\n", param));
++              pm8001_dbg(pm8001_ha, IO, "IO_UNDERFLOW,param = %d\n",
++                         param);
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_UNDERRUN;
+               ts->residual = param;
+@@ -1961,50 +1901,45 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_NO_DEVICE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_NO_DEVICE\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_PHY_DOWN;
+               break;
+       case IO_XFER_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               /* Force the midlayer to retry */
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PHY_NOT_READY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_EPROTO;
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+@@ -2014,68 +1949,59 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                               IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+               break;
+       case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_BAD_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+               break;
+       case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_CONNECTION_RATE_"
+-                      "NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+               break;
+       case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+               break;
+       case IO_XFER_ERROR_NAK_RECEIVED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_NAK_RECEIVED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_ACK_NAK_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               break;
+       case IO_XFER_ERROR_DMA:
+-              PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("IO_XFER_ERROR_DMA\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_DMA\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_OPEN_RETRY_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_XFER_ERROR_OFFSET_MISMATCH:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_OFFSET_MISMATCH\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               break;
+       case IO_PORT_IN_RESET:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_PORT_IN_RESET\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_PORT_IN_RESET\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               break;
+       case IO_DS_NON_OPERATIONAL:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_NON_OPERATIONAL\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               if (!t->uldd_task)
+@@ -2084,51 +2010,44 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                               IO_DS_NON_OPERATIONAL);
+               break;
+       case IO_DS_IN_RECOVERY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_IN_RECOVERY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_IN_RECOVERY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               break;
+       case IO_TM_TAG_NOT_FOUND:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_TM_TAG_NOT_FOUND\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_TM_TAG_NOT_FOUND\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               break;
+       case IO_SSP_EXT_IU_ZERO_LEN_ERROR:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_SSP_EXT_IU_ZERO_LEN_ERROR\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_SSP_EXT_IU_ZERO_LEN_ERROR\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               break;
+       case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown status 0x%x\n", status));
++              pm8001_dbg(pm8001_ha, DEVIO, "Unknown status 0x%x\n", status);
+               /* not allowed case. Therefore, return failed status */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               break;
+       }
+-      PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("scsi_status = %x\n ",
+-              psspPayload->ssp_resp_iu.status));
++      pm8001_dbg(pm8001_ha, IO, "scsi_status = %x\n",
++                 psspPayload->ssp_resp_iu.status);
+       spin_lock_irqsave(&t->task_state_lock, flags);
+       t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+       t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+       t->task_state_flags |= SAS_TASK_STATE_DONE;
+       if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("task 0x%p done with"
+-                      " io_status 0x%x resp 0x%x "
+-                      "stat 0x%x but aborted by upper layer!\n",
+-                      t, status, ts->resp, ts->stat));
++              pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
++                         t, status, ts->resp, ts->stat);
+               pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+       } else {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+@@ -2157,17 +2076,15 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       t = ccb->task;
+       pm8001_dev = ccb->device;
+       if (event)
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("sas IO status 0x%x\n", event));
++              pm8001_dbg(pm8001_ha, FAIL, "sas IO status 0x%x\n", event);
+       if (unlikely(!t || !t->lldd_task || !t->dev))
+               return;
+       ts = &t->task_status;
+-      PM8001_DEVIO_DBG(pm8001_ha,
+-              pm8001_printk("port_id = %x,device_id = %x\n",
+-              port_id, dev_id));
++      pm8001_dbg(pm8001_ha, DEVIO, "port_id = %x,device_id = %x\n",
++                 port_id, dev_id);
+       switch (event) {
+       case IO_OVERFLOW:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n");)
++              pm8001_dbg(pm8001_ha, IO, "IO_UNDERFLOW\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+@@ -2175,42 +2092,36 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
+               pm8001_handle_event(pm8001_ha, t, IO_XFER_ERROR_BREAK);
+               return;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PHY_NOT_READY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT"
+-                      "_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_EPROTO;
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+@@ -2220,88 +2131,78 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                               IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+               break;
+       case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_BAD_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+               break;
+       case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_CONNECTION_RATE_"
+-                      "NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+               break;
+       case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                     pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+               break;
+       case IO_XFER_ERROR_NAK_RECEIVED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_NAK_RECEIVED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_ACK_NAK_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_OPEN_RETRY_TIMEOUT\n");
+               pm8001_handle_event(pm8001_ha, t, IO_XFER_OPEN_RETRY_TIMEOUT);
+               return;
+       case IO_XFER_ERROR_UNEXPECTED_PHASE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_UNEXPECTED_PHASE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_UNEXPECTED_PHASE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_ERROR_XFER_RDY_OVERRUN:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_XFER_RDY_OVERRUN\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_XFER_RDY_OVERRUN\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                     pm8001_printk("IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_ERROR_OFFSET_MISMATCH:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_OFFSET_MISMATCH\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_ERROR_XFER_ZERO_DATA_LEN:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_CMD_FRAME_ISSUED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("  IO_XFER_CMD_FRAME_ISSUED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_CMD_FRAME_ISSUED\n");
+               return;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown status 0x%x\n", event));
++              pm8001_dbg(pm8001_ha, DEVIO, "Unknown status 0x%x\n", event);
+               /* not allowed case. Therefore, return failed status */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+@@ -2313,10 +2214,8 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       t->task_state_flags |= SAS_TASK_STATE_DONE;
+       if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("task 0x%p done with"
+-                      " event 0x%x resp 0x%x "
+-                      "stat 0x%x but aborted by upper layer!\n",
+-                      t, event, ts->resp, ts->stat));
++              pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
++                         t, event, ts->resp, ts->stat);
+               pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+       } else {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+@@ -2352,8 +2251,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       tag = le32_to_cpu(psataPayload->tag);
+ 
+       if (!tag) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("tag null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "tag null\n");
+               return;
+       }
+       ccb = &pm8001_ha->ccb_info[tag];
+@@ -2362,8 +2260,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               t = ccb->task;
+               pm8001_dev = ccb->device;
+       } else {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("ccb null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "ccb null\n");
+               return;
+       }
+ 
+@@ -2371,29 +2268,26 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               if (t->dev && (t->dev->lldd_dev))
+                       pm8001_dev = t->dev->lldd_dev;
+       } else {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("task null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "task null\n");
+               return;
+       }
+ 
+       if ((pm8001_dev && !(pm8001_dev->id & NCQ_READ_LOG_FLAG))
+               && unlikely(!t || !t->lldd_task || !t->dev)) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("task or dev null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "task or dev null\n");
+               return;
+       }
+ 
+       ts = &t->task_status;
+       if (!ts) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("ts null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "ts null\n");
+               return;
+       }
+ 
+       if (status)
+-              PM8001_IOERR_DBG(pm8001_ha, pm8001_printk(
+-                      "status:0x%x, tag:0x%x, task::0x%p\n",
+-                      status, tag, t));
++              pm8001_dbg(pm8001_ha, IOERR,
++                         "status:0x%x, tag:0x%x, task::0x%p\n",
++                         status, tag, t);
+ 
+       /* Print sas address of IO failed device */
+       if ((status != IO_SUCCESS) && (status != IO_OVERFLOW) &&
+@@ -2425,19 +2319,19 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                                               & 0xff000000)) +
+                                               pm8001_dev->attached_phy +
+                                               0x10);
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("SAS Address of IO Failure Drive:"
+-                              "%08x%08x", temp_sata_addr_hi,
+-                                      temp_sata_addr_low));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "SAS Address of IO Failure Drive:%08x%08x\n",
++                                 temp_sata_addr_hi,
++                                 temp_sata_addr_low);
+               } else {
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("SAS Address of IO Failure Drive:"
+-                              "%016llx", SAS_ADDR(t->dev->sas_addr)));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "SAS Address of IO Failure Drive:%016llx\n",
++                                 SAS_ADDR(t->dev->sas_addr));
+               }
+       }
+       switch (status) {
+       case IO_SUCCESS:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_SUCCESS\n");
+               if (param == 0) {
+                       ts->resp = SAS_TASK_COMPLETE;
+                       ts->stat = SAM_STAT_GOOD;
+@@ -2459,39 +2353,38 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       ts->resp = SAS_TASK_COMPLETE;
+                       ts->stat = SAS_PROTO_RESPONSE;
+                       ts->residual = param;
+-                      PM8001_IO_DBG(pm8001_ha,
+-                              pm8001_printk("SAS_PROTO_RESPONSE len = %d\n",
+-                              param));
++                      pm8001_dbg(pm8001_ha, IO,
++                                 "SAS_PROTO_RESPONSE len = %d\n",
++                                 param);
+                       sata_resp = &psataPayload->sata_resp[0];
+                       resp = (struct ata_task_resp *)ts->buf;
+                       if (t->ata_task.dma_xfer == 0 &&
+                           t->data_dir == DMA_FROM_DEVICE) {
+                               len = sizeof(struct pio_setup_fis);
+-                              PM8001_IO_DBG(pm8001_ha,
+-                              pm8001_printk("PIO read len = %d\n", len));
++                              pm8001_dbg(pm8001_ha, IO,
++                                         "PIO read len = %d\n", len);
+                       } else if (t->ata_task.use_ncq) {
+                               len = sizeof(struct set_dev_bits_fis);
+-                              PM8001_IO_DBG(pm8001_ha,
+-                                      pm8001_printk("FPDMA len = %d\n", len));
++                              pm8001_dbg(pm8001_ha, IO, "FPDMA len = %d\n",
++                                         len);
+                       } else {
+                               len = sizeof(struct dev_to_host_fis);
+-                              PM8001_IO_DBG(pm8001_ha,
+-                              pm8001_printk("other len = %d\n", len));
++                              pm8001_dbg(pm8001_ha, IO, "other len = %d\n",
++                                         len);
+                       }
+                       if (SAS_STATUS_BUF_SIZE >= sizeof(*resp)) {
+                               resp->frame_len = len;
+                               memcpy(&resp->ending_fis[0], sata_resp, len);
+                               ts->buf_valid_size = sizeof(*resp);
+                       } else
+-                              PM8001_IO_DBG(pm8001_ha,
+-                                      pm8001_printk("response to large\n"));
++                              pm8001_dbg(pm8001_ha, IO,
++                                         "response too large\n");
+               }
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_ABORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_ABORTED IOMB Tag\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_ABORTED IOMB Tag\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               if (pm8001_dev)
+@@ -2500,8 +2393,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               /* following cases are to do cases */
+       case IO_UNDERFLOW:
+               /* SATA Completion with error */
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_UNDERFLOW param = %d\n", param));
++              pm8001_dbg(pm8001_ha, IO, "IO_UNDERFLOW param = %d\n", param);
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_UNDERRUN;
+               ts->residual =  param;
+@@ -2509,24 +2401,21 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_NO_DEVICE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_NO_DEVICE\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_PHY_DOWN;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_INTERRUPTED;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PHY_NOT_READY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+@@ -2534,9 +2423,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT"
+-                      "_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_EPROTO;
+@@ -2544,8 +2431,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+@@ -2553,8 +2440,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+@@ -2562,8 +2448,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (!t->uldd_task) {
+@@ -2577,8 +2462,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_BAD_DESTINATION\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+@@ -2593,9 +2478,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_CONNECTION_RATE_"
+-                      "NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+@@ -2603,9 +2486,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_STP_RESOURCES"
+-                      "_BUSY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (!t->uldd_task) {
+@@ -2619,8 +2500,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                     pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+@@ -2628,64 +2509,56 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_NAK_RECEIVED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_NAK_RECEIVED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_ACK_NAK_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_DMA:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_DMA\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_DMA\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_SATA_LINK_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_SATA_LINK_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_SATA_LINK_TIMEOUT\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_REJECTED_NCQ_MODE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_REJECTED_NCQ_MODE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_REJECTED_NCQ_MODE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_UNDERRUN;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_OPEN_RETRY_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_PORT_IN_RESET:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_PORT_IN_RESET\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_PORT_IN_RESET\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_DS_NON_OPERATIONAL:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_NON_OPERATIONAL\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (!t->uldd_task) {
+@@ -2698,16 +2571,14 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case IO_DS_IN_RECOVERY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("  IO_DS_IN_RECOVERY\n"));
++              pm8001_dbg(pm8001_ha, IO, "  IO_DS_IN_RECOVERY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_DS_IN_ERROR:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_IN_ERROR\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_IN_ERROR\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (!t->uldd_task) {
+@@ -2720,8 +2591,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+@@ -2729,8 +2600,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown status 0x%x\n", status));
++              pm8001_dbg(pm8001_ha, DEVIO, "Unknown status 0x%x\n", status);
+               /* not allowed case. Therefore, return failed status */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+@@ -2744,10 +2614,9 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       t->task_state_flags |= SAS_TASK_STATE_DONE;
+       if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("task 0x%p done with io_status 0x%x"
+-                      " resp 0x%x stat 0x%x but aborted by upper layer!\n",
+-                      t, status, ts->resp, ts->stat));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
++                         t, status, ts->resp, ts->stat);
+               pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+       } else {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+@@ -2776,12 +2645,10 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               t = ccb->task;
+               pm8001_dev = ccb->device;
+       } else {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("No CCB !!!. returning\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "No CCB !!!. returning\n");
+       }
+       if (event)
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("SATA EVENT 0x%x\n", event));
++              pm8001_dbg(pm8001_ha, FAIL, "SATA EVENT 0x%x\n", event);
+ 
+       /* Check if this is NCQ error */
+       if (event == IO_XFER_ERROR_ABORTED_NCQ_MODE) {
+@@ -2797,17 +2664,16 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       t = ccb->task;
+       pm8001_dev = ccb->device;
+       if (event)
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("sata IO status 0x%x\n", event));
++              pm8001_dbg(pm8001_ha, FAIL, "sata IO status 0x%x\n", event);
+       if (unlikely(!t || !t->lldd_task || !t->dev))
+               return;
+       ts = &t->task_status;
+-      PM8001_DEVIO_DBG(pm8001_ha, pm8001_printk(
+-              "port_id:0x%x, device_id:0x%x, tag:0x%x, event:0x%x\n",
+-              port_id, dev_id, tag, event));
++      pm8001_dbg(pm8001_ha, DEVIO,
++                 "port_id:0x%x, device_id:0x%x, tag:0x%x, event:0x%x\n",
++                 port_id, dev_id, tag, event);
+       switch (event) {
+       case IO_OVERFLOW:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_UNDERFLOW\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+@@ -2815,43 +2681,37 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_INTERRUPTED;
+               break;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PHY_NOT_READY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT"
+-                      "_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_EPROTO;
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+               break;
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (!t->uldd_task) {
+@@ -2865,94 +2725,82 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               }
+               break;
+       case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_BAD_DESTINATION\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+               break;
+       case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_CONNECTION_RATE_"
+-                      "NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+               break;
+       case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                     pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+               break;
+       case IO_XFER_ERROR_NAK_RECEIVED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_NAK_RECEIVED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               break;
+       case IO_XFER_ERROR_PEER_ABORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PEER_ABORTED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PEER_ABORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               break;
+       case IO_XFER_ERROR_REJECTED_NCQ_MODE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_REJECTED_NCQ_MODE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_REJECTED_NCQ_MODE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_UNDERRUN;
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_OPEN_RETRY_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_ERROR_UNEXPECTED_PHASE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_UNEXPECTED_PHASE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_UNEXPECTED_PHASE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_ERROR_XFER_RDY_OVERRUN:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_XFER_RDY_OVERRUN\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_XFER_RDY_OVERRUN\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                     pm8001_printk("IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_ERROR_OFFSET_MISMATCH:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_OFFSET_MISMATCH\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_ERROR_XFER_ZERO_DATA_LEN:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_CMD_FRAME_ISSUED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_CMD_FRAME_ISSUED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_CMD_FRAME_ISSUED\n");
+               break;
+       case IO_XFER_PIO_SETUP_ERROR:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_PIO_SETUP_ERROR\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_PIO_SETUP_ERROR\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown status 0x%x\n", event));
++              pm8001_dbg(pm8001_ha, DEVIO, "Unknown status 0x%x\n", event);
+               /* not allowed case. Therefore, return failed status */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+@@ -2964,10 +2812,9 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       t->task_state_flags |= SAS_TASK_STATE_DONE;
+       if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("task 0x%p done with io_status 0x%x"
+-                      " resp 0x%x stat 0x%x but aborted by upper layer!\n",
+-                      t, event, ts->resp, ts->stat));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
++                         t, event, ts->resp, ts->stat);
+               pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+       } else {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+@@ -2997,33 +2844,31 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       ts = &t->task_status;
+       pm8001_dev = ccb->device;
+       if (status) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("smp IO status 0x%x\n", status));
+-              PM8001_IOERR_DBG(pm8001_ha,
+-                      pm8001_printk("status:0x%x, tag:0x%x, task:0x%p\n",
+-                      status, tag, t));
++              pm8001_dbg(pm8001_ha, FAIL, "smp IO status 0x%x\n", status);
++              pm8001_dbg(pm8001_ha, IOERR,
++                         "status:0x%x, tag:0x%x, task:0x%p\n",
++                         status, tag, t);
+       }
+       if (unlikely(!t || !t->lldd_task || !t->dev))
+               return;
+ 
+       switch (status) {
+       case IO_SUCCESS:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_SUCCESS\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAM_STAT_GOOD;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_ABORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_ABORTED IOMB\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_ABORTED IOMB\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OVERFLOW:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_UNDERFLOW\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+@@ -3031,52 +2876,47 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_NO_DEVICE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_NO_DEVICE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_PHY_DOWN;
+               break;
+       case IO_ERROR_HW_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_ERROR_HW_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_ERROR_HW_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAM_STAT_BUSY;
+               break;
+       case IO_XFER_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAM_STAT_BUSY;
+               break;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PHY_NOT_READY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAM_STAT_BUSY;
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+               break;
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+@@ -3085,76 +2925,67 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                               IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+               break;
+       case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_BAD_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+               break;
+       case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_CONNECTION_RATE_"
+-                      "NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+               break;
+       case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                     pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+               break;
+       case IO_XFER_ERROR_RX_FRAME:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_RX_FRAME\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_RX_FRAME\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_OPEN_RETRY_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_ERROR_INTERNAL_SMP_RESOURCE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_ERROR_INTERNAL_SMP_RESOURCE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_ERROR_INTERNAL_SMP_RESOURCE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_QUEUE_FULL;
+               break;
+       case IO_PORT_IN_RESET:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_PORT_IN_RESET\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_PORT_IN_RESET\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_DS_NON_OPERATIONAL:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_NON_OPERATIONAL\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               break;
+       case IO_DS_IN_RECOVERY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_IN_RECOVERY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_IN_RECOVERY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown status 0x%x\n", status));
++              pm8001_dbg(pm8001_ha, DEVIO, "Unknown status 0x%x\n", status);
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               /* not allowed case. Therefore, return failed status */
+@@ -3166,10 +2997,8 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       t->task_state_flags |= SAS_TASK_STATE_DONE;
+       if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("task 0x%p done with"
+-                      " io_status 0x%x resp 0x%x "
+-                      "stat 0x%x but aborted by upper layer!\n",
+-                      t, status, ts->resp, ts->stat));
++              pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
++                         t, status, ts->resp, ts->stat);
+               pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+       } else {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+@@ -3191,9 +3020,8 @@ void pm8001_mpi_set_dev_state_resp(struct pm8001_hba_info *pm8001_ha,
+       u32 device_id = le32_to_cpu(pPayload->device_id);
+       u8 pds = le32_to_cpu(pPayload->pds_nds) & PDS_BITS;
+       u8 nds = le32_to_cpu(pPayload->pds_nds) & NDS_BITS;
+-      PM8001_MSG_DBG(pm8001_ha, pm8001_printk("Set device id = 0x%x state "
+-              "from 0x%x to 0x%x status = 0x%x!\n",
+-              device_id, pds, nds, status));
++      pm8001_dbg(pm8001_ha, MSG, "Set device id = 0x%x state from 0x%x to 0x%x status = 0x%x!\n",
++                 device_id, pds, nds, status);
+       complete(pm8001_dev->setds_completion);
+       ccb->task = NULL;
+       ccb->ccb_tag = 0xFFFFFFFF;
+@@ -3208,10 +3036,9 @@ void pm8001_mpi_set_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       struct pm8001_ccb_info *ccb = &pm8001_ha->ccb_info[tag];
+       u32 dlen_status = le32_to_cpu(pPayload->dlen_status);
+       complete(pm8001_ha->nvmd_completion);
+-      PM8001_MSG_DBG(pm8001_ha, pm8001_printk("Set nvm data complete!\n"));
++      pm8001_dbg(pm8001_ha, MSG, "Set nvm data complete!\n");
+       if ((dlen_status & NVMD_STAT) != 0) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Set nvm data error!\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "Set nvm data error!\n");
+               return;
+       }
+       ccb->task = NULL;
+@@ -3233,26 +3060,22 @@ pm8001_mpi_get_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       void *virt_addr = pm8001_ha->memoryMap.region[NVMD].virt_ptr;
+       fw_control_context = ccb->fw_control_context;
+ 
+-      PM8001_MSG_DBG(pm8001_ha, pm8001_printk("Get nvm data complete!\n"));
++      pm8001_dbg(pm8001_ha, MSG, "Get nvm data complete!\n");
+       if ((dlen_status & NVMD_STAT) != 0) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Get nvm data error!\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "Get nvm data error!\n");
+               complete(pm8001_ha->nvmd_completion);
+               return;
+       }
+ 
+       if (ir_tds_bn_dps_das_nvm & IPMode) {
+               /* indirect mode - IR bit set */
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("Get NVMD success, IR=1\n"));
++              pm8001_dbg(pm8001_ha, MSG, "Get NVMD success, IR=1\n");
+               if ((ir_tds_bn_dps_das_nvm & NVMD_TYPE) == TWI_DEVICE) {
+                       if (ir_tds_bn_dps_das_nvm == 0x80a80200) {
+                               memcpy(pm8001_ha->sas_addr,
+                                     ((u8 *)virt_addr + 4),
+                                      SAS_ADDR_SIZE);
+-                              PM8001_MSG_DBG(pm8001_ha,
+-                                      pm8001_printk("Get SAS address"
+-                                      " from VPD successfully!\n"));
++                              pm8001_dbg(pm8001_ha, MSG, "Get SAS address from VPD successfully!\n");
+                       }
+               } else if (((ir_tds_bn_dps_das_nvm & NVMD_TYPE) == C_SEEPROM)
+                       || ((ir_tds_bn_dps_das_nvm & NVMD_TYPE) == VPD_FLASH) ||
+@@ -3263,14 +3086,14 @@ pm8001_mpi_get_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       ;
+               } else {
+                       /* Should not be happened*/
+-                      PM8001_MSG_DBG(pm8001_ha,
+-                              pm8001_printk("(IR=1)Wrong Device type 0x%x\n",
+-                              ir_tds_bn_dps_das_nvm));
++                      pm8001_dbg(pm8001_ha, MSG,
++                                 "(IR=1)Wrong Device type 0x%x\n",
++                                 ir_tds_bn_dps_das_nvm);
+               }
+       } else /* direct mode */{
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("Get NVMD success, IR=0, dataLen=%d\n",
+-                      (dlen_status & NVMD_LEN) >> 24));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "Get NVMD success, IR=0, dataLen=%d\n",
++                         (dlen_status & NVMD_LEN) >> 24);
+       }
+       /* Though fw_control_context is freed below, usrAddr still needs
+        * to be updated as this holds the response to the request function
+@@ -3284,7 +3107,7 @@ pm8001_mpi_get_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+        * fw_control_context->usrAddr
+        */
+       complete(pm8001_ha->nvmd_completion);
+-      PM8001_MSG_DBG(pm8001_ha, pm8001_printk("Set nvm data complete!\n"));
++      pm8001_dbg(pm8001_ha, MSG, "Set nvm data complete!\n");
+       ccb->task = NULL;
+       ccb->ccb_tag = 0xFFFFFFFF;
+       pm8001_tag_free(pm8001_ha, tag);
+@@ -3300,13 +3123,13 @@ int pm8001_mpi_local_phy_ctl(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       u32 phy_op = le32_to_cpu(pPayload->phyop_phyid) & OP_BITS;
+       tag = le32_to_cpu(pPayload->tag);
+       if (status != 0) {
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("%x phy execute %x phy op failed!\n",
+-                      phy_id, phy_op));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "%x phy execute %x phy op failed!\n",
++                         phy_id, phy_op);
+       } else {
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("%x phy execute %x phy op success!\n",
+-                      phy_id, phy_op));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "%x phy execute %x phy op success!\n",
++                         phy_id, phy_op);
+               pm8001_ha->phy[phy_id].reset_success = true;
+       }
+       if (pm8001_ha->phy[phy_id].enable_completion) {
+@@ -3353,7 +3176,7 @@ void pm8001_bytes_dmaed(struct pm8001_hba_info *pm8001_ha, int i)
+       } else if (phy->phy_type & PORT_TYPE_SATA) {
+               /*Nothing*/
+       }
+-      PM8001_MSG_DBG(pm8001_ha, pm8001_printk("phy %d byte dmaded.\n", i));
++      pm8001_dbg(pm8001_ha, MSG, "phy %d byte dmaded.\n", i);
+ 
+       sas_phy->frame_rcvd_size = phy->frame_rcvd_size;
+       pm8001_ha->sas->notify_port_event(sas_phy, PORTE_BYTES_DMAED);
+@@ -3476,37 +3299,34 @@ hw_event_sas_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       u8 deviceType = pPayload->sas_identify.dev_type;
+       port->port_state =  portstate;
+       phy->phy_state = PHY_STATE_LINK_UP_SPC;
+-      PM8001_MSG_DBG(pm8001_ha,
+-              pm8001_printk("HW_EVENT_SAS_PHY_UP port id = %d, phy id = %d\n",
+-              port_id, phy_id));
++      pm8001_dbg(pm8001_ha, MSG,
++                 "HW_EVENT_SAS_PHY_UP port id = %d, phy id = %d\n",
++                 port_id, phy_id);
+ 
+       switch (deviceType) {
+       case SAS_PHY_UNUSED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("device type no device.\n"));
++              pm8001_dbg(pm8001_ha, MSG, "device type no device.\n");
+               break;
+       case SAS_END_DEVICE:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk("end device.\n"));
++              pm8001_dbg(pm8001_ha, MSG, "end device.\n");
+               pm8001_chip_phy_ctl_req(pm8001_ha, phy_id,
+                       PHY_NOTIFY_ENABLE_SPINUP);
+               port->port_attached = 1;
+               pm8001_get_lrate_mode(phy, link_rate);
+               break;
+       case SAS_EDGE_EXPANDER_DEVICE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("expander device.\n"));
++              pm8001_dbg(pm8001_ha, MSG, "expander device.\n");
+               port->port_attached = 1;
+               pm8001_get_lrate_mode(phy, link_rate);
+               break;
+       case SAS_FANOUT_EXPANDER_DEVICE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("fanout expander device.\n"));
++              pm8001_dbg(pm8001_ha, MSG, "fanout expander device.\n");
+               port->port_attached = 1;
+               pm8001_get_lrate_mode(phy, link_rate);
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("unknown device type(%x)\n", deviceType));
++              pm8001_dbg(pm8001_ha, DEVIO, "unknown device type(%x)\n",
++                         deviceType);
+               break;
+       }
+       phy->phy_type |= PORT_TYPE_SAS;
+@@ -3552,9 +3372,8 @@ hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+       struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+       unsigned long flags;
+-      PM8001_DEVIO_DBG(pm8001_ha,
+-              pm8001_printk("HW_EVENT_SATA_PHY_UP port id = %d,"
+-              " phy id = %d\n", port_id, phy_id));
++      pm8001_dbg(pm8001_ha, DEVIO, "HW_EVENT_SATA_PHY_UP port id = %d, phy id = %d\n",
++                 port_id, phy_id);
+       port->port_state =  portstate;
+       phy->phy_state = PHY_STATE_LINK_UP_SPC;
+       port->port_attached = 1;
+@@ -3602,37 +3421,35 @@ hw_event_phy_down(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       case PORT_VALID:
+               break;
+       case PORT_INVALID:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" PortInvalid portID %d\n", port_id));
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" Last phy Down and port invalid\n"));
++              pm8001_dbg(pm8001_ha, MSG, " PortInvalid portID %d\n",
++                         port_id);
++              pm8001_dbg(pm8001_ha, MSG,
++                         " Last phy Down and port invalid\n");
+               port->port_attached = 0;
+               pm8001_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_PHY_DOWN,
+                       port_id, phy_id, 0, 0);
+               break;
+       case PORT_IN_RESET:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" Port In Reset portID %d\n", port_id));
++              pm8001_dbg(pm8001_ha, MSG, " Port In Reset portID %d\n",
++                         port_id);
+               break;
+       case PORT_NOT_ESTABLISHED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" phy Down and PORT_NOT_ESTABLISHED\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         " phy Down and PORT_NOT_ESTABLISHED\n");
+               port->port_attached = 0;
+               break;
+       case PORT_LOSTCOMM:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" phy Down and PORT_LOSTCOMM\n"));
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" Last phy Down and port invalid\n"));
++              pm8001_dbg(pm8001_ha, MSG, " phy Down and PORT_LOSTCOMM\n");
++              pm8001_dbg(pm8001_ha, MSG,
++                         " Last phy Down and port invalid\n");
+               port->port_attached = 0;
+               pm8001_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_PHY_DOWN,
+                       port_id, phy_id, 0, 0);
+               break;
+       default:
+               port->port_attached = 0;
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk(" phy Down and(default) = %x\n",
+-                      portstate));
++              pm8001_dbg(pm8001_ha, DEVIO, " phy Down and(default) = %x\n",
++                         portstate);
+               break;
+ 
+       }
+@@ -3663,44 +3480,42 @@ int pm8001_mpi_reg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       pm8001_dev = ccb->device;
+       status = le32_to_cpu(registerRespPayload->status);
+       device_id = le32_to_cpu(registerRespPayload->device_id);
+-      PM8001_MSG_DBG(pm8001_ha,
+-              pm8001_printk(" register device is status = %d\n", status));
++      pm8001_dbg(pm8001_ha, MSG, " register device is status = %d\n",
++                 status);
+       switch (status) {
+       case DEVREG_SUCCESS:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk("DEVREG_SUCCESS\n"));
++              pm8001_dbg(pm8001_ha, MSG, "DEVREG_SUCCESS\n");
+               pm8001_dev->device_id = device_id;
+               break;
+       case DEVREG_FAILURE_OUT_OF_RESOURCE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("DEVREG_FAILURE_OUT_OF_RESOURCE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "DEVREG_FAILURE_OUT_OF_RESOURCE\n");
+               break;
+       case DEVREG_FAILURE_DEVICE_ALREADY_REGISTERED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                 pm8001_printk("DEVREG_FAILURE_DEVICE_ALREADY_REGISTERED\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "DEVREG_FAILURE_DEVICE_ALREADY_REGISTERED\n");
+               break;
+       case DEVREG_FAILURE_INVALID_PHY_ID:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("DEVREG_FAILURE_INVALID_PHY_ID\n"));
++              pm8001_dbg(pm8001_ha, MSG, "DEVREG_FAILURE_INVALID_PHY_ID\n");
+               break;
+       case DEVREG_FAILURE_PHY_ID_ALREADY_REGISTERED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                 pm8001_printk("DEVREG_FAILURE_PHY_ID_ALREADY_REGISTERED\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "DEVREG_FAILURE_PHY_ID_ALREADY_REGISTERED\n");
+               break;
+       case DEVREG_FAILURE_PORT_ID_OUT_OF_RANGE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("DEVREG_FAILURE_PORT_ID_OUT_OF_RANGE\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "DEVREG_FAILURE_PORT_ID_OUT_OF_RANGE\n");
+               break;
+       case DEVREG_FAILURE_PORT_NOT_VALID_STATE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("DEVREG_FAILURE_PORT_NOT_VALID_STATE\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "DEVREG_FAILURE_PORT_NOT_VALID_STATE\n");
+               break;
+       case DEVREG_FAILURE_DEVICE_TYPE_NOT_VALID:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                     pm8001_printk("DEVREG_FAILURE_DEVICE_TYPE_NOT_VALID\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "DEVREG_FAILURE_DEVICE_TYPE_NOT_VALID\n");
+               break;
+       default:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("DEVREG_FAILURE_DEVICE_TYPE_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "DEVREG_FAILURE_DEVICE_TYPE_NOT_SUPPORTED\n");
+               break;
+       }
+       complete(pm8001_dev->dcompletion);
+@@ -3720,9 +3535,9 @@ int pm8001_mpi_dereg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       status = le32_to_cpu(registerRespPayload->status);
+       device_id = le32_to_cpu(registerRespPayload->device_id);
+       if (status != 0)
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" deregister device failed ,status = %x"
+-                      ", device_id = %x\n", status, device_id));
++              pm8001_dbg(pm8001_ha, MSG,
++                         " deregister device failed ,status = %x, device_id = %x\n",
++                         status, device_id);
+       return 0;
+ }
+ 
+@@ -3742,44 +3557,37 @@ int pm8001_mpi_fw_flash_update_resp(struct pm8001_hba_info *pm8001_ha,
+       status = le32_to_cpu(ppayload->status);
+       switch (status) {
+       case FLASH_UPDATE_COMPLETE_PENDING_REBOOT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-              pm8001_printk(": FLASH_UPDATE_COMPLETE_PENDING_REBOOT\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         ": FLASH_UPDATE_COMPLETE_PENDING_REBOOT\n");
+               break;
+       case FLASH_UPDATE_IN_PROGRESS:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(": FLASH_UPDATE_IN_PROGRESS\n"));
++              pm8001_dbg(pm8001_ha, MSG, ": FLASH_UPDATE_IN_PROGRESS\n");
+               break;
+       case FLASH_UPDATE_HDR_ERR:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(": FLASH_UPDATE_HDR_ERR\n"));
++              pm8001_dbg(pm8001_ha, MSG, ": FLASH_UPDATE_HDR_ERR\n");
+               break;
+       case FLASH_UPDATE_OFFSET_ERR:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(": FLASH_UPDATE_OFFSET_ERR\n"));
++              pm8001_dbg(pm8001_ha, MSG, ": FLASH_UPDATE_OFFSET_ERR\n");
+               break;
+       case FLASH_UPDATE_CRC_ERR:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(": FLASH_UPDATE_CRC_ERR\n"));
++              pm8001_dbg(pm8001_ha, MSG, ": FLASH_UPDATE_CRC_ERR\n");
+               break;
+       case FLASH_UPDATE_LENGTH_ERR:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(": FLASH_UPDATE_LENGTH_ERR\n"));
++              pm8001_dbg(pm8001_ha, MSG, ": FLASH_UPDATE_LENGTH_ERR\n");
+               break;
+       case FLASH_UPDATE_HW_ERR:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(": FLASH_UPDATE_HW_ERR\n"));
++              pm8001_dbg(pm8001_ha, MSG, ": FLASH_UPDATE_HW_ERR\n");
+               break;
+       case FLASH_UPDATE_DNLD_NOT_SUPPORTED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(": FLASH_UPDATE_DNLD_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         ": FLASH_UPDATE_DNLD_NOT_SUPPORTED\n");
+               break;
+       case FLASH_UPDATE_DISABLED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(": FLASH_UPDATE_DISABLED\n"));
++              pm8001_dbg(pm8001_ha, MSG, ": FLASH_UPDATE_DISABLED\n");
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("No matched status = %d\n", status));
++              pm8001_dbg(pm8001_ha, DEVIO, "No matched status = %d\n",
++                         status);
+               break;
+       }
+       kfree(ccb->fw_control_context);
+@@ -3797,12 +3605,11 @@ int pm8001_mpi_general_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       struct general_event_resp *pPayload =
+               (struct general_event_resp *)(piomb + 4);
+       status = le32_to_cpu(pPayload->status);
+-      PM8001_MSG_DBG(pm8001_ha,
+-              pm8001_printk(" status = 0x%x\n", status));
++      pm8001_dbg(pm8001_ha, MSG, " status = 0x%x\n", status);
+       for (i = 0; i < GENERAL_EVENT_PAYLOAD; i++)
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("inb_IOMB_payload[0x%x] 0x%x,\n", i,
+-                      pPayload->inb_IOMB_payload[i]));
++              pm8001_dbg(pm8001_ha, MSG, "inb_IOMB_payload[0x%x] 0x%x,\n",
++                         i,
++                         pPayload->inb_IOMB_payload[i]);
+       return 0;
+ }
+ 
+@@ -3822,8 +3629,7 @@ int pm8001_mpi_task_abort_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       status = le32_to_cpu(pPayload->status);
+       tag = le32_to_cpu(pPayload->tag);
+       if (!tag) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk(" TAG NULL. RETURNING !!!"));
++              pm8001_dbg(pm8001_ha, FAIL, " TAG NULL. RETURNING !!!\n");
+               return -1;
+       }
+ 
+@@ -3833,23 +3639,21 @@ int pm8001_mpi_task_abort_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       pm8001_dev = ccb->device; /* retrieve device */
+ 
+       if (!t) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk(" TASK NULL. RETURNING !!!"));
++              pm8001_dbg(pm8001_ha, FAIL, " TASK NULL. RETURNING !!!\n");
+               return -1;
+       }
+       ts = &t->task_status;
+       if (status != 0)
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("task abort failed status 0x%x ,"
+-                      "tag = 0x%x, scp= 0x%x\n", status, tag, scp));
++              pm8001_dbg(pm8001_ha, FAIL, "task abort failed status 0x%x ,tag = 0x%x, scp= 0x%x\n",
++                         status, tag, scp);
+       switch (status) {
+       case IO_SUCCESS:
+-              PM8001_EH_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS\n"));
++              pm8001_dbg(pm8001_ha, EH, "IO_SUCCESS\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAM_STAT_GOOD;
+               break;
+       case IO_NOT_VALID:
+-              PM8001_EH_DBG(pm8001_ha, pm8001_printk("IO_NOT_VALID\n"));
++              pm8001_dbg(pm8001_ha, EH, "IO_NOT_VALID\n");
+               ts->resp = TMF_RESP_FUNC_FAILED;
+               break;
+       }
+@@ -3894,14 +3698,13 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+       struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+       struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+       struct asd_sas_phy *sas_phy = sas_ha->sas_phy[phy_id];
+-      PM8001_DEVIO_DBG(pm8001_ha, pm8001_printk(
+-              "SPC HW event for portid:%d, phyid:%d, event:%x, status:%x\n",
+-              port_id, phy_id, eventType, status));
++      pm8001_dbg(pm8001_ha, DEVIO,
++                 "SPC HW event for portid:%d, phyid:%d, event:%x, status:%x\n",
++                 port_id, phy_id, eventType, status);
+       switch (eventType) {
+       case HW_EVENT_PHY_START_STATUS:
+-              PM8001_MSG_DBG(pm8001_ha,
+-              pm8001_printk("HW_EVENT_PHY_START_STATUS"
+-                      " status = %x\n", status));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_START_STATUS status = %x\n",
++                         status);
+               if (status == 0) {
+                       phy->phy_state = 1;
+                       if (pm8001_ha->flags == PM8001F_RUN_TIME &&
+@@ -3910,38 +3713,32 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               }
+               break;
+       case HW_EVENT_SAS_PHY_UP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PHY_START_STATUS\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_START_STATUS\n");
+               hw_event_sas_phy_up(pm8001_ha, piomb);
+               break;
+       case HW_EVENT_SATA_PHY_UP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_SATA_PHY_UP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_SATA_PHY_UP\n");
+               hw_event_sata_phy_up(pm8001_ha, piomb);
+               break;
+       case HW_EVENT_PHY_STOP_STATUS:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PHY_STOP_STATUS "
+-                      "status = %x\n", status));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_STOP_STATUS status = %x\n",
++                         status);
+               if (status == 0)
+                       phy->phy_state = 0;
+               break;
+       case HW_EVENT_SATA_SPINUP_HOLD:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_SATA_SPINUP_HOLD\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_SATA_SPINUP_HOLD\n");
+               sas_ha->notify_phy_event(&phy->sas_phy, PHYE_SPINUP_HOLD);
+               break;
+       case HW_EVENT_PHY_DOWN:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PHY_DOWN\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_DOWN\n");
+               sas_ha->notify_phy_event(&phy->sas_phy, PHYE_LOSS_OF_SIGNAL);
+               phy->phy_attached = 0;
+               phy->phy_state = 0;
+               hw_event_phy_down(pm8001_ha, piomb);
+               break;
+       case HW_EVENT_PORT_INVALID:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PORT_INVALID\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_INVALID\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+@@ -3949,8 +3746,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+       /* the broadcast change primitive received, tell the LIBSAS this event
+       to revalidate the sas domain*/
+       case HW_EVENT_BROADCAST_CHANGE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_BROADCAST_CHANGE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_BROADCAST_CHANGE\n");
+               pm8001_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_BROADCAST_CHANGE,
+                       port_id, phy_id, 1, 0);
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+@@ -3959,23 +3755,21 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_PHY_ERROR:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PHY_ERROR\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_ERROR\n");
+               sas_phy_disconnected(&phy->sas_phy);
+               phy->phy_attached = 0;
+               sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_ERROR);
+               break;
+       case HW_EVENT_BROADCAST_EXP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_BROADCAST_EXP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_BROADCAST_EXP\n");
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+               sas_phy->sas_prim = HW_EVENT_BROADCAST_EXP;
+               spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+               sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_LINK_ERR_INVALID_DWORD:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_LINK_ERR_INVALID_DWORD\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_LINK_ERR_INVALID_DWORD\n");
+               pm8001_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_LINK_ERR_INVALID_DWORD, port_id, phy_id, 0, 0);
+               sas_phy_disconnected(sas_phy);
+@@ -3983,8 +3777,8 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_LINK_ERR_DISPARITY_ERROR:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_LINK_ERR_DISPARITY_ERROR\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_LINK_ERR_DISPARITY_ERROR\n");
+               pm8001_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_LINK_ERR_DISPARITY_ERROR,
+                       port_id, phy_id, 0, 0);
+@@ -3993,8 +3787,8 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_LINK_ERR_CODE_VIOLATION:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_LINK_ERR_CODE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_LINK_ERR_CODE_VIOLATION\n");
+               pm8001_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_LINK_ERR_CODE_VIOLATION,
+                       port_id, phy_id, 0, 0);
+@@ -4003,8 +3797,8 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                    pm8001_printk("HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH\n");
+               pm8001_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH,
+                       port_id, phy_id, 0, 0);
+@@ -4013,39 +3807,34 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_MALFUNCTION:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_MALFUNCTION\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_MALFUNCTION\n");
+               break;
+       case HW_EVENT_BROADCAST_SES:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_BROADCAST_SES\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_BROADCAST_SES\n");
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+               sas_phy->sas_prim = HW_EVENT_BROADCAST_SES;
+               spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+               sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_INBOUND_CRC_ERROR:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_INBOUND_CRC_ERROR\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_INBOUND_CRC_ERROR\n");
+               pm8001_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_INBOUND_CRC_ERROR,
+                       port_id, phy_id, 0, 0);
+               break;
+       case HW_EVENT_HARD_RESET_RECEIVED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_HARD_RESET_RECEIVED\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_HARD_RESET_RECEIVED\n");
+               sas_ha->notify_port_event(sas_phy, PORTE_HARD_RESET);
+               break;
+       case HW_EVENT_ID_FRAME_TIMEOUT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_ID_FRAME_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_ID_FRAME_TIMEOUT\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_LINK_ERR_PHY_RESET_FAILED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_LINK_ERR_PHY_RESET_FAILED\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_LINK_ERR_PHY_RESET_FAILED\n");
+               pm8001_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_LINK_ERR_PHY_RESET_FAILED,
+                       port_id, phy_id, 0, 0);
+@@ -4054,34 +3843,30 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_PORT_RESET_TIMER_TMO:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PORT_RESET_TIMER_TMO\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_RESET_TIMER_TMO\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_PORT_RECOVERY_TIMER_TMO:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PORT_RECOVERY_TIMER_TMO\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_PORT_RECOVERY_TIMER_TMO\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_PORT_RECOVER:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PORT_RECOVER\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_RECOVER\n");
+               break;
+       case HW_EVENT_PORT_RESET_COMPLETE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PORT_RESET_COMPLETE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_RESET_COMPLETE\n");
+               break;
+       case EVENT_BROADCAST_ASYNCH_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("EVENT_BROADCAST_ASYNCH_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "EVENT_BROADCAST_ASYNCH_EVENT\n");
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown event type = %x\n", eventType));
++              pm8001_dbg(pm8001_ha, DEVIO, "Unknown event type = %x\n",
++                         eventType);
+               break;
+       }
+       return 0;
+@@ -4097,163 +3882,132 @@ static void process_one_iomb(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       __le32 pHeader = *(__le32 *)piomb;
+       u8 opc = (u8)((le32_to_cpu(pHeader)) & 0xFFF);
+ 
+-      PM8001_MSG_DBG(pm8001_ha, pm8001_printk("process_one_iomb:"));
++      pm8001_dbg(pm8001_ha, MSG, "process_one_iomb:\n");
+ 
+       switch (opc) {
+       case OPC_OUB_ECHO:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk("OPC_OUB_ECHO\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_ECHO\n");
+               break;
+       case OPC_OUB_HW_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_HW_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_HW_EVENT\n");
+               mpi_hw_event(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SSP_COMP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SSP_COMP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SSP_COMP\n");
+               mpi_ssp_completion(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SMP_COMP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SMP_COMP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SMP_COMP\n");
+               mpi_smp_completion(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_LOCAL_PHY_CNTRL:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_LOCAL_PHY_CNTRL\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_LOCAL_PHY_CNTRL\n");
+               pm8001_mpi_local_phy_ctl(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_DEV_REGIST:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_DEV_REGIST\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_DEV_REGIST\n");
+               pm8001_mpi_reg_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_DEREG_DEV:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("unregister the device\n"));
++              pm8001_dbg(pm8001_ha, MSG, "unregister the device\n");
+               pm8001_mpi_dereg_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_GET_DEV_HANDLE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GET_DEV_HANDLE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GET_DEV_HANDLE\n");
+               break;
+       case OPC_OUB_SATA_COMP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SATA_COMP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SATA_COMP\n");
+               mpi_sata_completion(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SATA_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SATA_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SATA_EVENT\n");
+               mpi_sata_event(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SSP_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SSP_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SSP_EVENT\n");
+               mpi_ssp_event(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_DEV_HANDLE_ARRIV:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_DEV_HANDLE_ARRIV\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_DEV_HANDLE_ARRIV\n");
+               /*This is for target*/
+               break;
+       case OPC_OUB_SSP_RECV_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SSP_RECV_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SSP_RECV_EVENT\n");
+               /*This is for target*/
+               break;
+       case OPC_OUB_DEV_INFO:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_DEV_INFO\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_DEV_INFO\n");
+               break;
+       case OPC_OUB_FW_FLASH_UPDATE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_FW_FLASH_UPDATE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_FW_FLASH_UPDATE\n");
+               pm8001_mpi_fw_flash_update_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_GPIO_RESPONSE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GPIO_RESPONSE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GPIO_RESPONSE\n");
+               break;
+       case OPC_OUB_GPIO_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GPIO_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GPIO_EVENT\n");
+               break;
+       case OPC_OUB_GENERAL_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GENERAL_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GENERAL_EVENT\n");
+               pm8001_mpi_general_event(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SSP_ABORT_RSP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SSP_ABORT_RSP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SSP_ABORT_RSP\n");
+               pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SATA_ABORT_RSP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SATA_ABORT_RSP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SATA_ABORT_RSP\n");
+               pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SAS_DIAG_MODE_START_END:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SAS_DIAG_MODE_START_END\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_SAS_DIAG_MODE_START_END\n");
+               break;
+       case OPC_OUB_SAS_DIAG_EXECUTE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SAS_DIAG_EXECUTE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SAS_DIAG_EXECUTE\n");
+               break;
+       case OPC_OUB_GET_TIME_STAMP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GET_TIME_STAMP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GET_TIME_STAMP\n");
+               break;
+       case OPC_OUB_SAS_HW_EVENT_ACK:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SAS_HW_EVENT_ACK\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SAS_HW_EVENT_ACK\n");
+               break;
+       case OPC_OUB_PORT_CONTROL:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_PORT_CONTROL\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_PORT_CONTROL\n");
+               break;
+       case OPC_OUB_SMP_ABORT_RSP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SMP_ABORT_RSP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SMP_ABORT_RSP\n");
+               pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_GET_NVMD_DATA:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GET_NVMD_DATA\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GET_NVMD_DATA\n");
+               pm8001_mpi_get_nvmd_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SET_NVMD_DATA:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SET_NVMD_DATA\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SET_NVMD_DATA\n");
+               pm8001_mpi_set_nvmd_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_DEVICE_HANDLE_REMOVAL:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_DEVICE_HANDLE_REMOVAL\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_DEVICE_HANDLE_REMOVAL\n");
+               break;
+       case OPC_OUB_SET_DEVICE_STATE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SET_DEVICE_STATE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SET_DEVICE_STATE\n");
+               pm8001_mpi_set_dev_state_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_GET_DEVICE_STATE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GET_DEVICE_STATE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GET_DEVICE_STATE\n");
+               break;
+       case OPC_OUB_SET_DEV_INFO:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SET_DEV_INFO\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SET_DEV_INFO\n");
+               break;
+       case OPC_OUB_SAS_RE_INITIALIZE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SAS_RE_INITIALIZE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SAS_RE_INITIALIZE\n");
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown outbound Queue IOMB OPC = %x\n",
+-                      opc));
++              pm8001_dbg(pm8001_ha, DEVIO,
++                         "Unknown outbound Queue IOMB OPC = %x\n",
++                         opc);
+               break;
+       }
+ }
+@@ -4466,19 +4220,19 @@ static int pm8001_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+       circularQ = &pm8001_ha->inbnd_q_tbl[0];
+       if (task->data_dir == DMA_NONE) {
+               ATAP = 0x04;  /* no data*/
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("no data\n"));
++              pm8001_dbg(pm8001_ha, IO, "no data\n");
+       } else if (likely(!task->ata_task.device_control_reg_update)) {
+               if (task->ata_task.dma_xfer) {
+                       ATAP = 0x06; /* DMA */
+-                      PM8001_IO_DBG(pm8001_ha, pm8001_printk("DMA\n"));
++                      pm8001_dbg(pm8001_ha, IO, "DMA\n");
+               } else {
+                       ATAP = 0x05; /* PIO*/
+-                      PM8001_IO_DBG(pm8001_ha, pm8001_printk("PIO\n"));
++                      pm8001_dbg(pm8001_ha, IO, "PIO\n");
+               }
+               if (task->ata_task.use_ncq &&
+                       dev->sata_dev.class != ATA_DEV_ATAPI) {
+                       ATAP = 0x07; /* FPDMA */
+-                      PM8001_IO_DBG(pm8001_ha, pm8001_printk("FPDMA\n"));
++                      pm8001_dbg(pm8001_ha, IO, "FPDMA\n");
+               }
+       }
+       if (task->ata_task.use_ncq && pm8001_get_ncq_tag(task, &hdr_tag)) {
+@@ -4535,10 +4289,10 @@ static int pm8001_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+                                       SAS_TASK_STATE_ABORTED))) {
+                               spin_unlock_irqrestore(&task->task_state_lock,
+                                                       flags);
+-                              PM8001_FAIL_DBG(pm8001_ha,
+-                                      pm8001_printk("task 0x%p resp 0x%x "
+-                                      " stat 0x%x but aborted by upper layer "
+-                                      "\n", task, ts->resp, ts->stat));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "task 0x%p resp 0x%x  stat 0x%x but aborted by upper layer\n",
++                                         task, ts->resp,
++                                         ts->stat);
+                               pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+                       } else {
+                               spin_unlock_irqrestore(&task->task_state_lock,
+@@ -4687,8 +4441,8 @@ int pm8001_chip_dereg_dev_req(struct pm8001_hba_info *pm8001_ha,
+       memset(&payload, 0, sizeof(payload));
+       payload.tag = cpu_to_le32(1);
+       payload.device_id = cpu_to_le32(device_id);
+-      PM8001_MSG_DBG(pm8001_ha,
+-              pm8001_printk("unregister device device_id = %d\n", device_id));
++      pm8001_dbg(pm8001_ha, MSG, "unregister device device_id = %d\n",
++                 device_id);
+       ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload,
+                       sizeof(payload), 0);
+       return ret;
+@@ -4740,9 +4494,9 @@ static irqreturn_t
+ pm8001_chip_isr(struct pm8001_hba_info *pm8001_ha, u8 vec)
+ {
+       pm8001_chip_interrupt_disable(pm8001_ha, vec);
+-      PM8001_DEVIO_DBG(pm8001_ha, pm8001_printk(
+-              "irq vec %d, ODMR:0x%x\n",
+-              vec, pm8001_cr32(pm8001_ha, 0, 0x30)));
++      pm8001_dbg(pm8001_ha, DEVIO,
++                 "irq vec %d, ODMR:0x%x\n",
++                 vec, pm8001_cr32(pm8001_ha, 0, 0x30));
+       process_oq(pm8001_ha, vec);
+       pm8001_chip_interrupt_enable(pm8001_ha, vec);
+       return IRQ_HANDLED;
+@@ -4779,9 +4533,8 @@ int pm8001_chip_abort_task(struct pm8001_hba_info *pm8001_ha,
+ {
+       u32 opc, device_id;
+       int rc = TMF_RESP_FUNC_FAILED;
+-      PM8001_EH_DBG(pm8001_ha,
+-              pm8001_printk("cmd_tag = %x, abort task tag = 0x%x",
+-                      cmd_tag, task_tag));
++      pm8001_dbg(pm8001_ha, EH, "cmd_tag = %x, abort task tag = 0x%x\n",
++                 cmd_tag, task_tag);
+       if (pm8001_dev->dev_type == SAS_END_DEVICE)
+               opc = OPC_INB_SSP_ABORT;
+       else if (pm8001_dev->dev_type == SAS_SATA_DEV)
+@@ -4792,7 +4545,7 @@ int pm8001_chip_abort_task(struct pm8001_hba_info *pm8001_ha,
+       rc = send_task_abort(pm8001_ha, opc, device_id, flag,
+               task_tag, cmd_tag);
+       if (rc != TMF_RESP_FUNC_COMPLETE)
+-              PM8001_EH_DBG(pm8001_ha, pm8001_printk("rc= %d\n", rc));
++              pm8001_dbg(pm8001_ha, EH, "rc= %d\n", rc);
+       return rc;
+ }
+ 
+@@ -5058,8 +4811,9 @@ pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha,
+       if (!fw_control_context)
+               return -ENOMEM;
+       fw_control = (struct fw_control_info *)&ioctl_payload->func_specific;
+-      PM8001_DEVIO_DBG(pm8001_ha, pm8001_printk(
+-              "dma fw_control context input length :%x\n", fw_control->len));
++      pm8001_dbg(pm8001_ha, DEVIO,
++                 "dma fw_control context input length :%x\n",
++                 fw_control->len);
+       memcpy(buffer, fw_control->buffer, fw_control->len);
+       flash_update_info.sgl.addr = cpu_to_le64(phys_addr);
+       flash_update_info.sgl.im_len.len = cpu_to_le32(fw_control->len);
+diff --git a/drivers/scsi/pm8001/pm8001_init.c b/drivers/scsi/pm8001/pm8001_init.c
+index 89397e5351ff..7657d68e12d5 100644
+--- a/drivers/scsi/pm8001/pm8001_init.c
++++ b/drivers/scsi/pm8001/pm8001_init.c
+@@ -271,15 +271,14 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha,
+ 
+       spin_lock_init(&pm8001_ha->lock);
+       spin_lock_init(&pm8001_ha->bitmap_lock);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("pm8001_alloc: PHY:%x\n",
+-                              pm8001_ha->chip->n_phy));
++      pm8001_dbg(pm8001_ha, INIT, "pm8001_alloc: PHY:%x\n",
++                 pm8001_ha->chip->n_phy);
+ 
+       /* Setup Interrupt */
+       rc = pm8001_setup_irq(pm8001_ha);
+       if (rc) {
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                              "pm8001_setup_irq failed [ret: %d]\n", rc));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "pm8001_setup_irq failed [ret: %d]\n", rc);
+               goto err_out_shost;
+       }
+       /* Request Interrupt */
+@@ -394,9 +393,9 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha,
+                       &pm8001_ha->memoryMap.region[i].phys_addr_lo,
+                       pm8001_ha->memoryMap.region[i].total_len,
+                       pm8001_ha->memoryMap.region[i].alignment) != 0) {
+-                              PM8001_FAIL_DBG(pm8001_ha,
+-                                      pm8001_printk("Mem%d alloc failed\n",
+-                                      i));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "Mem%d alloc failed\n",
++                                 i);
+                               goto err_out;
+               }
+       }
+@@ -467,15 +466,15 @@ static int pm8001_ioremap(struct pm8001_hba_info *pm8001_ha)
+                       pm8001_ha->io_mem[logicalBar].memvirtaddr =
+                               ioremap(pm8001_ha->io_mem[logicalBar].membase,
+                               pm8001_ha->io_mem[logicalBar].memsize);
+-                      PM8001_INIT_DBG(pm8001_ha,
+-                              pm8001_printk("PCI: bar %d, logicalBar %d ",
+-                              bar, logicalBar));
+-                      PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+-                              "base addr %llx virt_addr=%llx len=%d\n",
+-                              (u64)pm8001_ha->io_mem[logicalBar].membase,
+-                              (u64)(unsigned long)
+-                              pm8001_ha->io_mem[logicalBar].memvirtaddr,
+-                              pm8001_ha->io_mem[logicalBar].memsize));
++                      pm8001_dbg(pm8001_ha, INIT,
++                                 "PCI: bar %d, logicalBar %d\n",
++                                 bar, logicalBar);
++                      pm8001_dbg(pm8001_ha, INIT,
++                                 "base addr %llx virt_addr=%llx len=%d\n",
++                                 (u64)pm8001_ha->io_mem[logicalBar].membase,
++                                 (u64)(unsigned long)
++                                 pm8001_ha->io_mem[logicalBar].memvirtaddr,
++                                 pm8001_ha->io_mem[logicalBar].memsize);
+               } else {
+                       pm8001_ha->io_mem[logicalBar].membase   = 0;
+                       pm8001_ha->io_mem[logicalBar].memsize   = 0;
+@@ -520,8 +519,8 @@ static struct pm8001_hba_info *pm8001_pci_alloc(struct pci_dev *pdev,
+       else {
+               pm8001_ha->link_rate = LINKRATE_15 | LINKRATE_30 |
+                       LINKRATE_60 | LINKRATE_120;
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                      "Setting link rate to default value\n"));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "Setting link rate to default value\n");
+       }
+       sprintf(pm8001_ha->name, "%s%d", DRV_NAME, pm8001_ha->id);
+       /* IOMB size is 128 for 8088/89 controllers */
+@@ -684,13 +683,13 @@ static void pm8001_init_sas_add(struct pm8001_hba_info *pm8001_ha)
+       payload.offset = 0;
+       payload.func_specific = kzalloc(payload.rd_length, GFP_KERNEL);
+       if (!payload.func_specific) {
+-              PM8001_INIT_DBG(pm8001_ha, pm8001_printk("mem alloc fail\n"));
++              pm8001_dbg(pm8001_ha, INIT, "mem alloc fail\n");
+               return;
+       }
+       rc = PM8001_CHIP_DISP->get_nvmd_req(pm8001_ha, &payload);
+       if (rc) {
+               kfree(payload.func_specific);
+-              PM8001_INIT_DBG(pm8001_ha, pm8001_printk("nvmd failed\n"));
++              pm8001_dbg(pm8001_ha, INIT, "nvmd failed\n");
+               return;
+       }
+       wait_for_completion(&completion);
+@@ -718,9 +717,8 @@ static void pm8001_init_sas_add(struct pm8001_hba_info *pm8001_ha)
+                       sas_add[7] = sas_add[7] + 4;
+               memcpy(&pm8001_ha->phy[i].dev_sas_addr,
+                       sas_add, SAS_ADDR_SIZE);
+-              PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("phy %d sas_addr = %016llx\n", i,
+-                      pm8001_ha->phy[i].dev_sas_addr));
++              pm8001_dbg(pm8001_ha, INIT, "phy %d sas_addr = %016llx\n", i,
++                         pm8001_ha->phy[i].dev_sas_addr);
+       }
+       kfree(payload.func_specific);
+ #else
+@@ -760,7 +758,7 @@ static int pm8001_get_phy_settings_info(struct pm8001_hba_info *pm8001_ha)
+       rc = PM8001_CHIP_DISP->get_nvmd_req(pm8001_ha, &payload);
+       if (rc) {
+               kfree(payload.func_specific);
+-              PM8001_INIT_DBG(pm8001_ha, pm8001_printk("nvmd failed\n"));
++              pm8001_dbg(pm8001_ha, INIT, "nvmd failed\n");
+               return -ENOMEM;
+       }
+       wait_for_completion(&completion);
+@@ -854,9 +852,9 @@ void pm8001_get_phy_mask(struct pm8001_hba_info *pm8001_ha, int *phymask)
+               break;
+ 
+       default:
+-              PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown subsystem device=0x%.04x",
+-                              pm8001_ha->pdev->subsystem_device));
++              pm8001_dbg(pm8001_ha, INIT,
++                         "Unknown subsystem device=0x%.04x\n",
++                         pm8001_ha->pdev->subsystem_device);
+       }
+ }
+ 
+@@ -950,9 +948,9 @@ static u32 pm8001_setup_msix(struct pm8001_hba_info *pm8001_ha)
+       /* Maximum queue number updating in HBA structure */
+       pm8001_ha->max_q_num = number_of_intr;
+ 
+-      PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+-              "pci_alloc_irq_vectors request ret:%d no of intr %d\n",
+-                              rc, pm8001_ha->number_of_intr));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "pci_alloc_irq_vectors request ret:%d no of intr %d\n",
++                 rc, pm8001_ha->number_of_intr);
+       return 0;
+ }
+ 
+@@ -964,9 +962,9 @@ static u32 pm8001_request_msix(struct pm8001_hba_info *pm8001_ha)
+       if (pm8001_ha->chip_id != chip_8001)
+               flag &= ~IRQF_SHARED;
+ 
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("pci_enable_msix request number of intr %d\n",
+-              pm8001_ha->number_of_intr));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "pci_enable_msix request number of intr %d\n",
++                 pm8001_ha->number_of_intr);
+ 
+       for (i = 0; i < pm8001_ha->number_of_intr; i++) {
+               snprintf(pm8001_ha->intr_drvname[i],
+@@ -1002,8 +1000,7 @@ static u32 pm8001_setup_irq(struct pm8001_hba_info *pm8001_ha)
+ #ifdef PM8001_USE_MSIX
+       if (pci_find_capability(pdev, PCI_CAP_ID_MSIX))
+               return pm8001_setup_msix(pm8001_ha);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("MSIX not supported!!!\n"));
++      pm8001_dbg(pm8001_ha, INIT, "MSIX not supported!!!\n");
+ #endif
+       return 0;
+ }
+@@ -1023,8 +1020,7 @@ static u32 pm8001_request_irq(struct pm8001_hba_info *pm8001_ha)
+       if (pdev->msix_cap && pci_msi_enabled())
+               return pm8001_request_msix(pm8001_ha);
+       else {
+-              PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("MSIX not supported!!!\n"));
++              pm8001_dbg(pm8001_ha, INIT, "MSIX not supported!!!\n");
+               goto intx;
+       }
+ #endif
+@@ -1108,8 +1104,8 @@ static int pm8001_pci_probe(struct pci_dev *pdev,
+       PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha);
+       rc = PM8001_CHIP_DISP->chip_init(pm8001_ha);
+       if (rc) {
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                      "chip_init failed [ret: %d]\n", rc));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "chip_init failed [ret: %d]\n", rc);
+               goto err_out_ha_free;
+       }
+ 
+@@ -1138,8 +1134,8 @@ static int pm8001_pci_probe(struct pci_dev *pdev,
+       pm8001_post_sas_ha_init(shost, chip);
+       rc = sas_register_ha(SHOST_TO_SAS_HA(shost));
+       if (rc) {
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                      "sas_register_ha failed [ret: %d]\n", rc));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "sas_register_ha failed [ret: %d]\n", rc);
+               goto err_out_shost;
+       }
+       list_add_tail(&pm8001_ha->list, &hba_list);
+@@ -1191,8 +1187,8 @@ pm8001_init_ccb_tag(struct pm8001_hba_info *pm8001_ha, struct Scsi_Host *shost,
+       pm8001_ha->ccb_info = (struct pm8001_ccb_info *)
+               kcalloc(ccb_count, sizeof(struct pm8001_ccb_info), GFP_KERNEL);
+       if (!pm8001_ha->ccb_info) {
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk
+-                      ("Unable to allocate memory for ccb\n"));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "Unable to allocate memory for ccb\n");
+               goto err_out_noccb;
+       }
+       for (i = 0; i < ccb_count; i++) {
+@@ -1200,8 +1196,8 @@ pm8001_init_ccb_tag(struct pm8001_hba_info *pm8001_ha, struct Scsi_Host *shost,
+                               sizeof(struct pm8001_prd) * PM8001_MAX_DMA_SG,
+                               &pm8001_ha->ccb_info[i].ccb_dma_handle);
+               if (!pm8001_ha->ccb_info[i].buf_prd) {
+-                      PM8001_FAIL_DBG(pm8001_ha, pm8001_printk
+-                                      ("pm80xx: ccb prd memory allocation error\n"));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "pm80xx: ccb prd memory allocation error\n");
+                       goto err_out;
+               }
+               pm8001_ha->ccb_info[i].task = NULL;
+@@ -1345,8 +1341,7 @@ static int pm8001_pci_resume(struct pci_dev *pdev)
+       /* chip soft rst only for spc */
+       if (pm8001_ha->chip_id == chip_8001) {
+               PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha);
+-              PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("chip soft reset successful\n"));
++              pm8001_dbg(pm8001_ha, INIT, "chip soft reset successful\n");
+       }
+       rc = PM8001_CHIP_DISP->chip_init(pm8001_ha);
+       if (rc)
+diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
+index d6e0bc588698..7a6d34267585 100644
+--- a/drivers/scsi/pm8001/pm8001_sas.c
++++ b/drivers/scsi/pm8001/pm8001_sas.c
+@@ -250,8 +250,7 @@ int pm8001_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
+               spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+               return 0;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("func 0x%x\n", func));
++              pm8001_dbg(pm8001_ha, DEVIO, "func 0x%x\n", func);
+               rc = -EOPNOTSUPP;
+       }
+       msleep(300);
+@@ -405,7 +404,7 @@ static int pm8001_task_exec(struct sas_task *task,
+               t->task_done(t);
+               return 0;
+       }
+-      PM8001_IO_DBG(pm8001_ha, pm8001_printk("pm8001_task_exec device \n "));
++      pm8001_dbg(pm8001_ha, IO, "pm8001_task_exec device\n");
+       spin_lock_irqsave(&pm8001_ha->lock, flags);
+       do {
+               dev = t->dev;
+@@ -480,8 +479,7 @@ static int pm8001_task_exec(struct sas_task *task,
+               }
+ 
+               if (rc) {
+-                      PM8001_IO_DBG(pm8001_ha,
+-                              pm8001_printk("rc is %x\n", rc));
++                      pm8001_dbg(pm8001_ha, IO, "rc is %x\n", rc);
+                       atomic_dec(&pm8001_dev->running_req);
+                       goto err_out_tag;
+               }
+@@ -570,9 +568,9 @@ static struct pm8001_device *pm8001_alloc_dev(struct pm8001_hba_info *pm8001_ha)
+               }
+       }
+       if (dev == PM8001_MAX_DEVICES) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("max support %d devices, ignore ..\n",
+-                      PM8001_MAX_DEVICES));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "max support %d devices, ignore ..\n",
++                         PM8001_MAX_DEVICES);
+       }
+       return NULL;
+ }
+@@ -590,8 +588,7 @@ struct pm8001_device *pm8001_find_dev(struct pm8001_hba_info *pm8001_ha,
+                       return &pm8001_ha->devices[dev];
+       }
+       if (dev == PM8001_MAX_DEVICES) {
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("NO MATCHING "
+-                              "DEVICE FOUND !!!\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "NO MATCHING DEVICE FOUND !!!\n");
+       }
+       return NULL;
+ }
+@@ -652,10 +649,10 @@ static int pm8001_dev_found_notify(struct domain_device *dev)
+                       }
+               }
+               if (phy_id == parent_dev->ex_dev.num_phys) {
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Error: no attached dev:%016llx"
+-                      " at ex:%016llx.\n", SAS_ADDR(dev->sas_addr),
+-                              SAS_ADDR(parent_dev->sas_addr)));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "Error: no attached dev:%016llx at ex:%016llx.\n",
++                                 SAS_ADDR(dev->sas_addr),
++                                 SAS_ADDR(parent_dev->sas_addr));
+                       res = -1;
+               }
+       } else {
+@@ -665,7 +662,7 @@ static int pm8001_dev_found_notify(struct domain_device *dev)
+                       flag = 1; /* directly sata */
+               }
+       } /*register this device to HBA*/
+-      PM8001_DISC_DBG(pm8001_ha, pm8001_printk("Found device\n"));
++      pm8001_dbg(pm8001_ha, DISC, "Found device\n");
+       PM8001_CHIP_DISP->reg_dev_req(pm8001_ha, pm8001_device, flag);
+       spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+       wait_for_completion(&completion);
+@@ -737,9 +734,7 @@ static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
+ 
+               if (res) {
+                       del_timer(&task->slow_task->timer);
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("Executing internal task "
+-                              "failed\n"));
++                      pm8001_dbg(pm8001_ha, FAIL, "Executing internal task failed\n");
+                       goto ex_err;
+               }
+               wait_for_completion(&task->slow_task->completion);
+@@ -753,9 +748,9 @@ static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
+               /* Even TMF timed out, return direct. */
+               if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
+                       if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
+-                              PM8001_FAIL_DBG(pm8001_ha,
+-                                      pm8001_printk("TMF task[%x]timeout.\n",
+-                                      tmf->tmf));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "TMF task[%x]timeout.\n",
++                                         tmf->tmf);
+                               goto ex_err;
+                       }
+               }
+@@ -776,17 +771,15 @@ static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
+ 
+               if (task->task_status.resp == SAS_TASK_COMPLETE &&
+                       task->task_status.stat == SAS_DATA_OVERRUN) {
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("Blocked task error.\n"));
++                      pm8001_dbg(pm8001_ha, FAIL, "Blocked task error.\n");
+                       res = -EMSGSIZE;
+                       break;
+               } else {
+-                      PM8001_EH_DBG(pm8001_ha,
+-                              pm8001_printk(" Task to dev %016llx response:"
+-                              "0x%x status 0x%x\n",
+-                              SAS_ADDR(dev->sas_addr),
+-                              task->task_status.resp,
+-                              task->task_status.stat));
++                      pm8001_dbg(pm8001_ha, EH,
++                                 " Task to dev %016llx response:0x%x status 0x%x\n",
++                                 SAS_ADDR(dev->sas_addr),
++                                 task->task_status.resp,
++                                 task->task_status.stat);
+                       sas_free_task(task);
+                       task = NULL;
+               }
+@@ -833,9 +826,7 @@ pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
+ 
+               if (res) {
+                       del_timer(&task->slow_task->timer);
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("Executing internal task "
+-                              "failed\n"));
++                      pm8001_dbg(pm8001_ha, FAIL, "Executing internal task failed\n");
+                       goto ex_err;
+               }
+               wait_for_completion(&task->slow_task->completion);
+@@ -843,8 +834,8 @@ pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
+               /* Even TMF timed out, return direct. */
+               if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
+                       if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
+-                              PM8001_FAIL_DBG(pm8001_ha,
+-                                      pm8001_printk("TMF task timeout.\n"));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "TMF task timeout.\n");
+                               goto ex_err;
+                       }
+               }
+@@ -855,12 +846,11 @@ pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
+                       break;
+ 
+               } else {
+-                      PM8001_EH_DBG(pm8001_ha,
+-                              pm8001_printk(" Task to dev %016llx response: "
+-                                      "0x%x status 0x%x\n",
+-                              SAS_ADDR(dev->sas_addr),
+-                              task->task_status.resp,
+-                              task->task_status.stat));
++                      pm8001_dbg(pm8001_ha, EH,
++                                 " Task to dev %016llx response: 0x%x status 0x%x\n",
++                                 SAS_ADDR(dev->sas_addr),
++                                 task->task_status.resp,
++                                 task->task_status.stat);
+                       sas_free_task(task);
+                       task = NULL;
+               }
+@@ -886,9 +876,8 @@ static void pm8001_dev_gone_notify(struct domain_device *dev)
+       if (pm8001_dev) {
+               u32 device_id = pm8001_dev->device_id;
+ 
+-              PM8001_DISC_DBG(pm8001_ha,
+-                      pm8001_printk("found dev[%d:%x] is gone.\n",
+-                      pm8001_dev->device_id, pm8001_dev->dev_type));
++              pm8001_dbg(pm8001_ha, DISC, "found dev[%d:%x] is gone.\n",
++                         pm8001_dev->device_id, pm8001_dev->dev_type);
+               if (atomic_read(&pm8001_dev->running_req)) {
+                       spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                       pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
+@@ -900,8 +889,7 @@ static void pm8001_dev_gone_notify(struct domain_device *dev)
+               PM8001_CHIP_DISP->dereg_dev_req(pm8001_ha, device_id);
+               pm8001_free_dev(pm8001_dev);
+       } else {
+-              PM8001_DISC_DBG(pm8001_ha,
+-                      pm8001_printk("Found dev has gone.\n"));
++              pm8001_dbg(pm8001_ha, DISC, "Found dev has gone.\n");
+       }
+       dev->lldd_dev = NULL;
+       spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+@@ -1021,9 +1009,9 @@ int pm8001_I_T_nexus_reset(struct domain_device *dev)
+               }
+               rc = sas_phy_reset(phy, 1);
+               if (rc) {
+-                      PM8001_EH_DBG(pm8001_ha,
+-                      pm8001_printk("phy reset failed for device %x\n"
+-                      "with rc %d\n", pm8001_dev->device_id, rc));
++                      pm8001_dbg(pm8001_ha, EH,
++                                 "phy reset failed for device %x\n"
++                                 "with rc %d\n", pm8001_dev->device_id, rc);
+                       rc = TMF_RESP_FUNC_FAILED;
+                       goto out;
+               }
+@@ -1031,17 +1019,16 @@ int pm8001_I_T_nexus_reset(struct domain_device *dev)
+               rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
+                       dev, 1, 0);
+               if (rc) {
+-                      PM8001_EH_DBG(pm8001_ha,
+-                      pm8001_printk("task abort failed %x\n"
+-                      "with rc %d\n", pm8001_dev->device_id, rc));
++                      pm8001_dbg(pm8001_ha, EH, "task abort failed %x\n"
++                                 "with rc %d\n", pm8001_dev->device_id, rc);
+                       rc = TMF_RESP_FUNC_FAILED;
+               }
+       } else {
+               rc = sas_phy_reset(phy, 1);
+               msleep(2000);
+       }
+-      PM8001_EH_DBG(pm8001_ha, pm8001_printk(" for device[%x]:rc=%d\n",
+-              pm8001_dev->device_id, rc));
++      pm8001_dbg(pm8001_ha, EH, " for device[%x]:rc=%d\n",
++                 pm8001_dev->device_id, rc);
+  out:
+       sas_put_local_phy(phy);
+       return rc;
+@@ -1064,8 +1051,7 @@ int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
+       pm8001_dev = dev->lldd_dev;
+       pm8001_ha = pm8001_find_ha_by_dev(dev);
+ 
+-      PM8001_EH_DBG(pm8001_ha,
+-                      pm8001_printk("I_T_Nexus handler invoked !!"));
++      pm8001_dbg(pm8001_ha, EH, "I_T_Nexus handler invoked !!\n");
+ 
+       phy = sas_get_local_phy(dev);
+ 
+@@ -1104,8 +1090,8 @@ int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
+               rc = sas_phy_reset(phy, 1);
+               msleep(2000);
+       }
+-      PM8001_EH_DBG(pm8001_ha, pm8001_printk(" for device[%x]:rc=%d\n",
+-              pm8001_dev->device_id, rc));
++      pm8001_dbg(pm8001_ha, EH, " for device[%x]:rc=%d\n",
++                 pm8001_dev->device_id, rc);
+ out:
+       sas_put_local_phy(phy);
+ 
+@@ -1134,8 +1120,8 @@ int pm8001_lu_reset(struct domain_device *dev, u8 *lun)
+               rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
+       }
+       /* If failed, fall-through I_T_Nexus reset */
+-      PM8001_EH_DBG(pm8001_ha, pm8001_printk("for device[%x]:rc=%d\n",
+-              pm8001_dev->device_id, rc));
++      pm8001_dbg(pm8001_ha, EH, "for device[%x]:rc=%d\n",
++                 pm8001_dev->device_id, rc);
+       return rc;
+ }
+ 
+@@ -1143,7 +1129,6 @@ int pm8001_lu_reset(struct domain_device *dev, u8 *lun)
+ int pm8001_query_task(struct sas_task *task)
+ {
+       u32 tag = 0xdeadbeef;
+-      int i = 0;
+       struct scsi_lun lun;
+       struct pm8001_tmf_task tmf_task;
+       int rc = TMF_RESP_FUNC_FAILED;
+@@ -1162,10 +1147,7 @@ int pm8001_query_task(struct sas_task *task)
+                       rc = TMF_RESP_FUNC_FAILED;
+                       return rc;
+               }
+-              PM8001_EH_DBG(pm8001_ha, pm8001_printk("Query:["));
+-              for (i = 0; i < 16; i++)
+-                      printk(KERN_INFO "%02x ", cmnd->cmnd[i]);
+-              printk(KERN_INFO "]\n");
++              pm8001_dbg(pm8001_ha, EH, "Query:[%16ph]\n", cmnd->cmnd);
+               tmf_task.tmf =  TMF_QUERY_TASK;
+               tmf_task.tag_of_task_to_be_managed = tag;
+ 
+@@ -1173,15 +1155,14 @@ int pm8001_query_task(struct sas_task *task)
+               switch (rc) {
+               /* The task is still in Lun, release it then */
+               case TMF_RESP_FUNC_SUCC:
+-                      PM8001_EH_DBG(pm8001_ha,
+-                              pm8001_printk("The task is still in Lun\n"));
++                      pm8001_dbg(pm8001_ha, EH,
++                                 "The task is still in Lun\n");
+                       break;
+               /* The task is not in Lun or failed, reset the phy */
+               case TMF_RESP_FUNC_FAILED:
+               case TMF_RESP_FUNC_COMPLETE:
+-                      PM8001_EH_DBG(pm8001_ha,
+-                      pm8001_printk("The task is not in Lun or failed,"
+-                      " reset the phy\n"));
++                      pm8001_dbg(pm8001_ha, EH,
++                                 "The task is not in Lun or failed, reset the phy\n");
+                       break;
+               }
+       }
+@@ -1267,8 +1248,8 @@ int pm8001_abort_task(struct sas_task *task)
+                        * leaking the task in libsas or losing the race and
+                        * getting a double free.
+                        */
+-                      PM8001_MSG_DBG(pm8001_ha,
+-                              pm8001_printk("Waiting for local phy ctl\n"));
++                      pm8001_dbg(pm8001_ha, MSG,
++                                 "Waiting for local phy ctl\n");
+                       ret = wait_for_completion_timeout(&completion,
+                                       PM8001_TASK_TIMEOUT * HZ);
+                       if (!ret || !phy->reset_success) {
+@@ -1278,8 +1259,8 @@ int pm8001_abort_task(struct sas_task *task)
+                               /* 3. Wait for Port Reset complete or
+                                * Port reset TMO
+                                */
+-                              PM8001_MSG_DBG(pm8001_ha,
+-                              pm8001_printk("Waiting for Port reset\n"));
++                              pm8001_dbg(pm8001_ha, MSG,
++                                         "Waiting for Port reset\n");
+                               ret = wait_for_completion_timeout(
+                                       &completion_reset,
+                                       PM8001_TASK_TIMEOUT * HZ);
+@@ -1358,9 +1339,8 @@ int pm8001_clear_task_set(struct domain_device *dev, u8 *lun)
+       struct pm8001_device *pm8001_dev = dev->lldd_dev;
+       struct pm8001_hba_info *pm8001_ha = pm8001_find_ha_by_dev(dev);
+ 
+-      PM8001_EH_DBG(pm8001_ha,
+-              pm8001_printk("I_T_L_Q clear task set[%x]\n",
+-              pm8001_dev->device_id));
++      pm8001_dbg(pm8001_ha, EH, "I_T_L_Q clear task set[%x]\n",
++                 pm8001_dev->device_id);
+       tmf_task.tmf = TMF_CLEAR_TASK_SET;
+       return pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
+ }
+diff --git a/drivers/scsi/pm8001/pm8001_sas.h b/drivers/scsi/pm8001/pm8001_sas.h
+index 091574721ea1..5cd6fe6a7d2d 100644
+--- a/drivers/scsi/pm8001/pm8001_sas.h
++++ b/drivers/scsi/pm8001/pm8001_sas.h
+@@ -69,45 +69,16 @@
+ #define PM8001_DEV_LOGGING    0x80 /* development message logging */
+ #define PM8001_DEVIO_LOGGING  0x100 /* development io message logging */
+ #define PM8001_IOERR_LOGGING  0x200 /* development io err message logging */
+-#define pm8001_printk(format, arg...) pr_info("%s:: %s  %d:" \
+-                      format, pm8001_ha->name, __func__, __LINE__, ## arg)
+-#define PM8001_CHECK_LOGGING(HBA, LEVEL, CMD) \
+-do {                                          \
+-      if (unlikely(HBA->logging_level & LEVEL))       \
+-              do {                                    \
+-                      CMD;                            \
+-              } while (0);                            \
+-} while (0);
+ 
+-#define PM8001_EH_DBG(HBA, CMD)                       \
+-      PM8001_CHECK_LOGGING(HBA, PM8001_EH_LOGGING, CMD)
++#define pm8001_printk(fmt, ...)                                               \
++      pr_info("%s:: %s  %d:" fmt,                                     \
++              pm8001_ha->name, __func__, __LINE__, ##__VA_ARGS__)
+ 
+-#define PM8001_INIT_DBG(HBA, CMD)             \
+-      PM8001_CHECK_LOGGING(HBA, PM8001_INIT_LOGGING, CMD)
+-
+-#define PM8001_DISC_DBG(HBA, CMD)             \
+-      PM8001_CHECK_LOGGING(HBA, PM8001_DISC_LOGGING, CMD)
+-
+-#define PM8001_IO_DBG(HBA, CMD)               \
+-      PM8001_CHECK_LOGGING(HBA, PM8001_IO_LOGGING, CMD)
+-
+-#define PM8001_FAIL_DBG(HBA, CMD)             \
+-      PM8001_CHECK_LOGGING(HBA, PM8001_FAIL_LOGGING, CMD)
+-
+-#define PM8001_IOCTL_DBG(HBA, CMD)            \
+-      PM8001_CHECK_LOGGING(HBA, PM8001_IOCTL_LOGGING, CMD)
+-
+-#define PM8001_MSG_DBG(HBA, CMD)              \
+-      PM8001_CHECK_LOGGING(HBA, PM8001_MSG_LOGGING, CMD)
+-
+-#define PM8001_DEV_DBG(HBA, CMD)              \
+-      PM8001_CHECK_LOGGING(HBA, PM8001_DEV_LOGGING, CMD)
+-
+-#define PM8001_DEVIO_DBG(HBA, CMD)            \
+-      PM8001_CHECK_LOGGING(HBA, PM8001_DEVIO_LOGGING, CMD)
+-
+-#define PM8001_IOERR_DBG(HBA, CMD)            \
+-      PM8001_CHECK_LOGGING(HBA, PM8001_IOERR_LOGGING, CMD)
++#define pm8001_dbg(HBA, level, fmt, ...)                              \
++do {                                                                  \
++      if (unlikely((HBA)->logging_level & PM8001_##level##_LOGGING))  \
++              pm8001_printk(fmt, ##__VA_ARGS__);                      \
++} while (0)
+ 
+ #define PM8001_USE_TASKLET
+ #define PM8001_USE_MSIX
+diff --git a/drivers/scsi/pm8001/pm80xx_hwi.c b/drivers/scsi/pm8001/pm80xx_hwi.c
+index 59053c61908e..990501be47e7 100644
+--- a/drivers/scsi/pm8001/pm80xx_hwi.c
++++ b/drivers/scsi/pm8001/pm80xx_hwi.c
+@@ -58,9 +58,8 @@ int pm80xx_bar4_shift(struct pm8001_hba_info *pm8001_ha, u32 shift_value)
+               reg_val = pm8001_cr32(pm8001_ha, 0, MEMBASE_II_SHIFT_REGISTER);
+       } while ((reg_val != shift_value) && time_before(jiffies, start));
+       if (reg_val != shift_value) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("TIMEOUT:MEMBASE_II_SHIFT_REGISTER"
+-                      " = 0x%x\n", reg_val));
++              pm8001_dbg(pm8001_ha, FAIL, "TIMEOUT:MEMBASE_II_SHIFT_REGISTER = 0x%x\n",
++                         reg_val);
+               return -1;
+       }
+       return 0;
+@@ -109,8 +108,8 @@ ssize_t pm80xx_get_fatal_dump(struct device *cdev,
+       }
+       /* initialize variables for very first call from host application */
+       if (pm8001_ha->forensic_info.data_buf.direct_offset == 0) {
+-              PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("forensic_info TYPE_NON_FATAL..............\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "forensic_info TYPE_NON_FATAL..............\n");
+               direct_data = (u8 *)fatal_error_data;
+               pm8001_ha->forensic_info.data_type = TYPE_NON_FATAL;
+               pm8001_ha->forensic_info.data_buf.direct_len = SYSFS_OFFSET;
+@@ -123,17 +122,13 @@ ssize_t pm80xx_get_fatal_dump(struct device *cdev,
+                               MPI_FATAL_EDUMP_TABLE_SIGNATURE, 0x1234abcd);
+ 
+               pm8001_ha->forensic_info.data_buf.direct_data = direct_data;
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("ossaHwCB: status1 %d\n", status));
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("ossaHwCB: read_len 0x%x\n",
+-                      pm8001_ha->forensic_info.data_buf.read_len));
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("ossaHwCB: direct_len 0x%x\n",
+-                      pm8001_ha->forensic_info.data_buf.direct_len));
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("ossaHwCB: direct_offset 0x%x\n",
+-                      pm8001_ha->forensic_info.data_buf.direct_offset));
++              pm8001_dbg(pm8001_ha, IO, "ossaHwCB: status1 %d\n", status);
++              pm8001_dbg(pm8001_ha, IO, "ossaHwCB: read_len 0x%x\n",
++                         pm8001_ha->forensic_info.data_buf.read_len);
++              pm8001_dbg(pm8001_ha, IO, "ossaHwCB: direct_len 0x%x\n",
++                         pm8001_ha->forensic_info.data_buf.direct_len);
++              pm8001_dbg(pm8001_ha, IO, "ossaHwCB: direct_offset 0x%x\n",
++                         pm8001_ha->forensic_info.data_buf.direct_offset);
+       }
+       if (pm8001_ha->forensic_info.data_buf.direct_offset == 0) {
+               /* start to get data */
+@@ -153,29 +148,24 @@ ssize_t pm80xx_get_fatal_dump(struct device *cdev,
+        */
+       length_to_read =
+               accum_len - pm8001_ha->forensic_preserved_accumulated_transfer;
+-      PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("get_fatal_spcv: accum_len 0x%x\n", accum_len));
+-      PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("get_fatal_spcv: length_to_read 0x%x\n",
+-              length_to_read));
+-      PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("get_fatal_spcv: last_offset 0x%x\n",
+-              pm8001_ha->forensic_last_offset));
+-      PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("get_fatal_spcv: read_len 0x%x\n",
+-              pm8001_ha->forensic_info.data_buf.read_len));
+-      PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("get_fatal_spcv:: direct_len 0x%x\n",
+-              pm8001_ha->forensic_info.data_buf.direct_len));
+-      PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("get_fatal_spcv:: direct_offset 0x%x\n",
+-              pm8001_ha->forensic_info.data_buf.direct_offset));
++      pm8001_dbg(pm8001_ha, IO, "get_fatal_spcv: accum_len 0x%x\n",
++                 accum_len);
++      pm8001_dbg(pm8001_ha, IO, "get_fatal_spcv: length_to_read 0x%x\n",
++                 length_to_read);
++      pm8001_dbg(pm8001_ha, IO, "get_fatal_spcv: last_offset 0x%x\n",
++                 pm8001_ha->forensic_last_offset);
++      pm8001_dbg(pm8001_ha, IO, "get_fatal_spcv: read_len 0x%x\n",
++                 pm8001_ha->forensic_info.data_buf.read_len);
++      pm8001_dbg(pm8001_ha, IO, "get_fatal_spcv:: direct_len 0x%x\n",
++                 pm8001_ha->forensic_info.data_buf.direct_len);
++      pm8001_dbg(pm8001_ha, IO, "get_fatal_spcv:: direct_offset 0x%x\n",
++                 pm8001_ha->forensic_info.data_buf.direct_offset);
+ 
+       /* If accumulated length failed to read correctly fail the attempt.*/
+       if (accum_len == 0xFFFFFFFF) {
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("Possible PCI issue 0x%x not expected\n",
+-                      accum_len));
++              pm8001_dbg(pm8001_ha, IO,
++                         "Possible PCI issue 0x%x not expected\n",
++                         accum_len);
+               return status;
+       }
+       /* If accumulated length is zero fail the attempt */
+@@ -239,8 +229,8 @@ ssize_t pm80xx_get_fatal_dump(struct device *cdev,
+                       offset = (int)
+                       ((char *)pm8001_ha->forensic_info.data_buf.direct_data
+                       - (char *)buf);
+-                      PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("get_fatal_spcv:return1 0x%x\n", offset));
++                      pm8001_dbg(pm8001_ha, IO,
++                                 "get_fatal_spcv:return1 0x%x\n", offset);
+                       return (char *)pm8001_ha->
+                               forensic_info.data_buf.direct_data -
+                               (char *)buf;
+@@ -262,8 +252,8 @@ ssize_t pm80xx_get_fatal_dump(struct device *cdev,
+                       offset = (int)
+                       ((char *)pm8001_ha->forensic_info.data_buf.direct_data
+                       - (char *)buf);
+-                      PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("get_fatal_spcv:return2 0x%x\n", offset));
++                      pm8001_dbg(pm8001_ha, IO,
++                                 "get_fatal_spcv:return2 0x%x\n", offset);
+                       return (char *)pm8001_ha->
+                               forensic_info.data_buf.direct_data -
+                               (char *)buf;
+@@ -289,8 +279,8 @@ ssize_t pm80xx_get_fatal_dump(struct device *cdev,
+               offset = (int)
+                       ((char *)pm8001_ha->forensic_info.data_buf.direct_data
+                       - (char *)buf);
+-              PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("get_fatal_spcv: return3 0x%x\n", offset));
++              pm8001_dbg(pm8001_ha, IO, "get_fatal_spcv: return3 0x%x\n",
++                         offset);
+               return (char *)pm8001_ha->forensic_info.data_buf.direct_data -
+                       (char *)buf;
+       }
+@@ -327,9 +317,9 @@ ssize_t pm80xx_get_fatal_dump(struct device *cdev,
+                       } while ((reg_val) && time_before(jiffies, start));
+ 
+                       if (reg_val != 0) {
+-                              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                              "TIMEOUT:MPI_FATAL_EDUMP_TABLE_HDSHAKE 0x%x\n",
+-                              reg_val));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "TIMEOUT:MPI_FATAL_EDUMP_TABLE_HDSHAKE 0x%x\n",
++                                         reg_val);
+                              /* Fail the dump if a timeout occurs */
+                               pm8001_ha->forensic_info.data_buf.direct_data +=
+                               sprintf(
+@@ -351,9 +341,9 @@ ssize_t pm80xx_get_fatal_dump(struct device *cdev,
+                                       time_before(jiffies, start));
+ 
+                       if (reg_val < 2) {
+-                              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                              "TIMEOUT:MPI_FATAL_EDUMP_TABLE_STATUS = 0x%x\n",
+-                              reg_val));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "TIMEOUT:MPI_FATAL_EDUMP_TABLE_STATUS = 0x%x\n",
++                                         reg_val);
+                               /* Fail the dump if a timeout occurs */
+                               pm8001_ha->forensic_info.data_buf.direct_data +=
+                               sprintf(
+@@ -387,8 +377,7 @@ ssize_t pm80xx_get_fatal_dump(struct device *cdev,
+       }
+       offset = (int)((char *)pm8001_ha->forensic_info.data_buf.direct_data
+                       - (char *)buf);
+-      PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("get_fatal_spcv: return4 0x%x\n", offset));
++      pm8001_dbg(pm8001_ha, IO, "get_fatal_spcv: return4 0x%x\n", offset);
+       return (char *)pm8001_ha->forensic_info.data_buf.direct_data -
+               (char *)buf;
+ }
+@@ -419,8 +408,7 @@ ssize_t pm80xx_get_non_fatal_dump(struct device *cdev,
+                               PAGE_SIZE, "Not supported for SPC controller");
+                       return 0;
+               }
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("forensic_info TYPE_NON_FATAL...\n"));
++              pm8001_dbg(pm8001_ha, IO, "forensic_info TYPE_NON_FATAL...\n");
+               /*
+                * Step 1: Write the host buffer parameters in the MPI Fatal and
+                * Non-Fatal Error Dump Capture Table.This is the buffer
+@@ -581,24 +569,24 @@ static void read_main_config_table(struct pm8001_hba_info *pm8001_ha)
+       pm8001_ha->main_cfg_tbl.pm80xx_tbl.inc_fw_version =
+               pm8001_mr32(address, MAIN_MPI_INACTIVE_FW_VERSION);
+ 
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "Main cfg table: sign:%x interface rev:%x fw_rev:%x\n",
+-              pm8001_ha->main_cfg_tbl.pm80xx_tbl.signature,
+-              pm8001_ha->main_cfg_tbl.pm80xx_tbl.interface_rev,
+-              pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev));
+-
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "table offset: gst:%x iq:%x oq:%x int vec:%x phy attr:%x\n",
+-              pm8001_ha->main_cfg_tbl.pm80xx_tbl.gst_offset,
+-              pm8001_ha->main_cfg_tbl.pm80xx_tbl.inbound_queue_offset,
+-              pm8001_ha->main_cfg_tbl.pm80xx_tbl.outbound_queue_offset,
+-              pm8001_ha->main_cfg_tbl.pm80xx_tbl.int_vec_table_offset,
+-              pm8001_ha->main_cfg_tbl.pm80xx_tbl.phy_attr_table_offset));
+-
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "Main cfg table; ila rev:%x Inactive fw rev:%x\n",
+-              pm8001_ha->main_cfg_tbl.pm80xx_tbl.ila_version,
+-              pm8001_ha->main_cfg_tbl.pm80xx_tbl.inc_fw_version));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "Main cfg table: sign:%x interface rev:%x fw_rev:%x\n",
++                 pm8001_ha->main_cfg_tbl.pm80xx_tbl.signature,
++                 pm8001_ha->main_cfg_tbl.pm80xx_tbl.interface_rev,
++                 pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev);
++
++      pm8001_dbg(pm8001_ha, DEV,
++                 "table offset: gst:%x iq:%x oq:%x int vec:%x phy attr:%x\n",
++                 pm8001_ha->main_cfg_tbl.pm80xx_tbl.gst_offset,
++                 pm8001_ha->main_cfg_tbl.pm80xx_tbl.inbound_queue_offset,
++                 pm8001_ha->main_cfg_tbl.pm80xx_tbl.outbound_queue_offset,
++                 pm8001_ha->main_cfg_tbl.pm80xx_tbl.int_vec_table_offset,
++                 pm8001_ha->main_cfg_tbl.pm80xx_tbl.phy_attr_table_offset);
++
++      pm8001_dbg(pm8001_ha, DEV,
++                 "Main cfg table; ila rev:%x Inactive fw rev:%x\n",
++                 pm8001_ha->main_cfg_tbl.pm80xx_tbl.ila_version,
++                 pm8001_ha->main_cfg_tbl.pm80xx_tbl.inc_fw_version);
+ }
+ 
+ /**
+@@ -808,10 +796,10 @@ static void init_default_table_values(struct pm8001_hba_info *pm8001_ha)
+               pm8001_ha->inbnd_q_tbl[i].producer_idx          = 0;
+               pm8001_ha->inbnd_q_tbl[i].consumer_index        = 0;
+ 
+-              PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-                      "IQ %d pi_bar 0x%x pi_offset 0x%x\n", i,
+-                      pm8001_ha->inbnd_q_tbl[i].pi_pci_bar,
+-                      pm8001_ha->inbnd_q_tbl[i].pi_offset));
++              pm8001_dbg(pm8001_ha, DEV,
++                         "IQ %d pi_bar 0x%x pi_offset 0x%x\n", i,
++                         pm8001_ha->inbnd_q_tbl[i].pi_pci_bar,
++                         pm8001_ha->inbnd_q_tbl[i].pi_offset);
+       }
+       for (i = 0; i < pm8001_ha->max_q_num; i++) {
+               pm8001_ha->outbnd_q_tbl[i].element_size_cnt     =
+@@ -841,10 +829,10 @@ static void init_default_table_values(struct pm8001_hba_info *pm8001_ha)
+               pm8001_ha->outbnd_q_tbl[i].consumer_idx         = 0;
+               pm8001_ha->outbnd_q_tbl[i].producer_index       = 0;
+ 
+-              PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-                      "OQ %d ci_bar 0x%x ci_offset 0x%x\n", i,
+-                      pm8001_ha->outbnd_q_tbl[i].ci_pci_bar,
+-                      pm8001_ha->outbnd_q_tbl[i].ci_offset));
++              pm8001_dbg(pm8001_ha, DEV,
++                         "OQ %d ci_bar 0x%x ci_offset 0x%x\n", i,
++                         pm8001_ha->outbnd_q_tbl[i].ci_pci_bar,
++                         pm8001_ha->outbnd_q_tbl[i].ci_offset);
+       }
+ }
+ 
+@@ -878,9 +866,9 @@ static void update_main_config_table(struct pm8001_hba_info *pm8001_ha)
+                                       ((pm8001_ha->max_q_num - 1) << 8);
+       pm8001_mw32(address, MAIN_FATAL_ERROR_INTERRUPT,
+               pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_interrupt);
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "Updated Fatal error interrupt vector 0x%x\n",
+-              pm8001_mr32(address, MAIN_FATAL_ERROR_INTERRUPT)));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "Updated Fatal error interrupt vector 0x%x\n",
++                 pm8001_mr32(address, MAIN_FATAL_ERROR_INTERRUPT));
+ 
+       pm8001_mw32(address, MAIN_EVENT_CRC_CHECK,
+               pm8001_ha->main_cfg_tbl.pm80xx_tbl.crc_core_dump);
+@@ -891,9 +879,9 @@ static void update_main_config_table(struct pm8001_hba_info *pm8001_ha)
+       pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping |= 0x20000000;
+       pm8001_mw32(address, MAIN_GPIO_LED_FLAGS_OFFSET,
+               pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping);
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "Programming DW 0x21 in main cfg table with 0x%x\n",
+-              pm8001_mr32(address, MAIN_GPIO_LED_FLAGS_OFFSET)));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "Programming DW 0x21 in main cfg table with 0x%x\n",
++                 pm8001_mr32(address, MAIN_GPIO_LED_FLAGS_OFFSET));
+ 
+       pm8001_mw32(address, MAIN_PORT_RECOVERY_TIMER,
+               pm8001_ha->main_cfg_tbl.pm80xx_tbl.port_recovery_timer);
+@@ -934,20 +922,20 @@ static void update_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha,
+       pm8001_mw32(address, offset + IB_CI_BASE_ADDR_LO_OFFSET,
+               pm8001_ha->inbnd_q_tbl[number].ci_lower_base_addr);
+ 
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "IQ %d: Element pri size 0x%x\n",
+-              number,
+-              pm8001_ha->inbnd_q_tbl[number].element_pri_size_cnt));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "IQ %d: Element pri size 0x%x\n",
++                 number,
++                 pm8001_ha->inbnd_q_tbl[number].element_pri_size_cnt);
+ 
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "IQ upr base addr 0x%x IQ lwr base addr 0x%x\n",
+-              pm8001_ha->inbnd_q_tbl[number].upper_base_addr,
+-              pm8001_ha->inbnd_q_tbl[number].lower_base_addr));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "IQ upr base addr 0x%x IQ lwr base addr 0x%x\n",
++                 pm8001_ha->inbnd_q_tbl[number].upper_base_addr,
++                 pm8001_ha->inbnd_q_tbl[number].lower_base_addr);
+ 
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "CI upper base addr 0x%x CI lower base addr 0x%x\n",
+-              pm8001_ha->inbnd_q_tbl[number].ci_upper_base_addr,
+-              pm8001_ha->inbnd_q_tbl[number].ci_lower_base_addr));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "CI upper base addr 0x%x CI lower base addr 0x%x\n",
++                 pm8001_ha->inbnd_q_tbl[number].ci_upper_base_addr,
++                 pm8001_ha->inbnd_q_tbl[number].ci_lower_base_addr);
+ }
+ 
+ /**
+@@ -973,20 +961,20 @@ static void update_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha,
+       pm8001_mw32(address, offset + OB_INTERRUPT_COALES_OFFSET,
+               pm8001_ha->outbnd_q_tbl[number].interrup_vec_cnt_delay);
+ 
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "OQ %d: Element pri size 0x%x\n",
+-              number,
+-              pm8001_ha->outbnd_q_tbl[number].element_size_cnt));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "OQ %d: Element pri size 0x%x\n",
++                 number,
++                 pm8001_ha->outbnd_q_tbl[number].element_size_cnt);
+ 
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "OQ upr base addr 0x%x OQ lwr base addr 0x%x\n",
+-              pm8001_ha->outbnd_q_tbl[number].upper_base_addr,
+-              pm8001_ha->outbnd_q_tbl[number].lower_base_addr));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "OQ upr base addr 0x%x OQ lwr base addr 0x%x\n",
++                 pm8001_ha->outbnd_q_tbl[number].upper_base_addr,
++                 pm8001_ha->outbnd_q_tbl[number].lower_base_addr);
+ 
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "PI upper base addr 0x%x PI lower base addr 0x%x\n",
+-              pm8001_ha->outbnd_q_tbl[number].pi_upper_base_addr,
+-              pm8001_ha->outbnd_q_tbl[number].pi_lower_base_addr));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "PI upper base addr 0x%x PI lower base addr 0x%x\n",
++                 pm8001_ha->outbnd_q_tbl[number].pi_upper_base_addr,
++                 pm8001_ha->outbnd_q_tbl[number].pi_lower_base_addr);
+ }
+ 
+ /**
+@@ -1016,8 +1004,9 @@ static int mpi_init_check(struct pm8001_hba_info *pm8001_ha)
+ 
+       if (!max_wait_count) {
+               /* additional check */
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                      "Inb doorbell clear not toggled[value:%x]\n", value));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "Inb doorbell clear not toggled[value:%x]\n",
++                         value);
+               return -EBUSY;
+       }
+       /* check the MPI-State for initialization upto 100ms*/
+@@ -1068,9 +1057,9 @@ static int check_fw_ready(struct pm8001_hba_info *pm8001_ha)
+       if (!max_wait_count)
+               ret = -1;
+       else {
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" ila ready status in %d millisec\n",
+-                              (max_wait_time - max_wait_count)));
++              pm8001_dbg(pm8001_ha, MSG,
++                         " ila ready status in %d millisec\n",
++                         (max_wait_time - max_wait_count));
+       }
+ 
+       /* check RAAE status */
+@@ -1083,9 +1072,9 @@ static int check_fw_ready(struct pm8001_hba_info *pm8001_ha)
+       if (!max_wait_count)
+               ret = -1;
+       else {
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" raae ready status in %d millisec\n",
+-                                      (max_wait_time - max_wait_count)));
++              pm8001_dbg(pm8001_ha, MSG,
++                         " raae ready status in %d millisec\n",
++                         (max_wait_time - max_wait_count));
+       }
+ 
+       /* check iop0 status */
+@@ -1098,9 +1087,9 @@ static int check_fw_ready(struct pm8001_hba_info *pm8001_ha)
+       if (!max_wait_count)
+               ret = -1;
+       else {
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" iop0 ready status in %d millisec\n",
+-                              (max_wait_time - max_wait_count)));
++              pm8001_dbg(pm8001_ha, MSG,
++                         " iop0 ready status in %d millisec\n",
++                         (max_wait_time - max_wait_count));
+       }
+ 
+       /* check iop1 status only for 16 port controllers */
+@@ -1116,9 +1105,9 @@ static int check_fw_ready(struct pm8001_hba_info *pm8001_ha)
+               if (!max_wait_count)
+                       ret = -1;
+               else {
+-                      PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                              "iop1 ready status in %d millisec\n",
+-                              (max_wait_time - max_wait_count)));
++                      pm8001_dbg(pm8001_ha, MSG,
++                                 "iop1 ready status in %d millisec\n",
++                                 (max_wait_time - max_wait_count));
+               }
+       }
+ 
+@@ -1136,13 +1125,11 @@ static void init_pci_device_addresses(struct pm8001_hba_info *pm8001_ha)
+       value = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_0);
+       offset = value & 0x03FFFFFF; /* scratch pad 0 TBL address */
+ 
+-      PM8001_DEV_DBG(pm8001_ha,
+-              pm8001_printk("Scratchpad 0 Offset: 0x%x value 0x%x\n",
+-                              offset, value));
++      pm8001_dbg(pm8001_ha, DEV, "Scratchpad 0 Offset: 0x%x value 0x%x\n",
++                 offset, value);
+       pcilogic = (value & 0xFC000000) >> 26;
+       pcibar = get_pci_bar_index(pcilogic);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("Scratchpad 0 PCI BAR: %d\n", pcibar));
++      pm8001_dbg(pm8001_ha, INIT, "Scratchpad 0 PCI BAR: %d\n", pcibar);
+       pm8001_ha->main_cfg_tbl_addr = base_addr =
+               pm8001_ha->io_mem[pcibar].memvirtaddr + offset;
+       pm8001_ha->general_stat_tbl_addr =
+@@ -1164,33 +1151,25 @@ static void init_pci_device_addresses(struct pm8001_hba_info *pm8001_ha)
+               base_addr + (pm8001_cr32(pm8001_ha, pcibar, offset + 0xA0) &
+                                       0xFFFFFF);
+ 
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("GST OFFSET 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, pcibar, offset + 0x18)));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("INBND OFFSET 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, pcibar, offset + 0x1C)));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("OBND OFFSET 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, pcibar, offset + 0x20)));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("IVT OFFSET 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, pcibar, offset + 0x8C)));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("PSPA OFFSET 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, pcibar, offset + 0x90)));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("addr - main cfg %p general status %p\n",
+-                      pm8001_ha->main_cfg_tbl_addr,
+-                      pm8001_ha->general_stat_tbl_addr));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("addr - inbnd %p obnd %p\n",
+-                      pm8001_ha->inbnd_q_tbl_addr,
+-                      pm8001_ha->outbnd_q_tbl_addr));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("addr - pspa %p ivt %p\n",
+-                      pm8001_ha->pspa_q_tbl_addr,
+-                      pm8001_ha->ivt_tbl_addr));
++      pm8001_dbg(pm8001_ha, INIT, "GST OFFSET 0x%x\n",
++                 pm8001_cr32(pm8001_ha, pcibar, offset + 0x18));
++      pm8001_dbg(pm8001_ha, INIT, "INBND OFFSET 0x%x\n",
++                 pm8001_cr32(pm8001_ha, pcibar, offset + 0x1C));
++      pm8001_dbg(pm8001_ha, INIT, "OBND OFFSET 0x%x\n",
++                 pm8001_cr32(pm8001_ha, pcibar, offset + 0x20));
++      pm8001_dbg(pm8001_ha, INIT, "IVT OFFSET 0x%x\n",
++                 pm8001_cr32(pm8001_ha, pcibar, offset + 0x8C));
++      pm8001_dbg(pm8001_ha, INIT, "PSPA OFFSET 0x%x\n",
++                 pm8001_cr32(pm8001_ha, pcibar, offset + 0x90));
++      pm8001_dbg(pm8001_ha, INIT, "addr - main cfg %p general status %p\n",
++                 pm8001_ha->main_cfg_tbl_addr,
++                 pm8001_ha->general_stat_tbl_addr);
++      pm8001_dbg(pm8001_ha, INIT, "addr - inbnd %p obnd %p\n",
++                 pm8001_ha->inbnd_q_tbl_addr,
++                 pm8001_ha->outbnd_q_tbl_addr);
++      pm8001_dbg(pm8001_ha, INIT, "addr - pspa %p ivt %p\n",
++                 pm8001_ha->pspa_q_tbl_addr,
++                 pm8001_ha->ivt_tbl_addr);
+ }
+ 
+ /**
+@@ -1224,9 +1203,9 @@ pm80xx_set_thermal_config(struct pm8001_hba_info *pm8001_ha)
+                               (THERMAL_ENABLE << 8) | page_code;
+       payload.cfg_pg[1] = (LTEMPHIL << 24) | (RTEMPHIL << 8);
+ 
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "Setting up thermal config. cfg_pg 0 0x%x cfg_pg 1 0x%x\n",
+-              payload.cfg_pg[0], payload.cfg_pg[1]));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "Setting up thermal config. cfg_pg 0 0x%x cfg_pg 1 0x%x\n",
++                 payload.cfg_pg[0], payload.cfg_pg[1]);
+ 
+       rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload,
+                       sizeof(payload), 0);
+@@ -1281,32 +1260,24 @@ pm80xx_set_sas_protocol_timer_config(struct pm8001_hba_info *pm8001_ha)
+                                               | SAS_COPNRJT_RTRY_THR;
+       SASConfigPage.MAX_AIP =  SAS_MAX_AIP;
+ 
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("SASConfigPage.pageCode "
+-                      "0x%08x\n", SASConfigPage.pageCode));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("SASConfigPage.MST_MSI "
+-                      " 0x%08x\n", SASConfigPage.MST_MSI));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("SASConfigPage.STP_SSP_MCT_TMO "
+-                      " 0x%08x\n", SASConfigPage.STP_SSP_MCT_TMO));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("SASConfigPage.STP_FRM_TMO "
+-                      " 0x%08x\n", SASConfigPage.STP_FRM_TMO));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("SASConfigPage.STP_IDLE_TMO "
+-                      " 0x%08x\n", SASConfigPage.STP_IDLE_TMO));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("SASConfigPage.OPNRJT_RTRY_INTVL "
+-                      " 0x%08x\n", SASConfigPage.OPNRJT_RTRY_INTVL));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO "
+-                      " 0x%08x\n", SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO));
+-      PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR "
+-                      " 0x%08x\n", SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR));
+-      PM8001_INIT_DBG(pm8001_ha, pm8001_printk("SASConfigPage.MAX_AIP "
+-                      " 0x%08x\n", SASConfigPage.MAX_AIP));
++      pm8001_dbg(pm8001_ha, INIT, "SASConfigPage.pageCode 0x%08x\n",
++                 SASConfigPage.pageCode);
++      pm8001_dbg(pm8001_ha, INIT, "SASConfigPage.MST_MSI  0x%08x\n",
++                 SASConfigPage.MST_MSI);
++      pm8001_dbg(pm8001_ha, INIT, "SASConfigPage.STP_SSP_MCT_TMO  0x%08x\n",
++                 SASConfigPage.STP_SSP_MCT_TMO);
++      pm8001_dbg(pm8001_ha, INIT, "SASConfigPage.STP_FRM_TMO  0x%08x\n",
++                 SASConfigPage.STP_FRM_TMO);
++      pm8001_dbg(pm8001_ha, INIT, "SASConfigPage.STP_IDLE_TMO  0x%08x\n",
++                 SASConfigPage.STP_IDLE_TMO);
++      pm8001_dbg(pm8001_ha, INIT, "SASConfigPage.OPNRJT_RTRY_INTVL  0x%08x\n",
++                 SASConfigPage.OPNRJT_RTRY_INTVL);
++      pm8001_dbg(pm8001_ha, INIT, "SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO  0x%08x\n",
++                 SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO);
++      pm8001_dbg(pm8001_ha, INIT, "SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR  0x%08x\n",
++                 SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR);
++      pm8001_dbg(pm8001_ha, INIT, "SASConfigPage.MAX_AIP  0x%08x\n",
++                 SASConfigPage.MAX_AIP);
+ 
+       memcpy(&payload.cfg_pg, &SASConfigPage,
+                        sizeof(SASProtocolTimerConfig_t));
+@@ -1346,18 +1317,18 @@ pm80xx_get_encrypt_info(struct pm8001_hba_info *pm8001_ha)
+                                               SCRATCH_PAD3_SMB_ENABLED)
+                       pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMB;
+               pm8001_ha->encrypt_info.status = 0;
+-              PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+-                      "Encryption: SCRATCH_PAD3_ENC_READY 0x%08X."
+-                      "Cipher mode 0x%x Sec mode 0x%x status 0x%x\n",
+-                      scratch3_value, pm8001_ha->encrypt_info.cipher_mode,
+-                      pm8001_ha->encrypt_info.sec_mode,
+-                      pm8001_ha->encrypt_info.status));
++              pm8001_dbg(pm8001_ha, INIT,
++                         "Encryption: SCRATCH_PAD3_ENC_READY 0x%08X.Cipher mode 0x%x Sec mode 0x%x status 0x%x\n",
++                         scratch3_value,
++                         pm8001_ha->encrypt_info.cipher_mode,
++                         pm8001_ha->encrypt_info.sec_mode,
++                         pm8001_ha->encrypt_info.status);
+               ret = 0;
+       } else if ((scratch3_value & SCRATCH_PAD3_ENC_READY) ==
+                                       SCRATCH_PAD3_ENC_DISABLED) {
+-              PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+-                      "Encryption: SCRATCH_PAD3_ENC_DISABLED 0x%08X\n",
+-                      scratch3_value));
++              pm8001_dbg(pm8001_ha, INIT,
++                         "Encryption: SCRATCH_PAD3_ENC_DISABLED 0x%08X\n",
++                         scratch3_value);
+               pm8001_ha->encrypt_info.status = 0xFFFFFFFF;
+               pm8001_ha->encrypt_info.cipher_mode = 0;
+               pm8001_ha->encrypt_info.sec_mode = 0;
+@@ -1377,12 +1348,12 @@ pm80xx_get_encrypt_info(struct pm8001_hba_info *pm8001_ha)
+               if ((scratch3_value & SCRATCH_PAD3_SM_MASK) ==
+                                       SCRATCH_PAD3_SMB_ENABLED)
+                       pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMB;
+-              PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+-                      "Encryption: SCRATCH_PAD3_DIS_ERR 0x%08X."
+-                      "Cipher mode 0x%x sec mode 0x%x status 0x%x\n",
+-                      scratch3_value, pm8001_ha->encrypt_info.cipher_mode,
+-                      pm8001_ha->encrypt_info.sec_mode,
+-                      pm8001_ha->encrypt_info.status));
++              pm8001_dbg(pm8001_ha, INIT,
++                         "Encryption: SCRATCH_PAD3_DIS_ERR 0x%08X.Cipher mode 0x%x sec mode 0x%x status 0x%x\n",
++                         scratch3_value,
++                         pm8001_ha->encrypt_info.cipher_mode,
++                         pm8001_ha->encrypt_info.sec_mode,
++                         pm8001_ha->encrypt_info.status);
+       } else if ((scratch3_value & SCRATCH_PAD3_ENC_MASK) ==
+                                SCRATCH_PAD3_ENC_ENA_ERR) {
+ 
+@@ -1400,12 +1371,12 @@ pm80xx_get_encrypt_info(struct pm8001_hba_info *pm8001_ha)
+                                       SCRATCH_PAD3_SMB_ENABLED)
+                       pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMB;
+ 
+-              PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+-                      "Encryption: SCRATCH_PAD3_ENA_ERR 0x%08X."
+-                      "Cipher mode 0x%x sec mode 0x%x status 0x%x\n",
+-                      scratch3_value, pm8001_ha->encrypt_info.cipher_mode,
+-                      pm8001_ha->encrypt_info.sec_mode,
+-                      pm8001_ha->encrypt_info.status));
++              pm8001_dbg(pm8001_ha, INIT,
++                         "Encryption: SCRATCH_PAD3_ENA_ERR 0x%08X.Cipher mode 0x%x sec mode 0x%x status 0x%x\n",
++                         scratch3_value,
++                         pm8001_ha->encrypt_info.cipher_mode,
++                         pm8001_ha->encrypt_info.sec_mode,
++                         pm8001_ha->encrypt_info.status);
+       }
+       return ret;
+ }
+@@ -1435,9 +1406,9 @@ static int pm80xx_encrypt_update(struct pm8001_hba_info *pm8001_ha)
+       payload.new_curidx_ksop = ((1 << 24) | (1 << 16) | (1 << 8) |
+                                       KEK_MGMT_SUBOP_KEYCARDUPDATE);
+ 
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "Saving Encryption info to flash. payload 0x%x\n",
+-              payload.new_curidx_ksop));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "Saving Encryption info to flash. payload 0x%x\n",
++                 payload.new_curidx_ksop);
+ 
+       rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload,
+                       sizeof(payload), 0);
+@@ -1458,8 +1429,7 @@ static int pm80xx_chip_init(struct pm8001_hba_info *pm8001_ha)
+ 
+       /* check the firmware status */
+       if (-1 == check_fw_ready(pm8001_ha)) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Firmware is not ready!\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "Firmware is not ready!\n");
+               return -EBUSY;
+       }
+ 
+@@ -1483,8 +1453,7 @@ static int pm80xx_chip_init(struct pm8001_hba_info *pm8001_ha)
+       }
+       /* notify firmware update finished and check initialization status */
+       if (0 == mpi_init_check(pm8001_ha)) {
+-              PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("MPI initialize successful!\n"));
++              pm8001_dbg(pm8001_ha, INIT, "MPI initialize successful!\n");
+       } else
+               return -EBUSY;
+ 
+@@ -1493,16 +1462,13 @@ static int pm80xx_chip_init(struct pm8001_hba_info *pm8001_ha)
+ 
+       /* Check for encryption */
+       if (pm8001_ha->chip->encrypt) {
+-              PM8001_INIT_DBG(pm8001_ha,
+-                      pm8001_printk("Checking for encryption\n"));
++              pm8001_dbg(pm8001_ha, INIT, "Checking for encryption\n");
+               ret = pm80xx_get_encrypt_info(pm8001_ha);
+               if (ret == -1) {
+-                      PM8001_INIT_DBG(pm8001_ha,
+-                              pm8001_printk("Encryption error !!\n"));
++                      pm8001_dbg(pm8001_ha, INIT, "Encryption error !!\n");
+                       if (pm8001_ha->encrypt_info.status == 0x81) {
+-                              PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+-                                      "Encryption enabled with error."
+-                                      "Saving encryption key to flash\n"));
++                              pm8001_dbg(pm8001_ha, INIT,
++                                         "Encryption enabled with error.Saving encryption key to flash\n");
+                               pm80xx_encrypt_update(pm8001_ha);
+                       }
+               }
+@@ -1533,8 +1499,7 @@ static int mpi_uninit_check(struct pm8001_hba_info *pm8001_ha)
+       } while ((value != 0) && (--max_wait_count));
+ 
+       if (!max_wait_count) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("TIMEOUT:IBDB value/=%x\n", value));
++              pm8001_dbg(pm8001_ha, FAIL, "TIMEOUT:IBDB value/=%x\n", value);
+               return -1;
+       }
+ 
+@@ -1551,9 +1516,8 @@ static int mpi_uninit_check(struct pm8001_hba_info *pm8001_ha)
+                       break;
+       } while (--max_wait_count);
+       if (!max_wait_count) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk(" TIME OUT MPI State = 0x%x\n",
+-                              gst_len_mpistate & GST_MPI_STATE_MASK));
++              pm8001_dbg(pm8001_ha, FAIL, " TIME OUT MPI State = 0x%x\n",
++                         gst_len_mpistate & GST_MPI_STATE_MASK);
+               return -1;
+       }
+ 
+@@ -1581,9 +1545,9 @@ pm80xx_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+                       u32 r1 = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
+                       u32 r2 = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2);
+                       u32 r3 = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_3);
+-                      PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                              "MPI state is not ready scratch: %x:%x:%x:%x\n",
+-                              r0, r1, r2, r3));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "MPI state is not ready scratch: %x:%x:%x:%x\n",
++                                 r0, r1, r2, r3);
+                       /* if things aren't ready but the bootloader is ok then
+                        * try the reset anyway.
+                        */
+@@ -1593,25 +1557,25 @@ pm80xx_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+       }
+       /* checked for reset register normal state; 0x0 */
+       regval = pm8001_cr32(pm8001_ha, 0, SPC_REG_SOFT_RESET);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("reset register before write : 0x%x\n", regval));
++      pm8001_dbg(pm8001_ha, INIT, "reset register before write : 0x%x\n",
++                 regval);
+ 
+       pm8001_cw32(pm8001_ha, 0, SPC_REG_SOFT_RESET, SPCv_NORMAL_RESET_VALUE);
+       msleep(500);
+ 
+       regval = pm8001_cr32(pm8001_ha, 0, SPC_REG_SOFT_RESET);
+-      PM8001_INIT_DBG(pm8001_ha,
+-      pm8001_printk("reset register after write 0x%x\n", regval));
++      pm8001_dbg(pm8001_ha, INIT, "reset register after write 0x%x\n",
++                 regval);
+ 
+       if ((regval & SPCv_SOFT_RESET_READ_MASK) ==
+                       SPCv_SOFT_RESET_NORMAL_RESET_OCCURED) {
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" soft reset successful [regval: 0x%x]\n",
+-                                      regval));
++              pm8001_dbg(pm8001_ha, MSG,
++                         " soft reset successful [regval: 0x%x]\n",
++                         regval);
+       } else {
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" soft reset failed [regval: 0x%x]\n",
+-                                      regval));
++              pm8001_dbg(pm8001_ha, MSG,
++                         " soft reset failed [regval: 0x%x]\n",
++                         regval);
+ 
+               /* check bootloader is successfully executed or in HDA mode */
+               bootloader_state =
+@@ -1619,28 +1583,27 @@ pm80xx_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+                       SCRATCH_PAD1_BOOTSTATE_MASK;
+ 
+               if (bootloader_state == SCRATCH_PAD1_BOOTSTATE_HDA_SEEPROM) {
+-                      PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                              "Bootloader state - HDA mode SEEPROM\n"));
++                      pm8001_dbg(pm8001_ha, MSG,
++                                 "Bootloader state - HDA mode SEEPROM\n");
+               } else if (bootloader_state ==
+                               SCRATCH_PAD1_BOOTSTATE_HDA_BOOTSTRAP) {
+-                      PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                              "Bootloader state - HDA mode Bootstrap Pin\n"));
++                      pm8001_dbg(pm8001_ha, MSG,
++                                 "Bootloader state - HDA mode Bootstrap Pin\n");
+               } else if (bootloader_state ==
+                               SCRATCH_PAD1_BOOTSTATE_HDA_SOFTRESET) {
+-                      PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                              "Bootloader state - HDA mode soft reset\n"));
++                      pm8001_dbg(pm8001_ha, MSG,
++                                 "Bootloader state - HDA mode soft reset\n");
+               } else if (bootloader_state ==
+                                       SCRATCH_PAD1_BOOTSTATE_CRIT_ERROR) {
+-                      PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                              "Bootloader state-HDA mode critical error\n"));
++                      pm8001_dbg(pm8001_ha, MSG,
++                                 "Bootloader state-HDA mode critical error\n");
+               }
+               return -EBUSY;
+       }
+ 
+       /* check the firmware status after reset */
+       if (-1 == check_fw_ready(pm8001_ha)) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Firmware is not ready!\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "Firmware is not ready!\n");
+               /* check iButton feature support for motherboard controller */
+               if (pm8001_ha->pdev->subsystem_vendor !=
+                       PCI_VENDOR_ID_ADAPTEC2 &&
+@@ -1652,21 +1615,18 @@ pm80xx_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+                       ibutton1 = pm8001_cr32(pm8001_ha, 0,
+                                       MSGU_HOST_SCRATCH_PAD_7);
+                       if (!ibutton0 && !ibutton1) {
+-                              PM8001_FAIL_DBG(pm8001_ha,
+-                                      pm8001_printk("iButton Feature is"
+-                                      " not Available!!!\n"));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "iButton Feature is not Available!!!\n");
+                               return -EBUSY;
+                       }
+                       if (ibutton0 == 0xdeadbeef && ibutton1 == 0xdeadbeef) {
+-                              PM8001_FAIL_DBG(pm8001_ha,
+-                                      pm8001_printk("CRC Check for iButton"
+-                                      " Feature Failed!!!\n"));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "CRC Check for iButton Feature Failed!!!\n");
+                               return -EBUSY;
+                       }
+               }
+       }
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("SPCv soft reset Complete\n"));
++      pm8001_dbg(pm8001_ha, INIT, "SPCv soft reset Complete\n");
+       return 0;
+ }
+ 
+@@ -1674,13 +1634,11 @@ static void pm80xx_hw_chip_rst(struct pm8001_hba_info *pm8001_ha)
+ {
+       u32 i;
+ 
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("chip reset start\n"));
++      pm8001_dbg(pm8001_ha, INIT, "chip reset start\n");
+ 
+       /* do SPCv chip reset. */
+       pm8001_cw32(pm8001_ha, 0, SPC_REG_SOFT_RESET, 0x11);
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("SPC soft reset Complete\n"));
++      pm8001_dbg(pm8001_ha, INIT, "SPC soft reset Complete\n");
+ 
+       /* Check this ..whether delay is required or no */
+       /* delay 10 usec */
+@@ -1692,8 +1650,7 @@ static void pm80xx_hw_chip_rst(struct pm8001_hba_info *pm8001_ha)
+               mdelay(1);
+       } while ((--i) != 0);
+ 
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("chip reset finished\n"));
++      pm8001_dbg(pm8001_ha, INIT, "chip reset finished\n");
+ }
+ 
+ /**
+@@ -1769,15 +1726,14 @@ static void pm80xx_send_abort_all(struct pm8001_hba_info *pm8001_ha,
+       int ret;
+ 
+       if (!pm8001_ha_dev) {
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("dev is null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "dev is null\n");
+               return;
+       }
+ 
+       task = sas_alloc_slow_task(GFP_ATOMIC);
+ 
+       if (!task) {
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("cannot "
+-                                              "allocate task\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task\n");
+               return;
+       }
+ 
+@@ -1803,8 +1759,7 @@ static void pm80xx_send_abort_all(struct pm8001_hba_info *pm8001_ha,
+ 
+       ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &task_abort,
+                       sizeof(task_abort), 0);
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("Executing abort task end\n"));
++      pm8001_dbg(pm8001_ha, FAIL, "Executing abort task end\n");
+       if (ret) {
+               sas_free_task(task);
+               pm8001_tag_free(pm8001_ha, ccb_tag);
+@@ -1827,8 +1782,7 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
+       task = sas_alloc_slow_task(GFP_ATOMIC);
+ 
+       if (!task) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("cannot allocate task !!!\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task !!!\n");
+               return;
+       }
+       task->task_done = pm8001_task_done;
+@@ -1836,8 +1790,7 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
+       res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
+       if (res) {
+               sas_free_task(task);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("cannot allocate tag !!!\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "cannot allocate tag !!!\n");
+               return;
+       }
+ 
+@@ -1848,8 +1801,8 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
+       if (!dev) {
+               sas_free_task(task);
+               pm8001_tag_free(pm8001_ha, ccb_tag);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("Domain device cannot be allocated\n"));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "Domain device cannot be allocated\n");
+               return;
+       }
+ 
+@@ -1882,7 +1835,7 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
+ 
+       res = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &sata_cmd,
+                       sizeof(sata_cmd), 0);
+-      PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("Executing read log end\n"));
++      pm8001_dbg(pm8001_ha, FAIL, "Executing read log end\n");
+       if (res) {
+               sas_free_task(task);
+               pm8001_tag_free(pm8001_ha, ccb_tag);
+@@ -1928,27 +1881,24 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       t = ccb->task;
+ 
+       if (status && status != IO_UNDERFLOW)
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("sas IO status 0x%x\n", status));
++              pm8001_dbg(pm8001_ha, FAIL, "sas IO status 0x%x\n", status);
+       if (unlikely(!t || !t->lldd_task || !t->dev))
+               return;
+       ts = &t->task_status;
+ 
+-      PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
+-              "tag::0x%x, status::0x%x task::0x%p\n", tag, status, t));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "tag::0x%x, status::0x%x task::0x%p\n", tag, status, t);
+ 
+       /* Print sas address of IO failed device */
+       if ((status != IO_SUCCESS) && (status != IO_OVERFLOW) &&
+               (status != IO_UNDERFLOW))
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("SAS Address of IO Failure Drive"
+-                      ":%016llx", SAS_ADDR(t->dev->sas_addr)));
++              pm8001_dbg(pm8001_ha, FAIL, "SAS Address of IO Failure Drive:%016llx\n",
++                         SAS_ADDR(t->dev->sas_addr));
+ 
+       switch (status) {
+       case IO_SUCCESS:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_SUCCESS ,param = 0x%x\n",
+-                              param));
++              pm8001_dbg(pm8001_ha, IO, "IO_SUCCESS ,param = 0x%x\n",
++                         param);
+               if (param == 0) {
+                       ts->resp = SAS_TASK_COMPLETE;
+                       ts->stat = SAM_STAT_GOOD;
+@@ -1963,8 +1913,7 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_ABORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_ABORTED IOMB Tag\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_ABORTED IOMB Tag\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               if (pm8001_dev)
+@@ -1972,9 +1921,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               break;
+       case IO_UNDERFLOW:
+               /* SSP Completion with error */
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_UNDERFLOW ,param = 0x%x\n",
+-                              param));
++              pm8001_dbg(pm8001_ha, IO, "IO_UNDERFLOW ,param = 0x%x\n",
++                         param);
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_UNDERRUN;
+               ts->residual = param;
+@@ -1982,16 +1930,14 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_NO_DEVICE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_NO_DEVICE\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_PHY_DOWN;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               /* Force the midlayer to retry */
+@@ -2000,8 +1946,7 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PHY_NOT_READY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+@@ -2009,8 +1954,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_INVALID_SSP_RSP_FRAME:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_INVALID_SSP_RSP_FRAME\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_XFER_ERROR_INVALID_SSP_RSP_FRAME\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+@@ -2018,8 +1963,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_EPROTO;
+@@ -2027,8 +1972,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+@@ -2036,8 +1981,7 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+@@ -2050,8 +1994,7 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+@@ -2061,8 +2004,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                               IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+               break;
+       case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_BAD_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+@@ -2070,8 +2013,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+@@ -2079,8 +2022,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+@@ -2088,8 +2031,7 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_NAK_RECEIVED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_NAK_RECEIVED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+@@ -2097,24 +2039,21 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_ACK_NAK_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_DMA:
+-              PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("IO_XFER_ERROR_DMA\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_DMA\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_OPEN_RETRY_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+@@ -2122,24 +2061,21 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_OFFSET_MISMATCH:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_OFFSET_MISMATCH\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_PORT_IN_RESET:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_PORT_IN_RESET\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_PORT_IN_RESET\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_DS_NON_OPERATIONAL:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_NON_OPERATIONAL\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               if (!t->uldd_task)
+@@ -2148,32 +2084,29 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                               IO_DS_NON_OPERATIONAL);
+               break;
+       case IO_DS_IN_RECOVERY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_IN_RECOVERY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_IN_RECOVERY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_TM_TAG_NOT_FOUND:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_TM_TAG_NOT_FOUND\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_TM_TAG_NOT_FOUND\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_SSP_EXT_IU_ZERO_LEN_ERROR:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_SSP_EXT_IU_ZERO_LEN_ERROR\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_SSP_EXT_IU_ZERO_LEN_ERROR\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+@@ -2181,8 +2114,7 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown status 0x%x\n", status));
++              pm8001_dbg(pm8001_ha, DEVIO, "Unknown status 0x%x\n", status);
+               /* not allowed case. Therefore, return failed status */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+@@ -2190,19 +2122,17 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       }
+-      PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("scsi_status = 0x%x\n ",
+-              psspPayload->ssp_resp_iu.status));
++      pm8001_dbg(pm8001_ha, IO, "scsi_status = 0x%x\n ",
++                 psspPayload->ssp_resp_iu.status);
+       spin_lock_irqsave(&t->task_state_lock, flags);
+       t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+       t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+       t->task_state_flags |= SAS_TASK_STATE_DONE;
+       if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                      "task 0x%p done with io_status 0x%x resp 0x%x "
+-                      "stat 0x%x but aborted by upper layer!\n",
+-                      t, status, ts->resp, ts->stat));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
++                         t, status, ts->resp, ts->stat);
+               if (t->slow_task)
+                       complete(&t->slow_task->completion);
+               pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+@@ -2232,17 +2162,15 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       t = ccb->task;
+       pm8001_dev = ccb->device;
+       if (event)
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("sas IO status 0x%x\n", event));
++              pm8001_dbg(pm8001_ha, FAIL, "sas IO status 0x%x\n", event);
+       if (unlikely(!t || !t->lldd_task || !t->dev))
+               return;
+       ts = &t->task_status;
+-      PM8001_IOERR_DBG(pm8001_ha,
+-              pm8001_printk("port_id:0x%x, tag:0x%x, event:0x%x\n",
+-                              port_id, tag, event));
++      pm8001_dbg(pm8001_ha, IOERR, "port_id:0x%x, tag:0x%x, event:0x%x\n",
++                 port_id, tag, event);
+       switch (event) {
+       case IO_OVERFLOW:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n");)
++              pm8001_dbg(pm8001_ha, IO, "IO_UNDERFLOW\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+@@ -2250,34 +2178,31 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
+               pm8001_handle_event(pm8001_ha, t, IO_XFER_ERROR_BREAK);
+               return;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PHY_NOT_READY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_EPROTO;
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+@@ -2288,8 +2213,7 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+@@ -2299,94 +2223,86 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                               IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+               break;
+       case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_BAD_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+               break;
+       case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+               break;
+       case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+               break;
+       case IO_XFER_ERROR_NAK_RECEIVED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_NAK_RECEIVED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_ACK_NAK_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_OPEN_RETRY_TIMEOUT\n");
+               pm8001_handle_event(pm8001_ha, t, IO_XFER_OPEN_RETRY_TIMEOUT);
+               return;
+       case IO_XFER_ERROR_UNEXPECTED_PHASE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_UNEXPECTED_PHASE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_UNEXPECTED_PHASE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_ERROR_XFER_RDY_OVERRUN:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_XFER_RDY_OVERRUN\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_XFER_RDY_OVERRUN\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_ERROR_OFFSET_MISMATCH:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_OFFSET_MISMATCH\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_ERROR_XFER_ZERO_DATA_LEN:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_ERROR_INTERNAL_CRC_ERROR:
+-              PM8001_IOERR_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFR_ERROR_INTERNAL_CRC_ERROR\n"));
++              pm8001_dbg(pm8001_ha, IOERR,
++                         "IO_XFR_ERROR_INTERNAL_CRC_ERROR\n");
+               /* TBC: used default set values */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               break;
+       case IO_XFER_CMD_FRAME_ISSUED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_CMD_FRAME_ISSUED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_CMD_FRAME_ISSUED\n");
+               return;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown status 0x%x\n", event));
++              pm8001_dbg(pm8001_ha, DEVIO, "Unknown status 0x%x\n", event);
+               /* not allowed case. Therefore, return failed status */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+@@ -2398,10 +2314,9 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       t->task_state_flags |= SAS_TASK_STATE_DONE;
+       if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                      "task 0x%p done with event 0x%x resp 0x%x "
+-                      "stat 0x%x but aborted by upper layer!\n",
+-                      t, event, ts->resp, ts->stat));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
++                         t, event, ts->resp, ts->stat);
+               pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+       } else {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+@@ -2436,8 +2351,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       tag = le32_to_cpu(psataPayload->tag);
+ 
+       if (!tag) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("tag null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "tag null\n");
+               return;
+       }
+       ccb = &pm8001_ha->ccb_info[tag];
+@@ -2446,8 +2360,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               t = ccb->task;
+               pm8001_dev = ccb->device;
+       } else {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("ccb null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "ccb null\n");
+               return;
+       }
+ 
+@@ -2455,29 +2368,26 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               if (t->dev && (t->dev->lldd_dev))
+                       pm8001_dev = t->dev->lldd_dev;
+       } else {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("task null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "task null\n");
+               return;
+       }
+ 
+       if ((pm8001_dev && !(pm8001_dev->id & NCQ_READ_LOG_FLAG))
+               && unlikely(!t || !t->lldd_task || !t->dev)) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("task or dev null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "task or dev null\n");
+               return;
+       }
+ 
+       ts = &t->task_status;
+       if (!ts) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("ts null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "ts null\n");
+               return;
+       }
+ 
+       if (unlikely(status))
+-              PM8001_IOERR_DBG(pm8001_ha, pm8001_printk(
+-                      "status:0x%x, tag:0x%x, task::0x%p\n",
+-                      status, tag, t));
++              pm8001_dbg(pm8001_ha, IOERR,
++                         "status:0x%x, tag:0x%x, task::0x%p\n",
++                         status, tag, t);
+ 
+       /* Print sas address of IO failed device */
+       if ((status != IO_SUCCESS) && (status != IO_OVERFLOW) &&
+@@ -2509,20 +2419,20 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                                               & 0xff000000)) +
+                                               pm8001_dev->attached_phy +
+                                               0x10);
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("SAS Address of IO Failure Drive:"
+-                              "%08x%08x", temp_sata_addr_hi,
+-                                      temp_sata_addr_low));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "SAS Address of IO Failure Drive:%08x%08x\n",
++                                 temp_sata_addr_hi,
++                                 temp_sata_addr_low);
+ 
+               } else {
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("SAS Address of IO Failure Drive:"
+-                              "%016llx", SAS_ADDR(t->dev->sas_addr)));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "SAS Address of IO Failure Drive:%016llx\n",
++                                 SAS_ADDR(t->dev->sas_addr));
+               }
+       }
+       switch (status) {
+       case IO_SUCCESS:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_SUCCESS\n");
+               if (param == 0) {
+                       ts->resp = SAS_TASK_COMPLETE;
+                       ts->stat = SAM_STAT_GOOD;
+@@ -2544,39 +2454,38 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       ts->resp = SAS_TASK_COMPLETE;
+                       ts->stat = SAS_PROTO_RESPONSE;
+                       ts->residual = param;
+-                      PM8001_IO_DBG(pm8001_ha,
+-                              pm8001_printk("SAS_PROTO_RESPONSE len = %d\n",
+-                              param));
++                      pm8001_dbg(pm8001_ha, IO,
++                                 "SAS_PROTO_RESPONSE len = %d\n",
++                                 param);
+                       sata_resp = &psataPayload->sata_resp[0];
+                       resp = (struct ata_task_resp *)ts->buf;
+                       if (t->ata_task.dma_xfer == 0 &&
+                           t->data_dir == DMA_FROM_DEVICE) {
+                               len = sizeof(struct pio_setup_fis);
+-                              PM8001_IO_DBG(pm8001_ha,
+-                              pm8001_printk("PIO read len = %d\n", len));
++                              pm8001_dbg(pm8001_ha, IO,
++                                         "PIO read len = %d\n", len);
+                       } else if (t->ata_task.use_ncq) {
+                               len = sizeof(struct set_dev_bits_fis);
+-                              PM8001_IO_DBG(pm8001_ha,
+-                                      pm8001_printk("FPDMA len = %d\n", len));
++                              pm8001_dbg(pm8001_ha, IO, "FPDMA len = %d\n",
++                                         len);
+                       } else {
+                               len = sizeof(struct dev_to_host_fis);
+-                              PM8001_IO_DBG(pm8001_ha,
+-                              pm8001_printk("other len = %d\n", len));
++                              pm8001_dbg(pm8001_ha, IO, "other len = %d\n",
++                                         len);
+                       }
+                       if (SAS_STATUS_BUF_SIZE >= sizeof(*resp)) {
+                               resp->frame_len = len;
+                               memcpy(&resp->ending_fis[0], sata_resp, len);
+                               ts->buf_valid_size = sizeof(*resp);
+                       } else
+-                              PM8001_IO_DBG(pm8001_ha,
+-                                      pm8001_printk("response too large\n"));
++                              pm8001_dbg(pm8001_ha, IO,
++                                         "response too large\n");
+               }
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_ABORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_ABORTED IOMB Tag\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_ABORTED IOMB Tag\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               if (pm8001_dev)
+@@ -2585,8 +2494,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               /* following cases are to do cases */
+       case IO_UNDERFLOW:
+               /* SATA Completion with error */
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_UNDERFLOW param = %d\n", param));
++              pm8001_dbg(pm8001_ha, IO, "IO_UNDERFLOW param = %d\n", param);
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_UNDERRUN;
+               ts->residual = param;
+@@ -2594,24 +2502,21 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_NO_DEVICE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_NO_DEVICE\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_PHY_DOWN;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_INTERRUPTED;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PHY_NOT_READY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+@@ -2619,8 +2524,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_EPROTO;
+@@ -2628,8 +2533,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+@@ -2637,8 +2542,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+@@ -2651,8 +2555,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (!t->uldd_task) {
+@@ -2666,8 +2569,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_BAD_DESTINATION\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+@@ -2682,8 +2585,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+@@ -2691,8 +2594,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (!t->uldd_task) {
+@@ -2706,8 +2609,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+@@ -2715,64 +2618,56 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_NAK_RECEIVED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_NAK_RECEIVED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_ACK_NAK_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_DMA:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_DMA\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_DMA\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_SATA_LINK_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_SATA_LINK_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_SATA_LINK_TIMEOUT\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_REJECTED_NCQ_MODE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_REJECTED_NCQ_MODE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_REJECTED_NCQ_MODE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_UNDERRUN;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_OPEN_RETRY_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_PORT_IN_RESET:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_PORT_IN_RESET\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_PORT_IN_RESET\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_DS_NON_OPERATIONAL:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_NON_OPERATIONAL\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (!t->uldd_task) {
+@@ -2785,16 +2680,14 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case IO_DS_IN_RECOVERY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_IN_RECOVERY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_IN_RECOVERY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_DS_IN_ERROR:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_IN_ERROR\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_IN_ERROR\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (!t->uldd_task) {
+@@ -2807,8 +2700,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+@@ -2816,8 +2709,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown status 0x%x\n", status));
++              pm8001_dbg(pm8001_ha, DEVIO, "Unknown status 0x%x\n", status);
+               /* not allowed case. Therefore, return failed status */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+@@ -2831,10 +2723,9 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       t->task_state_flags |= SAS_TASK_STATE_DONE;
+       if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("task 0x%p done with io_status 0x%x"
+-                      " resp 0x%x stat 0x%x but aborted by upper layer!\n",
+-                      t, status, ts->resp, ts->stat));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
++                         t, status, ts->resp, ts->stat);
+               if (t->slow_task)
+                       complete(&t->slow_task->completion);
+               pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+@@ -2865,13 +2756,11 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               t = ccb->task;
+               pm8001_dev = ccb->device;
+       } else {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("No CCB !!!. returning\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "No CCB !!!. returning\n");
+               return;
+       }
+       if (event)
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("SATA EVENT 0x%x\n", event));
++              pm8001_dbg(pm8001_ha, FAIL, "SATA EVENT 0x%x\n", event);
+ 
+       /* Check if this is NCQ error */
+       if (event == IO_XFER_ERROR_ABORTED_NCQ_MODE) {
+@@ -2884,18 +2773,16 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       }
+ 
+       if (unlikely(!t || !t->lldd_task || !t->dev)) {
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("task or dev null\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "task or dev null\n");
+               return;
+       }
+ 
+       ts = &t->task_status;
+-      PM8001_IOERR_DBG(pm8001_ha,
+-              pm8001_printk("port_id:0x%x, tag:0x%x, event:0x%x\n",
+-                              port_id, tag, event));
++      pm8001_dbg(pm8001_ha, IOERR, "port_id:0x%x, tag:0x%x, event:0x%x\n",
++                 port_id, tag, event);
+       switch (event) {
+       case IO_OVERFLOW:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_UNDERFLOW\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+@@ -2903,35 +2790,32 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_INTERRUPTED;
+               break;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PHY_NOT_READY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_EPROTO;
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+@@ -2942,8 +2826,8 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               if (!t->uldd_task) {
+@@ -2957,107 +2841,96 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               }
+               break;
+       case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_BAD_DESTINATION\n");
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+               break;
+       case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+               break;
+       case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+               break;
+       case IO_XFER_ERROR_NAK_RECEIVED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_NAK_RECEIVED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               break;
+       case IO_XFER_ERROR_PEER_ABORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PEER_ABORTED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PEER_ABORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
+               break;
+       case IO_XFER_ERROR_REJECTED_NCQ_MODE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_REJECTED_NCQ_MODE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_REJECTED_NCQ_MODE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_UNDERRUN;
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_OPEN_RETRY_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_ERROR_UNEXPECTED_PHASE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_UNEXPECTED_PHASE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_UNEXPECTED_PHASE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_ERROR_XFER_RDY_OVERRUN:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_XFER_RDY_OVERRUN\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_XFER_RDY_OVERRUN\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_ERROR_OFFSET_MISMATCH:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_OFFSET_MISMATCH\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_ERROR_XFER_ZERO_DATA_LEN:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_CMD_FRAME_ISSUED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_CMD_FRAME_ISSUED\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_CMD_FRAME_ISSUED\n");
+               break;
+       case IO_XFER_PIO_SETUP_ERROR:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_PIO_SETUP_ERROR\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_PIO_SETUP_ERROR\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_ERROR_INTERNAL_CRC_ERROR:
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFR_ERROR_INTERNAL_CRC_ERROR\n"));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "IO_XFR_ERROR_INTERNAL_CRC_ERROR\n");
+               /* TBC: used default set values */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       case IO_XFER_DMA_ACTIVATE_TIMEOUT:
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFR_DMA_ACTIVATE_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "IO_XFR_DMA_ACTIVATE_TIMEOUT\n");
+               /* TBC: used default set values */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+               break;
+       default:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown status 0x%x\n", event));
++              pm8001_dbg(pm8001_ha, IO, "Unknown status 0x%x\n", event);
+               /* not allowed case. Therefore, return failed status */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
+@@ -3069,10 +2942,9 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+       t->task_state_flags |= SAS_TASK_STATE_DONE;
+       if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("task 0x%p done with io_status 0x%x"
+-                      " resp 0x%x stat 0x%x but aborted by upper layer!\n",
+-                      t, event, ts->resp, ts->stat));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
++                         t, event, ts->resp, ts->stat);
+               pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+       } else {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+@@ -3105,48 +2977,45 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       ts = &t->task_status;
+       pm8001_dev = ccb->device;
+       if (status)
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("smp IO status 0x%x\n", status));
++              pm8001_dbg(pm8001_ha, FAIL, "smp IO status 0x%x\n", status);
+       if (unlikely(!t || !t->lldd_task || !t->dev))
+               return;
+ 
+-      PM8001_DEV_DBG(pm8001_ha,
+-              pm8001_printk("tag::0x%x status::0x%x\n", tag, status));
++      pm8001_dbg(pm8001_ha, DEV, "tag::0x%x status::0x%x\n", tag, status);
+ 
+       switch (status) {
+ 
+       case IO_SUCCESS:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_SUCCESS\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAM_STAT_GOOD;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               if (pm8001_ha->smp_exp_mode == SMP_DIRECT) {
+-                      PM8001_IO_DBG(pm8001_ha,
+-                              pm8001_printk("DIRECT RESPONSE Length:%d\n",
+-                                              param));
++                      pm8001_dbg(pm8001_ha, IO,
++                                 "DIRECT RESPONSE Length:%d\n",
++                                 param);
+                       pdma_respaddr = (char *)(phys_to_virt(cpu_to_le64
+                                               ((u64)sg_dma_address
+                                               (&t->smp_task.smp_resp))));
+                       for (i = 0; i < param; i++) {
+                               *(pdma_respaddr+i) = psmpPayload->_r_a[i];
+-                              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                                      "SMP Byte%d DMA data 0x%x psmp 0x%x\n",
+-                                      i, *(pdma_respaddr+i),
+-                                      psmpPayload->_r_a[i]));
++                              pm8001_dbg(pm8001_ha, IO,
++                                         "SMP Byte%d DMA data 0x%x psmp 0x%x\n",
++                                         i, *(pdma_respaddr + i),
++                                         psmpPayload->_r_a[i]);
+                       }
+               }
+               break;
+       case IO_ABORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_ABORTED IOMB\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_ABORTED IOMB\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               if (pm8001_dev)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OVERFLOW:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_UNDERFLOW\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+@@ -3154,45 +3023,41 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_NO_DEVICE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_NO_DEVICE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_PHY_DOWN;
+               break;
+       case IO_ERROR_HW_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_ERROR_HW_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_ERROR_HW_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAM_STAT_BUSY;
+               break;
+       case IO_XFER_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAM_STAT_BUSY;
+               break;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_PHY_NOT_READY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAM_STAT_BUSY;
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_BREAK\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+@@ -3203,8 +3068,7 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+@@ -3213,75 +3077,68 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                               IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+               break;
+       case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_BAD_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+               break;
+       case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(\
+-                      "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+               break;
+       case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+               break;
+       case IO_XFER_ERROR_RX_FRAME:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_ERROR_RX_FRAME\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_RX_FRAME\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_XFER_OPEN_RETRY_TIMEOUT\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_ERROR_INTERNAL_SMP_RESOURCE:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_ERROR_INTERNAL_SMP_RESOURCE\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_ERROR_INTERNAL_SMP_RESOURCE\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_QUEUE_FULL;
+               break;
+       case IO_PORT_IN_RESET:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_PORT_IN_RESET\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_PORT_IN_RESET\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_DS_NON_OPERATIONAL:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_NON_OPERATIONAL\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               break;
+       case IO_DS_IN_RECOVERY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_DS_IN_RECOVERY\n"));
++              pm8001_dbg(pm8001_ha, IO, "IO_DS_IN_RECOVERY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
++              pm8001_dbg(pm8001_ha, IO,
++                         "IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n");
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown status 0x%x\n", status));
++              pm8001_dbg(pm8001_ha, DEVIO, "Unknown status 0x%x\n", status);
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
+               /* not allowed case. Therefore, return failed status */
+@@ -3293,10 +3150,9 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       t->task_state_flags |= SAS_TASK_STATE_DONE;
+       if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                      "task 0x%p done with io_status 0x%x resp 0x%x"
+-                      "stat 0x%x but aborted by upper layer!\n",
+-                      t, status, ts->resp, ts->stat));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "task 0x%p done with io_status 0x%x resp 0x%xstat 0x%x but aborted by upper layer!\n",
++                         t, status, ts->resp, ts->stat);
+               pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+       } else {
+               spin_unlock_irqrestore(&t->task_state_lock, flags);
+@@ -3393,38 +3249,34 @@ hw_event_sas_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       port->port_state = portstate;
+       port->wide_port_phymap |= (1U << phy_id);
+       phy->phy_state = PHY_STATE_LINK_UP_SPCV;
+-      PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-              "portid:%d; phyid:%d; linkrate:%d; "
+-              "portstate:%x; devicetype:%x\n",
+-              port_id, phy_id, link_rate, portstate, deviceType));
++      pm8001_dbg(pm8001_ha, MSG,
++                 "portid:%d; phyid:%d; linkrate:%d; portstate:%x; devicetype:%x\n",
++                 port_id, phy_id, link_rate, portstate, deviceType);
+ 
+       switch (deviceType) {
+       case SAS_PHY_UNUSED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("device type no device.\n"));
++              pm8001_dbg(pm8001_ha, MSG, "device type no device.\n");
+               break;
+       case SAS_END_DEVICE:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk("end device.\n"));
++              pm8001_dbg(pm8001_ha, MSG, "end device.\n");
+               pm80xx_chip_phy_ctl_req(pm8001_ha, phy_id,
+                       PHY_NOTIFY_ENABLE_SPINUP);
+               port->port_attached = 1;
+               pm8001_get_lrate_mode(phy, link_rate);
+               break;
+       case SAS_EDGE_EXPANDER_DEVICE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("expander device.\n"));
++              pm8001_dbg(pm8001_ha, MSG, "expander device.\n");
+               port->port_attached = 1;
+               pm8001_get_lrate_mode(phy, link_rate);
+               break;
+       case SAS_FANOUT_EXPANDER_DEVICE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("fanout expander device.\n"));
++              pm8001_dbg(pm8001_ha, MSG, "fanout expander device.\n");
+               port->port_attached = 1;
+               pm8001_get_lrate_mode(phy, link_rate);
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("unknown device type(%x)\n", deviceType));
++              pm8001_dbg(pm8001_ha, DEVIO, "unknown device type(%x)\n",
++                         deviceType);
+               break;
+       }
+       phy->phy_type |= PORT_TYPE_SAS;
+@@ -3472,9 +3324,9 @@ hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+       struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+       unsigned long flags;
+-      PM8001_DEVIO_DBG(pm8001_ha, pm8001_printk(
+-              "port id %d, phy id %d link_rate %d portstate 0x%x\n",
+-                              port_id, phy_id, link_rate, portstate));
++      pm8001_dbg(pm8001_ha, DEVIO,
++                 "port id %d, phy id %d link_rate %d portstate 0x%x\n",
++                 port_id, phy_id, link_rate, portstate);
+ 
+       port->port_state = portstate;
+       phy->phy_state = PHY_STATE_LINK_UP_SPCV;
+@@ -3524,10 +3376,10 @@ hw_event_phy_down(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       case PORT_VALID:
+               break;
+       case PORT_INVALID:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" PortInvalid portID %d\n", port_id));
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" Last phy Down and port invalid\n"));
++              pm8001_dbg(pm8001_ha, MSG, " PortInvalid portID %d\n",
++                         port_id);
++              pm8001_dbg(pm8001_ha, MSG,
++                         " Last phy Down and port invalid\n");
+               if (port_sata) {
+                       phy->phy_type = 0;
+                       port->port_attached = 0;
+@@ -3537,19 +3389,18 @@ hw_event_phy_down(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               sas_phy_disconnected(&phy->sas_phy);
+               break;
+       case PORT_IN_RESET:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" Port In Reset portID %d\n", port_id));
++              pm8001_dbg(pm8001_ha, MSG, " Port In Reset portID %d\n",
++                         port_id);
+               break;
+       case PORT_NOT_ESTABLISHED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" Phy Down and PORT_NOT_ESTABLISHED\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         " Phy Down and PORT_NOT_ESTABLISHED\n");
+               port->port_attached = 0;
+               break;
+       case PORT_LOSTCOMM:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" Phy Down and PORT_LOSTCOMM\n"));
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" Last phy Down and port invalid\n"));
++              pm8001_dbg(pm8001_ha, MSG, " Phy Down and PORT_LOSTCOMM\n");
++              pm8001_dbg(pm8001_ha, MSG,
++                         " Last phy Down and port invalid\n");
+               if (port_sata) {
+                       port->port_attached = 0;
+                       phy->phy_type = 0;
+@@ -3560,9 +3411,9 @@ hw_event_phy_down(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               break;
+       default:
+               port->port_attached = 0;
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk(" Phy Down and(default) = 0x%x\n",
+-                      portstate));
++              pm8001_dbg(pm8001_ha, DEVIO,
++                         " Phy Down and(default) = 0x%x\n",
++                         portstate);
+               break;
+ 
+       }
+@@ -3583,9 +3434,9 @@ static int mpi_phy_start_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               le32_to_cpu(pPayload->phyid);
+       struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+ 
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("phy start resp status:0x%x, phyid:0x%x\n",
+-                              status, phy_id));
++      pm8001_dbg(pm8001_ha, INIT,
++                 "phy start resp status:0x%x, phyid:0x%x\n",
++                 status, phy_id);
+       if (status == 0) {
+               phy->phy_state = PHY_LINK_DOWN;
+               if (pm8001_ha->flags == PM8001F_RUN_TIME &&
+@@ -3612,18 +3463,18 @@ static int mpi_thermal_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       u32 rht_lht = le32_to_cpu(pPayload->rht_lht);
+ 
+       if (thermal_event & 0x40) {
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "Thermal Event: Local high temperature violated!\n"));
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "Thermal Event: Measured local high temperature %d\n",
+-                              ((rht_lht & 0xFF00) >> 8)));
++              pm8001_dbg(pm8001_ha, IO,
++                         "Thermal Event: Local high temperature violated!\n");
++              pm8001_dbg(pm8001_ha, IO,
++                         "Thermal Event: Measured local high temperature %d\n",
++                         ((rht_lht & 0xFF00) >> 8));
+       }
+       if (thermal_event & 0x10) {
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "Thermal Event: Remote high temperature violated!\n"));
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "Thermal Event: Measured remote high temperature %d\n",
+-                              ((rht_lht & 0xFF000000) >> 24)));
++              pm8001_dbg(pm8001_ha, IO,
++                         "Thermal Event: Remote high temperature violated!\n");
++              pm8001_dbg(pm8001_ha, IO,
++                         "Thermal Event: Measured remote high temperature %d\n",
++                         ((rht_lht & 0xFF000000) >> 24));
+       }
+       return 0;
+ }
+@@ -3652,42 +3503,36 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+       struct pm8001_port *port = &pm8001_ha->port[port_id];
+       struct asd_sas_phy *sas_phy = sas_ha->sas_phy[phy_id];
+-      PM8001_DEV_DBG(pm8001_ha,
+-              pm8001_printk("portid:%d phyid:%d event:0x%x status:0x%x\n",
+-                              port_id, phy_id, eventType, status));
++      pm8001_dbg(pm8001_ha, DEV,
++                 "portid:%d phyid:%d event:0x%x status:0x%x\n",
++                 port_id, phy_id, eventType, status);
+ 
+       switch (eventType) {
+ 
+       case HW_EVENT_SAS_PHY_UP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PHY_START_STATUS\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_START_STATUS\n");
+               hw_event_sas_phy_up(pm8001_ha, piomb);
+               break;
+       case HW_EVENT_SATA_PHY_UP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_SATA_PHY_UP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_SATA_PHY_UP\n");
+               hw_event_sata_phy_up(pm8001_ha, piomb);
+               break;
+       case HW_EVENT_SATA_SPINUP_HOLD:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_SATA_SPINUP_HOLD\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_SATA_SPINUP_HOLD\n");
+               sas_ha->notify_phy_event(&phy->sas_phy, PHYE_SPINUP_HOLD);
+               break;
+       case HW_EVENT_PHY_DOWN:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PHY_DOWN\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_DOWN\n");
+               hw_event_phy_down(pm8001_ha, piomb);
+               if (pm8001_ha->reset_in_progress) {
+-                      PM8001_MSG_DBG(pm8001_ha,
+-                              pm8001_printk("Reset in progress\n"));
++                      pm8001_dbg(pm8001_ha, MSG, "Reset in progress\n");
+                       return 0;
+               }
+               phy->phy_attached = 0;
+               phy->phy_state = PHY_LINK_DISABLE;
+               break;
+       case HW_EVENT_PORT_INVALID:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PORT_INVALID\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_INVALID\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+@@ -3695,8 +3540,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       /* the broadcast change primitive received, tell the LIBSAS this event
+       to revalidate the sas domain*/
+       case HW_EVENT_BROADCAST_CHANGE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_BROADCAST_CHANGE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_BROADCAST_CHANGE\n");
+               pm80xx_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_BROADCAST_CHANGE,
+                       port_id, phy_id, 1, 0);
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+@@ -3705,81 +3549,74 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_PHY_ERROR:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PHY_ERROR\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PHY_ERROR\n");
+               sas_phy_disconnected(&phy->sas_phy);
+               phy->phy_attached = 0;
+               sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_ERROR);
+               break;
+       case HW_EVENT_BROADCAST_EXP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_BROADCAST_EXP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_BROADCAST_EXP\n");
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+               sas_phy->sas_prim = HW_EVENT_BROADCAST_EXP;
+               spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+               sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_LINK_ERR_INVALID_DWORD:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_LINK_ERR_INVALID_DWORD\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_LINK_ERR_INVALID_DWORD\n");
+               pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_LINK_ERR_INVALID_DWORD, port_id, phy_id, 0, 0);
+               break;
+       case HW_EVENT_LINK_ERR_DISPARITY_ERROR:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_LINK_ERR_DISPARITY_ERROR\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_LINK_ERR_DISPARITY_ERROR\n");
+               pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_LINK_ERR_DISPARITY_ERROR,
+                       port_id, phy_id, 0, 0);
+               break;
+       case HW_EVENT_LINK_ERR_CODE_VIOLATION:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_LINK_ERR_CODE_VIOLATION\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_LINK_ERR_CODE_VIOLATION\n");
+               pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_LINK_ERR_CODE_VIOLATION,
+                       port_id, phy_id, 0, 0);
+               break;
+       case HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                              "HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH\n");
+               pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH,
+                       port_id, phy_id, 0, 0);
+               break;
+       case HW_EVENT_MALFUNCTION:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_MALFUNCTION\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_MALFUNCTION\n");
+               break;
+       case HW_EVENT_BROADCAST_SES:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_BROADCAST_SES\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_BROADCAST_SES\n");
+               spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+               sas_phy->sas_prim = HW_EVENT_BROADCAST_SES;
+               spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+               sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+               break;
+       case HW_EVENT_INBOUND_CRC_ERROR:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_INBOUND_CRC_ERROR\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_INBOUND_CRC_ERROR\n");
+               pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_INBOUND_CRC_ERROR,
+                       port_id, phy_id, 0, 0);
+               break;
+       case HW_EVENT_HARD_RESET_RECEIVED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_HARD_RESET_RECEIVED\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_HARD_RESET_RECEIVED\n");
+               sas_ha->notify_port_event(sas_phy, PORTE_HARD_RESET);
+               break;
+       case HW_EVENT_ID_FRAME_TIMEOUT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_ID_FRAME_TIMEOUT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_ID_FRAME_TIMEOUT\n");
+               sas_phy_disconnected(sas_phy);
+               phy->phy_attached = 0;
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_LINK_ERR_PHY_RESET_FAILED:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_LINK_ERR_PHY_RESET_FAILED\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_LINK_ERR_PHY_RESET_FAILED\n");
+               pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_LINK_ERR_PHY_RESET_FAILED,
+                       port_id, phy_id, 0, 0);
+@@ -3788,8 +3625,7 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+               break;
+       case HW_EVENT_PORT_RESET_TIMER_TMO:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PORT_RESET_TIMER_TMO\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_RESET_TIMER_TMO\n");
+               pm80xx_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_PHY_DOWN,
+                       port_id, phy_id, 0, 0);
+               sas_phy_disconnected(sas_phy);
+@@ -3803,8 +3639,8 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case HW_EVENT_PORT_RECOVERY_TIMER_TMO:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PORT_RECOVERY_TIMER_TMO\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "HW_EVENT_PORT_RECOVERY_TIMER_TMO\n");
+               pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                       HW_EVENT_PORT_RECOVERY_TIMER_TMO,
+                       port_id, phy_id, 0, 0);
+@@ -3818,13 +3654,11 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case HW_EVENT_PORT_RECOVER:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PORT_RECOVER\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_RECOVER\n");
+               hw_event_port_recover(pm8001_ha, piomb);
+               break;
+       case HW_EVENT_PORT_RESET_COMPLETE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("HW_EVENT_PORT_RESET_COMPLETE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_RESET_COMPLETE\n");
+               if (pm8001_ha->phy[phy_id].reset_completion) {
+                       pm8001_ha->phy[phy_id].port_reset_status =
+                                       PORT_RESET_SUCCESS;
+@@ -3833,12 +3667,11 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               }
+               break;
+       case EVENT_BROADCAST_ASYNCH_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("EVENT_BROADCAST_ASYNCH_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "EVENT_BROADCAST_ASYNCH_EVENT\n");
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha,
+-                      pm8001_printk("Unknown event type 0x%x\n", eventType));
++              pm8001_dbg(pm8001_ha, DEVIO, "Unknown event type 0x%x\n",
++                         eventType);
+               break;
+       }
+       return 0;
+@@ -3858,9 +3691,8 @@ static int mpi_phy_stop_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+       u32 phyid =
+               le32_to_cpu(pPayload->phyid) & 0xFF;
+       struct pm8001_phy *phy = &pm8001_ha->phy[phyid];
+-      PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("phy:0x%x status:0x%x\n",
+-                                      phyid, status));
++      pm8001_dbg(pm8001_ha, MSG, "phy:0x%x status:0x%x\n",
++                 phyid, status);
+       if (status == PHY_STOP_SUCCESS ||
+               status == PHY_STOP_ERR_DEVICE_ATTACHED)
+               phy->phy_state = PHY_LINK_DISABLE;
+@@ -3880,9 +3712,9 @@ static int mpi_set_controller_config_resp(struct pm8001_hba_info *pm8001_ha,
+       u32 status = le32_to_cpu(pPayload->status);
+       u32 err_qlfr_pgcd = le32_to_cpu(pPayload->err_qlfr_pgcd);
+ 
+-      PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                      "SET CONTROLLER RESP: status 0x%x qlfr_pgcd 0x%x\n",
+-                      status, err_qlfr_pgcd));
++      pm8001_dbg(pm8001_ha, MSG,
++                 "SET CONTROLLER RESP: status 0x%x qlfr_pgcd 0x%x\n",
++                 status, err_qlfr_pgcd);
+ 
+       return 0;
+ }
+@@ -3895,8 +3727,7 @@ static int mpi_set_controller_config_resp(struct pm8001_hba_info *pm8001_ha,
+ static int mpi_get_controller_config_resp(struct pm8001_hba_info *pm8001_ha,
+                       void *piomb)
+ {
+-      PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" pm80xx_addition_functionality\n"));
++      pm8001_dbg(pm8001_ha, MSG, " pm80xx_addition_functionality\n");
+ 
+       return 0;
+ }
+@@ -3909,8 +3740,7 @@ static int mpi_get_controller_config_resp(struct pm8001_hba_info *pm8001_ha,
+ static int mpi_get_phy_profile_resp(struct pm8001_hba_info *pm8001_ha,
+                       void *piomb)
+ {
+-      PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" pm80xx_addition_functionality\n"));
++      pm8001_dbg(pm8001_ha, MSG, " pm80xx_addition_functionality\n");
+ 
+       return 0;
+ }
+@@ -3922,8 +3752,7 @@ static int mpi_get_phy_profile_resp(struct pm8001_hba_info *pm8001_ha,
+  */
+ static int mpi_flash_op_ext_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+ {
+-      PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" pm80xx_addition_functionality\n"));
++      pm8001_dbg(pm8001_ha, MSG, " pm80xx_addition_functionality\n");
+ 
+       return 0;
+ }
+@@ -3948,15 +3777,14 @@ static int mpi_set_phy_profile_resp(struct pm8001_hba_info *pm8001_ha,
+       page_code = (u8)((ppc_phyid & 0xFF00) >> 8);
+       if (status) {
+               /* status is FAILED */
+-              PM8001_FAIL_DBG(pm8001_ha,
+-                      pm8001_printk("PhyProfile command failed  with status "
+-                      "0x%08X \n", status));
++              pm8001_dbg(pm8001_ha, FAIL,
++                         "PhyProfile command failed  with status 0x%08X\n",
++                         status);
+               rc = -1;
+       } else {
+               if (page_code != SAS_PHY_ANALOG_SETTINGS_PAGE) {
+-                      PM8001_FAIL_DBG(pm8001_ha,
+-                              pm8001_printk("Invalid page code 0x%X\n",
+-                                      page_code));
++                      pm8001_dbg(pm8001_ha, FAIL, "Invalid page code 0x%X\n",
++                                 page_code);
+                       rc = -1;
+               }
+       }
+@@ -3978,9 +3806,9 @@ static int mpi_kek_management_resp(struct pm8001_hba_info *pm8001_ha,
+       u32 kidx_new_curr_ksop = le32_to_cpu(pPayload->kidx_new_curr_ksop);
+       u32 err_qlfr = le32_to_cpu(pPayload->err_qlfr);
+ 
+-      PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-              "KEK MGMT RESP. Status 0x%x idx_ksop 0x%x err_qlfr 0x%x\n",
+-              status, kidx_new_curr_ksop, err_qlfr));
++      pm8001_dbg(pm8001_ha, MSG,
++                 "KEK MGMT RESP. Status 0x%x idx_ksop 0x%x err_qlfr 0x%x\n",
++                 status, kidx_new_curr_ksop, err_qlfr);
+ 
+       return 0;
+ }
+@@ -3993,8 +3821,7 @@ static int mpi_kek_management_resp(struct pm8001_hba_info *pm8001_ha,
+ static int mpi_dek_management_resp(struct pm8001_hba_info *pm8001_ha,
+                       void *piomb)
+ {
+-      PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" pm80xx_addition_functionality\n"));
++      pm8001_dbg(pm8001_ha, MSG, " pm80xx_addition_functionality\n");
+ 
+       return 0;
+ }
+@@ -4007,8 +3834,7 @@ static int mpi_dek_management_resp(struct pm8001_hba_info *pm8001_ha,
+ static int ssp_coalesced_comp_resp(struct pm8001_hba_info *pm8001_ha,
+                       void *piomb)
+ {
+-      PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk(" pm80xx_addition_functionality\n"));
++      pm8001_dbg(pm8001_ha, MSG, " pm80xx_addition_functionality\n");
+ 
+       return 0;
+ }
+@@ -4025,248 +3851,206 @@ static void process_one_iomb(struct pm8001_hba_info *pm8001_ha, void *piomb)
+ 
+       switch (opc) {
+       case OPC_OUB_ECHO:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk("OPC_OUB_ECHO\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_ECHO\n");
+               break;
+       case OPC_OUB_HW_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_HW_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_HW_EVENT\n");
+               mpi_hw_event(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_THERM_HW_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_THERMAL_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_THERMAL_EVENT\n");
+               mpi_thermal_hw_event(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SSP_COMP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SSP_COMP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SSP_COMP\n");
+               mpi_ssp_completion(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SMP_COMP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SMP_COMP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SMP_COMP\n");
+               mpi_smp_completion(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_LOCAL_PHY_CNTRL:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_LOCAL_PHY_CNTRL\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_LOCAL_PHY_CNTRL\n");
+               pm8001_mpi_local_phy_ctl(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_DEV_REGIST:
+-              PM8001_MSG_DBG(pm8001_ha,
+-              pm8001_printk("OPC_OUB_DEV_REGIST\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_DEV_REGIST\n");
+               pm8001_mpi_reg_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_DEREG_DEV:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("unregister the device\n"));
++              pm8001_dbg(pm8001_ha, MSG, "unregister the device\n");
+               pm8001_mpi_dereg_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_GET_DEV_HANDLE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GET_DEV_HANDLE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GET_DEV_HANDLE\n");
+               break;
+       case OPC_OUB_SATA_COMP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SATA_COMP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SATA_COMP\n");
+               mpi_sata_completion(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SATA_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SATA_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SATA_EVENT\n");
+               mpi_sata_event(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SSP_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SSP_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SSP_EVENT\n");
+               mpi_ssp_event(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_DEV_HANDLE_ARRIV:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_DEV_HANDLE_ARRIV\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_DEV_HANDLE_ARRIV\n");
+               /*This is for target*/
+               break;
+       case OPC_OUB_SSP_RECV_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SSP_RECV_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SSP_RECV_EVENT\n");
+               /*This is for target*/
+               break;
+       case OPC_OUB_FW_FLASH_UPDATE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_FW_FLASH_UPDATE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_FW_FLASH_UPDATE\n");
+               pm8001_mpi_fw_flash_update_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_GPIO_RESPONSE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GPIO_RESPONSE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GPIO_RESPONSE\n");
+               break;
+       case OPC_OUB_GPIO_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GPIO_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GPIO_EVENT\n");
+               break;
+       case OPC_OUB_GENERAL_EVENT:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GENERAL_EVENT\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GENERAL_EVENT\n");
+               pm8001_mpi_general_event(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SSP_ABORT_RSP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SSP_ABORT_RSP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SSP_ABORT_RSP\n");
+               pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SATA_ABORT_RSP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SATA_ABORT_RSP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SATA_ABORT_RSP\n");
+               pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SAS_DIAG_MODE_START_END:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SAS_DIAG_MODE_START_END\n"));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_SAS_DIAG_MODE_START_END\n");
+               break;
+       case OPC_OUB_SAS_DIAG_EXECUTE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SAS_DIAG_EXECUTE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SAS_DIAG_EXECUTE\n");
+               break;
+       case OPC_OUB_GET_TIME_STAMP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GET_TIME_STAMP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GET_TIME_STAMP\n");
+               break;
+       case OPC_OUB_SAS_HW_EVENT_ACK:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SAS_HW_EVENT_ACK\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SAS_HW_EVENT_ACK\n");
+               break;
+       case OPC_OUB_PORT_CONTROL:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_PORT_CONTROL\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_PORT_CONTROL\n");
+               break;
+       case OPC_OUB_SMP_ABORT_RSP:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SMP_ABORT_RSP\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SMP_ABORT_RSP\n");
+               pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_GET_NVMD_DATA:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GET_NVMD_DATA\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GET_NVMD_DATA\n");
+               pm8001_mpi_get_nvmd_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SET_NVMD_DATA:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SET_NVMD_DATA\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SET_NVMD_DATA\n");
+               pm8001_mpi_set_nvmd_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_DEVICE_HANDLE_REMOVAL:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_DEVICE_HANDLE_REMOVAL\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_DEVICE_HANDLE_REMOVAL\n");
+               break;
+       case OPC_OUB_SET_DEVICE_STATE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SET_DEVICE_STATE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SET_DEVICE_STATE\n");
+               pm8001_mpi_set_dev_state_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_GET_DEVICE_STATE:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_GET_DEVICE_STATE\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_GET_DEVICE_STATE\n");
+               break;
+       case OPC_OUB_SET_DEV_INFO:
+-              PM8001_MSG_DBG(pm8001_ha,
+-                      pm8001_printk("OPC_OUB_SET_DEV_INFO\n"));
++              pm8001_dbg(pm8001_ha, MSG, "OPC_OUB_SET_DEV_INFO\n");
+               break;
+       /* spcv specifc commands */
+       case OPC_OUB_PHY_START_RESP:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                      "OPC_OUB_PHY_START_RESP opcode:%x\n", opc));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_PHY_START_RESP opcode:%x\n", opc);
+               mpi_phy_start_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_PHY_STOP_RESP:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                      "OPC_OUB_PHY_STOP_RESP opcode:%x\n", opc));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_PHY_STOP_RESP opcode:%x\n", opc);
+               mpi_phy_stop_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SET_CONTROLLER_CONFIG:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                      "OPC_OUB_SET_CONTROLLER_CONFIG opcode:%x\n", opc));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_SET_CONTROLLER_CONFIG opcode:%x\n", opc);
+               mpi_set_controller_config_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_GET_CONTROLLER_CONFIG:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                      "OPC_OUB_GET_CONTROLLER_CONFIG opcode:%x\n", opc));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_GET_CONTROLLER_CONFIG opcode:%x\n", opc);
+               mpi_get_controller_config_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_GET_PHY_PROFILE:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                      "OPC_OUB_GET_PHY_PROFILE opcode:%x\n", opc));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_GET_PHY_PROFILE opcode:%x\n", opc);
+               mpi_get_phy_profile_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_FLASH_OP_EXT:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                      "OPC_OUB_FLASH_OP_EXT opcode:%x\n", opc));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_FLASH_OP_EXT opcode:%x\n", opc);
+               mpi_flash_op_ext_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SET_PHY_PROFILE:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                      "OPC_OUB_SET_PHY_PROFILE opcode:%x\n", opc));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_SET_PHY_PROFILE opcode:%x\n", opc);
+               mpi_set_phy_profile_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_KEK_MANAGEMENT_RESP:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                      "OPC_OUB_KEK_MANAGEMENT_RESP opcode:%x\n", opc));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_KEK_MANAGEMENT_RESP opcode:%x\n", opc);
+               mpi_kek_management_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_DEK_MANAGEMENT_RESP:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                      "OPC_OUB_DEK_MANAGEMENT_RESP opcode:%x\n", opc));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_DEK_MANAGEMENT_RESP opcode:%x\n", opc);
+               mpi_dek_management_resp(pm8001_ha, piomb);
+               break;
+       case OPC_OUB_SSP_COALESCED_COMP_RESP:
+-              PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+-                      "OPC_OUB_SSP_COALESCED_COMP_RESP opcode:%x\n", opc));
++              pm8001_dbg(pm8001_ha, MSG,
++                         "OPC_OUB_SSP_COALESCED_COMP_RESP opcode:%x\n", opc);
+               ssp_coalesced_comp_resp(pm8001_ha, piomb);
+               break;
+       default:
+-              PM8001_DEVIO_DBG(pm8001_ha, pm8001_printk(
+-                      "Unknown outbound Queue IOMB OPC = 0x%x\n", opc));
++              pm8001_dbg(pm8001_ha, DEVIO,
++                         "Unknown outbound Queue IOMB OPC = 0x%x\n", opc);
+               break;
+       }
+ }
+ 
+ static void print_scratchpad_registers(struct pm8001_hba_info *pm8001_ha)
+ {
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_SCRATCH_PAD_0: 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_0)));
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_SCRATCH_PAD_1:0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1)));
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_SCRATCH_PAD_2: 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2)));
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_SCRATCH_PAD_3: 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_3)));
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_HOST_SCRATCH_PAD_0: 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_0)));
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_HOST_SCRATCH_PAD_1: 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_1)));
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_HOST_SCRATCH_PAD_2: 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_2)));
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_HOST_SCRATCH_PAD_3: 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_3)));
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_HOST_SCRATCH_PAD_4: 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_4)));
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_HOST_SCRATCH_PAD_5: 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_5)));
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_RSVD_SCRATCH_PAD_0: 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_6)));
+-      PM8001_FAIL_DBG(pm8001_ha,
+-              pm8001_printk("MSGU_RSVD_SCRATCH_PAD_1: 0x%x\n",
+-                      pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_7)));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_SCRATCH_PAD_0: 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_0));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_SCRATCH_PAD_1:0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_SCRATCH_PAD_2: 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_SCRATCH_PAD_3: 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_3));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_HOST_SCRATCH_PAD_0: 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_0));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_HOST_SCRATCH_PAD_1: 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_1));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_HOST_SCRATCH_PAD_2: 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_2));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_HOST_SCRATCH_PAD_3: 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_3));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_HOST_SCRATCH_PAD_4: 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_4));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_HOST_SCRATCH_PAD_5: 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_5));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_RSVD_SCRATCH_PAD_0: 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_6));
++      pm8001_dbg(pm8001_ha, FAIL, "MSGU_RSVD_SCRATCH_PAD_1: 0x%x\n",
++                 pm8001_cr32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_7));
+ }
+ 
+ static int process_oq(struct pm8001_hba_info *pm8001_ha, u8 vec)
+@@ -4283,8 +4067,9 @@ static int process_oq(struct pm8001_hba_info *pm8001_ha, u8 vec)
+               if ((regval & SCRATCH_PAD_MIPSALL_READY) !=
+                                       SCRATCH_PAD_MIPSALL_READY) {
+                       pm8001_ha->controller_fatal_error = true;
+-                      PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+-                              "Firmware Fatal error! Regval:0x%x\n", regval));
++                      pm8001_dbg(pm8001_ha, FAIL,
++                                 "Firmware Fatal error! Regval:0x%x\n",
++                                 regval);
+                       print_scratchpad_registers(pm8001_ha);
+                       return ret;
+               }
+@@ -4390,8 +4175,7 @@ static int pm80xx_chip_smp_req(struct pm8001_hba_info *pm8001_ha,
+       smp_cmd.tag = cpu_to_le32(ccb->ccb_tag);
+ 
+       length = sg_req->length;
+-      PM8001_IO_DBG(pm8001_ha,
+-              pm8001_printk("SMP Frame Length %d\n", sg_req->length));
++      pm8001_dbg(pm8001_ha, IO, "SMP Frame Length %d\n", sg_req->length);
+       if (!(length - 8))
+               pm8001_ha->smp_exp_mode = SMP_DIRECT;
+       else
+@@ -4403,8 +4187,7 @@ static int pm80xx_chip_smp_req(struct pm8001_hba_info *pm8001_ha,
+ 
+       /* INDIRECT MODE command settings. Use DMA */
+       if (pm8001_ha->smp_exp_mode == SMP_INDIRECT) {
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("SMP REQUEST INDIRECT MODE\n"));
++              pm8001_dbg(pm8001_ha, IO, "SMP REQUEST INDIRECT MODE\n");
+               /* for SPCv indirect mode. Place the top 4 bytes of
+                * SMP Request header here. */
+               for (i = 0; i < 4; i++)
+@@ -4436,21 +4219,20 @@ static int pm80xx_chip_smp_req(struct pm8001_hba_info *pm8001_ha,
+                       ((u32)sg_dma_len(&task->smp_task.smp_resp)-4);
+       }
+       if (pm8001_ha->smp_exp_mode == SMP_DIRECT) {
+-              PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("SMP REQUEST DIRECT MODE\n"));
++              pm8001_dbg(pm8001_ha, IO, "SMP REQUEST DIRECT MODE\n");
+               for (i = 0; i < length; i++)
+                       if (i < 16) {
+                               smp_cmd.smp_req16[i] = *(preq_dma_addr+i);
+-                              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                                      "Byte[%d]:%x (DMA data:%x)\n",
+-                                      i, smp_cmd.smp_req16[i],
+-                                      *(preq_dma_addr)));
++                              pm8001_dbg(pm8001_ha, IO,
++                                         "Byte[%d]:%x (DMA data:%x)\n",
++                                         i, smp_cmd.smp_req16[i],
++                                         *(preq_dma_addr));
+                       } else {
+                               smp_cmd.smp_req[i] = *(preq_dma_addr+i);
+-                              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                                      "Byte[%d]:%x (DMA data:%x)\n",
+-                                      i, smp_cmd.smp_req[i],
+-                                      *(preq_dma_addr)));
++                              pm8001_dbg(pm8001_ha, IO,
++                                         "Byte[%d]:%x (DMA data:%x)\n",
++                                         i, smp_cmd.smp_req[i],
++                                         *(preq_dma_addr));
+                       }
+       }
+ 
+@@ -4547,9 +4329,9 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha,
+       /* Check if encryption is set */
+       if (pm8001_ha->chip->encrypt &&
+               !(pm8001_ha->encrypt_info.status) && check_enc_sas_cmd(task)) {
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "Encryption enabled.Sending Encrypt SAS command 0x%x\n",
+-                      task->ssp_task.cmd->cmnd[0]));
++              pm8001_dbg(pm8001_ha, IO,
++                         "Encryption enabled.Sending Encrypt SAS command 0x%x\n",
++                         task->ssp_task.cmd->cmnd[0]);
+               opc = OPC_INB_SSP_INI_DIF_ENC_IO;
+               /* enable encryption. 0 for SAS 1.1 and SAS 2.0 compatible TLR*/
+               ssp_cmd.dad_dir_m_tlr = cpu_to_le32
+@@ -4579,13 +4361,10 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha,
+                       end_addr_low = cpu_to_le32(lower_32_bits(end_addr));
+                       end_addr_high = cpu_to_le32(upper_32_bits(end_addr));
+                       if (end_addr_high != ssp_cmd.enc_addr_high) {
+-                              PM8001_FAIL_DBG(pm8001_ha,
+-                                      pm8001_printk("The sg list address "
+-                                      "start_addr=0x%016llx data_len=0x%x "
+-                                      "end_addr_high=0x%08x end_addr_low="
+-                                      "0x%08x has crossed 4G boundary\n",
+-                                              start_addr, ssp_cmd.enc_len,
+-                                              end_addr_high, end_addr_low));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "The sg list address start_addr=0x%016llx data_len=0x%x end_addr_high=0x%08x end_addr_low=0x%08x has crossed 4G boundary\n",
++                                         start_addr, ssp_cmd.enc_len,
++                                         end_addr_high, end_addr_low);
+                               pm8001_chip_make_sg(task->scatter, 1,
+                                       ccb->buf_prd);
+                               phys_addr = ccb->ccb_dma_handle;
+@@ -4609,9 +4388,9 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha,
+                                               (task->ssp_task.cmd->cmnd[4] << 8) |
+                                               (task->ssp_task.cmd->cmnd[5]));
+       } else {
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "Sending Normal SAS command 0x%x inb q %x\n",
+-                      task->ssp_task.cmd->cmnd[0], q_index));
++              pm8001_dbg(pm8001_ha, IO,
++                         "Sending Normal SAS command 0x%x inb q %x\n",
++                         task->ssp_task.cmd->cmnd[0], q_index);
+               /* fill in PRD (scatter/gather) table, if any */
+               if (task->num_scatter > 1) {
+                       pm8001_chip_make_sg(task->scatter, ccb->n_elem,
+@@ -4635,13 +4414,10 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha,
+                       end_addr_low = cpu_to_le32(lower_32_bits(end_addr));
+                       end_addr_high = cpu_to_le32(upper_32_bits(end_addr));
+                       if (end_addr_high != ssp_cmd.addr_high) {
+-                              PM8001_FAIL_DBG(pm8001_ha,
+-                                      pm8001_printk("The sg list address "
+-                                      "start_addr=0x%016llx data_len=0x%x "
+-                                      "end_addr_high=0x%08x end_addr_low="
+-                                      "0x%08x has crossed 4G boundary\n",
+-                                               start_addr, ssp_cmd.len,
+-                                               end_addr_high, end_addr_low));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "The sg list address start_addr=0x%016llx data_len=0x%x end_addr_high=0x%08x end_addr_low=0x%08x has crossed 4G boundary\n",
++                                         start_addr, ssp_cmd.len,
++                                         end_addr_high, end_addr_low);
+                               pm8001_chip_make_sg(task->scatter, 1,
+                                       ccb->buf_prd);
+                               phys_addr = ccb->ccb_dma_handle;
+@@ -4688,19 +4464,19 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+ 
+       if (task->data_dir == DMA_NONE) {
+               ATAP = 0x04; /* no data*/
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk("no data\n"));
++              pm8001_dbg(pm8001_ha, IO, "no data\n");
+       } else if (likely(!task->ata_task.device_control_reg_update)) {
+               if (task->ata_task.dma_xfer) {
+                       ATAP = 0x06; /* DMA */
+-                      PM8001_IO_DBG(pm8001_ha, pm8001_printk("DMA\n"));
++                      pm8001_dbg(pm8001_ha, IO, "DMA\n");
+               } else {
+                       ATAP = 0x05; /* PIO*/
+-                      PM8001_IO_DBG(pm8001_ha, pm8001_printk("PIO\n"));
++                      pm8001_dbg(pm8001_ha, IO, "PIO\n");
+               }
+               if (task->ata_task.use_ncq &&
+                   dev->sata_dev.class != ATA_DEV_ATAPI) {
+                       ATAP = 0x07; /* FPDMA */
+-                      PM8001_IO_DBG(pm8001_ha, pm8001_printk("FPDMA\n"));
++                      pm8001_dbg(pm8001_ha, IO, "FPDMA\n");
+               }
+       }
+       if (task->ata_task.use_ncq && pm8001_get_ncq_tag(task, &hdr_tag)) {
+@@ -4720,9 +4496,9 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+       /* Check if encryption is set */
+       if (pm8001_ha->chip->encrypt &&
+               !(pm8001_ha->encrypt_info.status) && check_enc_sat_cmd(task)) {
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "Encryption enabled.Sending Encrypt SATA cmd 0x%x\n",
+-                      sata_cmd.sata_fis.command));
++              pm8001_dbg(pm8001_ha, IO,
++                         "Encryption enabled.Sending Encrypt SATA cmd 0x%x\n",
++                         sata_cmd.sata_fis.command);
+               opc = OPC_INB_SATA_DIF_ENC_IO;
+ 
+               /* set encryption bit */
+@@ -4750,13 +4526,10 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+                       end_addr_low = cpu_to_le32(lower_32_bits(end_addr));
+                       end_addr_high = cpu_to_le32(upper_32_bits(end_addr));
+                       if (end_addr_high != sata_cmd.enc_addr_high) {
+-                              PM8001_FAIL_DBG(pm8001_ha,
+-                                      pm8001_printk("The sg list address "
+-                                      "start_addr=0x%016llx data_len=0x%x "
+-                                      "end_addr_high=0x%08x end_addr_low"
+-                                      "=0x%08x has crossed 4G boundary\n",
+-                                              start_addr, sata_cmd.enc_len,
+-                                              end_addr_high, end_addr_low));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "The sg list address start_addr=0x%016llx data_len=0x%x end_addr_high=0x%08x end_addr_low=0x%08x has crossed 4G boundary\n",
++                                         start_addr, sata_cmd.enc_len,
++                                         end_addr_high, end_addr_low);
+                               pm8001_chip_make_sg(task->scatter, 1,
+                                       ccb->buf_prd);
+                               phys_addr = ccb->ccb_dma_handle;
+@@ -4785,9 +4558,9 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+                       cpu_to_le32((sata_cmd.sata_fis.lbah_exp << 8) |
+                                        (sata_cmd.sata_fis.lbam_exp));
+       } else {
+-              PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+-                      "Sending Normal SATA command 0x%x inb %x\n",
+-                      sata_cmd.sata_fis.command, q_index));
++              pm8001_dbg(pm8001_ha, IO,
++                         "Sending Normal SATA command 0x%x inb %x\n",
++                         sata_cmd.sata_fis.command, q_index);
+               /* dad (bit 0-1) is 0 */
+               sata_cmd.ncqtag_atap_dir_m_dad =
+                       cpu_to_le32(((ncg_tag & 0xff)<<16) |
+@@ -4813,13 +4586,10 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+                       end_addr_low = cpu_to_le32(lower_32_bits(end_addr));
+                       end_addr_high = cpu_to_le32(upper_32_bits(end_addr));
+                       if (end_addr_high != sata_cmd.addr_high) {
+-                              PM8001_FAIL_DBG(pm8001_ha,
+-                                      pm8001_printk("The sg list address "
+-                                      "start_addr=0x%016llx data_len=0x%x"
+-                                      "end_addr_high=0x%08x end_addr_low="
+-                                      "0x%08x has crossed 4G boundary\n",
+-                                              start_addr, sata_cmd.len,
+-                                              end_addr_high, end_addr_low));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "The sg list address start_addr=0x%016llx data_len=0x%xend_addr_high=0x%08x end_addr_low=0x%08x has crossed 4G boundary\n",
++                                         start_addr, sata_cmd.len,
++                                         end_addr_high, end_addr_low);
+                               pm8001_chip_make_sg(task->scatter, 1,
+                                       ccb->buf_prd);
+                               phys_addr = ccb->ccb_dma_handle;
+@@ -4878,10 +4648,10 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+                                       SAS_TASK_STATE_ABORTED))) {
+                               spin_unlock_irqrestore(&task->task_state_lock,
+                                                       flags);
+-                              PM8001_FAIL_DBG(pm8001_ha,
+-                                      pm8001_printk("task 0x%p resp 0x%x "
+-                                      " stat 0x%x but aborted by upper layer "
+-                                      "\n", task, ts->resp, ts->stat));
++                              pm8001_dbg(pm8001_ha, FAIL,
++                                         "task 0x%p resp 0x%x  stat 0x%x but aborted by upper layer\n",
++                                         task, ts->resp,
++                                         ts->stat);
+                               pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+                               return 0;
+                       } else {
+@@ -4916,8 +4686,7 @@ pm80xx_chip_phy_start_req(struct pm8001_hba_info *pm8001_ha, u8 phy_id)
+       memset(&payload, 0, sizeof(payload));
+       payload.tag = cpu_to_le32(tag);
+ 
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("PHY START REQ for phy_id %d\n", phy_id));
++      pm8001_dbg(pm8001_ha, INIT, "PHY START REQ for phy_id %d\n", phy_id);
+ 
+       payload.ase_sh_lm_slr_phyid = cpu_to_le32(SPINHOLD_DISABLE |
+                       LINKMODE_AUTO | pm8001_ha->link_rate | phy_id);
+@@ -5081,9 +4850,9 @@ static irqreturn_t
+ pm80xx_chip_isr(struct pm8001_hba_info *pm8001_ha, u8 vec)
+ {
+       pm80xx_chip_interrupt_disable(pm8001_ha, vec);
+-      PM8001_DEVIO_DBG(pm8001_ha, pm8001_printk(
+-              "irq vec %d, ODMR:0x%x\n",
+-              vec, pm8001_cr32(pm8001_ha, 0, 0x30)));
++      pm8001_dbg(pm8001_ha, DEVIO,
++                 "irq vec %d, ODMR:0x%x\n",
++                 vec, pm8001_cr32(pm8001_ha, 0, 0x30));
+       process_oq(pm8001_ha, vec);
+       pm80xx_chip_interrupt_enable(pm8001_ha, vec);
+       return IRQ_HANDLED;
+@@ -5102,13 +4871,13 @@ static void mpi_set_phy_profile_req(struct pm8001_hba_info *pm8001_ha,
+       memset(&payload, 0, sizeof(payload));
+       rc = pm8001_tag_alloc(pm8001_ha, &tag);
+       if (rc)
+-              PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("Invalid tag\n"));
++              pm8001_dbg(pm8001_ha, FAIL, "Invalid tag\n");
+       circularQ = &pm8001_ha->inbnd_q_tbl[0];
+       payload.tag = cpu_to_le32(tag);
+       payload.ppc_phyid = (((operation & 0xF) << 8) | (phyid  & 0xFF));
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk(" phy profile command for phy %x ,length is %d\n",
+-                      payload.ppc_phyid, length));
++      pm8001_dbg(pm8001_ha, INIT,
++                 " phy profile command for phy %x ,length is %d\n",
++                 payload.ppc_phyid, length);
+       for (i = length; i < (length + PHY_DWORD_LENGTH - 1); i++) {
+               payload.reserved[j] =  cpu_to_le32(*((u32 *)buf + i));
+               j++;
+@@ -5129,7 +4898,7 @@ void pm8001_set_phy_profile(struct pm8001_hba_info *pm8001_ha,
+                       SAS_PHY_ANALOG_SETTINGS_PAGE, i, length, (u32 *)buf);
+               length = length + PHY_DWORD_LENGTH;
+       }
+-      PM8001_INIT_DBG(pm8001_ha, pm8001_printk("phy settings completed\n"));
++      pm8001_dbg(pm8001_ha, INIT, "phy settings completed\n");
+ }
+ 
+ void pm8001_set_phy_profile_single(struct pm8001_hba_info *pm8001_ha,
+@@ -5144,7 +4913,7 @@ void pm8001_set_phy_profile_single(struct pm8001_hba_info *pm8001_ha,
+ 
+       rc = pm8001_tag_alloc(pm8001_ha, &tag);
+       if (rc)
+-              PM8001_INIT_DBG(pm8001_ha, pm8001_printk("Invalid tag"));
++              pm8001_dbg(pm8001_ha, INIT, "Invalid tag\n");
+ 
+       circularQ = &pm8001_ha->inbnd_q_tbl[0];
+       opc = OPC_INB_SET_PHY_PROFILE;
+@@ -5161,8 +4930,7 @@ void pm8001_set_phy_profile_single(struct pm8001_hba_info *pm8001_ha,
+       if (rc)
+               pm8001_tag_free(pm8001_ha, tag);
+ 
+-      PM8001_INIT_DBG(pm8001_ha,
+-              pm8001_printk("PHY %d settings applied", phy));
++      pm8001_dbg(pm8001_ha, INIT, "PHY %d settings applied\n", phy);
+ }
+ const struct pm8001_dispatch pm8001_80xx_dispatch = {
+       .name                   = "pmc80xx",
+-- 
+2.30.1
+

diff --git a/queue-5.10/scsi-pm80xx-fix-pm8001_mpi_get_nvmd_resp-race-condit.patch b/queue-5.10/scsi-pm80xx-fix-pm8001_mpi_get_nvmd_resp-race-condit.patch
new file mode 100644 (file)
index 0000000..6577597
--- /dev/null
+++ b/queue-5.10/scsi-pm80xx-fix-pm8001_mpi_get_nvmd_resp-race-condit.patch
@@ -0,0 +1,56 @@
+From 8ed61a0e8334611bb88a367390e4f8f867c1b9b0 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 2 Nov 2020 22:25:28 +0530
+Subject: scsi: pm80xx: Fix pm8001_mpi_get_nvmd_resp() race condition
+
+From: yuuzheng <yuuzheng@google.com>
+
+[ Upstream commit 1f889b58716a5f5e3e4fe0e6742c1a4472f29ac1 ]
+
+A use-after-free or null-pointer error occurs when the 251-byte response
+data is copied from IOMB buffer to response message buffer in function
+pm8001_mpi_get_nvmd_resp().
+
+After sending the command get_nvmd_data(), the caller begins to sleep by
+calling wait_for_complete() and waits for the wake-up from calling
+complete() in pm8001_mpi_get_nvmd_resp(). Due to unexpected events (e.g.,
+interrupt), if response buffer gets freed before memcpy(), a use-after-free
+error will occur. To fix this, the complete() should be called after
+memcpy().
+
+Link: https://lore.kernel.org/r/20201102165528.26510-5-Viswas.G@microchip.com.com
+Acked-by: Jack Wang <jinpu.wang@cloud.ionos.com>
+Signed-off-by: yuuzheng <yuuzheng@google.com>
+Signed-off-by: Viswas G <Viswas.G@microchip.com>
+Signed-off-by: Ruksar Devadi <Ruksar.devadi@microchip.com>
+Signed-off-by: Radha Ramachandran <radha@google.com>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/scsi/pm8001/pm8001_hwi.c | 7 ++++++-
+ 1 file changed, 6 insertions(+), 1 deletion(-)
+
+diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
+index 9e9a546da959..2054c2b03d92 100644
+--- a/drivers/scsi/pm8001/pm8001_hwi.c
++++ b/drivers/scsi/pm8001/pm8001_hwi.c
+@@ -3279,10 +3279,15 @@ pm8001_mpi_get_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               pm8001_ha->memoryMap.region[NVMD].virt_ptr,
+               fw_control_context->len);
+       kfree(ccb->fw_control_context);
++      /* To avoid race condition, complete should be
++       * called after the message is copied to
++       * fw_control_context->usrAddr
++       */
++      complete(pm8001_ha->nvmd_completion);
++      PM8001_MSG_DBG(pm8001_ha, pm8001_printk("Set nvm data complete!\n"));
+       ccb->task = NULL;
+       ccb->ccb_tag = 0xFFFFFFFF;
+       pm8001_tag_free(pm8001_ha, tag);
+-      complete(pm8001_ha->nvmd_completion);
+ }
+ 
+ int pm8001_mpi_local_phy_ctl(struct pm8001_hba_info *pm8001_ha, void *piomb)
+-- 
+2.30.1
+

diff --git a/queue-5.10/scsi-pm80xx-make-mpi_build_cmd-locking-consistent.patch b/queue-5.10/scsi-pm80xx-make-mpi_build_cmd-locking-consistent.patch
new file mode 100644 (file)
index 0000000..036e32f
--- /dev/null
+++ b/queue-5.10/scsi-pm80xx-make-mpi_build_cmd-locking-consistent.patch
@@ -0,0 +1,125 @@
+From 0e2d4ac6bfc99179bf7756e028f1a5134a9cfc31 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 2 Nov 2020 22:25:25 +0530
+Subject: scsi: pm80xx: Make mpi_build_cmd locking consistent
+
+From: peter chang <dpf@google.com>
+
+[ Upstream commit 7640e1eb8c5de33dafa6c68fd4389214ff9ec1f9 ]
+
+Driver submits all internal requests (like abort_task, event acknowledgment
+etc.) through inbound queue 0. While submitting those, driver does not
+acquire any lock and this may lead to a race when there is an I/O request
+coming in on CPU0 and submitted through inbound queue 0.  To avoid this,
+lock acquisition has been moved to pm8001_mpi_build_cmd().  All command
+submission will go through this path.
+
+Link: https://lore.kernel.org/r/20201102165528.26510-2-Viswas.G@microchip.com.com
+Acked-by: Jack Wang <jinpu.wang@cloud.ionos.com>
+Signed-off-by: peter chang <dpf@google.com>
+Signed-off-by: Viswas G <Viswas.G@microchip.com>
+Signed-off-by: Ruksar Devadi <Ruksar.devadi@microchip.com>
+Signed-off-by: Radha Ramachandran <radha@google.com>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/scsi/pm8001/pm8001_hwi.c | 21 +++++++++++++++------
+ drivers/scsi/pm8001/pm80xx_hwi.c |  8 --------
+ 2 files changed, 15 insertions(+), 14 deletions(-)
+
+diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
+index 2b7b2954ec31..597d7a096a97 100644
+--- a/drivers/scsi/pm8001/pm8001_hwi.c
++++ b/drivers/scsi/pm8001/pm8001_hwi.c
+@@ -1356,12 +1356,19 @@ int pm8001_mpi_build_cmd(struct pm8001_hba_info *pm8001_ha,
+ {
+       u32 Header = 0, hpriority = 0, bc = 1, category = 0x02;
+       void *pMessage;
+-
+-      if (pm8001_mpi_msg_free_get(circularQ, pm8001_ha->iomb_size,
+-              &pMessage) < 0) {
++      unsigned long flags;
++      int q_index = circularQ - pm8001_ha->inbnd_q_tbl;
++      int rv = -1;
++
++      WARN_ON(q_index >= PM8001_MAX_INB_NUM);
++      spin_lock_irqsave(&circularQ->iq_lock, flags);
++      rv = pm8001_mpi_msg_free_get(circularQ, pm8001_ha->iomb_size,
++                      &pMessage);
++      if (rv < 0) {
+               PM8001_IO_DBG(pm8001_ha,
+-                      pm8001_printk("No free mpi buffer\n"));
+-              return -ENOMEM;
++                            pm8001_printk("No free mpi buffer\n"));
++              rv = -ENOMEM;
++              goto done;
+       }
+ 
+       if (nb > (pm8001_ha->iomb_size - sizeof(struct mpi_msg_hdr)))
+@@ -1384,7 +1391,9 @@ int pm8001_mpi_build_cmd(struct pm8001_hba_info *pm8001_ha,
+               pm8001_printk("INB Q %x OPCODE:%x , UPDATED PI=%d CI=%d\n",
+                       responseQueue, opCode, circularQ->producer_idx,
+                       circularQ->consumer_index));
+-      return 0;
++done:
++      spin_unlock_irqrestore(&circularQ->iq_lock, flags);
++      return rv;
+ }
+ 
+ u32 pm8001_mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha, void *pMsg,
+diff --git a/drivers/scsi/pm8001/pm80xx_hwi.c b/drivers/scsi/pm8001/pm80xx_hwi.c
+index 155382ce8469..c9a89e980e1c 100644
+--- a/drivers/scsi/pm8001/pm80xx_hwi.c
++++ b/drivers/scsi/pm8001/pm80xx_hwi.c
+@@ -4281,7 +4281,6 @@ static int pm80xx_chip_smp_req(struct pm8001_hba_info *pm8001_ha,
+       char *preq_dma_addr = NULL;
+       __le64 tmp_addr;
+       u32 i, length;
+-      unsigned long flags;
+ 
+       memset(&smp_cmd, 0, sizeof(smp_cmd));
+       /*
+@@ -4377,10 +4376,8 @@ static int pm80xx_chip_smp_req(struct pm8001_hba_info *pm8001_ha,
+ 
+       build_smp_cmd(pm8001_dev->device_id, smp_cmd.tag,
+                               &smp_cmd, pm8001_ha->smp_exp_mode, length);
+-      spin_lock_irqsave(&circularQ->iq_lock, flags);
+       rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &smp_cmd,
+                       sizeof(smp_cmd), 0);
+-      spin_unlock_irqrestore(&circularQ->iq_lock, flags);
+       if (rc)
+               goto err_out_2;
+       return 0;
+@@ -4444,7 +4441,6 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha,
+       u64 phys_addr, start_addr, end_addr;
+       u32 end_addr_high, end_addr_low;
+       struct inbound_queue_table *circularQ;
+-      unsigned long flags;
+       u32 q_index, cpu_id;
+       u32 opc = OPC_INB_SSPINIIOSTART;
+       memset(&ssp_cmd, 0, sizeof(ssp_cmd));
+@@ -4582,10 +4578,8 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha,
+                       ssp_cmd.esgl = 0;
+               }
+       }
+-      spin_lock_irqsave(&circularQ->iq_lock, flags);
+       ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc,
+                       &ssp_cmd, sizeof(ssp_cmd), q_index);
+-      spin_unlock_irqrestore(&circularQ->iq_lock, flags);
+       return ret;
+ }
+ 
+@@ -4819,10 +4813,8 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+                       }
+               }
+       }
+-      spin_lock_irqsave(&circularQ->iq_lock, flags);
+       ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc,
+                       &sata_cmd, sizeof(sata_cmd), q_index);
+-      spin_unlock_irqrestore(&circularQ->iq_lock, flags);
+       return ret;
+ }
+ 
+-- 
+2.30.1
+

diff --git a/queue-5.10/scsi-pm80xx-make-running_req-atomic.patch b/queue-5.10/scsi-pm80xx-make-running_req-atomic.patch
new file mode 100644 (file)
index 0000000..db884d8
--- /dev/null
+++ b/queue-5.10/scsi-pm80xx-make-running_req-atomic.patch
@@ -0,0 +1,828 @@
+From c4d248fd8f7cbd43285c11552b15ce27f52e81e1 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 2 Nov 2020 22:25:26 +0530
+Subject: scsi: pm80xx: Make running_req atomic
+
+From: Viswas G <Viswas.G@microchip.com>
+
+[ Upstream commit 4a2efd4b89fcaa6e9a7b4ce49a441afaacba00ea ]
+
+Incorrect value of the running_req was causing the driver unload to be
+stuck during the SAS lldd_dev_gone notification handling.  During SATA I/O
+completion, for some error status values, the driver schedules the event
+handler and running_req is decremented from that.  However, there are some
+other error status values (like IO_DS_IN_RECOVERY,
+IO_XFER_ERR_LAST_PIO_DATAIN_CRC_ERR) where the I/O has already been
+completed by fw/driver so running_req is not decremented.
+
+Also during NCQ error handling, driver itself will initiate READ_LOG_EXT
+and ABORT_ALL. When libsas/libata initiate READ_LOG_EXT (0x2F), driver
+increments running_req. This will be completed by the driver in
+pm80xx_chip_sata_req(), but running_req was not decremented.
+
+Link: https://lore.kernel.org/r/20201102165528.26510-3-Viswas.G@microchip.com.com
+Acked-by: Jack Wang <jinpu.wang@cloud.ionos.com>
+Signed-off-by: Viswas G <Viswas.G@microchip.com>
+Signed-off-by: Ruksar Devadi <Ruksar.devadi@microchip.com>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/scsi/pm8001/pm8001_hwi.c  |  58 +++++++++++++----
+ drivers/scsi/pm8001/pm8001_init.c |   2 +-
+ drivers/scsi/pm8001/pm8001_sas.c  |  11 ++--
+ drivers/scsi/pm8001/pm8001_sas.h  |   2 +-
+ drivers/scsi/pm8001/pm80xx_hwi.c  | 101 +++++++++++++++++++++++++++---
+ 5 files changed, 147 insertions(+), 27 deletions(-)
+
+diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
+index 597d7a096a97..9e9a546da959 100644
+--- a/drivers/scsi/pm8001/pm8001_hwi.c
++++ b/drivers/scsi/pm8001/pm8001_hwi.c
+@@ -1587,7 +1587,7 @@ void pm8001_work_fn(struct work_struct *work)
+               ts->stat = SAS_QUEUE_FULL;
+               pm8001_dev = ccb->device;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               spin_lock_irqsave(&t->task_state_lock, flags1);
+               t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+               t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+@@ -1942,7 +1942,7 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       sas_ssp_task_response(pm8001_ha->dev, t, iu);
+               }
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_ABORTED:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -1958,7 +1958,7 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->stat = SAS_DATA_UNDERRUN;
+               ts->residual = param;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2172,7 +2172,7 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2487,7 +2487,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                                       pm8001_printk("response to large\n"));
+               }
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_ABORTED:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2495,7 +2495,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+               /* following cases are to do cases */
+       case IO_UNDERFLOW:
+@@ -2506,19 +2506,23 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->stat = SAS_DATA_UNDERRUN;
+               ts->residual =  param;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_NO_DEVICE\n"));
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_PHY_DOWN;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_INTERRUPTED;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2526,6 +2530,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2534,6 +2540,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_EPROTO;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2541,6 +2549,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2548,6 +2558,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2587,6 +2599,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2610,48 +2624,64 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_NAK_RECEIVED:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_DMA:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_DMA\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_SATA_LINK_TIMEOUT:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_SATA_LINK_TIMEOUT\n"));
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_DEV_NO_RESPONSE;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_REJECTED_NCQ_MODE:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_REJECTED_NCQ_MODE\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_UNDERRUN;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_PORT_IN_RESET:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_PORT_IN_RESET\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_DS_NON_OPERATIONAL:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2672,6 +2702,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       pm8001_printk("  IO_DS_IN_RECOVERY\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_DS_IN_ERROR:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2693,6 +2725,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       default:
+               PM8001_DEVIO_DBG(pm8001_ha,
+@@ -2700,6 +2734,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               /* not allowed case. Therefore, return failed status */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       }
+       spin_lock_irqsave(&t->task_state_lock, flags);
+@@ -2776,7 +2812,7 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2976,7 +3012,7 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAM_STAT_GOOD;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_ABORTED:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2984,7 +3020,7 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OVERFLOW:
+               PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n"));
+@@ -2992,7 +3028,7 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+               PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_NO_DEVICE\n"));
+diff --git a/drivers/scsi/pm8001/pm8001_init.c b/drivers/scsi/pm8001/pm8001_init.c
+index 2025361b36e9..89397e5351ff 100644
+--- a/drivers/scsi/pm8001/pm8001_init.c
++++ b/drivers/scsi/pm8001/pm8001_init.c
+@@ -412,7 +412,7 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha,
+               pm8001_ha->devices[i].dev_type = SAS_PHY_UNUSED;
+               pm8001_ha->devices[i].id = i;
+               pm8001_ha->devices[i].device_id = PM8001_MAX_DEVICES;
+-              pm8001_ha->devices[i].running_req = 0;
++              atomic_set(&pm8001_ha->devices[i].running_req, 0);
+       }
+       pm8001_ha->flags = PM8001F_INIT_TIME;
+       /* Initialize tags */
+diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
+index 9889bab7d31c..d6e0bc588698 100644
+--- a/drivers/scsi/pm8001/pm8001_sas.c
++++ b/drivers/scsi/pm8001/pm8001_sas.c
+@@ -456,9 +456,11 @@ static int pm8001_task_exec(struct sas_task *task,
+               ccb->device = pm8001_dev;
+               switch (task_proto) {
+               case SAS_PROTOCOL_SMP:
++                      atomic_inc(&pm8001_dev->running_req);
+                       rc = pm8001_task_prep_smp(pm8001_ha, ccb);
+                       break;
+               case SAS_PROTOCOL_SSP:
++                      atomic_inc(&pm8001_dev->running_req);
+                       if (is_tmf)
+                               rc = pm8001_task_prep_ssp_tm(pm8001_ha,
+                                       ccb, tmf);
+@@ -467,6 +469,7 @@ static int pm8001_task_exec(struct sas_task *task,
+                       break;
+               case SAS_PROTOCOL_SATA:
+               case SAS_PROTOCOL_STP:
++                      atomic_inc(&pm8001_dev->running_req);
+                       rc = pm8001_task_prep_ata(pm8001_ha, ccb);
+                       break;
+               default:
+@@ -479,13 +482,13 @@ static int pm8001_task_exec(struct sas_task *task,
+               if (rc) {
+                       PM8001_IO_DBG(pm8001_ha,
+                               pm8001_printk("rc is %x\n", rc));
++                      atomic_dec(&pm8001_dev->running_req);
+                       goto err_out_tag;
+               }
+               /* TODO: select normal or high priority */
+               spin_lock(&t->task_state_lock);
+               t->task_state_flags |= SAS_TASK_AT_INITIATOR;
+               spin_unlock(&t->task_state_lock);
+-              pm8001_dev->running_req++;
+       } while (0);
+       rc = 0;
+       goto out_done;
+@@ -886,11 +889,11 @@ static void pm8001_dev_gone_notify(struct domain_device *dev)
+               PM8001_DISC_DBG(pm8001_ha,
+                       pm8001_printk("found dev[%d:%x] is gone.\n",
+                       pm8001_dev->device_id, pm8001_dev->dev_type));
+-              if (pm8001_dev->running_req) {
++              if (atomic_read(&pm8001_dev->running_req)) {
+                       spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                       pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
+                               dev, 1, 0);
+-                      while (pm8001_dev->running_req)
++                      while (atomic_read(&pm8001_dev->running_req))
+                               msleep(20);
+                       spin_lock_irqsave(&pm8001_ha->lock, flags);
+               }
+@@ -968,7 +971,7 @@ void pm8001_open_reject_retry(
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               spin_lock_irqsave(&task->task_state_lock, flags1);
+               task->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+               task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+diff --git a/drivers/scsi/pm8001/pm8001_sas.h b/drivers/scsi/pm8001/pm8001_sas.h
+index 95663e138083..091574721ea1 100644
+--- a/drivers/scsi/pm8001/pm8001_sas.h
++++ b/drivers/scsi/pm8001/pm8001_sas.h
+@@ -293,7 +293,7 @@ struct pm8001_device {
+       struct completion       *dcompletion;
+       struct completion       *setds_completion;
+       u32                     device_id;
+-      u32                     running_req;
++      atomic_t                running_req;
+ };
+ 
+ struct pm8001_prd_imt {
+diff --git a/drivers/scsi/pm8001/pm80xx_hwi.c b/drivers/scsi/pm8001/pm80xx_hwi.c
+index c9a89e980e1c..59053c61908e 100644
+--- a/drivers/scsi/pm8001/pm80xx_hwi.c
++++ b/drivers/scsi/pm8001/pm80xx_hwi.c
+@@ -1960,13 +1960,15 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       sas_ssp_task_response(pm8001_ha->dev, t, iu);
+               }
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_ABORTED:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_ABORTED IOMB Tag\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_UNDERFLOW:
+               /* SSP Completion with error */
+@@ -1977,13 +1979,15 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->stat = SAS_DATA_UNDERRUN;
+               ts->residual = param;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_NO_DEVICE\n"));
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_PHY_DOWN;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -1992,6 +1996,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->stat = SAS_OPEN_REJECT;
+               /* Force the midlayer to retry */
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -1999,6 +2005,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_INVALID_SSP_RSP_FRAME:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2006,6 +2014,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2013,6 +2023,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_EPROTO;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2020,6 +2032,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2027,6 +2041,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+       case IO_XFER_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
+@@ -2050,6 +2066,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_BAD_DEST;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+               PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+@@ -2057,6 +2075,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2064,6 +2084,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_NAK_RECEIVED:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2071,18 +2093,24 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_DMA:
+               PM8001_IO_DBG(pm8001_ha,
+               pm8001_printk("IO_XFER_ERROR_DMA\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2090,18 +2118,24 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_OFFSET_MISMATCH:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_PORT_IN_RESET:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_PORT_IN_RESET\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_DS_NON_OPERATIONAL:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2118,18 +2152,24 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+                       pm8001_printk("IO_DS_IN_RECOVERY\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_TM_TAG_NOT_FOUND:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_TM_TAG_NOT_FOUND\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_SSP_EXT_IU_ZERO_LEN_ERROR:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_SSP_EXT_IU_ZERO_LEN_ERROR\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2137,6 +2177,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       default:
+               PM8001_DEVIO_DBG(pm8001_ha,
+@@ -2144,6 +2186,8 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               /* not allowed case. Therefore, return failed status */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       }
+       PM8001_IO_DBG(pm8001_ha,
+@@ -2203,7 +2247,7 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2528,7 +2572,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                                       pm8001_printk("response too large\n"));
+               }
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_ABORTED:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2536,7 +2580,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+               /* following cases are to do cases */
+       case IO_UNDERFLOW:
+@@ -2547,19 +2591,23 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->stat = SAS_DATA_UNDERRUN;
+               ts->residual = param;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_NO_DEVICE\n"));
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_PHY_DOWN;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_INTERRUPTED;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_PHY_NOT_READY:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2567,6 +2615,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+               PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+@@ -2574,6 +2624,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_EPROTO;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2581,6 +2633,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_UNKNOWN;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_BREAK:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2588,6 +2642,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+       case IO_XFER_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
+@@ -2631,6 +2687,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_CONN_RATE;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY:
+               PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+@@ -2653,48 +2711,64 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_NAK_RECEIVED:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_NAK_R_ERR;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_DMA:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_DMA\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_SATA_LINK_TIMEOUT:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_SATA_LINK_TIMEOUT\n"));
+               ts->resp = SAS_TASK_UNDELIVERED;
+               ts->stat = SAS_DEV_NO_RESPONSE;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_REJECTED_NCQ_MODE:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_REJECTED_NCQ_MODE\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DATA_UNDERRUN;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_OPEN_RETRY_TIMEOUT:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_TO;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_PORT_IN_RESET:
+               PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_PORT_IN_RESET\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_DS_NON_OPERATIONAL:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2715,6 +2789,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+                       pm8001_printk("IO_DS_IN_RECOVERY\n"));
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_DS_IN_ERROR:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -2736,6 +2812,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_OPEN_REJECT;
+               ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       default:
+               PM8001_DEVIO_DBG(pm8001_ha,
+@@ -2743,6 +2821,8 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               /* not allowed case. Therefore, return failed status */
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_DEV_NO_RESPONSE;
++              if (pm8001_dev)
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       }
+       spin_lock_irqsave(&t->task_state_lock, flags);
+@@ -2820,7 +2900,7 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_XFER_ERROR_BREAK:
+               PM8001_IO_DBG(pm8001_ha,
+@@ -3040,7 +3120,7 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAM_STAT_GOOD;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               if (pm8001_ha->smp_exp_mode == SMP_DIRECT) {
+                       PM8001_IO_DBG(pm8001_ha,
+                               pm8001_printk("DIRECT RESPONSE Length:%d\n",
+@@ -3063,7 +3143,7 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->resp = SAS_TASK_COMPLETE;
+               ts->stat = SAS_ABORTED_TASK;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_OVERFLOW:
+               PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n"));
+@@ -3071,7 +3151,7 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+               ts->stat = SAS_DATA_OVERRUN;
+               ts->residual = 0;
+               if (pm8001_dev)
+-                      pm8001_dev->running_req--;
++                      atomic_dec(&pm8001_dev->running_req);
+               break;
+       case IO_NO_DEVICE:
+               PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_NO_DEVICE\n"));
+@@ -4809,6 +4889,7 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+                                                       flags);
+                               pm8001_ccb_task_free_done(pm8001_ha, task,
+                                                               ccb, tag);
++                              atomic_dec(&pm8001_ha_dev->running_req);
+                               return 0;
+                       }
+               }
+-- 
+2.30.1
+

diff --git a/queue-5.10/serial-stm32-fix-dma-initialization-error-handling.patch b/queue-5.10/serial-stm32-fix-dma-initialization-error-handling.patch
new file mode 100644 (file)
index 0000000..8407255
--- /dev/null
+++ b/queue-5.10/serial-stm32-fix-dma-initialization-error-handling.patch
@@ -0,0 +1,87 @@
+From 3837a77a7da9b0788bdfe341b017cce43c82e8b8 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Wed, 6 Jan 2021 17:21:56 +0100
+Subject: serial: stm32: fix DMA initialization error handling
+
+From: Erwan Le Ray <erwan.leray@foss.st.com>
+
+[ Upstream commit e7997f7ff7f8154d477f6f976698d868a2ac3934 ]
+
+DMA initialization error handling is not properly implemented in the
+driver.
+Fix DMA initialization error handling by:
+- moving TX DMA descriptor request error handling in a new dedicated
+fallback_err label
+- adding error handling to TX DMA descriptor submission
+- adding error handling to RX DMA descriptor submission
+
+This patch depends on '24832ca3ee85 ("tty: serial: stm32-usart: Remove set
+but unused 'cookie' variables")' which unfortunately doesn't include a
+"Fixes" tag.
+
+Fixes: 3489187204eb ("serial: stm32: adding dma support")
+Signed-off-by: Erwan Le Ray <erwan.leray@foss.st.com>
+Link: https://lore.kernel.org/r/20210106162203.28854-2-erwan.leray@foss.st.com
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/tty/serial/stm32-usart.c | 24 +++++++++++++++++-------
+ 1 file changed, 17 insertions(+), 7 deletions(-)
+
+diff --git a/drivers/tty/serial/stm32-usart.c b/drivers/tty/serial/stm32-usart.c
+index f4de32d3f2af..6248304a001f 100644
+--- a/drivers/tty/serial/stm32-usart.c
++++ b/drivers/tty/serial/stm32-usart.c
+@@ -383,17 +383,18 @@ static void stm32_transmit_chars_dma(struct uart_port *port)
+                                          DMA_MEM_TO_DEV,
+                                          DMA_PREP_INTERRUPT);
+ 
+-      if (!desc) {
+-              for (i = count; i > 0; i--)
+-                      stm32_transmit_chars_pio(port);
+-              return;
+-      }
++      if (!desc)
++              goto fallback_err;
+ 
+       desc->callback = stm32_tx_dma_complete;
+       desc->callback_param = port;
+ 
+       /* Push current DMA TX transaction in the pending queue */
+-      dmaengine_submit(desc);
++      if (dma_submit_error(dmaengine_submit(desc))) {
++              /* dma no yet started, safe to free resources */
++              dmaengine_terminate_async(stm32port->tx_ch);
++              goto fallback_err;
++      }
+ 
+       /* Issue pending DMA TX requests */
+       dma_async_issue_pending(stm32port->tx_ch);
+@@ -402,6 +403,11 @@ static void stm32_transmit_chars_dma(struct uart_port *port)
+ 
+       xmit->tail = (xmit->tail + count) & (UART_XMIT_SIZE - 1);
+       port->icount.tx += count;
++      return;
++
++fallback_err:
++      for (i = count; i > 0; i--)
++              stm32_transmit_chars_pio(port);
+ }
+ 
+ static void stm32_transmit_chars(struct uart_port *port)
+@@ -1130,7 +1136,11 @@ static int stm32_of_dma_rx_probe(struct stm32_port *stm32port,
+       desc->callback_param = NULL;
+ 
+       /* Push current DMA transaction in the pending queue */
+-      dmaengine_submit(desc);
++      ret = dma_submit_error(dmaengine_submit(desc));
++      if (ret) {
++              dmaengine_terminate_sync(stm32port->rx_ch);
++              goto config_err;
++      }
+ 
+       /* Issue pending DMA requests */
+       dma_async_issue_pending(stm32port->rx_ch);
+-- 
+2.30.1
+

diff --git a/queue-5.10/series b/queue-5.10/series
index 7948125d4c292399b7b6f42144e481b7271127d3..6a748f95cbb5616db0cb018cc38e651bead5a432 100644 (file)
--- a/queue-5.10/series
+++ b/queue-5.10/series
@@ -57,3 +57,58 @@ scsi-lpfc-fix-some-error-codes-in-debugfs.patch
 scsi-myrs-fix-a-double-free-in-myrs_cleanup.patch
 scsi-ufs-ufs-mediatek-correct-operator.patch
 risc-v-correct-enum-sbi_ext_rfence_fid.patch
+counter-stm32-timer-cnt-report-count-function-when-s.patch
+gpiolib-assign-fwnode-to-parent-s-if-no-primary-one-.patch
+nvme-rdma-fix-possible-hang-when-failing-to-set-io-q.patch
+ibmvnic-add-some-debugs.patch
+ibmvnic-serialize-access-to-work-queue-on-remove.patch
+tty-serial-stm32-usart-remove-set-but-unused-cookie-.patch
+serial-stm32-fix-dma-initialization-error-handling.patch
+bpf-declare-__bpf_free_used_maps-unconditionally.patch
+rdma-rtrs-remove-unnecessary-argument-dir-of-rtrs_iu.patch
+rdma-rtrs-srv-jump-to-dereg_mr-label-if-allocate-iu-.patch
+rdma-rtrs-introduce-rtrs_post_send.patch
+rdma-rtrs-fix-kasan-stack-out-of-bounds-bug.patch
+module-merge-repetitive-strings-in-module_sig_check.patch
+module-avoid-goto-s-in-module_sig_check.patch
+module-harden-elf-info-handling.patch
+scsi-pm80xx-make-mpi_build_cmd-locking-consistent.patch
+scsi-pm80xx-make-running_req-atomic.patch
+scsi-pm80xx-fix-pm8001_mpi_get_nvmd_resp-race-condit.patch
+scsi-pm8001-neaten-debug-logging-macros-and-uses.patch
+scsi-libsas-remove-notifier-indirection.patch
+scsi-libsas-introduce-a-_gfp-variant-of-event-notifi.patch
+scsi-mvsas-pass-gfp_t-flags-to-libsas-event-notifier.patch
+scsi-isci-pass-gfp_t-flags-in-isci_port_link_down.patch
+scsi-isci-pass-gfp_t-flags-in-isci_port_link_up.patch
+scsi-isci-pass-gfp_t-flags-in-isci_port_bc_change_re.patch
+rdma-mlx5-allow-creating-all-qps-even-when-non-rdma-.patch
+powerpc-sstep-fix-load-store-and-update-emulation.patch
+powerpc-sstep-fix-darn-emulation.patch
+i40e-fix-endianness-conversions.patch
+net-phy-micrel-set-soft_reset-callback-to-genphy_sof.patch
+mips-compressed-fix-build-with-enabled-ubsan.patch
+drm-amd-display-turn-dpms-off-on-connector-unplug.patch
+rcu-nocb-trigger-self-ipi-on-late-deferred-wake-up-b.patch
+entry-explicitly-flush-pending-rcuog-wakeup-before-l.patch
+entry-kvm-explicitly-flush-pending-rcuog-wakeup-befo.patch
+iwlwifi-add-a-new-card-for-ma-family.patch
+mptcp-split-mptcp_clean_una-function.patch
+mptcp-reduce-the-arguments-of-mptcp_sendmsg_frag.patch
+io_uring-fix-inconsistent-lock-state.patch
+media-cedrus-h264-support-profile-controls.patch
+ibmvnic-remove-excessive-irqsave.patch
+s390-qeth-schedule-tx-napi-on-qaob-completion.patch
+drm-amd-pm-fulfill-the-polaris-implementation-for-ge.patch
+mips-kernel-reserve-exception-base-early-to-prevent-.patch
+mptcp-put-subflow-sock-on-connect-error.patch
+io_uring-don-t-attempt-io-reissue-from-the-ring-exit.patch
+io_uring-clear-iocb_waitq-for-non-eiocbqueued-return.patch
+gpiolib-read-gpio-line-names-from-a-firmware-node.patch
+net-bonding-fix-error-return-code-of-bond_neigh_init.patch
+regulator-pca9450-add-sd_vsel-gpio-for-ldo5.patch
+regulator-pca9450-enable-system-reset-on-wdog_b-asse.patch
+regulator-pca9450-clear-preset_en-bit-to-fix-buck1-2.patch
+gfs2-add-common-helper-for-holding-and-releasing-the.patch
+gfs2-move-freeze-glock-outside-the-make_fs_rw-and-_r.patch
+gfs2-bypass-signal_our_withdraw-if-no-journal.patch

diff --git a/queue-5.10/tty-serial-stm32-usart-remove-set-but-unused-cookie-.patch b/queue-5.10/tty-serial-stm32-usart-remove-set-but-unused-cookie-.patch
new file mode 100644 (file)
index 0000000..06c46b6
--- /dev/null
+++ b/queue-5.10/tty-serial-stm32-usart-remove-set-but-unused-cookie-.patch
@@ -0,0 +1,75 @@
+From 17205320028fe5a60e720c30abe01fe2f2c530cc Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Wed, 4 Nov 2020 19:35:41 +0000
+Subject: tty: serial: stm32-usart: Remove set but unused 'cookie' variables
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+From: Lee Jones <lee.jones@linaro.org>
+
+[ Upstream commit 24832ca3ee85a14c42a4f23a5c8841ef5db3d029 ]
+
+Fixes the following W=1 kernel build warning(s):
+
+ drivers/tty/serial/stm32-usart.c: In function ‘stm32_transmit_chars_dma’:
+ drivers/tty/serial/stm32-usart.c:353:15: warning: variable ‘cookie’ set but not used [-Wunused-but-set-variable]
+ drivers/tty/serial/stm32-usart.c: In function ‘stm32_of_dma_rx_probe’:
+ drivers/tty/serial/stm32-usart.c:1090:15: warning: variable ‘cookie’ set but not used [-Wunused-but-set-variable]
+
+Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+Cc: Jiri Slaby <jirislaby@kernel.org>
+Cc: Maxime Coquelin <mcoquelin.stm32@gmail.com>
+Cc: Alexandre Torgue <alexandre.torgue@st.com>
+Cc: Gerald Baeza <gerald.baeza@st.com>
+Cc: linux-serial@vger.kernel.org
+Cc: linux-stm32@st-md-mailman.stormreply.com
+Signed-off-by: Lee Jones <lee.jones@linaro.org>
+Link: https://lore.kernel.org/r/20201104193549.4026187-29-lee.jones@linaro.org
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/tty/serial/stm32-usart.c | 6 ++----
+ 1 file changed, 2 insertions(+), 4 deletions(-)
+
+diff --git a/drivers/tty/serial/stm32-usart.c b/drivers/tty/serial/stm32-usart.c
+index ee6c7762d355..f4de32d3f2af 100644
+--- a/drivers/tty/serial/stm32-usart.c
++++ b/drivers/tty/serial/stm32-usart.c
+@@ -350,7 +350,6 @@ static void stm32_transmit_chars_dma(struct uart_port *port)
+       struct stm32_usart_offsets *ofs = &stm32port->info->ofs;
+       struct circ_buf *xmit = &port->state->xmit;
+       struct dma_async_tx_descriptor *desc = NULL;
+-      dma_cookie_t cookie;
+       unsigned int count, i;
+ 
+       if (stm32port->tx_dma_busy)
+@@ -394,7 +393,7 @@ static void stm32_transmit_chars_dma(struct uart_port *port)
+       desc->callback_param = port;
+ 
+       /* Push current DMA TX transaction in the pending queue */
+-      cookie = dmaengine_submit(desc);
++      dmaengine_submit(desc);
+ 
+       /* Issue pending DMA TX requests */
+       dma_async_issue_pending(stm32port->tx_ch);
+@@ -1087,7 +1086,6 @@ static int stm32_of_dma_rx_probe(struct stm32_port *stm32port,
+       struct device *dev = &pdev->dev;
+       struct dma_slave_config config;
+       struct dma_async_tx_descriptor *desc = NULL;
+-      dma_cookie_t cookie;
+       int ret;
+ 
+       /* Request DMA RX channel */
+@@ -1132,7 +1130,7 @@ static int stm32_of_dma_rx_probe(struct stm32_port *stm32port,
+       desc->callback_param = NULL;
+ 
+       /* Push current DMA transaction in the pending queue */
+-      cookie = dmaengine_submit(desc);
++      dmaengine_submit(desc);
+ 
+       /* Issue pending DMA requests */
+       dma_async_issue_pending(stm32port->rx_ch);
+-- 
+2.30.1
+