From: Sasha Levin Date: Mon, 22 Mar 2021 03:05:02 +0000 (-0400) Subject: Fixes for 5.10 X-Git-Tag: v4.4.263~51 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=d51476e0a856bd30f0100fcd22af7a09827c11e1;p=thirdparty%2Fkernel%2Fstable-queue.git Fixes for 5.10 Signed-off-by: Sasha Levin --- 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 index 00000000000..724a7db86dd --- /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 +Date: Mon, 11 Jan 2021 23:55:16 -0800 +Subject: bpf: Declare __bpf_free_used_maps() unconditionally + +From: Andrii Nakryiko + +[ 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 +Signed-off-by: Andrii Nakryiko +Signed-off-by: Alexei Starovoitov +Acked-by: Yonghong Song +Link: https://lore.kernel.org/bpf/20210112075520.4103414-4-andrii@kernel.org +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..acefb657bae --- /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 +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 + +[ 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 +Cc: Maxime Coquelin +Cc: Alexandre Torgue +Signed-off-by: William Breathitt Gray +Reviewed-by: Fabrice Gasnier +Link: https://lore.kernel.org/r/20210226012931.161429-1-vilhelm.gray@gmail.com +Signed-off-by: Jonathan Cameron +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..cf9ebe961ae --- /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 +Date: Thu, 26 Nov 2020 16:45:59 -0500 +Subject: drm/amd/display: turn DPMS off on connector unplug + +From: Aurabindo Pillai + +[ 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 +Signed-off-by: Eryk Brol +Reviewed-by: Nicholas Kazlauskas +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + .../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 index 00000000000..bb166e6327a --- /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 +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 + +[ Upstream commit 690cdc2635849db8b782dbbcabfb1c7519c84fa1 ] + +Fulfill Polaris get_clock_by_type_with_latency(). + +Signed-off-by: Evan Quan +Acked-by: Alex Deucher +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + .../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 index 00000000000..dc928388b91 --- /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 +Date: Mon, 1 Feb 2021 00:05:47 +0100 +Subject: entry: Explicitly flush pending rcuog wakeup before last rescheduling + point + +From: Frederic Weisbecker + +[ 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 +Signed-off-by: Peter Zijlstra (Intel) +Signed-off-by: Ingo Molnar +Cc: stable@vger.kernel.org +Link: https://lkml.kernel.org/r/20210131230548.32970-5-frederic@kernel.org +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..68a91dd1ed1 --- /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 +Date: Mon, 1 Feb 2021 00:05:48 +0100 +Subject: entry/kvm: Explicitly flush pending rcuog wakeup before last + rescheduling point + +From: Frederic Weisbecker + +[ 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 +Signed-off-by: Frederic Weisbecker +Signed-off-by: Peter Zijlstra (Intel) +Signed-off-by: Ingo Molnar +Cc: stable@vger.kernel.org +Link: https://lkml.kernel.org/r/20210131230548.32970-6-frederic@kernel.org +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..bec61c13f01 --- /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 +Date: Tue, 22 Dec 2020 14:43:27 -0600 +Subject: gfs2: Add common helper for holding and releasing the freeze glock + +From: Bob Peterson + +[ 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 +Signed-off-by: Andreas Gruenbacher +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..ea7862dab39 --- /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 +Date: Fri, 12 Mar 2021 07:58:54 -0500 +Subject: gfs2: bypass signal_our_withdraw if no journal + +From: Bob Peterson + +[ 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 +Signed-off-by: Andreas Gruenbacher +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..b75836e72b0 --- /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 +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 + +[ 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 +Signed-off-by: Andreas Gruenbacher +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..26b1b0c3cd6 --- /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 +Date: Mon, 15 Mar 2021 20:44:30 +0200 +Subject: gpiolib: Assign fwnode to parent's if no primary one provided + +From: Andy Shevchenko + +[ 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 +Tested-by: Bartosz Golaszewski +Signed-off-by: Andy Shevchenko +Signed-off-by: Bartosz Golaszewski +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..2b4b69506f1 --- /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 +Date: Fri, 5 Mar 2021 14:02:40 +0200 +Subject: gpiolib: Read "gpio-line-names" from a firmware node + +From: Andy Shevchenko + +[ 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 +Reported-by: Roman Guskov +Signed-off-by: Andy Shevchenko +Tested-by: Marek Vasut +Reviewed-by: Marek Vasut +Signed-off-by: Bartosz Golaszewski +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..b757ba27d76 --- /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 +Date: Fri, 5 Feb 2021 08:48:52 +0000 +Subject: i40e: Fix endianness conversions + +From: Norbert Ciosek + +[ 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 +Tested-by: Tony Brelinski +Signed-off-by: Tony Nguyen +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..8aba1fb467d --- /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 +Date: Fri, 4 Dec 2020 18:22:35 -0800 +Subject: ibmvnic: add some debugs + +From: Sukadev Bhattiprolu + +[ 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 +Link: https://lore.kernel.org/r/20201205022235.2414110-1-sukadev@linux.ibm.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..95c7e4063b0 --- /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 +Date: Fri, 5 Mar 2021 16:48:39 +0800 +Subject: ibmvnic: remove excessive irqsave + +From: Junlin Yang + +[ 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 +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..02b34292fba --- /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 +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 + +[ 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 +Cc:Uwe Kleine-König +Cc:Saeed Mahameed +Reviewed-by: Dany Madden +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..4c71ddbe3f0 --- /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 +Date: Thu, 4 Mar 2021 21:02:58 -0700 +Subject: io_uring: clear IOCB_WAITQ for non -EIOCBQUEUED return + +From: Jens Axboe + +[ 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 +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..7e9afbfe577 --- /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 +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 + +[ 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 +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..af29935f04d --- /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 +Date: Wed, 10 Mar 2021 11:30:37 +0000 +Subject: io_uring: fix inconsistent lock state + +From: Pavel Begunkov + +[ 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); + + 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: + +[...] + _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 + + __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 +Signed-off-by: Jens Axboe +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..6ff3f450911 --- /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 +Date: Wed, 9 Dec 2020 23:16:45 +0200 +Subject: iwlwifi: Add a new card for MA family + +From: Matti Gottlieb + +[ Upstream commit ac1a98e1e924e7e8d7c7e5b1ca8ddc522e10ddd0 ] + +Add a PCI ID for snj with mr in AX family. + +Signed-off-by: Matti Gottlieb +Signed-off-by: Luca Coelho +Link: https://lore.kernel.org/r/iwlwifi.20201209231352.101ac3058c04.Idd28706b122cdc8103956f8e72bb062fe4adb54e@changeid +Signed-off-by: Luca Coelho +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..8fa0d53c89c --- /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 +Date: Thu, 26 Nov 2020 10:36:08 +0100 +Subject: media: cedrus: h264: Support profile controls + +From: Ezequiel Garcia + +[ 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 +Reviewed-by: Jernej Skrabec +Tested-by: Jernej Skrabec +Signed-off-by: Hans Verkuil +Signed-off-by: Mauro Carvalho Chehab +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..6334c9daa02 --- /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 +Date: Mon, 8 Feb 2021 12:37:42 +0000 +Subject: MIPS: compressed: fix build with enabled UBSAN + +From: Alexander Lobakin + +[ 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 +Signed-off-by: Thomas Bogendoerfer +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..4ed93cdbf66 --- /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 +Date: Mon, 8 Mar 2021 10:24:47 +0100 +Subject: MIPS: kernel: Reserve exception base early to prevent corruption + +From: Thomas Bogendoerfer + +[ 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 +Debugged-by: Serge Semin +Acked-by: Mike Rapoport +Tested-by: Florian Fainelli +Reviewed-by: Serge Semin +Signed-off-by: Thomas Bogendoerfer +Signed-off-by: Sasha Levin +--- + 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 + #include + #include ++#include + #include + + #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 + #include + #include ++#include + + #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 index 00000000000..83a7ffbda1c --- /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 +Date: Sat, 31 Oct 2020 23:09:31 +0300 +Subject: module: avoid *goto*s in module_sig_check() + +From: Sergey Shtylyov + +[ 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 +Reviewed-by: Miroslav Benes +Signed-off-by: Sergey Shtylyov +Signed-off-by: Jessica Yu +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..635912d8f80 --- /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 +Date: Thu, 14 Jan 2021 22:21:46 +0000 +Subject: module: harden ELF info handling + +From: Frank van der Linden + +[ 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 +Signed-off-by: Jessica Yu +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..8d2563e6806 --- /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 +Date: Sat, 31 Oct 2020 23:06:45 +0300 +Subject: module: merge repetitive strings in module_sig_check() + +From: Sergey Shtylyov + +[ 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 +Reviewed-by: Miroslav Benes +Signed-off-by: Sergey Shtylyov +Signed-off-by: Jessica Yu +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..b7f3353a692 --- /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 +Date: Thu, 4 Mar 2021 13:32:09 -0800 +Subject: mptcp: put subflow sock on connect error + +From: Florian Westphal + +[ 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 +Signed-off-by: Mat Martineau +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..c75a7d55deb --- /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 +Date: Mon, 16 Nov 2020 10:48:06 +0100 +Subject: mptcp: reduce the arguments of mptcp_sendmsg_frag + +From: Paolo Abeni + +[ 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 +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..7cfc2bbe062 --- /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 +Date: Tue, 3 Nov 2020 11:05:06 -0800 +Subject: mptcp: split mptcp_clean_una function + +From: Florian Westphal + +[ 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 +Signed-off-by: Mat Martineau +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..473fd464b1d --- /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 +Date: Sun, 7 Mar 2021 19:11:02 -0800 +Subject: net: bonding: fix error return code of bond_neigh_init() + +From: Jia-Ju Bai + +[ 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 +Signed-off-by: Jia-Ju Bai +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..00dda640613 --- /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 +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 + +[ 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 +Reviewed-by: Andrew Lunn +Link: https://lore.kernel.org/r/20210224205536.9349-1-christian.melki@t2data.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..d52ffcf3fd1 --- /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 +Date: Mon, 15 Mar 2021 14:04:27 -0700 +Subject: nvme-rdma: fix possible hang when failing to set io queues + +From: Sagi Grimberg + +[ 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 +Fixes: 711023071960 ("nvme-rdma: add a NVMe over Fabrics RDMA host driver") +Signed-off-by: Sagi Grimberg +Reviewed-by: Chao Leng +Signed-off-by: Christoph Hellwig +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..1d680e48690 --- /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 +Date: Thu, 4 Feb 2021 13:37:44 +0530 +Subject: powerpc/sstep: Fix darn emulation + +From: Sandipan Das + +[ 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 +Signed-off-by: Michael Ellerman +Link: https://lore.kernel.org/r/20210204080744.135785-2-sandipan@linux.ibm.com +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..f7d824667a2 --- /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 +Date: Thu, 4 Feb 2021 13:37:43 +0530 +Subject: powerpc/sstep: Fix load-store and update emulation + +From: Sandipan Das + +[ 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 +Reviewed-by: Naveen N. Rao +Signed-off-by: Michael Ellerman +Link: https://lore.kernel.org/r/20210204080744.135785-1-sandipan@linux.ibm.com +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..3b44d9e80c4 --- /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 +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 + +[ 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 +Signed-off-by: Frederic Weisbecker +Signed-off-by: Peter Zijlstra (Intel) +Signed-off-by: Ingo Molnar +Cc: stable@vger.kernel.org +Link: https://lkml.kernel.org/r/20210131230548.32970-4-frederic@kernel.org +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..90915c3befd --- /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 +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 + +[ 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 +Reviewed-by: Maor Gottlieb +Signed-off-by: Leon Romanovsky +Signed-off-by: Jason Gunthorpe +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..2c1797521ab --- /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 +Date: Thu, 17 Dec 2020 15:19:15 +0100 +Subject: RDMA/rtrs: Fix KASAN: stack-out-of-bounds bug + +From: Jack Wang + +[ 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 +Reviewed-by: Gioh Kim +Signed-off-by: Jason Gunthorpe +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..9c3e3ff02ad --- /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 +Date: Fri, 23 Oct 2020 09:43:52 +0200 +Subject: RDMA/rtrs: Introduce rtrs_post_send + +From: Guoqing Jiang + +[ 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 +Signed-off-by: Jack Wang +Signed-off-by: Jason Gunthorpe +Signed-off-by: Sasha Levin +--- + 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 = ≀ +- } else { +- head = ≀ +- } +- +- 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 = ≀ +- } else { +- head = ≀ +- } +- +- 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 index 00000000000..24f5141543d --- /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 +Date: Fri, 23 Oct 2020 09:43:48 +0200 +Subject: RDMA/rtrs: Remove unnecessary argument dir of rtrs_iu_free + +From: Gioh Kim + +[ 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 +Signed-off-by: Jack Wang +Signed-off-by: Jason Gunthorpe +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..dbbe2e0bfc1 --- /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 +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 + +[ 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 +Reviewed-by: Gioh Kim +Signed-off-by: Jack Wang +Signed-off-by: Jason Gunthorpe +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..a0b9e66cb10 --- /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 +Date: Thu, 11 Feb 2021 11:55:28 +0100 +Subject: regulator: pca9450: Add SD_VSEL GPIO for LDO5 + +From: Frieder Schrempf + +[ 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 +Link: https://lore.kernel.org/r/20210211105534.38972-1-frieder.schrempf@kontron.de +Signed-off-by: Mark Brown +Signed-off-by: Sasha Levin +--- + 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 ++#include + #include + #include + #include +@@ -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 index 00000000000..28482177bf6 --- /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 +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 + +[ 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: +Signed-off-by: Frieder Schrempf +Link: https://lore.kernel.org/r/20210222115229.166620-1-frieder.schrempf@kontron.de +Signed-off-by: Mark Brown +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..d2d380d91ff --- /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 +Date: Thu, 11 Feb 2021 11:55:30 +0100 +Subject: regulator: pca9450: Enable system reset on WDOG_B assertion + +From: Frieder Schrempf + +[ 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 +Link: https://lore.kernel.org/r/20210211105534.38972-3-frieder.schrempf@kontron.de +Signed-off-by: Mark Brown +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..9aba0aa5e57 --- /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 +Date: Tue, 9 Mar 2021 17:52:20 +0100 +Subject: s390/qeth: schedule TX NAPI on QAOB completion + +From: Julian Wiedmann + +[ 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 +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..339133ca313 --- /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 +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 + +[ 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 +Reviewed-by: John Garry +Signed-off-by: Ahmed S. Darwish +Signed-off-by: Martin K. Petersen +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..eda2cc213ef --- /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 +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 + +[ 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 +Reviewed-by: John Garry +Signed-off-by: Ahmed S. Darwish +Signed-off-by: Martin K. Petersen +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..e036c7c6914 --- /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 +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 + +[ 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 +Reviewed-by: John Garry +Signed-off-by: Ahmed S. Darwish +Signed-off-by: Martin K. Petersen +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..e836953a53f --- /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 +Date: Mon, 18 Jan 2021 11:09:39 +0100 +Subject: scsi: libsas: Introduce a _gfp() variant of event notifiers + +From: Ahmed S. Darwish + +[ 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 +Reviewed-by: John Garry +Signed-off-by: Ahmed S. Darwish +Signed-off-by: Martin K. Petersen +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..a0f7348cd63 --- /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 +Date: Mon, 18 Jan 2021 11:09:38 +0100 +Subject: scsi: libsas: Remove notifier indirection + +From: John Garry + +[ 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 +Reviewed-by: Jack Wang +Signed-off-by: John Garry +Signed-off-by: Ahmed S. Darwish +Signed-off-by: Martin K. Petersen +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..1c283091b4b --- /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 +Date: Mon, 18 Jan 2021 11:09:40 +0100 +Subject: scsi: mvsas: Pass gfp_t flags to libsas event notifiers + +From: Ahmed S. Darwish + +[ 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 +Reviewed-by: John Garry +Signed-off-by: Ahmed S. Darwish +Signed-off-by: Martin K. Petersen +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..eae958f69e3 --- /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 +Date: Fri, 20 Nov 2020 15:16:09 -0800 +Subject: scsi: pm8001: Neaten debug logging macros and uses + +From: Joe Perches + +[ Upstream commit 1b5d2793283dcb97b401b3b2c02b8a94eee29af1 ] + +Every PM8001__DBG macro uses an internal call to pm8001_printk. + +Convert all uses of: + + PM8001__DBG(hba, pm8001_printk(fmt, ...)) +to + pm8001_dbg(hba, , 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 +Acked-by: Jack Wang +Signed-off-by: Joe Perches +Signed-off-by: Martin K. Petersen +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..65775976199 --- /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 +Date: Mon, 2 Nov 2020 22:25:28 +0530 +Subject: scsi: pm80xx: Fix pm8001_mpi_get_nvmd_resp() race condition + +From: yuuzheng + +[ 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 +Signed-off-by: yuuzheng +Signed-off-by: Viswas G +Signed-off-by: Ruksar Devadi +Signed-off-by: Radha Ramachandran +Signed-off-by: Martin K. Petersen +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..036e32f38d8 --- /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 +Date: Mon, 2 Nov 2020 22:25:25 +0530 +Subject: scsi: pm80xx: Make mpi_build_cmd locking consistent + +From: peter chang + +[ 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 +Signed-off-by: peter chang +Signed-off-by: Viswas G +Signed-off-by: Ruksar Devadi +Signed-off-by: Radha Ramachandran +Signed-off-by: Martin K. Petersen +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..db884d8e911 --- /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 +Date: Mon, 2 Nov 2020 22:25:26 +0530 +Subject: scsi: pm80xx: Make running_req atomic + +From: Viswas G + +[ 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 +Signed-off-by: Viswas G +Signed-off-by: Ruksar Devadi +Signed-off-by: Martin K. Petersen +Signed-off-by: Sasha Levin +--- + 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 index 00000000000..84072557361 --- /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 +Date: Wed, 6 Jan 2021 17:21:56 +0100 +Subject: serial: stm32: fix DMA initialization error handling + +From: Erwan Le Ray + +[ 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 +Link: https://lore.kernel.org/r/20210106162203.28854-2-erwan.leray@foss.st.com +Signed-off-by: Greg Kroah-Hartman +Signed-off-by: Sasha Levin +--- + 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 7948125d4c2..6a748f95cbb 100644 --- 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 index 00000000000..06c46b60920 --- /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 +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 + +[ 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 +Cc: Jiri Slaby +Cc: Maxime Coquelin +Cc: Alexandre Torgue +Cc: Gerald Baeza +Cc: linux-serial@vger.kernel.org +Cc: linux-stm32@st-md-mailman.stormreply.com +Signed-off-by: Lee Jones +Link: https://lore.kernel.org/r/20201104193549.4026187-29-lee.jones@linaro.org +Signed-off-by: Greg Kroah-Hartman +Signed-off-by: Sasha Levin +--- + 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 +