From: Greg Kroah-Hartman Date: Sat, 21 May 2022 14:40:17 +0000 (+0200) Subject: 4.19-stable patches X-Git-Tag: v4.9.316~30 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=cdb2b9e039de18596e4a39bc3398d7994734ff52;p=thirdparty%2Fkernel%2Fstable-queue.git 4.19-stable patches added patches: mmc-core-cleanup-bkops-support.patch --- diff --git a/queue-4.19/mmc-block-use-generic_cmd6_time-when-modifying-inand_cmd38_arg_ext_csd.patch b/queue-4.19/mmc-block-use-generic_cmd6_time-when-modifying-inand_cmd38_arg_ext_csd.patch index 453f8c193bf..d7dc2875674 100644 --- a/queue-4.19/mmc-block-use-generic_cmd6_time-when-modifying-inand_cmd38_arg_ext_csd.patch +++ b/queue-4.19/mmc-block-use-generic_cmd6_time-when-modifying-inand_cmd38_arg_ext_csd.patch @@ -1,10 +1,10 @@ -From foo@baz Thu May 19 04:19:13 PM CEST 2022 +From foo@baz Sat May 21 04:39:35 PM CEST 2022 From: Florian Fainelli -Date: Tue, 17 May 2022 11:22:10 -0700 +Date: Thu, 19 May 2022 11:45:35 -0700 Subject: mmc: block: Use generic_cmd6_time when modifying INAND_CMD38_ARG_EXT_CSD To: stable@vger.kernel.org Cc: "Ulf Hansson" , "Florian Fainelli" , "Adrian Hunter" , "Greg Kroah-Hartman" , "Avri Altman" , "Bean Huo" , "Nishad Kamdar" , "Christian Löhle" , linux-mmc@vger.kernel.org (open list:MULTIMEDIA CARD (MMC), SECURE DIGITAL (SD) AND...), linux-kernel@vger.kernel.org (open list), alcooperx@gmail.com, kdasu.kdev@gmail.com -Message-ID: <20220517182211.249775-3-f.fainelli@gmail.com> +Message-ID: <20220519184536.370540-4-f.fainelli@gmail.com> From: Ulf Hansson diff --git a/queue-4.19/mmc-core-cleanup-bkops-support.patch b/queue-4.19/mmc-core-cleanup-bkops-support.patch new file mode 100644 index 00000000000..845ce01c37f --- /dev/null +++ b/queue-4.19/mmc-core-cleanup-bkops-support.patch @@ -0,0 +1,224 @@ +From foo@baz Sat May 21 04:39:35 PM CEST 2022 +From: Florian Fainelli +Date: Thu, 19 May 2022 11:45:33 -0700 +Subject: mmc: core: Cleanup BKOPS support +To: stable@vger.kernel.org +Cc: "Ulf Hansson" , "Jaehoon Chung" , "Florian Fainelli" , "Adrian Hunter" , "Greg Kroah-Hartman" , "Avri Altman" , "Bean Huo" , "Nishad Kamdar" , "Christian Löhle" , linux-mmc@vger.kernel.org (open list:MULTIMEDIA CARD (MMC), SECURE DIGITAL (SD) AND...), linux-kernel@vger.kernel.org (open list), alcooperx@gmail.com, kdasu.kdev@gmail.com +Message-ID: <20220519184536.370540-2-f.fainelli@gmail.com> + +From: Ulf Hansson + +commit 0c204979c691f05666ecfb74501e7adfdde8fbf9 upstream + +It's been ~6 years ago since we introduced the BKOPS support for eMMC +cards. The current code is a bit messy and primarily that's because it +prepares to support running BKOPS in an asynchronous mode. However, that +mode has never been fully implemented/enabled. Instead BKOPS is always +executed in synchronously, when the card has reported an urgent BKOPS +level. + +For these reasons, let's make the code more readable by dropping the unused +parts. Let's also rename mmc_start_bkops() to mmc_run_bkops(), as to make +it more descriptive. + +Cc: Jaehoon Chung +Signed-off-by: Ulf Hansson +Signed-off-by: Florian Fainelli +Signed-off-by: Greg Kroah-Hartman +--- + drivers/mmc/core/block.c | 2 - + drivers/mmc/core/card.h | 6 --- + drivers/mmc/core/mmc.c | 6 --- + drivers/mmc/core/mmc_ops.c | 87 +++++++++------------------------------------ + drivers/mmc/core/mmc_ops.h | 3 - + 5 files changed, 21 insertions(+), 83 deletions(-) + +--- a/drivers/mmc/core/block.c ++++ b/drivers/mmc/core/block.c +@@ -1944,7 +1944,7 @@ static void mmc_blk_urgent_bkops(struct + struct mmc_queue_req *mqrq) + { + if (mmc_blk_urgent_bkops_needed(mq, mqrq)) +- mmc_start_bkops(mq->card, true); ++ mmc_run_bkops(mq->card); + } + + void mmc_blk_mq_complete(struct request *req) +--- a/drivers/mmc/core/card.h ++++ b/drivers/mmc/core/card.h +@@ -23,15 +23,13 @@ + #define MMC_STATE_BLOCKADDR (1<<2) /* card uses block-addressing */ + #define MMC_CARD_SDXC (1<<3) /* card is SDXC */ + #define MMC_CARD_REMOVED (1<<4) /* card has been removed */ +-#define MMC_STATE_DOING_BKOPS (1<<5) /* card is doing BKOPS */ +-#define MMC_STATE_SUSPENDED (1<<6) /* card is suspended */ ++#define MMC_STATE_SUSPENDED (1<<5) /* card is suspended */ + + #define mmc_card_present(c) ((c)->state & MMC_STATE_PRESENT) + #define mmc_card_readonly(c) ((c)->state & MMC_STATE_READONLY) + #define mmc_card_blockaddr(c) ((c)->state & MMC_STATE_BLOCKADDR) + #define mmc_card_ext_capacity(c) ((c)->state & MMC_CARD_SDXC) + #define mmc_card_removed(c) ((c) && ((c)->state & MMC_CARD_REMOVED)) +-#define mmc_card_doing_bkops(c) ((c)->state & MMC_STATE_DOING_BKOPS) + #define mmc_card_suspended(c) ((c)->state & MMC_STATE_SUSPENDED) + + #define mmc_card_set_present(c) ((c)->state |= MMC_STATE_PRESENT) +@@ -39,8 +37,6 @@ + #define mmc_card_set_blockaddr(c) ((c)->state |= MMC_STATE_BLOCKADDR) + #define mmc_card_set_ext_capacity(c) ((c)->state |= MMC_CARD_SDXC) + #define mmc_card_set_removed(c) ((c)->state |= MMC_CARD_REMOVED) +-#define mmc_card_set_doing_bkops(c) ((c)->state |= MMC_STATE_DOING_BKOPS) +-#define mmc_card_clr_doing_bkops(c) ((c)->state &= ~MMC_STATE_DOING_BKOPS) + #define mmc_card_set_suspended(c) ((c)->state |= MMC_STATE_SUSPENDED) + #define mmc_card_clr_suspended(c) ((c)->state &= ~MMC_STATE_SUSPENDED) + +--- a/drivers/mmc/core/mmc.c ++++ b/drivers/mmc/core/mmc.c +@@ -2026,12 +2026,6 @@ static int _mmc_suspend(struct mmc_host + if (mmc_card_suspended(host->card)) + goto out; + +- if (mmc_card_doing_bkops(host->card)) { +- err = mmc_stop_bkops(host->card); +- if (err) +- goto out; +- } +- + err = mmc_flush_cache(host->card); + if (err) + goto out; +--- a/drivers/mmc/core/mmc_ops.c ++++ b/drivers/mmc/core/mmc_ops.c +@@ -899,34 +899,6 @@ int mmc_can_ext_csd(struct mmc_card *car + return (card && card->csd.mmca_vsn > CSD_SPEC_VER_3); + } + +-/** +- * mmc_stop_bkops - stop ongoing BKOPS +- * @card: MMC card to check BKOPS +- * +- * Send HPI command to stop ongoing background operations to +- * allow rapid servicing of foreground operations, e.g. read/ +- * writes. Wait until the card comes out of the programming state +- * to avoid errors in servicing read/write requests. +- */ +-int mmc_stop_bkops(struct mmc_card *card) +-{ +- int err = 0; +- +- err = mmc_interrupt_hpi(card); +- +- /* +- * If err is EINVAL, we can't issue an HPI. +- * It should complete the BKOPS. +- */ +- if (!err || (err == -EINVAL)) { +- mmc_card_clr_doing_bkops(card); +- mmc_retune_release(card->host); +- err = 0; +- } +- +- return err; +-} +- + static int mmc_read_bkops_status(struct mmc_card *card) + { + int err; +@@ -943,22 +915,17 @@ static int mmc_read_bkops_status(struct + } + + /** +- * mmc_start_bkops - start BKOPS for supported cards +- * @card: MMC card to start BKOPS +- * @from_exception: A flag to indicate if this function was +- * called due to an exception raised by the card ++ * mmc_run_bkops - Run BKOPS for supported cards ++ * @card: MMC card to run BKOPS for + * +- * Start background operations whenever requested. +- * When the urgent BKOPS bit is set in a R1 command response +- * then background operations should be started immediately. ++ * Run background operations synchronously for cards having manual BKOPS ++ * enabled and in case it reports urgent BKOPS level. + */ +-void mmc_start_bkops(struct mmc_card *card, bool from_exception) ++void mmc_run_bkops(struct mmc_card *card) + { + int err; +- int timeout; +- bool use_busy_signal; + +- if (!card->ext_csd.man_bkops_en || mmc_card_doing_bkops(card)) ++ if (!card->ext_csd.man_bkops_en) + return; + + err = mmc_read_bkops_status(card); +@@ -968,44 +935,26 @@ void mmc_start_bkops(struct mmc_card *ca + return; + } + +- if (!card->ext_csd.raw_bkops_status) ++ if (!card->ext_csd.raw_bkops_status || ++ card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2) + return; + +- if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 && +- from_exception) +- return; +- +- if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) { +- timeout = MMC_OPS_TIMEOUT_MS; +- use_busy_signal = true; +- } else { +- timeout = 0; +- use_busy_signal = false; +- } +- + mmc_retune_hold(card->host); + +- err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, +- EXT_CSD_BKOPS_START, 1, timeout, 0, +- use_busy_signal, true, false); +- if (err) { ++ /* ++ * For urgent BKOPS status, LEVEL_2 and higher, let's execute ++ * synchronously. Future wise, we may consider to start BKOPS, for less ++ * urgent levels by using an asynchronous background task, when idle. ++ */ ++ err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, ++ EXT_CSD_BKOPS_START, 1, MMC_OPS_TIMEOUT_MS); ++ if (err) + pr_warn("%s: Error %d starting bkops\n", + mmc_hostname(card->host), err); +- mmc_retune_release(card->host); +- return; +- } + +- /* +- * For urgent bkops status (LEVEL_2 and more) +- * bkops executed synchronously, otherwise +- * the operation is in progress +- */ +- if (!use_busy_signal) +- mmc_card_set_doing_bkops(card); +- else +- mmc_retune_release(card->host); ++ mmc_retune_release(card->host); + } +-EXPORT_SYMBOL(mmc_start_bkops); ++EXPORT_SYMBOL(mmc_run_bkops); + + /* + * Flush the cache to the non-volatile storage. +--- a/drivers/mmc/core/mmc_ops.h ++++ b/drivers/mmc/core/mmc_ops.h +@@ -40,8 +40,7 @@ int __mmc_switch(struct mmc_card *card, + bool use_busy_signal, bool send_status, bool retry_crc_err); + int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, + unsigned int timeout_ms); +-int mmc_stop_bkops(struct mmc_card *card); +-void mmc_start_bkops(struct mmc_card *card, bool from_exception); ++void mmc_run_bkops(struct mmc_card *card); + int mmc_flush_cache(struct mmc_card *card); + int mmc_cmdq_enable(struct mmc_card *card); + int mmc_cmdq_disable(struct mmc_card *card); diff --git a/queue-4.19/mmc-core-default-to-generic_cmd6_time-as-timeout-in-__mmc_switch.patch b/queue-4.19/mmc-core-default-to-generic_cmd6_time-as-timeout-in-__mmc_switch.patch index 12d9d4db25f..698e92f8a14 100644 --- a/queue-4.19/mmc-core-default-to-generic_cmd6_time-as-timeout-in-__mmc_switch.patch +++ b/queue-4.19/mmc-core-default-to-generic_cmd6_time-as-timeout-in-__mmc_switch.patch @@ -1,10 +1,10 @@ -From foo@baz Thu May 19 04:19:13 PM CEST 2022 +From foo@baz Sat May 21 04:39:35 PM CEST 2022 From: Florian Fainelli -Date: Tue, 17 May 2022 11:22:11 -0700 +Date: Thu, 19 May 2022 11:45:36 -0700 Subject: mmc: core: Default to generic_cmd6_time as timeout in __mmc_switch() To: stable@vger.kernel.org Cc: "Ulf Hansson" , "Florian Fainelli" , "Adrian Hunter" , "Greg Kroah-Hartman" , "Avri Altman" , "Bean Huo" , "Nishad Kamdar" , "Christian Löhle" , linux-mmc@vger.kernel.org (open list:MULTIMEDIA CARD (MMC), SECURE DIGITAL (SD) AND...), linux-kernel@vger.kernel.org (open list), alcooperx@gmail.com, kdasu.kdev@gmail.com -Message-ID: <20220517182211.249775-4-f.fainelli@gmail.com> +Message-ID: <20220519184536.370540-5-f.fainelli@gmail.com> From: Ulf Hansson diff --git a/queue-4.19/mmc-core-specify-timeouts-for-bkops-and-cache_flush-for-emmc.patch b/queue-4.19/mmc-core-specify-timeouts-for-bkops-and-cache_flush-for-emmc.patch index 40403636913..b8da43ec38a 100644 --- a/queue-4.19/mmc-core-specify-timeouts-for-bkops-and-cache_flush-for-emmc.patch +++ b/queue-4.19/mmc-core-specify-timeouts-for-bkops-and-cache_flush-for-emmc.patch @@ -1,10 +1,10 @@ -From foo@baz Thu May 19 04:19:13 PM CEST 2022 +From foo@baz Sat May 21 04:39:35 PM CEST 2022 From: Florian Fainelli -Date: Tue, 17 May 2022 11:22:09 -0700 +Date: Thu, 19 May 2022 11:45:34 -0700 Subject: mmc: core: Specify timeouts for BKOPS and CACHE_FLUSH for eMMC To: stable@vger.kernel.org Cc: "Ulf Hansson" , "Florian Fainelli" , "Adrian Hunter" , "Greg Kroah-Hartman" , "Avri Altman" , "Bean Huo" , "Nishad Kamdar" , "Christian Löhle" , linux-mmc@vger.kernel.org (open list:MULTIMEDIA CARD (MMC), SECURE DIGITAL (SD) AND...), linux-kernel@vger.kernel.org (open list), alcooperx@gmail.com, kdasu.kdev@gmail.com -Message-ID: <20220517182211.249775-2-f.fainelli@gmail.com> +Message-ID: <20220519184536.370540-3-f.fainelli@gmail.com> From: Ulf Hansson @@ -37,16 +37,16 @@ Signed-off-by: Greg Kroah-Hartman static const u8 tuning_blk_pattern_4bit[] = { 0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc, -@@ -986,7 +988,7 @@ void mmc_start_bkops(struct mmc_card *ca - mmc_retune_hold(card->host); - - err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, -- EXT_CSD_BKOPS_START, 1, timeout, 0, -+ EXT_CSD_BKOPS_START, 1, MMC_BKOPS_TIMEOUT_MS, 0, - use_busy_signal, true, false); - if (err) { +@@ -947,7 +949,7 @@ void mmc_run_bkops(struct mmc_card *card + * urgent levels by using an asynchronous background task, when idle. + */ + err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, +- EXT_CSD_BKOPS_START, 1, MMC_OPS_TIMEOUT_MS); ++ EXT_CSD_BKOPS_START, 1, MMC_BKOPS_TIMEOUT_MS); + if (err) pr_warn("%s: Error %d starting bkops\n", -@@ -1016,7 +1018,8 @@ int mmc_flush_cache(struct mmc_card *car + mmc_hostname(card->host), err); +@@ -965,7 +967,8 @@ int mmc_flush_cache(struct mmc_card *car if (mmc_cache_enabled(card->host)) { err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, diff --git a/queue-4.19/series b/queue-4.19/series index 29454026b7f..d466f1fba3f 100644 --- a/queue-4.19/series +++ b/queue-4.19/series @@ -8,12 +8,13 @@ drbd-remove-usage-of-list-iterator-variable-after-lo.patch arm-9191-1-arm-stacktrace-kasan-silence-kasan-warnin.patch nilfs2-fix-lockdep-warnings-in-page-operations-for-b.patch nilfs2-fix-lockdep-warnings-during-disk-space-reclam.patch -mmc-core-specify-timeouts-for-bkops-and-cache_flush-for-emmc.patch -mmc-block-use-generic_cmd6_time-when-modifying-inand_cmd38_arg_ext_csd.patch -mmc-core-default-to-generic_cmd6_time-as-timeout-in-__mmc_switch.patch alsa-wavefront-proper-check-of-get_user-error.patch perf-fix-sys_perf_event_open-race-against-self.patch fix-double-fget-in-vhost_net_set_backend.patch pci-pm-avoid-putting-elo-i2-pcie-ports-in-d3cold.patch crypto-qcom-rng-fix-infinite-loop-on-requests-not-multiple-of-word_sz.patch drm-dp-mst-fix-a-possible-memory-leak-in-fetch_monitor_name.patch +mmc-core-cleanup-bkops-support.patch +mmc-core-specify-timeouts-for-bkops-and-cache_flush-for-emmc.patch +mmc-block-use-generic_cmd6_time-when-modifying-inand_cmd38_arg_ext_csd.patch +mmc-core-default-to-generic_cmd6_time-as-timeout-in-__mmc_switch.patch