From: Sasha Levin Date: Sun, 29 Oct 2023 22:49:28 +0000 (-0400) Subject: Fixes for 5.15 X-Git-Tag: v6.1.61~45 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=c20efb4caa6a08625e2fc6d00cdc890d28c9abe1;p=thirdparty%2Fkernel%2Fstable-queue.git Fixes for 5.15 Signed-off-by: Sasha Levin --- diff --git a/queue-5.15/acpica-add-support-for-madt-online-enabled-bit.patch b/queue-5.15/acpica-add-support-for-madt-online-enabled-bit.patch new file mode 100644 index 00000000000..8e64393b6e6 --- /dev/null +++ b/queue-5.15/acpica-add-support-for-madt-online-enabled-bit.patch @@ -0,0 +1,36 @@ +From 6bbfb39a4aeced79feedb2cefc8bc3a207df6126 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 8 Sep 2021 16:41:45 -0500 +Subject: ACPICA: Add support for MADT online enabled bit + +From: Mario Limonciello + +[ Upstream commit 435a8dc8d9b9d91e625901fea5b5695b9b976d84 ] + +The online enabled bit on newer ACPI implmentations will indicate +whether the CPU is hotpluggable. + +Link: http://github.com/acpica/acpica/pull/708/ +Signed-off-by: Mario Limonciello +Signed-off-by: Rafael J. Wysocki +Stable-dep-of: 128b0c9781c9 ("x86/i8259: Skip probing when ACPI/MADT advertises PCAT compatibility") +Signed-off-by: Sasha Levin +--- + include/acpi/actbl2.h | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/include/acpi/actbl2.h b/include/acpi/actbl2.h +index a47b32a5cbdeb..074449cb11a17 100644 +--- a/include/acpi/actbl2.h ++++ b/include/acpi/actbl2.h +@@ -978,6 +978,7 @@ struct acpi_madt_multiproc_wakeup_mailbox { + /* MADT Local APIC flags */ + + #define ACPI_MADT_ENABLED (1) /* 00: Processor is usable if set */ ++#define ACPI_MADT_ONLINE_CAPABLE (2) /* 01: System HW supports enabling processor at runtime */ + + /* MADT MPS INTI flags (inti_flags) */ + +-- +2.42.0 + diff --git a/queue-5.15/iio-afe-rescale-accept-only-offset-channels.patch b/queue-5.15/iio-afe-rescale-accept-only-offset-channels.patch new file mode 100644 index 00000000000..2f0c1669ceb --- /dev/null +++ b/queue-5.15/iio-afe-rescale-accept-only-offset-channels.patch @@ -0,0 +1,74 @@ +From 9017f1c97947dfb8054891f3acdda2dc84964813 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 2 Sep 2023 21:46:20 +0200 +Subject: iio: afe: rescale: Accept only offset channels + +From: Linus Walleij + +[ Upstream commit bee448390e5166d019e9e037194d487ee94399d9 ] + +As noted by Jonathan Cameron: it is perfectly legal for a channel +to have an offset but no scale in addition to the raw interface. +The conversion will imply that scale is 1:1. + +Make rescale_configure_channel() accept just scale, or just offset +to process a channel. + +When a user asks for IIO_CHAN_INFO_OFFSET in rescale_read_raw() +we now have to deal with the fact that OFFSET could be present +but SCALE missing. Add code to simply scale 1:1 in this case. + +Link: https://lore.kernel.org/linux-iio/CACRpkdZXBjHU4t-GVOCFxRO-AHGxKnxMeHD2s4Y4PuC29gBq6g@mail.gmail.com/ +Fixes: 53ebee949980 ("iio: afe: iio-rescale: Support processed channels") +Fixes: 9decacd8b3a4 ("iio: afe: rescale: Fix boolean logic bug") +Reported-by: Jonathan Cameron +Signed-off-by: Linus Walleij +Reviewed-by: Peter Rosin +Link: https://lore.kernel.org/r/20230902-iio-rescale-only-offset-v2-1-988b807754c8@linaro.org +Cc: +Signed-off-by: Jonathan Cameron +Signed-off-by: Sasha Levin +--- + drivers/iio/afe/iio-rescale.c | 19 +++++++++++++++---- + 1 file changed, 15 insertions(+), 4 deletions(-) + +diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c +index 84f21dc94a2f7..ea0a39882eb25 100644 +--- a/drivers/iio/afe/iio-rescale.c ++++ b/drivers/iio/afe/iio-rescale.c +@@ -152,8 +152,18 @@ static int rescale_read_raw(struct iio_dev *indio_dev, + return ret < 0 ? ret : -EOPNOTSUPP; + } + +- ret = iio_read_channel_scale(rescale->source, &scale, &scale2); +- return rescale_process_offset(rescale, ret, scale, scale2, ++ if (iio_channel_has_info(rescale->source->channel, ++ IIO_CHAN_INFO_SCALE)) { ++ ret = iio_read_channel_scale(rescale->source, &scale, &scale2); ++ return rescale_process_offset(rescale, ret, scale, scale2, ++ schan_off, val, val2); ++ } ++ ++ /* ++ * If we get here we have no scale so scale 1:1 but apply ++ * rescaler and offset, if any. ++ */ ++ return rescale_process_offset(rescale, IIO_VAL_FRACTIONAL, 1, 1, + schan_off, val, val2); + default: + return -EINVAL; +@@ -218,8 +228,9 @@ static int rescale_configure_channel(struct device *dev, + chan->type = rescale->cfg->type; + + if (iio_channel_has_info(schan, IIO_CHAN_INFO_RAW) && +- iio_channel_has_info(schan, IIO_CHAN_INFO_SCALE)) { +- dev_info(dev, "using raw+scale source channel\n"); ++ (iio_channel_has_info(schan, IIO_CHAN_INFO_SCALE) || ++ iio_channel_has_info(schan, IIO_CHAN_INFO_OFFSET))) { ++ dev_info(dev, "using raw+scale/offset source channel\n"); + } else if (iio_channel_has_info(schan, IIO_CHAN_INFO_PROCESSED)) { + dev_info(dev, "using processed channel\n"); + rescale->chan_processed = true; +-- +2.42.0 + diff --git a/queue-5.15/iio-afe-rescale-add-offset-support.patch b/queue-5.15/iio-afe-rescale-add-offset-support.patch new file mode 100644 index 00000000000..8a365d18315 --- /dev/null +++ b/queue-5.15/iio-afe-rescale-add-offset-support.patch @@ -0,0 +1,169 @@ +From 6d6740c90c77d6aaff27745ab1060378fc23dfc6 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 12 Feb 2022 21:57:32 -0500 +Subject: iio: afe: rescale: add offset support + +From: Liam Beguin + +[ Upstream commit a29c3283653b80b916c5ca5292c5d36415e38e92 ] + +This is a preparatory change required for the addition of temperature +sensing front ends. + +Signed-off-by: Liam Beguin +Reviewed-by: Peter Rosin +Reviewed-by: Andy Shevchenko +Link: https://lore.kernel.org/r/20220213025739.2561834-4-liambeguin@gmail.com +Signed-off-by: Jonathan Cameron +Stable-dep-of: bee448390e51 ("iio: afe: rescale: Accept only offset channels") +Signed-off-by: Sasha Levin +--- + drivers/iio/afe/iio-rescale.c | 81 +++++++++++++++++++++++++++++++++ + include/linux/iio/afe/rescale.h | 4 ++ + 2 files changed, 85 insertions(+) + +diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c +index 6cc453ab9c685..84f21dc94a2f7 100644 +--- a/drivers/iio/afe/iio-rescale.c ++++ b/drivers/iio/afe/iio-rescale.c +@@ -3,6 +3,7 @@ + * IIO rescale driver + * + * Copyright (C) 2018 Axentia Technologies AB ++ * Copyright (C) 2022 Liam Beguin + * + * Author: Peter Rosin + */ +@@ -47,11 +48,46 @@ int rescale_process_scale(struct rescale *rescale, int scale_type, + } + } + ++int rescale_process_offset(struct rescale *rescale, int scale_type, ++ int scale, int scale2, int schan_off, ++ int *val, int *val2) ++{ ++ s64 tmp, tmp2; ++ ++ switch (scale_type) { ++ case IIO_VAL_FRACTIONAL: ++ tmp = (s64)rescale->offset * scale2; ++ *val = div_s64(tmp, scale) + schan_off; ++ return IIO_VAL_INT; ++ case IIO_VAL_INT: ++ *val = div_s64(rescale->offset, scale) + schan_off; ++ return IIO_VAL_INT; ++ case IIO_VAL_FRACTIONAL_LOG2: ++ tmp = (s64)rescale->offset * (1 << scale2); ++ *val = div_s64(tmp, scale) + schan_off; ++ return IIO_VAL_INT; ++ case IIO_VAL_INT_PLUS_NANO: ++ tmp = (s64)rescale->offset * 1000000000LL; ++ tmp2 = ((s64)scale * 1000000000LL) + scale2; ++ *val = div64_s64(tmp, tmp2) + schan_off; ++ return IIO_VAL_INT; ++ case IIO_VAL_INT_PLUS_MICRO: ++ tmp = (s64)rescale->offset * 1000000LL; ++ tmp2 = ((s64)scale * 1000000LL) + scale2; ++ *val = div64_s64(tmp, tmp2) + schan_off; ++ return IIO_VAL_INT; ++ default: ++ return -EOPNOTSUPP; ++ } ++} ++ + static int rescale_read_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int *val, int *val2, long mask) + { + struct rescale *rescale = iio_priv(indio_dev); ++ int scale, scale2; ++ int schan_off = 0; + int ret; + + switch (mask) { +@@ -78,6 +114,47 @@ static int rescale_read_raw(struct iio_dev *indio_dev, + ret = iio_read_channel_scale(rescale->source, val, val2); + } + return rescale_process_scale(rescale, ret, val, val2); ++ case IIO_CHAN_INFO_OFFSET: ++ /* ++ * Processed channels are scaled 1-to-1 and source offset is ++ * already taken into account. ++ * ++ * In other cases, real world measurement are expressed as: ++ * ++ * schan_scale * (raw + schan_offset) ++ * ++ * Given that the rescaler parameters are applied recursively: ++ * ++ * rescaler_scale * (schan_scale * (raw + schan_offset) + ++ * rescaler_offset) ++ * ++ * Or, ++ * ++ * (rescaler_scale * schan_scale) * (raw + ++ * (schan_offset + rescaler_offset / schan_scale) ++ * ++ * Thus, reusing the original expression the parameters exposed ++ * to userspace are: ++ * ++ * scale = schan_scale * rescaler_scale ++ * offset = schan_offset + rescaler_offset / schan_scale ++ */ ++ if (rescale->chan_processed) { ++ *val = rescale->offset; ++ return IIO_VAL_INT; ++ } ++ ++ if (iio_channel_has_info(rescale->source->channel, ++ IIO_CHAN_INFO_OFFSET)) { ++ ret = iio_read_channel_offset(rescale->source, ++ &schan_off, NULL); ++ if (ret != IIO_VAL_INT) ++ return ret < 0 ? ret : -EOPNOTSUPP; ++ } ++ ++ ret = iio_read_channel_scale(rescale->source, &scale, &scale2); ++ return rescale_process_offset(rescale, ret, scale, scale2, ++ schan_off, val, val2); + default: + return -EINVAL; + } +@@ -154,6 +231,9 @@ static int rescale_configure_channel(struct device *dev, + chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | + BIT(IIO_CHAN_INFO_SCALE); + ++ if (rescale->offset) ++ chan->info_mask_separate |= BIT(IIO_CHAN_INFO_OFFSET); ++ + /* + * Using .read_avail() is fringe to begin with and makes no sense + * whatsoever for processed channels, so we make sure that this cannot +@@ -318,6 +398,7 @@ static int rescale_probe(struct platform_device *pdev) + rescale->cfg = of_device_get_match_data(dev); + rescale->numerator = 1; + rescale->denominator = 1; ++ rescale->offset = 0; + + ret = rescale->cfg->props(dev, rescale); + if (ret) +diff --git a/include/linux/iio/afe/rescale.h b/include/linux/iio/afe/rescale.h +index 8a2eb34af3271..6eecb435488f1 100644 +--- a/include/linux/iio/afe/rescale.h ++++ b/include/linux/iio/afe/rescale.h +@@ -25,8 +25,12 @@ struct rescale { + bool chan_processed; + s32 numerator; + s32 denominator; ++ s32 offset; + }; + + int rescale_process_scale(struct rescale *rescale, int scale_type, + int *val, int *val2); ++int rescale_process_offset(struct rescale *rescale, int scale_type, ++ int scale, int scale2, int schan_off, ++ int *val, int *val2); + #endif /* __IIO_RESCALE_H__ */ +-- +2.42.0 + diff --git a/queue-5.15/iio-afe-rescale-expose-scale-processing-function.patch b/queue-5.15/iio-afe-rescale-expose-scale-processing-function.patch new file mode 100644 index 00000000000..87b71743b0c --- /dev/null +++ b/queue-5.15/iio-afe-rescale-expose-scale-processing-function.patch @@ -0,0 +1,159 @@ +From 49297ba6a1b82ab14c6e0e0df935ab947941e7f0 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 12 Feb 2022 21:57:30 -0500 +Subject: iio: afe: rescale: expose scale processing function + +From: Liam Beguin + +[ Upstream commit bc437f7515f5e14aec9f2801412d9ea48116a97d ] + +In preparation for the addition of kunit tests, expose the logic +responsible for combining channel scales. + +Signed-off-by: Liam Beguin +Reviewed-by: Peter Rosin +Reviewed-by: Andy Shevchenko +Link: https://lore.kernel.org/r/20220213025739.2561834-2-liambeguin@gmail.com +Signed-off-by: Jonathan Cameron +Stable-dep-of: bee448390e51 ("iio: afe: rescale: Accept only offset channels") +Signed-off-by: Sasha Levin +--- + drivers/iio/afe/iio-rescale.c | 65 ++++++++++++++------------------- + include/linux/iio/afe/rescale.h | 32 ++++++++++++++++ + 2 files changed, 60 insertions(+), 37 deletions(-) + create mode 100644 include/linux/iio/afe/rescale.h + +diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c +index b0934f85a4a04..6cc453ab9c685 100644 +--- a/drivers/iio/afe/iio-rescale.c ++++ b/drivers/iio/afe/iio-rescale.c +@@ -15,32 +15,43 @@ + #include + #include + ++#include + #include + #include + +-struct rescale; +- +-struct rescale_cfg { +- enum iio_chan_type type; +- int (*props)(struct device *dev, struct rescale *rescale); +-}; ++int rescale_process_scale(struct rescale *rescale, int scale_type, ++ int *val, int *val2) ++{ ++ s64 tmp; + +-struct rescale { +- const struct rescale_cfg *cfg; +- struct iio_channel *source; +- struct iio_chan_spec chan; +- struct iio_chan_spec_ext_info *ext_info; +- bool chan_processed; +- s32 numerator; +- s32 denominator; +-}; ++ switch (scale_type) { ++ case IIO_VAL_FRACTIONAL: ++ *val *= rescale->numerator; ++ *val2 *= rescale->denominator; ++ return scale_type; ++ case IIO_VAL_INT: ++ *val *= rescale->numerator; ++ if (rescale->denominator == 1) ++ return scale_type; ++ *val2 = rescale->denominator; ++ return IIO_VAL_FRACTIONAL; ++ case IIO_VAL_FRACTIONAL_LOG2: ++ tmp = (s64)*val * 1000000000LL; ++ tmp = div_s64(tmp, rescale->denominator); ++ tmp *= rescale->numerator; ++ tmp = div_s64(tmp, 1000000000LL); ++ *val = tmp; ++ return scale_type; ++ default: ++ return -EOPNOTSUPP; ++ } ++} + + static int rescale_read_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int *val, int *val2, long mask) + { + struct rescale *rescale = iio_priv(indio_dev); +- s64 tmp; + int ret; + + switch (mask) { +@@ -66,27 +77,7 @@ static int rescale_read_raw(struct iio_dev *indio_dev, + } else { + ret = iio_read_channel_scale(rescale->source, val, val2); + } +- switch (ret) { +- case IIO_VAL_FRACTIONAL: +- *val *= rescale->numerator; +- *val2 *= rescale->denominator; +- return ret; +- case IIO_VAL_INT: +- *val *= rescale->numerator; +- if (rescale->denominator == 1) +- return ret; +- *val2 = rescale->denominator; +- return IIO_VAL_FRACTIONAL; +- case IIO_VAL_FRACTIONAL_LOG2: +- tmp = (s64)*val * 1000000000LL; +- tmp = div_s64(tmp, rescale->denominator); +- tmp *= rescale->numerator; +- tmp = div_s64(tmp, 1000000000LL); +- *val = tmp; +- return ret; +- default: +- return -EOPNOTSUPP; +- } ++ return rescale_process_scale(rescale, ret, val, val2); + default: + return -EINVAL; + } +diff --git a/include/linux/iio/afe/rescale.h b/include/linux/iio/afe/rescale.h +new file mode 100644 +index 0000000000000..8a2eb34af3271 +--- /dev/null ++++ b/include/linux/iio/afe/rescale.h +@@ -0,0 +1,32 @@ ++/* SPDX-License-Identifier: GPL-2.0-only */ ++/* ++ * Copyright (C) 2018 Axentia Technologies AB ++ */ ++ ++#ifndef __IIO_RESCALE_H__ ++#define __IIO_RESCALE_H__ ++ ++#include ++#include ++ ++struct device; ++struct rescale; ++ ++struct rescale_cfg { ++ enum iio_chan_type type; ++ int (*props)(struct device *dev, struct rescale *rescale); ++}; ++ ++struct rescale { ++ const struct rescale_cfg *cfg; ++ struct iio_channel *source; ++ struct iio_chan_spec chan; ++ struct iio_chan_spec_ext_info *ext_info; ++ bool chan_processed; ++ s32 numerator; ++ s32 denominator; ++}; ++ ++int rescale_process_scale(struct rescale *rescale, int scale_type, ++ int *val, int *val2); ++#endif /* __IIO_RESCALE_H__ */ +-- +2.42.0 + diff --git a/queue-5.15/iio-afe-rescale-reorder-includes.patch b/queue-5.15/iio-afe-rescale-reorder-includes.patch new file mode 100644 index 00000000000..7c933955644 --- /dev/null +++ b/queue-5.15/iio-afe-rescale-reorder-includes.patch @@ -0,0 +1,48 @@ +From b297eb959e92d9585ed80f1f866842573a2e5c5d Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 8 Jan 2022 15:53:08 -0500 +Subject: iio: afe: rescale: reorder includes + +From: Liam Beguin + +[ Upstream commit cd717ac6f69db4953ca701c6220c7cb58e17f35a ] + +Includes should be ordered alphabetically which is already the case, +but follow what is done in other drivers by separation IIO specific +headers with a blank line. + +Signed-off-by: Liam Beguin +Reviewed-by: Andy Shevchenko +Link: https://lore.kernel.org/r/20220108205319.2046348-6-liambeguin@gmail.com +Signed-off-by: Jonathan Cameron +Stable-dep-of: bee448390e51 ("iio: afe: rescale: Accept only offset channels") +Signed-off-by: Sasha Levin +--- + drivers/iio/afe/iio-rescale.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c +index cc28713b0dc8b..b0934f85a4a04 100644 +--- a/drivers/iio/afe/iio-rescale.c ++++ b/drivers/iio/afe/iio-rescale.c +@@ -9,14 +9,15 @@ + + #include + #include +-#include +-#include + #include + #include + #include + #include + #include + ++#include ++#include ++ + struct rescale; + + struct rescale_cfg { +-- +2.42.0 + diff --git a/queue-5.15/series b/queue-5.15/series index 718a48065bd..b50ca601256 100644 --- a/queue-5.15/series +++ b/queue-5.15/series @@ -69,3 +69,11 @@ nvmem-imx-correct-nregs-for-i.mx6ul.patch perf-core-fix-potential-null-deref.patch sparc32-fix-a-braino-in-fault-handling-in-csum_and_copy_..._user.patch clk-sanitize-possible_parent_show-to-handle-return-value-of-of_clk_get_parent_name.patch +iio-afe-rescale-reorder-includes.patch +iio-afe-rescale-expose-scale-processing-function.patch +iio-afe-rescale-add-offset-support.patch +iio-afe-rescale-accept-only-offset-channels.patch +acpica-add-support-for-madt-online-enabled-bit.patch +x86-acpi-don-t-add-cpus-that-are-not-online-capable.patch +x86-acpi-boot-use-fadt-version-to-check-support-for-.patch +x86-i8259-skip-probing-when-acpi-madt-advertises-pca.patch diff --git a/queue-5.15/x86-acpi-boot-use-fadt-version-to-check-support-for-.patch b/queue-5.15/x86-acpi-boot-use-fadt-version-to-check-support-for-.patch new file mode 100644 index 00000000000..2ce9a42109e --- /dev/null +++ b/queue-5.15/x86-acpi-boot-use-fadt-version-to-check-support-for-.patch @@ -0,0 +1,55 @@ +From 34ade583680b1ffe8f88f0edbb890f58e733a0dd Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 29 Mar 2023 12:45:35 -0500 +Subject: x86/ACPI/boot: Use FADT version to check support for online capable + +From: Mario Limonciello + +[ Upstream commit a74fabfbd1b7013045afc8cc541e6cab3360ccb5 ] + +ACPI 6.3 introduced the online capable bit, and also introduced MADT +version 5. + +Latter was used to distinguish whether the offset storing online capable +could be used. However ACPI 6.2b has MADT version "45" which is for +an errata version of the ACPI 6.2 spec. This means that the Linux code +for detecting availability of MADT will mistakenly flag ACPI 6.2b as +supporting online capable which is inaccurate as it's an ACPI 6.3 feature. + +Instead use the FADT major and minor revision fields to distinguish this. + + [ bp: Massage. ] + +Fixes: aa06e20f1be6 ("x86/ACPI: Don't add CPUs that are not online capable") +Reported-by: Eric DeVolder +Reported-by: Borislav Petkov +Signed-off-by: Mario Limonciello +Signed-off-by: Borislav Petkov (AMD) +Cc: +Link: https://lore.kernel.org/r/943d2445-84df-d939-f578-5d8240d342cc@unsolicited.net +Stable-dep-of: 128b0c9781c9 ("x86/i8259: Skip probing when ACPI/MADT advertises PCAT compatibility") +Signed-off-by: Sasha Levin +--- + arch/x86/kernel/acpi/boot.c | 6 +++++- + 1 file changed, 5 insertions(+), 1 deletion(-) + +diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c +index 0d01e7f5078c2..6d716b9c0ec19 100644 +--- a/arch/x86/kernel/acpi/boot.c ++++ b/arch/x86/kernel/acpi/boot.c +@@ -139,7 +139,11 @@ static int __init acpi_parse_madt(struct acpi_table_header *table) + + pr_debug("Local APIC address 0x%08x\n", madt->address); + } +- if (madt->header.revision >= 5) ++ ++ /* ACPI 6.3 and newer support the online capable bit. */ ++ if (acpi_gbl_FADT.header.revision > 6 || ++ (acpi_gbl_FADT.header.revision == 6 && ++ acpi_gbl_FADT.minor_revision >= 3)) + acpi_support_online_capable = true; + + default_acpi_madt_oem_check(madt->header.oem_id, +-- +2.42.0 + diff --git a/queue-5.15/x86-acpi-don-t-add-cpus-that-are-not-online-capable.patch b/queue-5.15/x86-acpi-don-t-add-cpus-that-are-not-online-capable.patch new file mode 100644 index 00000000000..754d2233875 --- /dev/null +++ b/queue-5.15/x86-acpi-don-t-add-cpus-that-are-not-online-capable.patch @@ -0,0 +1,64 @@ +From 93c81745f8a495babd9b08f8be0cd36dab9cdf7a Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 8 Sep 2021 16:41:46 -0500 +Subject: x86/ACPI: Don't add CPUs that are not online capable + +From: Mario Limonciello + +[ Upstream commit aa06e20f1be628186f0c2dcec09ea0009eb69778 ] + +A number of systems are showing "hotplug capable" CPUs when they +are not really hotpluggable. This is because the MADT has extra +CPU entries to support different CPUs that may be inserted into +the socket with different numbers of cores. + +Starting with ACPI 6.3 the spec has an Online Capable bit in the +MADT used to determine whether or not a CPU is hotplug capable +when the enabled bit is not set. + +Link: https://uefi.org/htmlspecs/ACPI_Spec_6_4_html/05_ACPI_Software_Programming_Model/ACPI_Software_Programming_Model.html?#local-apic-flags +Signed-off-by: Mario Limonciello +Signed-off-by: Rafael J. Wysocki +Stable-dep-of: 128b0c9781c9 ("x86/i8259: Skip probing when ACPI/MADT advertises PCAT compatibility") +Signed-off-by: Sasha Levin +--- + arch/x86/kernel/acpi/boot.c | 9 +++++++++ + 1 file changed, 9 insertions(+) + +diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c +index 94ac7402c1ac2..0d01e7f5078c2 100644 +--- a/arch/x86/kernel/acpi/boot.c ++++ b/arch/x86/kernel/acpi/boot.c +@@ -62,6 +62,7 @@ int acpi_fix_pin2_polarity __initdata; + + #ifdef CONFIG_X86_LOCAL_APIC + static u64 acpi_lapic_addr __initdata = APIC_DEFAULT_PHYS_BASE; ++static bool acpi_support_online_capable; + #endif + + #ifdef CONFIG_X86_IO_APIC +@@ -138,6 +139,8 @@ static int __init acpi_parse_madt(struct acpi_table_header *table) + + pr_debug("Local APIC address 0x%08x\n", madt->address); + } ++ if (madt->header.revision >= 5) ++ acpi_support_online_capable = true; + + default_acpi_madt_oem_check(madt->header.oem_id, + madt->header.oem_table_id); +@@ -239,6 +242,12 @@ acpi_parse_lapic(union acpi_subtable_headers * header, const unsigned long end) + if (processor->id == 0xff) + return 0; + ++ /* don't register processors that can not be onlined */ ++ if (acpi_support_online_capable && ++ !(processor->lapic_flags & ACPI_MADT_ENABLED) && ++ !(processor->lapic_flags & ACPI_MADT_ONLINE_CAPABLE)) ++ return 0; ++ + /* + * We need to register disabled CPU as well to permit + * counting disabled CPUs. This allows us to size +-- +2.42.0 + diff --git a/queue-5.15/x86-i8259-skip-probing-when-acpi-madt-advertises-pca.patch b/queue-5.15/x86-i8259-skip-probing-when-acpi-madt-advertises-pca.patch new file mode 100644 index 00000000000..9fdc9f246d8 --- /dev/null +++ b/queue-5.15/x86-i8259-skip-probing-when-acpi-madt-advertises-pca.patch @@ -0,0 +1,151 @@ +From e0fe8d54195b3d88a7c1acbe953035cc56ad4143 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 25 Oct 2023 23:04:15 +0200 +Subject: x86/i8259: Skip probing when ACPI/MADT advertises PCAT compatibility + +From: Thomas Gleixner + +[ Upstream commit 128b0c9781c9f2651bea163cb85e52a6c7be0f9e ] + +David and a few others reported that on certain newer systems some legacy +interrupts fail to work correctly. + +Debugging revealed that the BIOS of these systems leaves the legacy PIC in +uninitialized state which makes the PIC detection fail and the kernel +switches to a dummy implementation. + +Unfortunately this fallback causes quite some code to fail as it depends on +checks for the number of legacy PIC interrupts or the availability of the +real PIC. + +In theory there is no reason to use the PIC on any modern system when +IO/APIC is available, but the dependencies on the related checks cannot be +resolved trivially and on short notice. This needs lots of analysis and +rework. + +The PIC detection has been added to avoid quirky checks and force selection +of the dummy implementation all over the place, especially in VM guest +scenarios. So it's not an option to revert the relevant commit as that +would break a lot of other scenarios. + +One solution would be to try to initialize the PIC on detection fail and +retry the detection, but that puts the burden on everything which does not +have a PIC. + +Fortunately the ACPI/MADT table header has a flag field, which advertises +in bit 0 that the system is PCAT compatible, which means it has a legacy +8259 PIC. + +Evaluate that bit and if set avoid the detection routine and keep the real +PIC installed, which then gets initialized (for nothing) and makes the rest +of the code with all the dependencies work again. + +Fixes: e179f6914152 ("x86, irq, pic: Probe for legacy PIC and set legacy_pic appropriately") +Reported-by: David Lazar +Signed-off-by: Thomas Gleixner +Tested-by: David Lazar +Reviewed-by: Hans de Goede +Reviewed-by: Mario Limonciello +Cc: stable@vger.kernel.org +Closes: https://bugzilla.kernel.org/show_bug.cgi?id=218003 +Link: https://lore.kernel.org/r/875y2u5s8g.ffs@tglx +Signed-off-by: Sasha Levin +--- + arch/x86/include/asm/i8259.h | 2 ++ + arch/x86/kernel/acpi/boot.c | 3 +++ + arch/x86/kernel/i8259.c | 38 ++++++++++++++++++++++++++++-------- + 3 files changed, 35 insertions(+), 8 deletions(-) + +diff --git a/arch/x86/include/asm/i8259.h b/arch/x86/include/asm/i8259.h +index 637fa1df35124..c715097e92fd2 100644 +--- a/arch/x86/include/asm/i8259.h ++++ b/arch/x86/include/asm/i8259.h +@@ -69,6 +69,8 @@ struct legacy_pic { + void (*make_irq)(unsigned int irq); + }; + ++void legacy_pic_pcat_compat(void); ++ + extern struct legacy_pic *legacy_pic; + extern struct legacy_pic null_legacy_pic; + +diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c +index 6d716b9c0ec19..5491987374537 100644 +--- a/arch/x86/kernel/acpi/boot.c ++++ b/arch/x86/kernel/acpi/boot.c +@@ -140,6 +140,9 @@ static int __init acpi_parse_madt(struct acpi_table_header *table) + pr_debug("Local APIC address 0x%08x\n", madt->address); + } + ++ if (madt->flags & ACPI_MADT_PCAT_COMPAT) ++ legacy_pic_pcat_compat(); ++ + /* ACPI 6.3 and newer support the online capable bit. */ + if (acpi_gbl_FADT.header.revision > 6 || + (acpi_gbl_FADT.header.revision == 6 && +diff --git a/arch/x86/kernel/i8259.c b/arch/x86/kernel/i8259.c +index f91e5e31aa4f0..2ac5f488300cf 100644 +--- a/arch/x86/kernel/i8259.c ++++ b/arch/x86/kernel/i8259.c +@@ -32,6 +32,7 @@ + */ + static void init_8259A(int auto_eoi); + ++static bool pcat_compat __ro_after_init; + static int i8259A_auto_eoi; + DEFINE_RAW_SPINLOCK(i8259A_lock); + +@@ -301,15 +302,32 @@ static void unmask_8259A(void) + + static int probe_8259A(void) + { ++ unsigned char new_val, probe_val = ~(1 << PIC_CASCADE_IR); + unsigned long flags; +- unsigned char probe_val = ~(1 << PIC_CASCADE_IR); +- unsigned char new_val; ++ ++ /* ++ * If MADT has the PCAT_COMPAT flag set, then do not bother probing ++ * for the PIC. Some BIOSes leave the PIC uninitialized and probing ++ * fails. ++ * ++ * Right now this causes problems as quite some code depends on ++ * nr_legacy_irqs() > 0 or has_legacy_pic() == true. This is silly ++ * when the system has an IO/APIC because then PIC is not required ++ * at all, except for really old machines where the timer interrupt ++ * must be routed through the PIC. So just pretend that the PIC is ++ * there and let legacy_pic->init() initialize it for nothing. ++ * ++ * Alternatively this could just try to initialize the PIC and ++ * repeat the probe, but for cases where there is no PIC that's ++ * just pointless. ++ */ ++ if (pcat_compat) ++ return nr_legacy_irqs(); ++ + /* +- * Check to see if we have a PIC. +- * Mask all except the cascade and read +- * back the value we just wrote. If we don't +- * have a PIC, we will read 0xff as opposed to the +- * value we wrote. ++ * Check to see if we have a PIC. Mask all except the cascade and ++ * read back the value we just wrote. If we don't have a PIC, we ++ * will read 0xff as opposed to the value we wrote. + */ + raw_spin_lock_irqsave(&i8259A_lock, flags); + +@@ -431,5 +449,9 @@ static int __init i8259A_init_ops(void) + + return 0; + } +- + device_initcall(i8259A_init_ops); ++ ++void __init legacy_pic_pcat_compat(void) ++{ ++ pcat_compat = true; ++} +-- +2.42.0 +