From: Greg Kroah-Hartman Date: Sun, 3 Dec 2023 13:01:24 +0000 (+0100) Subject: 5.15-stable patches X-Git-Tag: v4.14.332~49 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=4a302bcdb30e6c103839283247456709715f4009;p=thirdparty%2Fkernel%2Fstable-queue.git 5.15-stable patches added patches: alsa-hda-disable-power-save-on-kontron-singlepc.patch alsa-hda-realtek-add-supported-alc257-for-chromeos.patch alsa-hda-realtek-headset-mic-vref-to-100.patch dm-verity-align-struct-dm_verity_fec_io-properly.patch firewire-core-fix-possible-memory-leak-in-create_units.patch mmc-block-be-sure-to-wait-while-busy-in-cqe-error-recovery.patch mmc-block-do-not-lose-cache-flush-during-cqe-error-recovery.patch mmc-block-retry-commands-in-cqe-error-recovery.patch mmc-cqhci-fix-task-clearing-in-cqe-error-recovery.patch mmc-cqhci-increase-recovery-halt-timeout.patch mmc-cqhci-warn-of-halt-or-task-clear-failure.patch mmc-sdhci-sprd-fix-vqmmc-not-shutting-down-after-the-card-was-pulled.patch perf-inject-fix-gen_elf_text_offset-for-jit.patch pinctrl-avoid-reload-of-p-state-in-list-iteration.patch series --- diff --git a/queue-5.15/alsa-hda-disable-power-save-on-kontron-singlepc.patch b/queue-5.15/alsa-hda-disable-power-save-on-kontron-singlepc.patch new file mode 100644 index 00000000000..75002ae09dc --- /dev/null +++ b/queue-5.15/alsa-hda-disable-power-save-on-kontron-singlepc.patch @@ -0,0 +1,35 @@ +From a337c355719c42a6c5b67e985ad753590ed844fb Mon Sep 17 00:00:00 2001 +From: Takashi Iwai +Date: Thu, 30 Nov 2023 16:13:21 +0100 +Subject: ALSA: hda: Disable power-save on KONTRON SinglePC + +From: Takashi Iwai + +commit a337c355719c42a6c5b67e985ad753590ed844fb upstream. + +It's been reported that the runtime PM on KONTRON SinglePC (PCI SSID +1734:1232) caused a stall of playback after a bunch of invocations. +(FWIW, this looks like an timing issue, and the stall happens rather +on the controller side.) + +As a workaround, disable the default power-save on this platform. + +Cc: +Link: https://lore.kernel.org/r/20231130151321.9813-1-tiwai@suse.de +Signed-off-by: Takashi Iwai +Signed-off-by: Greg Kroah-Hartman +--- + sound/pci/hda/hda_intel.c | 2 ++ + 1 file changed, 2 insertions(+) + +--- a/sound/pci/hda/hda_intel.c ++++ b/sound/pci/hda/hda_intel.c +@@ -2210,6 +2210,8 @@ static const struct snd_pci_quirk power_ + SND_PCI_QUIRK(0x17aa, 0x36a7, "Lenovo C50 All in one", 0), + /* https://bugs.launchpad.net/bugs/1821663 */ + SND_PCI_QUIRK(0x1631, 0xe017, "Packard Bell NEC IMEDIA 5204", 0), ++ /* KONTRON SinglePC may cause a stall at runtime resume */ ++ SND_PCI_QUIRK(0x1734, 0x1232, "KONTRON SinglePC", 0), + {} + }; + #endif /* CONFIG_PM */ diff --git a/queue-5.15/alsa-hda-realtek-add-supported-alc257-for-chromeos.patch b/queue-5.15/alsa-hda-realtek-add-supported-alc257-for-chromeos.patch new file mode 100644 index 00000000000..702f6c4489c --- /dev/null +++ b/queue-5.15/alsa-hda-realtek-add-supported-alc257-for-chromeos.patch @@ -0,0 +1,47 @@ +From cae2bdb579ecc9d4219c58a7d3fde1958118dc1d Mon Sep 17 00:00:00 2001 +From: Kailang Yang +Date: Wed, 29 Nov 2023 15:38:40 +0800 +Subject: ALSA: hda/realtek: Add supported ALC257 for ChromeOS + +From: Kailang Yang + +commit cae2bdb579ecc9d4219c58a7d3fde1958118dc1d upstream. + +ChromeOS want to support ALC257. +Add codec ID to some relation function. + +Signed-off-by: Kailang Yang +Cc: +Link: https://lore.kernel.org/r/99a88a7dbdb045fd9d934abeb6cec15f@realtek.com +Signed-off-by: Takashi Iwai +Signed-off-by: Greg Kroah-Hartman +--- + sound/pci/hda/patch_realtek.c | 3 +++ + 1 file changed, 3 insertions(+) + +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -3258,6 +3258,7 @@ static void alc_disable_headset_jack_key + case 0x10ec0230: + case 0x10ec0236: + case 0x10ec0256: ++ case 0x10ec0257: + case 0x19e58326: + alc_write_coef_idx(codec, 0x48, 0x0); + alc_update_coef_idx(codec, 0x49, 0x0045, 0x0); +@@ -3287,6 +3288,7 @@ static void alc_enable_headset_jack_key( + case 0x10ec0230: + case 0x10ec0236: + case 0x10ec0256: ++ case 0x10ec0257: + case 0x19e58326: + alc_write_coef_idx(codec, 0x48, 0xd011); + alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045); +@@ -6481,6 +6483,7 @@ static void alc_combo_jack_hp_jd_restart + case 0x10ec0236: + case 0x10ec0255: + case 0x10ec0256: ++ case 0x10ec0257: + case 0x19e58326: + alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */ + alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15); diff --git a/queue-5.15/alsa-hda-realtek-headset-mic-vref-to-100.patch b/queue-5.15/alsa-hda-realtek-headset-mic-vref-to-100.patch new file mode 100644 index 00000000000..69d6bf62fc5 --- /dev/null +++ b/queue-5.15/alsa-hda-realtek-headset-mic-vref-to-100.patch @@ -0,0 +1,52 @@ +From baaacbff64d9f34b64f294431966d035aeadb81c Mon Sep 17 00:00:00 2001 +From: Kailang Yang +Date: Wed, 25 Oct 2023 15:24:06 +0800 +Subject: ALSA: hda/realtek: Headset Mic VREF to 100% + +From: Kailang Yang + +commit baaacbff64d9f34b64f294431966d035aeadb81c upstream. + +This platform need to set Mic VREF to 100%. + +Signed-off-by: Kailang Yang +Cc: +Link: https://lore.kernel.org/r/0916af40f08a4348a3298a9a59e6967e@realtek.com +Signed-off-by: Takashi Iwai +Signed-off-by: Greg Kroah-Hartman +--- + sound/pci/hda/patch_realtek.c | 9 +++++++++ + 1 file changed, 9 insertions(+) + +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -1980,6 +1980,7 @@ enum { + ALC887_FIXUP_ASUS_AUDIO, + ALC887_FIXUP_ASUS_HMIC, + ALCS1200A_FIXUP_MIC_VREF, ++ ALC888VD_FIXUP_MIC_100VREF, + }; + + static void alc889_fixup_coef(struct hda_codec *codec, +@@ -2533,6 +2534,13 @@ static const struct hda_fixup alc882_fix + {} + } + }, ++ [ALC888VD_FIXUP_MIC_100VREF] = { ++ .type = HDA_FIXUP_PINCTLS, ++ .v.pins = (const struct hda_pintbl[]) { ++ { 0x18, PIN_VREF100 }, /* headset mic */ ++ {} ++ } ++ }, + }; + + static const struct snd_pci_quirk alc882_fixup_tbl[] = { +@@ -2602,6 +2610,7 @@ static const struct snd_pci_quirk alc882 + SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF), + + SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD), ++ SND_PCI_QUIRK(0x10ec, 0x12d8, "iBase Elo Touch", ALC888VD_FIXUP_MIC_100VREF), + SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD), + SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE), + SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), diff --git a/queue-5.15/dm-verity-align-struct-dm_verity_fec_io-properly.patch b/queue-5.15/dm-verity-align-struct-dm_verity_fec_io-properly.patch new file mode 100644 index 00000000000..55a95aac681 --- /dev/null +++ b/queue-5.15/dm-verity-align-struct-dm_verity_fec_io-properly.patch @@ -0,0 +1,52 @@ +From 38bc1ab135db87577695816b190e7d6d8ec75879 Mon Sep 17 00:00:00 2001 +From: Mikulas Patocka +Date: Tue, 28 Nov 2023 14:50:23 +0100 +Subject: dm-verity: align struct dm_verity_fec_io properly + +From: Mikulas Patocka + +commit 38bc1ab135db87577695816b190e7d6d8ec75879 upstream. + +dm_verity_fec_io is placed after the end of two hash digests. If the hash +digest has unaligned length, struct dm_verity_fec_io could be unaligned. + +This commit fixes the placement of struct dm_verity_fec_io, so that it's +aligned. + +Signed-off-by: Mikulas Patocka +Cc: stable@vger.kernel.org +Fixes: a739ff3f543a ("dm verity: add support for forward error correction") +Signed-off-by: Mike Snitzer +Signed-off-by: Greg Kroah-Hartman +--- + drivers/md/dm-verity-fec.c | 3 ++- + drivers/md/dm-verity.h | 6 ------ + 2 files changed, 2 insertions(+), 7 deletions(-) + +--- a/drivers/md/dm-verity-fec.c ++++ b/drivers/md/dm-verity-fec.c +@@ -24,7 +24,8 @@ bool verity_fec_is_enabled(struct dm_ver + */ + static inline struct dm_verity_fec_io *fec_io(struct dm_verity_io *io) + { +- return (struct dm_verity_fec_io *) verity_io_digest_end(io->v, io); ++ return (struct dm_verity_fec_io *) ++ ((char *)io + io->v->ti->per_io_data_size - sizeof(struct dm_verity_fec_io)); + } + + /* +--- a/drivers/md/dm-verity.h ++++ b/drivers/md/dm-verity.h +@@ -111,12 +111,6 @@ static inline u8 *verity_io_want_digest( + return (u8 *)(io + 1) + v->ahash_reqsize + v->digest_size; + } + +-static inline u8 *verity_io_digest_end(struct dm_verity *v, +- struct dm_verity_io *io) +-{ +- return verity_io_want_digest(v, io) + v->digest_size; +-} +- + extern int verity_for_bv_block(struct dm_verity *v, struct dm_verity_io *io, + struct bvec_iter *iter, + int (*process)(struct dm_verity *v, diff --git a/queue-5.15/firewire-core-fix-possible-memory-leak-in-create_units.patch b/queue-5.15/firewire-core-fix-possible-memory-leak-in-create_units.patch new file mode 100644 index 00000000000..f5471b42d99 --- /dev/null +++ b/queue-5.15/firewire-core-fix-possible-memory-leak-in-create_units.patch @@ -0,0 +1,60 @@ +From 891e0eab32a57fca4d36c5162628eb0bcb1f0edf Mon Sep 17 00:00:00 2001 +From: Yang Yingliang +Date: Wed, 29 Nov 2023 17:34:08 +0800 +Subject: firewire: core: fix possible memory leak in create_units() + +From: Yang Yingliang + +commit 891e0eab32a57fca4d36c5162628eb0bcb1f0edf upstream. + +If device_register() fails, the refcount of device is not 0, the name +allocated in dev_set_name() is leaked. To fix this by calling put_device(), +so that it will be freed in callback function kobject_cleanup(). + +unreferenced object 0xffff9d99035c7a90 (size 8): + comm "systemd-udevd", pid 168, jiffies 4294672386 (age 152.089s) + hex dump (first 8 bytes): + 66 77 30 2e 30 00 ff ff fw0.0... + backtrace: + [<00000000e1d62bac>] __kmem_cache_alloc_node+0x1e9/0x360 + [<00000000bbeaff31>] __kmalloc_node_track_caller+0x44/0x1a0 + [<00000000491f2fb4>] kvasprintf+0x67/0xd0 + [<000000005b960ddc>] kobject_set_name_vargs+0x1e/0x90 + [<00000000427ac591>] dev_set_name+0x4e/0x70 + [<000000003b4e447d>] create_units+0xc5/0x110 + +fw_unit_release() will be called in the error path, move fw_device_get() +before calling device_register() to keep balanced with fw_device_put() in +fw_unit_release(). + +Cc: stable@vger.kernel.org +Fixes: 1fa5ae857bb1 ("driver core: get rid of struct device's bus_id string array") +Fixes: a1f64819fe9f ("firewire: struct device - replace bus_id with dev_name(), dev_set_name()") +Signed-off-by: Yang Yingliang +Signed-off-by: Takashi Sakamoto +Signed-off-by: Greg Kroah-Hartman +--- + drivers/firewire/core-device.c | 11 ++++------- + 1 file changed, 4 insertions(+), 7 deletions(-) + +--- a/drivers/firewire/core-device.c ++++ b/drivers/firewire/core-device.c +@@ -719,14 +719,11 @@ static void create_units(struct fw_devic + fw_unit_attributes, + &unit->attribute_group); + +- if (device_register(&unit->device) < 0) +- goto skip_unit; +- + fw_device_get(device); +- continue; +- +- skip_unit: +- kfree(unit); ++ if (device_register(&unit->device) < 0) { ++ put_device(&unit->device); ++ continue; ++ } + } + } + diff --git a/queue-5.15/mmc-block-be-sure-to-wait-while-busy-in-cqe-error-recovery.patch b/queue-5.15/mmc-block-be-sure-to-wait-while-busy-in-cqe-error-recovery.patch new file mode 100644 index 00000000000..52933aeb0d2 --- /dev/null +++ b/queue-5.15/mmc-block-be-sure-to-wait-while-busy-in-cqe-error-recovery.patch @@ -0,0 +1,36 @@ +From c616696a902987352426fdaeec1b0b3240949e6b Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Fri, 3 Nov 2023 10:47:17 +0200 +Subject: mmc: block: Be sure to wait while busy in CQE error recovery + +From: Adrian Hunter + +commit c616696a902987352426fdaeec1b0b3240949e6b upstream. + +STOP command does not guarantee to wait while busy, but subsequent command +MMC_CMDQ_TASK_MGMT to discard the queue will fail if the card is busy, so +be sure to wait by employing mmc_poll_for_busy(). + +Fixes: 72a5af554df8 ("mmc: core: Add support for handling CQE requests") +Cc: stable@vger.kernel.org +Signed-off-by: Adrian Hunter +Reviewed-by: Avri Altman +Reviewed-by: Christian Loehle +Link: https://lore.kernel.org/r/20231103084720.6886-4-adrian.hunter@intel.com +Signed-off-by: Ulf Hansson +Signed-off-by: Greg Kroah-Hartman +--- + drivers/mmc/core/core.c | 2 ++ + 1 file changed, 2 insertions(+) + +--- a/drivers/mmc/core/core.c ++++ b/drivers/mmc/core/core.c +@@ -554,6 +554,8 @@ int mmc_cqe_recovery(struct mmc_host *ho + cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT; + mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); + ++ mmc_poll_for_busy(host->card, MMC_CQE_RECOVERY_TIMEOUT, true, MMC_BUSY_IO); ++ + memset(&cmd, 0, sizeof(cmd)); + cmd.opcode = MMC_CMDQ_TASK_MGMT; + cmd.arg = 1; /* Discard entire queue */ diff --git a/queue-5.15/mmc-block-do-not-lose-cache-flush-during-cqe-error-recovery.patch b/queue-5.15/mmc-block-do-not-lose-cache-flush-during-cqe-error-recovery.patch new file mode 100644 index 00000000000..114f9e72329 --- /dev/null +++ b/queue-5.15/mmc-block-do-not-lose-cache-flush-during-cqe-error-recovery.patch @@ -0,0 +1,38 @@ +From 174925d340aac55296318e43fd96c0e1d196e105 Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Fri, 3 Nov 2023 10:47:15 +0200 +Subject: mmc: block: Do not lose cache flush during CQE error recovery + +From: Adrian Hunter + +commit 174925d340aac55296318e43fd96c0e1d196e105 upstream. + +During CQE error recovery, error-free data commands get requeued if there +is any data left to transfer, but non-data commands are completed even +though they have not been processed. Requeue them instead. + +Note the only non-data command is cache flush, which would have resulted in +a cache flush being lost if it was queued at the time of CQE recovery. + +Fixes: 1e8e55b67030 ("mmc: block: Add CQE support") +Cc: stable@vger.kernel.org +Signed-off-by: Adrian Hunter +Reviewed-by: Avri Altman +Link: https://lore.kernel.org/r/20231103084720.6886-2-adrian.hunter@intel.com +Signed-off-by: Ulf Hansson +Signed-off-by: Greg Kroah-Hartman +--- + drivers/mmc/core/block.c | 2 ++ + 1 file changed, 2 insertions(+) + +--- a/drivers/mmc/core/block.c ++++ b/drivers/mmc/core/block.c +@@ -1465,6 +1465,8 @@ static void mmc_blk_cqe_complete_rq(stru + blk_mq_requeue_request(req, true); + else + __blk_mq_end_request(req, BLK_STS_OK); ++ } else if (mq->in_recovery) { ++ blk_mq_requeue_request(req, true); + } else { + blk_mq_end_request(req, BLK_STS_OK); + } diff --git a/queue-5.15/mmc-block-retry-commands-in-cqe-error-recovery.patch b/queue-5.15/mmc-block-retry-commands-in-cqe-error-recovery.patch new file mode 100644 index 00000000000..e8dc37c88b4 --- /dev/null +++ b/queue-5.15/mmc-block-retry-commands-in-cqe-error-recovery.patch @@ -0,0 +1,50 @@ +From 8155d1fa3a747baad5caff5f8303321d68ddd48c Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Fri, 3 Nov 2023 10:47:18 +0200 +Subject: mmc: block: Retry commands in CQE error recovery + +From: Adrian Hunter + +commit 8155d1fa3a747baad5caff5f8303321d68ddd48c upstream. + +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: Greg Kroah-Hartman +--- + drivers/mmc/core/core.c | 7 +++++-- + 1 file changed, 5 insertions(+), 2 deletions(-) + +--- a/drivers/mmc/core/core.c ++++ b/drivers/mmc/core/core.c +@@ -552,7 +552,7 @@ int mmc_cqe_recovery(struct mmc_host *ho + 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; +@@ -560,10 +560,13 @@ int mmc_cqe_recovery(struct mmc_host *ho + 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; diff --git a/queue-5.15/mmc-cqhci-fix-task-clearing-in-cqe-error-recovery.patch b/queue-5.15/mmc-cqhci-fix-task-clearing-in-cqe-error-recovery.patch new file mode 100644 index 00000000000..83c05fdabde --- /dev/null +++ b/queue-5.15/mmc-cqhci-fix-task-clearing-in-cqe-error-recovery.patch @@ -0,0 +1,93 @@ +From 1de1b77982e1a1df9707cb11f9b1789e6b8919d4 Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +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 + +commit 1de1b77982e1a1df9707cb11f9b1789e6b8919d4 upstream. + +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: Greg Kroah-Hartman +--- + drivers/mmc/host/cqhci-core.c | 32 ++++++++++++++++---------------- + 1 file changed, 16 insertions(+), 16 deletions(-) + +--- a/drivers/mmc/host/cqhci-core.c ++++ b/drivers/mmc/host/cqhci-core.c +@@ -1068,28 +1068,28 @@ static void cqhci_recovery_finish(struct + + 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); + diff --git a/queue-5.15/mmc-cqhci-increase-recovery-halt-timeout.patch b/queue-5.15/mmc-cqhci-increase-recovery-halt-timeout.patch new file mode 100644 index 00000000000..32167a82e52 --- /dev/null +++ b/queue-5.15/mmc-cqhci-increase-recovery-halt-timeout.patch @@ -0,0 +1,40 @@ +From b578d5d18e929aa7c007a98cce32657145dde219 Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Fri, 3 Nov 2023 10:47:16 +0200 +Subject: mmc: cqhci: Increase recovery halt timeout + +From: Adrian Hunter + +commit b578d5d18e929aa7c007a98cce32657145dde219 upstream. + +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: Greg Kroah-Hartman +--- + drivers/mmc/host/cqhci-core.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +--- a/drivers/mmc/host/cqhci-core.c ++++ b/drivers/mmc/host/cqhci-core.c +@@ -977,10 +977,10 @@ static bool cqhci_halt(struct mmc_host * + /* + * 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) + { diff --git a/queue-5.15/mmc-cqhci-warn-of-halt-or-task-clear-failure.patch b/queue-5.15/mmc-cqhci-warn-of-halt-or-task-clear-failure.patch new file mode 100644 index 00000000000..6ebcb8783b2 --- /dev/null +++ b/queue-5.15/mmc-cqhci-warn-of-halt-or-task-clear-failure.patch @@ -0,0 +1,47 @@ +From 35597bdb04ec27ef3b1cea007dc69f8ff5df75a5 Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Fri, 3 Nov 2023 10:47:19 +0200 +Subject: mmc: cqhci: Warn of halt or task clear failure + +From: Adrian Hunter + +commit 35597bdb04ec27ef3b1cea007dc69f8ff5df75a5 upstream. + +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: Greg Kroah-Hartman +--- + drivers/mmc/host/cqhci-core.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +--- a/drivers/mmc/host/cqhci-core.c ++++ b/drivers/mmc/host/cqhci-core.c +@@ -935,8 +935,8 @@ static bool cqhci_clear_all_tasks(struct + 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; + } +@@ -969,7 +969,7 @@ static bool cqhci_halt(struct mmc_host * + 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; + } diff --git a/queue-5.15/mmc-sdhci-sprd-fix-vqmmc-not-shutting-down-after-the-card-was-pulled.patch b/queue-5.15/mmc-sdhci-sprd-fix-vqmmc-not-shutting-down-after-the-card-was-pulled.patch new file mode 100644 index 00000000000..3bf8540edbf --- /dev/null +++ b/queue-5.15/mmc-sdhci-sprd-fix-vqmmc-not-shutting-down-after-the-card-was-pulled.patch @@ -0,0 +1,88 @@ +From 477865af60b2117ceaa1d558e03559108c15c78c Mon Sep 17 00:00:00 2001 +From: Wenchao Chen +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 + +commit 477865af60b2117ceaa1d558e03559108c15c78c upstream. + +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: Greg Kroah-Hartman +--- + drivers/mmc/host/sdhci-sprd.c | 25 +++++++++++++++++++++++++ + 1 file changed, 25 insertions(+) + +--- a/drivers/mmc/host/sdhci-sprd.c ++++ b/drivers/mmc/host/sdhci-sprd.c +@@ -392,12 +392,33 @@ static void sdhci_sprd_request_done(stru + 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 platf + 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; diff --git a/queue-5.15/perf-inject-fix-gen_elf_text_offset-for-jit.patch b/queue-5.15/perf-inject-fix-gen_elf_text_offset-for-jit.patch new file mode 100644 index 00000000000..dcdafcb4f22 --- /dev/null +++ b/queue-5.15/perf-inject-fix-gen_elf_text_offset-for-jit.patch @@ -0,0 +1,48 @@ +From 89b15d00527b7825ff19130ed83478e80e3fae99 Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Fri, 14 Oct 2022 20:09:04 +0300 +Subject: perf inject: Fix GEN_ELF_TEXT_OFFSET for jit + +From: Adrian Hunter + +commit 89b15d00527b7825ff19130ed83478e80e3fae99 upstream. + +When a program header was added, it moved the text section but +GEN_ELF_TEXT_OFFSET was not updated. + +Fix by adding the program header size and aligning. + +Fixes: babd04386b1df8c3 ("perf jit: Include program header in ELF files") +Signed-off-by: Adrian Hunter +Tested-by: Arnaldo Carvalho de Melo +Cc: Ian Rogers +Cc: Jiri Olsa +Cc: Lieven Hey +Cc: Namhyung Kim +Link: https://lore.kernel.org/r/20221014170905.64069-7-adrian.hunter@intel.com +Signed-off-by: Arnaldo Carvalho de Melo +Cc: Namhyung Kim +Signed-off-by: Greg Kroah-Hartman +--- + tools/perf/util/genelf.h | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +--- a/tools/perf/util/genelf.h ++++ b/tools/perf/util/genelf.h +@@ -2,6 +2,8 @@ + #ifndef __GENELF_H__ + #define __GENELF_H__ + ++#include ++ + /* genelf.c */ + int jit_write_elf(int fd, uint64_t code_addr, const char *sym, + const void *code, int csize, void *debug, int nr_debug_entries, +@@ -73,6 +75,6 @@ int jit_add_debug_info(Elf *e, uint64_t + #endif + + /* The .text section is directly after the ELF header */ +-#define GEN_ELF_TEXT_OFFSET sizeof(Elf_Ehdr) ++#define GEN_ELF_TEXT_OFFSET round_up(sizeof(Elf_Ehdr) + sizeof(Elf_Phdr), 16) + + #endif diff --git a/queue-5.15/pinctrl-avoid-reload-of-p-state-in-list-iteration.patch b/queue-5.15/pinctrl-avoid-reload-of-p-state-in-list-iteration.patch new file mode 100644 index 00000000000..a2d218f6728 --- /dev/null +++ b/queue-5.15/pinctrl-avoid-reload-of-p-state-in-list-iteration.patch @@ -0,0 +1,54 @@ +From 4198a9b571065978632276264e01d71d68000ac5 Mon Sep 17 00:00:00 2001 +From: Maria Yu +Date: Wed, 15 Nov 2023 18:28:24 +0800 +Subject: pinctrl: avoid reload of p state in list iteration + +From: Maria Yu + +commit 4198a9b571065978632276264e01d71d68000ac5 upstream. + +When in the list_for_each_entry iteration, reload of p->state->settings +with a local setting from old_state will turn the list iteration into an +infinite loop. + +The typical symptom when the issue happens, will be a printk message like: + + "not freeing pin xx (xxx) as part of deactivating group xxx - it is +already used for some other setting". + +This is a compiler-dependent problem, one instance occurred using Clang +version 10.0 on the arm64 architecture with linux version 4.19. + +Fixes: 6e5e959dde0d ("pinctrl: API changes to support multiple states per device") +Signed-off-by: Maria Yu +Cc: +Link: https://lore.kernel.org/r/20231115102824.23727-1-quic_aiquny@quicinc.com +Signed-off-by: Linus Walleij +Signed-off-by: Greg Kroah-Hartman +--- + drivers/pinctrl/core.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +--- a/drivers/pinctrl/core.c ++++ b/drivers/pinctrl/core.c +@@ -1239,17 +1239,17 @@ static void pinctrl_link_add(struct pinc + static int pinctrl_commit_state(struct pinctrl *p, struct pinctrl_state *state) + { + struct pinctrl_setting *setting, *setting2; +- struct pinctrl_state *old_state = p->state; ++ struct pinctrl_state *old_state = READ_ONCE(p->state); + int ret; + +- if (p->state) { ++ if (old_state) { + /* + * For each pinmux setting in the old state, forget SW's record + * of mux owner for that pingroup. Any pingroups which are + * still owned by the new state will be re-acquired by the call + * to pinmux_enable_setting() in the loop below. + */ +- list_for_each_entry(setting, &p->state->settings, node) { ++ list_for_each_entry(setting, &old_state->settings, node) { + if (setting->type != PIN_MAP_TYPE_MUX_GROUP) + continue; + pinmux_disable_setting(setting); diff --git a/queue-5.15/series b/queue-5.15/series new file mode 100644 index 00000000000..80765ed3c2c --- /dev/null +++ b/queue-5.15/series @@ -0,0 +1,14 @@ +perf-inject-fix-gen_elf_text_offset-for-jit.patch +pinctrl-avoid-reload-of-p-state-in-list-iteration.patch +firewire-core-fix-possible-memory-leak-in-create_units.patch +mmc-sdhci-sprd-fix-vqmmc-not-shutting-down-after-the-card-was-pulled.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-block-retry-commands-in-cqe-error-recovery.patch +mmc-block-do-not-lose-cache-flush-during-cqe-error-recovery.patch +mmc-block-be-sure-to-wait-while-busy-in-cqe-error-recovery.patch +alsa-hda-disable-power-save-on-kontron-singlepc.patch +alsa-hda-realtek-headset-mic-vref-to-100.patch +alsa-hda-realtek-add-supported-alc257-for-chromeos.patch +dm-verity-align-struct-dm_verity_fec_io-properly.patch