From: Sasha Levin Date: Mon, 4 Dec 2023 10:40:11 +0000 (-0500) Subject: Fixes for 5.10 X-Git-Tag: v4.14.332~23^2~32 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=222a9b9ac1a8596b546069e749d52a9eed3d9ac7;p=thirdparty%2Fkernel%2Fstable-queue.git Fixes for 5.10 Signed-off-by: Sasha Levin --- diff --git a/queue-5.10/mmc-block-retry-commands-in-cqe-error-recovery.patch b/queue-5.10/mmc-block-retry-commands-in-cqe-error-recovery.patch new file mode 100644 index 00000000000..14a57706216 --- /dev/null +++ b/queue-5.10/mmc-block-retry-commands-in-cqe-error-recovery.patch @@ -0,0 +1,55 @@ +From 3a1787a8b4e160fc77a0f63fa070afe01723a71b Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 3 Nov 2023 10:47:18 +0200 +Subject: mmc: block: Retry commands in CQE error recovery + +From: Adrian Hunter + +[ Upstream commit 8155d1fa3a747baad5caff5f8303321d68ddd48c ] + +It is important that MMC_CMDQ_TASK_MGMT command to discard the queue is +successful because otherwise a subsequent reset might fail to flush the +cache first. Retry it and the previous STOP command. + +Fixes: 72a5af554df8 ("mmc: core: Add support for handling CQE requests") +Cc: stable@vger.kernel.org +Signed-off-by: Adrian Hunter +Reviewed-by: Avri Altman +Link: https://lore.kernel.org/r/20231103084720.6886-5-adrian.hunter@intel.com +Signed-off-by: Ulf Hansson +Signed-off-by: Sasha Levin +--- + drivers/mmc/core/core.c | 7 +++++-- + 1 file changed, 5 insertions(+), 2 deletions(-) + +diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c +index 9cc4e3a0bc9a8..fdeaaae080603 100644 +--- a/drivers/mmc/core/core.c ++++ b/drivers/mmc/core/core.c +@@ -551,7 +551,7 @@ int mmc_cqe_recovery(struct mmc_host *host) + cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; + cmd.flags &= ~MMC_RSP_CRC; /* Ignore CRC */ + cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT; +- mmc_wait_for_cmd(host, &cmd, 0); ++ mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); + + memset(&cmd, 0, sizeof(cmd)); + cmd.opcode = MMC_CMDQ_TASK_MGMT; +@@ -559,10 +559,13 @@ int mmc_cqe_recovery(struct mmc_host *host) + cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; + cmd.flags &= ~MMC_RSP_CRC; /* Ignore CRC */ + cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT; +- err = mmc_wait_for_cmd(host, &cmd, 0); ++ err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); + + host->cqe_ops->cqe_recovery_finish(host); + ++ if (err) ++ err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); ++ + mmc_retune_release(host); + + return err; +-- +2.42.0 + diff --git a/queue-5.10/mmc-core-add-helpers-mmc_regulator_enable-disable_vq.patch b/queue-5.10/mmc-core-add-helpers-mmc_regulator_enable-disable_vq.patch new file mode 100644 index 00000000000..30696c56ed4 --- /dev/null +++ b/queue-5.10/mmc-core-add-helpers-mmc_regulator_enable-disable_vq.patch @@ -0,0 +1,100 @@ +From bc04507bce6e9191af4e8d91d19e7ee638ed8658 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 11 Mar 2023 23:39:55 +0100 +Subject: mmc: core: add helpers mmc_regulator_enable/disable_vqmmc + +From: Heiner Kallweit + +[ Upstream commit 8d91f3f8ae57e6292142ca89f322e90fa0d6ac02 ] + +There's a number of drivers (e.g. dw_mmc, meson-gx, mmci, sunxi) using +the same mechanism and a private flag vqmmc_enabled to deal with +enabling/disabling the vqmmc regulator. + +Move this to the core and create new helpers mmc_regulator_enable_vqmmc +and mmc_regulator_disable_vqmmc. + +Signed-off-by: Heiner Kallweit +Acked-by: Martin Blumenstingl +Link: https://lore.kernel.org/r/71586432-360f-9b92-17f6-b05a8a971bc2@gmail.com +Signed-off-by: Ulf Hansson +Stable-dep-of: 477865af60b2 ("mmc: sdhci-sprd: Fix vqmmc not shutting down after the card was pulled") +Signed-off-by: Sasha Levin +--- + drivers/mmc/core/regulator.c | 41 ++++++++++++++++++++++++++++++++++++ + include/linux/mmc/host.h | 3 +++ + 2 files changed, 44 insertions(+) + +diff --git a/drivers/mmc/core/regulator.c b/drivers/mmc/core/regulator.c +index 609201a467ef9..4dcbc2281d2b5 100644 +--- a/drivers/mmc/core/regulator.c ++++ b/drivers/mmc/core/regulator.c +@@ -271,3 +271,44 @@ int mmc_regulator_get_supply(struct mmc_host *mmc) + return 0; + } + EXPORT_SYMBOL_GPL(mmc_regulator_get_supply); ++ ++/** ++ * mmc_regulator_enable_vqmmc - enable VQMMC regulator for a host ++ * @mmc: the host to regulate ++ * ++ * Returns 0 or errno. Enables the regulator for vqmmc. ++ * Keeps track of the enable status for ensuring that calls to ++ * regulator_enable/disable are balanced. ++ */ ++int mmc_regulator_enable_vqmmc(struct mmc_host *mmc) ++{ ++ int ret = 0; ++ ++ if (!IS_ERR(mmc->supply.vqmmc) && !mmc->vqmmc_enabled) { ++ ret = regulator_enable(mmc->supply.vqmmc); ++ if (ret < 0) ++ dev_err(mmc_dev(mmc), "enabling vqmmc regulator failed\n"); ++ else ++ mmc->vqmmc_enabled = true; ++ } ++ ++ return ret; ++} ++EXPORT_SYMBOL_GPL(mmc_regulator_enable_vqmmc); ++ ++/** ++ * mmc_regulator_disable_vqmmc - disable VQMMC regulator for a host ++ * @mmc: the host to regulate ++ * ++ * Returns 0 or errno. Disables the regulator for vqmmc. ++ * Keeps track of the enable status for ensuring that calls to ++ * regulator_enable/disable are balanced. ++ */ ++void mmc_regulator_disable_vqmmc(struct mmc_host *mmc) ++{ ++ if (!IS_ERR(mmc->supply.vqmmc) && mmc->vqmmc_enabled) { ++ regulator_disable(mmc->supply.vqmmc); ++ mmc->vqmmc_enabled = false; ++ } ++} ++EXPORT_SYMBOL_GPL(mmc_regulator_disable_vqmmc); +diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h +index fb294cbb9081d..fb08b86acdbf3 100644 +--- a/include/linux/mmc/host.h ++++ b/include/linux/mmc/host.h +@@ -405,6 +405,7 @@ struct mmc_host { + unsigned int use_blk_mq:1; /* use blk-mq */ + unsigned int retune_crc_disable:1; /* don't trigger retune upon crc */ + unsigned int can_dma_map_merge:1; /* merging can be used */ ++ unsigned int vqmmc_enabled:1; /* vqmmc regulator is enabled */ + + int rescan_disable; /* disable card detection */ + int rescan_entered; /* used with nonremovable devices */ +@@ -546,6 +547,8 @@ static inline int mmc_regulator_set_vqmmc(struct mmc_host *mmc, + #endif + + int mmc_regulator_get_supply(struct mmc_host *mmc); ++int mmc_regulator_enable_vqmmc(struct mmc_host *mmc); ++void mmc_regulator_disable_vqmmc(struct mmc_host *mmc); + + static inline int mmc_card_is_removable(struct mmc_host *host) + { +-- +2.42.0 + diff --git a/queue-5.10/mmc-core-convert-comma-to-semicolon.patch b/queue-5.10/mmc-core-convert-comma-to-semicolon.patch new file mode 100644 index 00000000000..233208c440c --- /dev/null +++ b/queue-5.10/mmc-core-convert-comma-to-semicolon.patch @@ -0,0 +1,50 @@ +From 9c57b5dc61327290ad2908d4b42a2d9fdc82b011 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 16 Dec 2020 21:17:37 +0800 +Subject: mmc: core: convert comma to semicolon + +From: Zheng Yongjun + +[ Upstream commit 6b1dc6229aecbcb45e8901576684a8c09e25ad7b ] + +Replace a comma between expression statements by a semicolon. + +Signed-off-by: Zheng Yongjun +Link: https://lore.kernel.org/r/20201216131737.14883-1-zhengyongjun3@huawei.com +Signed-off-by: Ulf Hansson +Stable-dep-of: 8155d1fa3a74 ("mmc: block: Retry commands in CQE error recovery") +Signed-off-by: Sasha Levin +--- + drivers/mmc/core/core.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c +index 8f24653942536..9cc4e3a0bc9a8 100644 +--- a/drivers/mmc/core/core.c ++++ b/drivers/mmc/core/core.c +@@ -547,10 +547,10 @@ int mmc_cqe_recovery(struct mmc_host *host) + host->cqe_ops->cqe_recovery_start(host); + + memset(&cmd, 0, sizeof(cmd)); +- cmd.opcode = MMC_STOP_TRANSMISSION, +- cmd.flags = MMC_RSP_R1B | MMC_CMD_AC, ++ cmd.opcode = MMC_STOP_TRANSMISSION; ++ cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; + cmd.flags &= ~MMC_RSP_CRC; /* Ignore CRC */ +- cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT, ++ cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT; + mmc_wait_for_cmd(host, &cmd, 0); + + memset(&cmd, 0, sizeof(cmd)); +@@ -558,7 +558,7 @@ int mmc_cqe_recovery(struct mmc_host *host) + cmd.arg = 1; /* Discard entire queue */ + cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; + cmd.flags &= ~MMC_RSP_CRC; /* Ignore CRC */ +- cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT, ++ cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT; + err = mmc_wait_for_cmd(host, &cmd, 0); + + host->cqe_ops->cqe_recovery_finish(host); +-- +2.42.0 + diff --git a/queue-5.10/mmc-cqhci-fix-task-clearing-in-cqe-error-recovery.patch b/queue-5.10/mmc-cqhci-fix-task-clearing-in-cqe-error-recovery.patch new file mode 100644 index 00000000000..351d52a7e1f --- /dev/null +++ b/queue-5.10/mmc-cqhci-fix-task-clearing-in-cqe-error-recovery.patch @@ -0,0 +1,98 @@ +From a3a697ff94a2d2a7ec128c88aa18363b4175ad3d Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 3 Nov 2023 10:47:20 +0200 +Subject: mmc: cqhci: Fix task clearing in CQE error recovery +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +From: Adrian Hunter + +[ Upstream commit 1de1b77982e1a1df9707cb11f9b1789e6b8919d4 ] + +If a task completion notification (TCN) is received when there is no +outstanding task, the cqhci driver issues a "spurious TCN" warning. This +was observed to happen right after CQE error recovery. + +When an error interrupt is received the driver runs recovery logic. +It halts the controller, clears all pending tasks, and then re-enables +it. On some platforms, like Intel Jasper Lake, a stale task completion +event was observed, regardless of the CQHCI_CLEAR_ALL_TASKS bit being set. + +This results in either: +a) Spurious TC completion event for an empty slot. +b) Corrupted data being passed up the stack, as a result of premature + completion for a newly added task. + +Rather than add a quirk for affected controllers, ensure tasks are cleared +by toggling CQHCI_ENABLE, which would happen anyway if +cqhci_clear_all_tasks() timed out. This is simpler and should be safe and +effective for all controllers. + +Fixes: a4080225f51d ("mmc: cqhci: support for command queue enabled host") +Cc: stable@vger.kernel.org +Reported-by: Kornel Dulęba +Tested-by: Kornel Dulęba +Co-developed-by: Kornel Dulęba +Signed-off-by: Kornel Dulęba +Signed-off-by: Adrian Hunter +Reviewed-by: Avri Altman +Link: https://lore.kernel.org/r/20231103084720.6886-7-adrian.hunter@intel.com +Signed-off-by: Ulf Hansson +Signed-off-by: Sasha Levin +--- + drivers/mmc/host/cqhci.c | 32 ++++++++++++++++---------------- + 1 file changed, 16 insertions(+), 16 deletions(-) + +diff --git a/drivers/mmc/host/cqhci.c b/drivers/mmc/host/cqhci.c +index 7bccd6494cd93..23cf7912c1ba3 100644 +--- a/drivers/mmc/host/cqhci.c ++++ b/drivers/mmc/host/cqhci.c +@@ -1023,28 +1023,28 @@ static void cqhci_recovery_finish(struct mmc_host *mmc) + + ok = cqhci_halt(mmc, CQHCI_FINISH_HALT_TIMEOUT); + +- if (!cqhci_clear_all_tasks(mmc, CQHCI_CLEAR_TIMEOUT)) +- ok = false; +- + /* + * The specification contradicts itself, by saying that tasks cannot be + * cleared if CQHCI does not halt, but if CQHCI does not halt, it should + * be disabled/re-enabled, but not to disable before clearing tasks. + * Have a go anyway. + */ +- if (!ok) { +- pr_debug("%s: cqhci: disable / re-enable\n", mmc_hostname(mmc)); +- cqcfg = cqhci_readl(cq_host, CQHCI_CFG); +- cqcfg &= ~CQHCI_ENABLE; +- cqhci_writel(cq_host, cqcfg, CQHCI_CFG); +- cqcfg |= CQHCI_ENABLE; +- cqhci_writel(cq_host, cqcfg, CQHCI_CFG); +- /* Be sure that there are no tasks */ +- ok = cqhci_halt(mmc, CQHCI_FINISH_HALT_TIMEOUT); +- if (!cqhci_clear_all_tasks(mmc, CQHCI_CLEAR_TIMEOUT)) +- ok = false; +- WARN_ON(!ok); +- } ++ if (!cqhci_clear_all_tasks(mmc, CQHCI_CLEAR_TIMEOUT)) ++ ok = false; ++ ++ /* Disable to make sure tasks really are cleared */ ++ cqcfg = cqhci_readl(cq_host, CQHCI_CFG); ++ cqcfg &= ~CQHCI_ENABLE; ++ cqhci_writel(cq_host, cqcfg, CQHCI_CFG); ++ ++ cqcfg = cqhci_readl(cq_host, CQHCI_CFG); ++ cqcfg |= CQHCI_ENABLE; ++ cqhci_writel(cq_host, cqcfg, CQHCI_CFG); ++ ++ cqhci_halt(mmc, CQHCI_FINISH_HALT_TIMEOUT); ++ ++ if (!ok) ++ cqhci_clear_all_tasks(mmc, CQHCI_CLEAR_TIMEOUT); + + cqhci_recover_mrqs(cq_host); + +-- +2.42.0 + diff --git a/queue-5.10/mmc-cqhci-increase-recovery-halt-timeout.patch b/queue-5.10/mmc-cqhci-increase-recovery-halt-timeout.patch new file mode 100644 index 00000000000..4a631bf41f3 --- /dev/null +++ b/queue-5.10/mmc-cqhci-increase-recovery-halt-timeout.patch @@ -0,0 +1,45 @@ +From 06eb4a0e704f4372832802d6b6ac18640926b1be Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 3 Nov 2023 10:47:16 +0200 +Subject: mmc: cqhci: Increase recovery halt timeout + +From: Adrian Hunter + +[ Upstream commit b578d5d18e929aa7c007a98cce32657145dde219 ] + +Failing to halt complicates the recovery. Additionally, unless the card or +controller are stuck, which is expected to be very rare, then the halt +should succeed, so it is better to wait. Set a large timeout. + +Fixes: a4080225f51d ("mmc: cqhci: support for command queue enabled host") +Cc: stable@vger.kernel.org +Signed-off-by: Adrian Hunter +Reviewed-by: Avri Altman +Link: https://lore.kernel.org/r/20231103084720.6886-3-adrian.hunter@intel.com +Signed-off-by: Ulf Hansson +Signed-off-by: Sasha Levin +--- + drivers/mmc/host/cqhci.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/drivers/mmc/host/cqhci.c b/drivers/mmc/host/cqhci.c +index 7ba4f714106f9..a0a9cb6e2a150 100644 +--- a/drivers/mmc/host/cqhci.c ++++ b/drivers/mmc/host/cqhci.c +@@ -932,10 +932,10 @@ static bool cqhci_halt(struct mmc_host *mmc, unsigned int timeout) + /* + * After halting we expect to be able to use the command line. We interpret the + * failure to halt to mean the data lines might still be in use (and the upper +- * layers will need to send a STOP command), so we set the timeout based on a +- * generous command timeout. ++ * layers will need to send a STOP command), however failing to halt complicates ++ * the recovery, so set a timeout that would reasonably allow I/O to complete. + */ +-#define CQHCI_START_HALT_TIMEOUT 5 ++#define CQHCI_START_HALT_TIMEOUT 500 + + static void cqhci_recovery_start(struct mmc_host *mmc) + { +-- +2.42.0 + diff --git a/queue-5.10/mmc-cqhci-warn-of-halt-or-task-clear-failure.patch b/queue-5.10/mmc-cqhci-warn-of-halt-or-task-clear-failure.patch new file mode 100644 index 00000000000..cc6bd65850b --- /dev/null +++ b/queue-5.10/mmc-cqhci-warn-of-halt-or-task-clear-failure.patch @@ -0,0 +1,52 @@ +From d39f98c3f049aa70d19816b15b97789f2438518f Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 3 Nov 2023 10:47:19 +0200 +Subject: mmc: cqhci: Warn of halt or task clear failure + +From: Adrian Hunter + +[ Upstream commit 35597bdb04ec27ef3b1cea007dc69f8ff5df75a5 ] + +A correctly operating controller should successfully halt and clear tasks. +Failure may result in errors elsewhere, so promote messages from debug to +warnings. + +Fixes: a4080225f51d ("mmc: cqhci: support for command queue enabled host") +Cc: stable@vger.kernel.org +Signed-off-by: Adrian Hunter +Reviewed-by: Avri Altman +Reviewed-by: Avri Altman +Link: https://lore.kernel.org/r/20231103084720.6886-6-adrian.hunter@intel.com +Signed-off-by: Ulf Hansson +Signed-off-by: Sasha Levin +--- + drivers/mmc/host/cqhci.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/drivers/mmc/host/cqhci.c b/drivers/mmc/host/cqhci.c +index a0a9cb6e2a150..7bccd6494cd93 100644 +--- a/drivers/mmc/host/cqhci.c ++++ b/drivers/mmc/host/cqhci.c +@@ -890,8 +890,8 @@ static bool cqhci_clear_all_tasks(struct mmc_host *mmc, unsigned int timeout) + ret = cqhci_tasks_cleared(cq_host); + + if (!ret) +- pr_debug("%s: cqhci: Failed to clear tasks\n", +- mmc_hostname(mmc)); ++ pr_warn("%s: cqhci: Failed to clear tasks\n", ++ mmc_hostname(mmc)); + + return ret; + } +@@ -924,7 +924,7 @@ static bool cqhci_halt(struct mmc_host *mmc, unsigned int timeout) + ret = cqhci_halted(cq_host); + + if (!ret) +- pr_debug("%s: cqhci: Failed to halt\n", mmc_hostname(mmc)); ++ pr_warn("%s: cqhci: Failed to halt\n", mmc_hostname(mmc)); + + return ret; + } +-- +2.42.0 + diff --git a/queue-5.10/mmc-sdhci-sprd-fix-vqmmc-not-shutting-down-after-the.patch b/queue-5.10/mmc-sdhci-sprd-fix-vqmmc-not-shutting-down-after-the.patch new file mode 100644 index 00000000000..392c41c9093 --- /dev/null +++ b/queue-5.10/mmc-sdhci-sprd-fix-vqmmc-not-shutting-down-after-the.patch @@ -0,0 +1,94 @@ +From 67fb25c83388023ba4b929a7b962b2119f62c210 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 15 Nov 2023 16:34:06 +0800 +Subject: mmc: sdhci-sprd: Fix vqmmc not shutting down after the card was + pulled + +From: Wenchao Chen + +[ Upstream commit 477865af60b2117ceaa1d558e03559108c15c78c ] + +With cat regulator_summary, we found that vqmmc was not shutting +down after the card was pulled. + +cat /sys/kernel/debug/regulator/regulator_summary +1.before fix +1)Insert SD card + vddsdio 1 1 0 unknown 3500mV 0mA 1200mV 3750mV + 71100000.mmc-vqmmc 1 0mA 3500mV 3600mV + +2)Pull out the SD card + vddsdio 1 1 0 unknown 3500mV 0mA 1200mV 3750mV + 71100000.mmc-vqmmc 1 0mA 3500mV 3600mV + +2.after fix +1)Insert SD cardt + vddsdio 1 1 0 unknown 3500mV 0mA 1200mV 3750mV + 71100000.mmc-vqmmc 1 0mA 3500mV 3600mV + +2)Pull out the SD card + vddsdio 0 1 0 unknown 3500mV 0mA 1200mV 3750mV + 71100000.mmc-vqmmc 0 0mA 3500mV 3600mV + +Fixes: fb8bd90f83c4 ("mmc: sdhci-sprd: Add Spreadtrum's initial host controller") +Signed-off-by: Wenchao Chen +Cc: stable@vger.kernel.org +Link: https://lore.kernel.org/r/20231115083406.7368-1-wenchao.chen@unisoc.com +Signed-off-by: Ulf Hansson +Signed-off-by: Sasha Levin +--- + drivers/mmc/host/sdhci-sprd.c | 25 +++++++++++++++++++++++++ + 1 file changed, 25 insertions(+) + +diff --git a/drivers/mmc/host/sdhci-sprd.c b/drivers/mmc/host/sdhci-sprd.c +index 540ebccaa9a35..d8e412bbb93bf 100644 +--- a/drivers/mmc/host/sdhci-sprd.c ++++ b/drivers/mmc/host/sdhci-sprd.c +@@ -392,12 +392,33 @@ static void sdhci_sprd_request_done(struct sdhci_host *host, + mmc_request_done(host->mmc, mrq); + } + ++static void sdhci_sprd_set_power(struct sdhci_host *host, unsigned char mode, ++ unsigned short vdd) ++{ ++ struct mmc_host *mmc = host->mmc; ++ ++ switch (mode) { ++ case MMC_POWER_OFF: ++ mmc_regulator_set_ocr(host->mmc, mmc->supply.vmmc, 0); ++ ++ mmc_regulator_disable_vqmmc(mmc); ++ break; ++ case MMC_POWER_ON: ++ mmc_regulator_enable_vqmmc(mmc); ++ break; ++ case MMC_POWER_UP: ++ mmc_regulator_set_ocr(host->mmc, mmc->supply.vmmc, vdd); ++ break; ++ } ++} ++ + static struct sdhci_ops sdhci_sprd_ops = { + .read_l = sdhci_sprd_readl, + .write_l = sdhci_sprd_writel, + .write_w = sdhci_sprd_writew, + .write_b = sdhci_sprd_writeb, + .set_clock = sdhci_sprd_set_clock, ++ .set_power = sdhci_sprd_set_power, + .get_max_clock = sdhci_sprd_get_max_clock, + .get_min_clock = sdhci_sprd_get_min_clock, + .set_bus_width = sdhci_set_bus_width, +@@ -663,6 +684,10 @@ static int sdhci_sprd_probe(struct platform_device *pdev) + host->caps1 &= ~(SDHCI_SUPPORT_SDR50 | SDHCI_SUPPORT_SDR104 | + SDHCI_SUPPORT_DDR50); + ++ ret = mmc_regulator_get_supply(host->mmc); ++ if (ret) ++ goto pm_runtime_disable; ++ + ret = sdhci_setup_host(host); + if (ret) + goto pm_runtime_disable; +-- +2.42.0 + diff --git a/queue-5.10/r8169-disable-aspm-in-case-of-tx-timeout.patch b/queue-5.10/r8169-disable-aspm-in-case-of-tx-timeout.patch new file mode 100644 index 00000000000..5627912eddb --- /dev/null +++ b/queue-5.10/r8169-disable-aspm-in-case-of-tx-timeout.patch @@ -0,0 +1,76 @@ +From 54c5d9083e8d69274e2020139511d32df89c3173 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 10 Jan 2023 23:03:18 +0100 +Subject: r8169: disable ASPM in case of tx timeout + +From: Heiner Kallweit + +[ Upstream commit 80c0576ef179311f624bc450fede30a89afe9792 ] + +There are still single reports of systems where ASPM incompatibilities +cause tx timeouts. It's not clear whom to blame, so let's disable +ASPM in case of a tx timeout. + +v2: +- add one-time warning for informing the user + +Signed-off-by: Heiner Kallweit +Reviewed-by: Alexander Duyck +Link: https://lore.kernel.org/r/92369a92-dc32-4529-0509-11459ba0e391@gmail.com +Signed-off-by: Jakub Kicinski +Stable-dep-of: 59d395ed606d ("r8169: fix deadlock on RTL8125 in jumbo mtu mode") +Signed-off-by: Sasha Levin +--- + drivers/net/ethernet/realtek/r8169_main.c | 14 +++++++++++++- + 1 file changed, 13 insertions(+), 1 deletion(-) + +diff --git a/drivers/net/ethernet/realtek/r8169_main.c b/drivers/net/ethernet/realtek/r8169_main.c +index d33720f68c679..759fc7a08960d 100644 +--- a/drivers/net/ethernet/realtek/r8169_main.c ++++ b/drivers/net/ethernet/realtek/r8169_main.c +@@ -582,6 +582,7 @@ struct rtl8169_tc_offsets { + enum rtl_flag { + RTL_FLAG_TASK_ENABLED = 0, + RTL_FLAG_TASK_RESET_PENDING, ++ RTL_FLAG_TASK_TX_TIMEOUT, + RTL_FLAG_MAX + }; + +@@ -4036,7 +4037,7 @@ static void rtl8169_tx_timeout(struct net_device *dev, unsigned int txqueue) + { + struct rtl8169_private *tp = netdev_priv(dev); + +- rtl_schedule_task(tp, RTL_FLAG_TASK_RESET_PENDING); ++ rtl_schedule_task(tp, RTL_FLAG_TASK_TX_TIMEOUT); + } + + static int rtl8169_tx_map(struct rtl8169_private *tp, const u32 *opts, u32 len, +@@ -4656,6 +4657,7 @@ static void rtl_task(struct work_struct *work) + { + struct rtl8169_private *tp = + container_of(work, struct rtl8169_private, wk.work); ++ int ret; + + rtnl_lock(); + +@@ -4663,7 +4665,17 @@ static void rtl_task(struct work_struct *work) + !test_bit(RTL_FLAG_TASK_ENABLED, tp->wk.flags)) + goto out_unlock; + ++ if (test_and_clear_bit(RTL_FLAG_TASK_TX_TIMEOUT, tp->wk.flags)) { ++ /* ASPM compatibility issues are a typical reason for tx timeouts */ ++ ret = pci_disable_link_state(tp->pci_dev, PCIE_LINK_STATE_L1 | ++ PCIE_LINK_STATE_L0S); ++ if (!ret) ++ netdev_warn_once(tp->dev, "ASPM disabled on Tx timeout\n"); ++ goto reset; ++ } ++ + if (test_and_clear_bit(RTL_FLAG_TASK_RESET_PENDING, tp->wk.flags)) { ++reset: + rtl_reset_work(tp); + netif_wake_queue(tp->dev); + } +-- +2.42.0 + diff --git a/queue-5.10/r8169-fix-deadlock-on-rtl8125-in-jumbo-mtu-mode.patch b/queue-5.10/r8169-fix-deadlock-on-rtl8125-in-jumbo-mtu-mode.patch new file mode 100644 index 00000000000..8de45498ae9 --- /dev/null +++ b/queue-5.10/r8169-fix-deadlock-on-rtl8125-in-jumbo-mtu-mode.patch @@ -0,0 +1,60 @@ +From b86104bf70d40a1a115bebf912fcce6307ddd51d Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sun, 26 Nov 2023 19:36:46 +0100 +Subject: r8169: fix deadlock on RTL8125 in jumbo mtu mode + +From: Heiner Kallweit + +[ Upstream commit 59d395ed606d8df14615712b0cdcdadb2d962175 ] + +The original change results in a deadlock if jumbo mtu mode is used. +Reason is that the phydev lock is held when rtl_reset_work() is called +here, and rtl_jumbo_config() calls phy_start_aneg() which also tries +to acquire the phydev lock. Fix this by calling rtl_reset_work() +asynchronously. + +Fixes: 621735f59064 ("r8169: fix rare issue with broken rx after link-down on RTL8125") +Reported-by: Ian Chen +Tested-by: Ian Chen +Cc: stable@vger.kernel.org +Signed-off-by: Heiner Kallweit +Link: https://lore.kernel.org/r/caf6a487-ef8c-4570-88f9-f47a659faf33@gmail.com +Signed-off-by: Paolo Abeni +Signed-off-by: Sasha Levin +--- + drivers/net/ethernet/realtek/r8169_main.c | 5 ++++- + 1 file changed, 4 insertions(+), 1 deletion(-) + +diff --git a/drivers/net/ethernet/realtek/r8169_main.c b/drivers/net/ethernet/realtek/r8169_main.c +index 759fc7a08960d..88253cedd9d96 100644 +--- a/drivers/net/ethernet/realtek/r8169_main.c ++++ b/drivers/net/ethernet/realtek/r8169_main.c +@@ -582,6 +582,7 @@ struct rtl8169_tc_offsets { + enum rtl_flag { + RTL_FLAG_TASK_ENABLED = 0, + RTL_FLAG_TASK_RESET_PENDING, ++ RTL_FLAG_TASK_RESET_NO_QUEUE_WAKE, + RTL_FLAG_TASK_TX_TIMEOUT, + RTL_FLAG_MAX + }; +@@ -4678,6 +4679,8 @@ static void rtl_task(struct work_struct *work) + reset: + rtl_reset_work(tp); + netif_wake_queue(tp->dev); ++ } else if (test_and_clear_bit(RTL_FLAG_TASK_RESET_NO_QUEUE_WAKE, tp->wk.flags)) { ++ rtl_reset_work(tp); + } + out_unlock: + rtnl_unlock(); +@@ -4711,7 +4714,7 @@ static void r8169_phylink_handler(struct net_device *ndev) + } else { + /* In few cases rx is broken after link-down otherwise */ + if (rtl_is_8125(tp)) +- rtl_reset_work(tp); ++ rtl_schedule_task(tp, RTL_FLAG_TASK_RESET_NO_QUEUE_WAKE); + pm_runtime_idle(d); + } + +-- +2.42.0 + diff --git a/queue-5.10/series b/queue-5.10/series index bb84d545efa..cbcf031c474 100644 --- a/queue-5.10/series +++ b/queue-5.10/series @@ -126,3 +126,12 @@ scsi-qla2xxx-use-scsi_cmd_to_rq-instead-of-scsi_cmnd.patch scsi-qla2xxx-fix-system-crash-due-to-bad-pointer-acc.patch cpufreq-imx6q-don-t-warn-for-disabling-a-non-existin.patch cpufreq-imx6q-don-t-disable-792-mhz-opp-unnecessaril.patch +mmc-cqhci-increase-recovery-halt-timeout.patch +mmc-cqhci-warn-of-halt-or-task-clear-failure.patch +mmc-cqhci-fix-task-clearing-in-cqe-error-recovery.patch +mmc-core-convert-comma-to-semicolon.patch +mmc-block-retry-commands-in-cqe-error-recovery.patch +mmc-core-add-helpers-mmc_regulator_enable-disable_vq.patch +mmc-sdhci-sprd-fix-vqmmc-not-shutting-down-after-the.patch +r8169-disable-aspm-in-case-of-tx-timeout.patch +r8169-fix-deadlock-on-rtl8125-in-jumbo-mtu-mode.patch