diff --git a/.checkpackageignore b/.checkpackageignore index 3ce5f08ba396..a9e9d21da940 100644 --- a/.checkpackageignore +++ b/.checkpackageignore @@ -1068,7 +1068,6 @@ support/libtool/buildroot-libtool-v2.4.4.patch lib_patch.ApplyOrder lib_patch.Up support/libtool/buildroot-libtool-v2.4.patch lib_patch.ApplyOrder lib_patch.Sob lib_patch.Upstream support/misc/relocate-sdk.sh Shellcheck support/scripts/apply-patches.sh Shellcheck -support/scripts/br2-external Shellcheck support/scripts/check-bin-arch Shellcheck support/scripts/check-host-rpath Shellcheck support/scripts/expunge-gconv-modules Shellcheck diff --git a/arch/Config.in.arm b/arch/Config.in.arm index a0bf6c3386c9..eb5babe29b28 100644 --- a/arch/Config.in.arm +++ b/arch/Config.in.arm @@ -498,6 +498,12 @@ config BR2_tsv110 select BR2_ARCH_NEEDS_GCC_AT_LEAST_9 comment "armv8.4a cores" +config BR2_neoverse_v1 + bool "neoverse-V1 (aka zeus)" + depends on BR2_ARCH_IS_64 + select BR2_ARM_CPU_HAS_FP_ARMV8 + select BR2_ARM_CPU_ARMV8A + select BR2_ARCH_NEEDS_GCC_AT_LEAST_11 config BR2_saphira bool "saphira" depends on BR2_ARCH_IS_64 @@ -518,6 +524,12 @@ config BR2_neoverse_n2 select BR2_ARM_CPU_HAS_FP_ARMV8 select BR2_ARM_CPU_ARMV9A select BR2_ARCH_NEEDS_GCC_AT_LEAST_11 +config BR2_neoverse_v2 + bool "neoverse-V2 (aka demeter)" + depends on BR2_ARCH_IS_64 + select BR2_ARM_CPU_HAS_FP_ARMV8 + select BR2_ARM_CPU_ARMV9A + select BR2_ARCH_NEEDS_GCC_AT_LEAST_13 comment "armv9.2a cores" config BR2_cortex_a720 @@ -526,6 +538,18 @@ config BR2_cortex_a720 select BR2_ARM_CPU_HAS_FP_ARMV8 select BR2_ARM_CPU_ARMV9A select BR2_ARCH_NEEDS_GCC_AT_LEAST_14 +config BR2_neoverse_v3 + bool "neoverse-V3 (aka poseidon)" + depends on BR2_ARCH_IS_64 + select BR2_ARM_CPU_HAS_FP_ARMV8 + select BR2_ARM_CPU_ARMV9A + select BR2_ARCH_NEEDS_GCC_AT_LEAST_15 +config BR2_neoverse_v3ae + bool "neoverse-V3AE (aka poseidon)" + depends on BR2_ARCH_IS_64 + select BR2_ARM_CPU_HAS_FP_ARMV8 + select BR2_ARM_CPU_ARMV9A + select BR2_ARCH_NEEDS_GCC_AT_LEAST_15 endchoice config BR2_ARM_ENABLE_NEON @@ -918,12 +942,16 @@ config BR2_GCC_TARGET_CPU default "neoverse-n1" if BR2_neoverse_n1 default "tsv110" if BR2_tsv110 # armv8.4a + default "neoverse-v1" if BR2_neoverse_v1 default "saphira" if BR2_saphira # armv9.0a default "cortex-a710" if BR2_cortex_a710 default "neoverse-n2" if BR2_neoverse_n2 + default "neoverse-v2" if BR2_neoverse_v2 # armv9.2a default "cortex-a720" if BR2_cortex_a720 + default "neoverse-v3" if BR2_neoverse_v3 + default "neoverse-v3ae" if BR2_neoverse_v3ae config BR2_GCC_TARGET_ABI default "aapcs-linux" if BR2_arm || BR2_armeb diff --git a/board/stmicroelectronics/common/stm32mp1xx/patches/uboot/001-ARM-dts-stm32-Add-SCMI-clocks-in-rcc-node-for-stm32m.patch b/board/stmicroelectronics/common/stm32mp1xx/patches/uboot/001-ARM-dts-stm32-Add-SCMI-clocks-in-rcc-node-for-stm32m.patch new file mode 100644 index 000000000000..a75166635d03 --- /dev/null +++ b/board/stmicroelectronics/common/stm32mp1xx/patches/uboot/001-ARM-dts-stm32-Add-SCMI-clocks-in-rcc-node-for-stm32m.patch @@ -0,0 +1,59 @@ +From ebfc6864f27c7170422db0c8c3d934f23a8a83b7 Mon Sep 17 00:00:00 2001 +From: Patrice Chotard +Date: Fri, 16 Jan 2026 19:57:26 +0100 +Subject: [PATCH] ARM: dts: stm32: Add SCMI clocks in rcc node for + stm32mp131.dtsi + +Add SCMI clocks. These clocks are used as parent clocks and are +referenced by their rcc's node position in clk-stm32mp13.c + +Fixes: fdb1bffe2827 ("clk: scmi: Postpone clock name resolution") +Reviewed-by: Patrick Delaunay +Signed-off-by: Patrice Chotard +Upstream: https://source.denx.de/u-boot/u-boot/-/commit/7795c5ec6a608a104cf41331cbd387d39f7f6f49 +Signed-off-by: Thomas Richard +--- + arch/arm/dts/stm32mp13-u-boot.dtsi | 27 +++++++++++++++++++++++++++ + 1 file changed, 27 insertions(+) + +diff --git a/arch/arm/dts/stm32mp13-u-boot.dtsi b/arch/arm/dts/stm32mp13-u-boot.dtsi +index ad63d5027b2..623c796cc79 100644 +--- a/arch/arm/dts/stm32mp13-u-boot.dtsi ++++ b/arch/arm/dts/stm32mp13-u-boot.dtsi +@@ -186,6 +186,33 @@ + }; + + &rcc { ++ clocks = <&scmi_clk CK_SCMI_HSE>, ++ <&scmi_clk CK_SCMI_HSI>, ++ <&scmi_clk CK_SCMI_CSI>, ++ <&scmi_clk CK_SCMI_LSE>, ++ <&scmi_clk CK_SCMI_LSI>, ++ <&scmi_clk CK_SCMI_HSE_DIV2>, ++ <&scmi_clk CK_SCMI_PLL2_Q>, ++ <&scmi_clk CK_SCMI_PLL2_R>, ++ <&scmi_clk CK_SCMI_PLL3_P>, ++ <&scmi_clk CK_SCMI_PLL3_Q>, ++ <&scmi_clk CK_SCMI_PLL3_R>, ++ <&scmi_clk CK_SCMI_PLL4_P>, ++ <&scmi_clk CK_SCMI_PLL4_Q>, ++ <&scmi_clk CK_SCMI_PLL4_R>, ++ <&scmi_clk CK_SCMI_MPU>, ++ <&scmi_clk CK_SCMI_AXI>, ++ <&scmi_clk CK_SCMI_MLAHB>, ++ <&scmi_clk CK_SCMI_CKPER>, ++ <&scmi_clk CK_SCMI_PCLK1>, ++ <&scmi_clk CK_SCMI_PCLK2>, ++ <&scmi_clk CK_SCMI_PCLK3>, ++ <&scmi_clk CK_SCMI_PCLK4>, ++ <&scmi_clk CK_SCMI_PCLK5>, ++ <&scmi_clk CK_SCMI_PCLK6>, ++ <&scmi_clk CK_SCMI_CKTIMG1>, ++ <&scmi_clk CK_SCMI_CKTIMG2>, ++ <&scmi_clk CK_SCMI_CKTIMG3>; + bootph-all; + }; + +-- +2.51.0 + diff --git a/board/stmicroelectronics/common/stm32mp1xx/patches/uboot/002-clk-stm32-Update-clock-management-for-STM32MP13-25.patch b/board/stmicroelectronics/common/stm32mp1xx/patches/uboot/002-clk-stm32-Update-clock-management-for-STM32MP13-25.patch new file mode 100644 index 000000000000..f5837ee5b37d --- /dev/null +++ b/board/stmicroelectronics/common/stm32mp1xx/patches/uboot/002-clk-stm32-Update-clock-management-for-STM32MP13-25.patch @@ -0,0 +1,1548 @@ +From e3fac965740946241645c2c2d682171ee895b7c7 Mon Sep 17 00:00:00 2001 +From: Patrice Chotard +Date: Fri, 16 Jan 2026 19:57:27 +0100 +Subject: [PATCH] clk: stm32: Update clock management for STM32MP13/25 + +During clock's registration, clock's name are used to establish parent - +child relation. On STM32MP13 and STM32MP25, most of SCMI clocks are parent +clocks. + +Since commit fdb1bffe2827 ("clk: scmi: Postpone clock name resolution"), +all scmi clocks are named by default "scmi-%zu" until they are enabled, +it breaks clocks registration and boot process for STM32MP13/25 +platforms. + +Rework the STM32 core clock driver and STM32MP13/25 clock description +to use clock index instead of their real name. + +Introduce struct clk_parent_data which allows to identify parent clock +either by index or by name. Name is only used for particular clocks +provided by IP which are clock provider as i2s/i2s_ckin, usb0/ck_usbo_48m, +and ltdc/ck_ker_ltdc. + +STM32_GATE() and STM32_COMPOSITE_NOMUX macros are updated in order to +use parent clock index. + +As STM32MP13 supports both SPL and SCMI boot, keep using an array +with clock's name for SPL. + +Fixes: fdb1bffe2827 ("clk: scmi: Postpone clock name resolution") +Reviewed-by: Patrick Delaunay +Signed-off-by: Patrice Chotard +Upstream: https://source.denx.de/u-boot/u-boot/-/commit/213f927a59288bbaa4b141c593424c3b205b5e6c +Signed-off-by: Thomas Richard +--- + drivers/clk/stm32/clk-stm32-core.c | 116 ++++++-- + drivers/clk/stm32/clk-stm32-core.h | 42 ++- + drivers/clk/stm32/clk-stm32mp13.c | 417 ++++++++++++++++++++--------- + drivers/clk/stm32/clk-stm32mp25.c | 405 +++++++++++++++++----------- + 4 files changed, 671 insertions(+), 309 deletions(-) + +diff --git a/drivers/clk/stm32/clk-stm32-core.c b/drivers/clk/stm32/clk-stm32-core.c +index 858f122db1a..cd6bdee5412 100644 +--- a/drivers/clk/stm32/clk-stm32-core.c ++++ b/drivers/clk/stm32/clk-stm32-core.c +@@ -11,6 +11,8 @@ + #include + #include + #include ++#include ++#include + #include + #include "clk-stm32-core.h" + +@@ -34,8 +36,8 @@ int stm32_rcc_init(struct udevice *dev, + return -ENOMEM; + + priv->gate_cpt = cpt; +- +- priv->data = clock_data; ++ priv->clock_data = clock_data; ++ priv->match_data = data; + + for (i = 0; i < data->num_clocks; i++) { + const struct clock_config *cfg = &data->tab_clocks[i]; +@@ -57,9 +59,58 @@ int stm32_rcc_init(struct udevice *dev, + return 0; + } + +-ulong clk_stm32_get_rate_by_name(const char *name) ++static int clk_stm32_resolve_clk_name(struct udevice *dev, int idx, const char **name) + { +- struct udevice *dev; ++#ifdef CONFIG_TFABOOT ++ struct ofnode_phandle_args args; ++ struct udevice *clk_udevice; ++ struct udevice *child; ++ int ret; ++ ++ ret = dev_read_phandle_with_args(dev, "clocks", "#clock-cells", 0, idx, &args); ++ if (ret) { ++ dev_err(dev, "%s: dev_read_phandle_with_args failed: err=%d\n", ++ __func__, ret); ++ return ret; ++ } ++ ++ ret = uclass_find_device_by_ofnode(UCLASS_CLK, args.node, &clk_udevice); ++ if (ret) ++ return ret; ++ ++ if (args.args_count) { ++ device_foreach_child(child, clk_udevice) { ++ struct clk *clkp; ++ ++ clkp = dev_get_clk_ptr(child); ++ if (clk_get_id(clkp) == args.args[0]) ++ break; ++ ++ clk_udevice = child; ++ } ++ *name = child->name; ++ } else { ++ *name = clk_udevice->name; ++ } ++#else ++ struct stm32mp_rcc_priv *priv = dev_get_priv(dev); ++ *name = priv->match_data->get_clock_name(idx); ++ ++ if (!*name) ++ return -ENOENT; ++#endif ++ ++ return 0; ++} ++ ++ulong clk_stm32_get_rate_by_index(struct udevice *dev, int index) ++{ ++ const char *name; ++ int ret; ++ ++ ret = clk_stm32_resolve_clk_name(dev, index, &name); ++ if (ret) ++ return ret; + + if (!uclass_get_device_by_name(UCLASS_CLK, name, &dev)) { + struct clk *clk = dev_get_clk_ptr(dev); +@@ -171,7 +222,7 @@ static int clk_stm32_gate_enable(struct clk *clk) + struct clk_stm32_gate *stm32_gate = to_clk_stm32_gate(clk); + struct stm32mp_rcc_priv *priv = stm32_gate->priv; + +- clk_stm32_gate_set_state(priv->base, priv->data, priv->gate_cpt, ++ clk_stm32_gate_set_state(priv->base, priv->clock_data, priv->gate_cpt, + stm32_gate->gate_id, 1); + + return 0; +@@ -182,7 +233,7 @@ static int clk_stm32_gate_disable(struct clk *clk) + struct clk_stm32_gate *stm32_gate = to_clk_stm32_gate(clk); + struct stm32mp_rcc_priv *priv = stm32_gate->priv; + +- clk_stm32_gate_set_state(priv->base, priv->data, priv->gate_cpt, ++ clk_stm32_gate_set_state(priv->base, priv->clock_data, priv->gate_cpt, + stm32_gate->gate_id, 0); + + return 0; +@@ -209,6 +260,7 @@ struct clk *clk_stm32_gate_register(struct udevice *dev, + struct stm32_clk_gate_cfg *clk_cfg = cfg->clock_cfg; + struct clk_stm32_gate *stm32_gate; + struct clk *clk; ++ const char *parent_name; + int ret; + + stm32_gate = kzalloc(sizeof(*stm32_gate), GFP_KERNEL); +@@ -221,8 +273,17 @@ struct clk *clk_stm32_gate_register(struct udevice *dev, + clk = &stm32_gate->clk; + clk->flags = cfg->flags; + ++ if (cfg->parent_data->name) { ++ parent_name = cfg->parent_data->name; ++ } else { ++ ret = clk_stm32_resolve_clk_name(dev, cfg->parent_data->index, ++ &parent_name); ++ if (ret) ++ return ERR_PTR(ret); ++ } ++ + ret = clk_register(clk, UBOOT_DM_CLK_STM32_GATE, +- cfg->name, cfg->parent_name); ++ cfg->name, parent_name); + if (ret) { + kfree(stm32_gate); + return ERR_PTR(ret); +@@ -236,7 +297,7 @@ clk_stm32_register_composite(struct udevice *dev, + const struct clock_config *cfg) + { + struct stm32_clk_composite_cfg *composite = cfg->clock_cfg; +- const char *const *parent_names; ++ const char **parent_names = NULL; + int num_parents; + struct clk *clk = ERR_PTR(-ENOMEM); + struct clk_mux *mux = NULL; +@@ -249,7 +310,8 @@ clk_stm32_register_composite(struct udevice *dev, + struct clk *div_clk = NULL; + const struct clk_ops *div_ops = NULL; + struct stm32mp_rcc_priv *priv = dev_get_priv(dev); +- const struct clk_stm32_clock_data *data = priv->data; ++ const struct clk_stm32_clock_data *data = priv->clock_data; ++ int i, ret; + + if (composite->mux_id != NO_STM32_MUX) { + const struct stm32_mux_cfg *mux_cfg; +@@ -260,27 +322,50 @@ clk_stm32_register_composite(struct udevice *dev, + + mux_cfg = &data->muxes[composite->mux_id]; + ++ parent_names = devm_kcalloc(dev, mux_cfg->num_parents, ++ sizeof(char *), GFP_KERNEL); ++ if (!parent_names) ++ goto fail; ++ + mux->reg = priv->base + mux_cfg->reg_off; + mux->shift = mux_cfg->shift; + mux->mask = BIT(mux_cfg->width) - 1; + mux->num_parents = mux_cfg->num_parents; + mux->flags = 0; +- mux->parent_names = mux_cfg->parent_names; + ++ for (i = 0; i < mux_cfg->num_parents; i++) { ++ if (mux_cfg->parent_data[i].name) { ++ parent_names[i] = mux_cfg->parent_data[i].name; ++ } else { ++ ret = clk_stm32_resolve_clk_name(dev, ++ mux_cfg->parent_data[i].index, ++ &parent_names[i]); ++ if (ret) ++ return ERR_CAST(clk); ++ } ++ } ++ ++ mux->parent_names = (const char * const*)parent_names; + mux_clk = &mux->clk; + mux_ops = &clk_mux_ops; +- +- parent_names = mux_cfg->parent_names; + num_parents = mux_cfg->num_parents; + } else { +- parent_names = &cfg->parent_name; ++ parent_names = devm_kzalloc(dev, sizeof(char *), GFP_KERNEL); ++ if (!parent_names) ++ goto fail; ++ ++ ret = clk_stm32_resolve_clk_name(dev, cfg->parent_data->index, ++ parent_names); ++ if (ret) ++ return ERR_CAST(clk); ++ + num_parents = 1; + } + + if (composite->div_id != NO_STM32_DIV) { + const struct stm32_div_cfg *div_cfg; + +- div = kzalloc(sizeof(*div), GFP_KERNEL); ++ div = devm_kzalloc(dev, sizeof(*div), GFP_KERNEL); + if (!div) + goto fail; + +@@ -310,7 +395,7 @@ clk_stm32_register_composite(struct udevice *dev, + } + + clk = clk_register_composite(dev, cfg->name, +- parent_names, num_parents, ++ (const char * const *)parent_names, num_parents, + mux_clk, mux_ops, + div_clk, div_ops, + gate_clk, gate_ops, +@@ -321,6 +406,7 @@ clk_stm32_register_composite(struct udevice *dev, + return clk; + + fail: ++ kfree(parent_names); + kfree(gate); + kfree(div); + kfree(mux); +diff --git a/drivers/clk/stm32/clk-stm32-core.h b/drivers/clk/stm32/clk-stm32-core.h +index baf2a996ef3..3134e33aa6c 100644 +--- a/drivers/clk/stm32/clk-stm32-core.h ++++ b/drivers/clk/stm32/clk-stm32-core.h +@@ -6,10 +6,20 @@ + + struct stm32_clock_match_data; + ++/** ++ * struct clk_parent_data - clk parent information ++ * @name: globally unique parent name ++ * @index: parent index local to provider registering clk ++ */ ++struct clk_parent_data { ++ const char *name; ++ int index; ++}; ++ + /** + * struct stm32_mux_cfg - multiplexer configuration + * +- * @parent_names: array of string names for all possible parents ++ * @parent_data: array of parent information for all possible parent + * @num_parents: number of possible parents + * @reg_off: register controlling multiplexer + * @shift: shift to multiplexer bit field +@@ -19,7 +29,7 @@ struct stm32_clock_match_data; + * index + */ + struct stm32_mux_cfg { +- const char * const *parent_names; ++ const struct clk_parent_data *parent_data; + u8 num_parents; + u32 reg_off; + u8 shift; +@@ -81,7 +91,7 @@ struct stm32_composite_cfg { + * + * @id: binding id of the clock + * @name: clock name +- * @parent_name: name of the clock parent ++ * @parent_data: parent information + * @flags: framework-specific flags + * @sec_id: secure id (use to known if the clock is secured or not) + * @clock_cfg: specific clock data configuration +@@ -91,7 +101,7 @@ struct stm32_composite_cfg { + struct clock_config { + unsigned long id; + const char *name; +- const char *parent_name; ++ const struct clk_parent_data *parent_data; + unsigned long flags; + int sec_id; + void *clock_cfg; +@@ -129,6 +139,7 @@ struct stm32_clock_match_data { + const struct clk_stm32_clock_data *clock_data; + int (*check_security)(struct udevice *dev, void __iomem *base, + const struct clock_config *cfg); ++ const char *(*get_clock_name)(u8 index); + }; + + /** +@@ -143,7 +154,8 @@ struct stm32_clock_match_data { + struct stm32mp_rcc_priv { + void __iomem *base; + u8 *gate_cpt; +- const struct clk_stm32_clock_data *data; ++ const struct clk_stm32_clock_data *clock_data; ++ const struct stm32_clock_match_data *match_data; + struct clk osc_clk[6]; + }; + +@@ -224,12 +236,14 @@ struct stm32_clk_gate_cfg { + + #define STM32_GATE(_id, _name, _parent, _flags, _gate_id, _sec_id) \ + { \ +- .id = _id, \ +- .sec_id = _sec_id, \ +- .name = _name, \ +- .parent_name = _parent, \ +- .flags = _flags, \ +- .clock_cfg = &(struct stm32_clk_gate_cfg) { \ ++ .id = _id, \ ++ .sec_id = _sec_id, \ ++ .name = _name, \ ++ .parent_data = &(struct clk_parent_data) { \ ++ .index = _parent, \ ++ }, \ ++ .flags = _flags, \ ++ .clock_cfg = &(struct stm32_clk_gate_cfg) { \ + .gate_id = _gate_id, \ + }, \ + .setup = clk_stm32_gate_register, \ +@@ -261,7 +275,9 @@ struct stm32_clk_composite_cfg { + { \ + .id = _id, \ + .name = _name, \ +- .parent_name = _parent, \ ++ .parent_data = &(struct clk_parent_data) { \ ++ .index = _parent, \ ++ }, \ + .sec_id = _sec_id, \ + .flags = _flags, \ + .clock_cfg = &(struct stm32_clk_composite_cfg) { \ +@@ -274,4 +290,4 @@ struct stm32_clk_composite_cfg { + + extern const struct clk_ops stm32_clk_ops; + +-ulong clk_stm32_get_rate_by_name(const char *name); ++ulong clk_stm32_get_rate_by_index(struct udevice *dev, int index); +diff --git a/drivers/clk/stm32/clk-stm32mp13.c b/drivers/clk/stm32/clk-stm32mp13.c +index b4d0890f902..fc34f49edf0 100644 +--- a/drivers/clk/stm32/clk-stm32mp13.c ++++ b/drivers/clk/stm32/clk-stm32mp13.c +@@ -33,123 +33,248 @@ + + DECLARE_GLOBAL_DATA_PTR; + +-static const char * const adc12_src[] = { +- "pll4_r", "ck_per", "pll3_q" ++ /* must match scmi clock order found in DT */ ++enum { ++ IDX_HSE, ++ IDX_HSI, ++ IDX_CSI, ++ IDX_LSE, ++ IDX_LSI, ++ IDX_HSE_DIV2, ++ IDX_PLL2_Q, ++ IDX_PLL2_R, ++ IDX_PLL3_P, ++ IDX_PLL3_Q, ++ IDX_PLL3_R, ++ IDX_PLL4_P, ++ IDX_PLL4_Q, ++ IDX_PLL4_R, ++ IDX_MPU, ++ IDX_AXI, ++ IDX_MLAHB, ++ IDX_CKPER, ++ IDX_PCLK1, ++ IDX_PCLK2, ++ IDX_PCLK3, ++ IDX_PCLK4, ++ IDX_PCLK5, ++ IDX_PCLK6, ++ IDX_CKTIMG1, ++ IDX_CKTIMG2, ++ IDX_CKTIMG3, ++ IDX_PARENT_NB, + }; + +-static const char * const dcmipp_src[] = { +- "ck_axi", "pll2_q", "pll4_p", "ck_per", ++static const struct clk_parent_data adc12_src[] = { ++ { .index = IDX_PLL4_R }, ++ { .index = IDX_CKPER }, ++ { .index = IDX_PLL3_Q }, + }; + +-static const char * const eth12_src[] = { +- "pll4_p", "pll3_q" ++static const struct clk_parent_data dcmipp_src[] = { ++ { .index = IDX_AXI }, ++ { .index = IDX_PLL2_Q }, ++ { .index = IDX_PLL4_P }, ++ { .index = IDX_CKPER }, + }; + +-static const char * const fdcan_src[] = { +- "ck_hse", "pll3_q", "pll4_q", "pll4_r" ++static const struct clk_parent_data eth12_src[] = { ++ { .index = IDX_PLL4_P }, ++ { .index = IDX_PLL3_Q }, + }; + +-static const char * const fmc_src[] = { +- "ck_axi", "pll3_r", "pll4_p", "ck_per" ++static const struct clk_parent_data fdcan_src[] = { ++ { .index = IDX_HSE }, ++ { .index = IDX_PLL3_Q }, ++ { .index = IDX_PLL4_Q }, ++ { .index = IDX_PLL4_R }, + }; + +-static const char * const i2c12_src[] = { +- "pclk1", "pll4_r", "ck_hsi", "ck_csi" ++static const struct clk_parent_data fmc_src[] = { ++ { .index = IDX_AXI }, ++ { .index = IDX_PLL3_R }, ++ { .index = IDX_PLL4_P }, ++ { .index = IDX_CKPER }, + }; + +-static const char * const i2c345_src[] = { +- "pclk6", "pll4_r", "ck_hsi", "ck_csi" ++static const struct clk_parent_data i2c12_src[] = { ++ { .index = IDX_PCLK1 }, ++ { .index = IDX_PLL4_R }, ++ { .index = IDX_HSI }, ++ { .index = IDX_CSI }, + }; + +-static const char * const lptim1_src[] = { +- "pclk1", "pll4_p", "pll3_q", "ck_lse", "ck_lsi", "ck_per" ++static const struct clk_parent_data i2c345_src[] = { ++ { .index = IDX_PCLK6 }, ++ { .index = IDX_PLL4_R }, ++ { .index = IDX_HSI }, ++ { .index = IDX_CSI }, + }; + +-static const char * const lptim23_src[] = { +- "pclk3", "pll4_q", "ck_per", "ck_lse", "ck_lsi" ++static const struct clk_parent_data lptim1_src[] = { ++ { .index = IDX_PCLK1 }, ++ { .index = IDX_PLL4_P }, ++ { .index = IDX_PLL3_Q }, ++ { .index = IDX_LSE }, ++ { .index = IDX_LSI }, ++ { .index = IDX_CKPER }, + }; + +-static const char * const lptim45_src[] = { +- "pclk3", "pll4_p", "pll3_q", "ck_lse", "ck_lsi", "ck_per" ++static const struct clk_parent_data lptim23_src[] = { ++ { .index = IDX_PCLK3 }, ++ { .index = IDX_PLL4_Q }, ++ { .index = IDX_CKPER }, ++ { .index = IDX_LSE }, ++ { .index = IDX_LSI }, + }; + +-static const char * const mco1_src[] = { +- "ck_hsi", "ck_hse", "ck_csi", "ck_lsi", "ck_lse" ++static const struct clk_parent_data lptim45_src[] = { ++ { .index = IDX_PCLK3 }, ++ { .index = IDX_PLL4_P }, ++ { .index = IDX_PLL3_Q }, ++ { .index = IDX_LSE }, ++ { .index = IDX_LSI }, ++ { .index = IDX_CKPER }, + }; + +-static const char * const mco2_src[] = { +- "ck_mpu", "ck_axi", "ck_mlahb", "pll4_p", "ck_hse", "ck_hsi" ++static const struct clk_parent_data mco1_src[] = { ++ { .index = IDX_HSI }, ++ { .index = IDX_HSE }, ++ { .index = IDX_CSI }, ++ { .index = IDX_LSI }, ++ { .index = IDX_LSE }, + }; + +-static const char * const qspi_src[] = { +- "ck_axi", "pll3_r", "pll4_p", "ck_per" ++static const struct clk_parent_data mco2_src[] = { ++ { .index = IDX_MPU }, ++ { .index = IDX_AXI }, ++ { .index = IDX_MLAHB }, ++ { .index = IDX_PLL4_P }, ++ { .index = IDX_HSE }, ++ { .index = IDX_HSI }, + }; + +-static const char * const rng1_src[] = { +- "ck_csi", "pll4_r", "reserved", "ck_lsi" ++static const struct clk_parent_data qspi_src[] = { ++ { .index = IDX_AXI }, ++ { .index = IDX_PLL3_R }, ++ { .index = IDX_PLL4_P }, ++ { .index = IDX_CKPER }, + }; + +-static const char * const saes_src[] = { +- "ck_axi", "ck_per", "pll4_r", "ck_lsi" ++static const struct clk_parent_data rng1_src[] = { ++ { .index = IDX_CSI }, ++ { .index = IDX_PLL4_R }, ++ { .name = "reserved" }, ++ { .index = IDX_LSI }, + }; + +-static const char * const sai1_src[] = { +- "pll4_q", "pll3_q", "i2s_ckin", "ck_per", "pll3_r" ++static const struct clk_parent_data saes_src[] = { ++ { .index = IDX_AXI }, ++ { .index = IDX_CKPER }, ++ { .index = IDX_PLL4_R }, ++ { .index = IDX_LSI }, + }; + +-static const char * const sai2_src[] = { +- "pll4_q", "pll3_q", "i2s_ckin", "ck_per", "spdif_ck_symb", "pll3_r" ++static const struct clk_parent_data sai1_src[] = { ++ { .index = IDX_PLL4_Q }, ++ { .index = IDX_PLL3_Q }, ++ { .name = "i2s_ckin" }, ++ { .index = IDX_CKPER }, ++ { .index = IDX_PLL3_R }, + }; + +-static const char * const sdmmc12_src[] = { +- "ck_axi", "pll3_r", "pll4_p", "ck_hsi" ++static const struct clk_parent_data sai2_src[] = { ++ { .index = IDX_PLL4_Q }, ++ { .index = IDX_PLL3_Q }, ++ { .name = "i2s_ckin" }, ++ { .index = IDX_CKPER }, ++ { .name = "spdif_ck_symb" }, ++ { .index = IDX_PLL3_R }, + }; + +-static const char * const spdif_src[] = { +- "pll4_p", "pll3_q", "ck_hsi" ++static const struct clk_parent_data sdmmc12_src[] = { ++ { .index = IDX_AXI }, ++ { .index = IDX_PLL3_R }, ++ { .index = IDX_PLL4_P }, ++ { .index = IDX_HSI }, + }; + +-static const char * const spi123_src[] = { +- "pll4_p", "pll3_q", "i2s_ckin", "ck_per", "pll3_r" ++static const struct clk_parent_data spdif_src[] = { ++ { .index = IDX_PLL4_P }, ++ { .index = IDX_PLL3_Q }, ++ { .index = IDX_HSI }, + }; + +-static const char * const spi4_src[] = { +- "pclk6", "pll4_q", "ck_hsi", "ck_csi", "ck_hse", "i2s_ckin" ++static const struct clk_parent_data spi123_src[] = { ++ { .index = IDX_PLL4_P }, ++ { .index = IDX_PLL3_Q }, ++ { .name = "i2s_ckin" }, ++ { .index = IDX_CKPER }, ++ { .index = IDX_PLL3_R }, + }; + +-static const char * const spi5_src[] = { +- "pclk6", "pll4_q", "ck_hsi", "ck_csi", "ck_hse" ++static const struct clk_parent_data spi4_src[] = { ++ { .index = IDX_PCLK6 }, ++ { .index = IDX_PLL4_Q }, ++ { .index = IDX_HSI }, ++ { .index = IDX_CSI }, ++ { .index = IDX_HSE }, ++ { .name = "i2s_ckin" }, + }; + +-static const char * const stgen_src[] = { +- "ck_hsi", "ck_hse" ++static const struct clk_parent_data spi5_src[] = { ++ { .index = IDX_PCLK6 }, ++ { .index = IDX_PLL4_Q }, ++ { .index = IDX_HSI }, ++ { .index = IDX_CSI }, ++ { .index = IDX_HSE }, + }; + +-static const char * const usart12_src[] = { +- "pclk6", "pll3_q", "ck_hsi", "ck_csi", "pll4_q", "ck_hse" ++static const struct clk_parent_data stgen_src[] = { ++ { .index = IDX_HSI }, ++ { .index = IDX_HSE }, + }; + +-static const char * const usart34578_src[] = { +- "pclk1", "pll4_q", "ck_hsi", "ck_csi", "ck_hse" ++static const struct clk_parent_data usart12_src[] = { ++ { .index = IDX_PCLK6 }, ++ { .index = IDX_PLL3_Q }, ++ { .index = IDX_HSI }, ++ { .index = IDX_CSI }, ++ { .index = IDX_PLL4_Q }, ++ { .index = IDX_HSE }, + }; + +-static const char * const usart6_src[] = { +- "pclk2", "pll4_q", "ck_hsi", "ck_csi", "ck_hse" ++static const struct clk_parent_data usart34578_src[] = { ++ { .index = IDX_PCLK1 }, ++ { .index = IDX_PLL4_Q }, ++ { .index = IDX_HSI }, ++ { .index = IDX_CSI }, ++ { .index = IDX_HSE }, + }; + +-static const char * const usbo_src[] = { +- "pll4_r", "ck_usbo_48m" ++static const struct clk_parent_data usart6_src[] = { ++ { .index = IDX_PCLK2 }, ++ { .index = IDX_PLL4_Q }, ++ { .index = IDX_HSI }, ++ { .index = IDX_CSI }, ++ { .index = IDX_HSE }, + }; + +-static const char * const usbphy_src[] = { +- "ck_hse", "pll4_r", "clk-hse-div2" ++static const struct clk_parent_data usbo_src[] = { ++ { .index = IDX_PLL4_R }, ++ { .name = "ck_usbo_48m" }, + }; + ++static const struct clk_parent_data usbphy_src[] = { ++ { .index = IDX_HSE }, ++ { .index = IDX_PLL4_R }, ++ { .index = IDX_HSE_DIV2 }, ++}; + + #define MUX_CFG(id, src, _offset, _shift, _witdh) \ + [id] = { \ + .num_parents = ARRAY_SIZE(src), \ +- .parent_names = (src), \ ++ .parent_data = (src), \ + .reg_off = (_offset), \ + .shift = (_shift), \ + .width = (_witdh), \ +@@ -604,73 +729,73 @@ static const struct clk_stm32_security stm32mp13_security[] = { + + static const struct clock_config stm32mp13_clock_cfg[] = { + #ifndef CONFIG_XPL_BUILD +- TIMER(TIM2_K, "tim2_k", "timg1_ck", 0, GATE_TIM2, SECF_NONE), +- TIMER(TIM3_K, "tim3_k", "timg1_ck", 0, GATE_TIM3, SECF_NONE), +- TIMER(TIM4_K, "tim4_k", "timg1_ck", 0, GATE_TIM4, SECF_NONE), +- TIMER(TIM5_K, "tim5_k", "timg1_ck", 0, GATE_TIM5, SECF_NONE), +- TIMER(TIM6_K, "tim6_k", "timg1_ck", 0, GATE_TIM6, SECF_NONE), +- TIMER(TIM7_K, "tim7_k", "timg1_ck", 0, GATE_TIM7, SECF_NONE), +- TIMER(TIM1_K, "tim1_k", "timg2_ck", 0, GATE_TIM1, SECF_NONE), +- TIMER(TIM8_K, "tim8_k", "timg2_ck", 0, GATE_TIM8, SECF_NONE), +- TIMER(TIM12_K, "tim12_k", "timg3_ck", 0, GATE_TIM12, SECF_TIM12), +- TIMER(TIM13_K, "tim13_k", "timg3_ck", 0, GATE_TIM13, SECF_TIM13), +- TIMER(TIM14_K, "tim14_k", "timg3_ck", 0, GATE_TIM14, SECF_TIM14), +- TIMER(TIM15_K, "tim15_k", "timg3_ck", 0, GATE_TIM15, SECF_TIM15), +- TIMER(TIM16_K, "tim16_k", "timg3_ck", 0, GATE_TIM16, SECF_TIM16), +- TIMER(TIM17_K, "tim17_k", "timg3_ck", 0, GATE_TIM17, SECF_TIM17), ++ TIMER(TIM2_K, "tim2_k", IDX_CKTIMG1, 0, GATE_TIM2, SECF_NONE), ++ TIMER(TIM3_K, "tim3_k", IDX_CKTIMG1, 0, GATE_TIM3, SECF_NONE), ++ TIMER(TIM4_K, "tim4_k", IDX_CKTIMG1, 0, GATE_TIM4, SECF_NONE), ++ TIMER(TIM5_K, "tim5_k", IDX_CKTIMG1, 0, GATE_TIM5, SECF_NONE), ++ TIMER(TIM6_K, "tim6_k", IDX_CKTIMG1, 0, GATE_TIM6, SECF_NONE), ++ TIMER(TIM7_K, "tim7_k", IDX_CKTIMG1, 0, GATE_TIM7, SECF_NONE), ++ TIMER(TIM1_K, "tim1_k", IDX_CKTIMG2, 0, GATE_TIM1, SECF_NONE), ++ TIMER(TIM8_K, "tim8_k", IDX_CKTIMG2, 0, GATE_TIM8, SECF_NONE), ++ TIMER(TIM12_K, "tim12_k", IDX_CKTIMG3, 0, GATE_TIM12, SECF_TIM12), ++ TIMER(TIM13_K, "tim13_k", IDX_CKTIMG3, 0, GATE_TIM13, SECF_TIM13), ++ TIMER(TIM14_K, "tim14_k", IDX_CKTIMG3, 0, GATE_TIM14, SECF_TIM14), ++ TIMER(TIM15_K, "tim15_k", IDX_CKTIMG3, 0, GATE_TIM15, SECF_TIM15), ++ TIMER(TIM16_K, "tim16_k", IDX_CKTIMG3, 0, GATE_TIM16, SECF_TIM16), ++ TIMER(TIM17_K, "tim17_k", IDX_CKTIMG3, 0, GATE_TIM17, SECF_TIM17), + #endif + + /* Peripheral clocks */ +- PCLK(SYSCFG, "syscfg", "pclk3", 0, GATE_SYSCFG, SECF_NONE), +- PCLK(VREF, "vref", "pclk3", 0, GATE_VREF, SECF_VREF), ++ PCLK(SYSCFG, "syscfg", IDX_PCLK3, 0, GATE_SYSCFG, SECF_NONE), ++ PCLK(VREF, "vref", IDX_PCLK3, 0, GATE_VREF, SECF_VREF), + #ifndef CONFIG_XPL_BUILD +- PCLK(PMBCTRL, "pmbctrl", "pclk3", 0, GATE_PMBCTRL, SECF_NONE), +- PCLK(HDP, "hdp", "pclk3", 0, GATE_HDP, SECF_NONE), ++ PCLK(PMBCTRL, "pmbctrl", IDX_PCLK3, 0, GATE_PMBCTRL, SECF_NONE), ++ PCLK(HDP, "hdp", IDX_PCLK3, 0, GATE_HDP, SECF_NONE), + #endif +- PCLK(IWDG2, "iwdg2", "pclk4", 0, GATE_IWDG2APB, SECF_NONE), +- PCLK(STGENRO, "stgenro", "pclk4", 0, GATE_STGENRO, SECF_STGENRO), +- PCLK(TZPC, "tzpc", "pclk5", 0, GATE_TZC, SECF_TZC), +- PCLK(IWDG1, "iwdg1", "pclk5", 0, GATE_IWDG1APB, SECF_IWDG1), +- PCLK(BSEC, "bsec", "pclk5", 0, GATE_BSEC, SECF_BSEC), ++ PCLK(IWDG2, "iwdg2", IDX_PCLK4, 0, GATE_IWDG2APB, SECF_NONE), ++ PCLK(STGENRO, "stgenro", IDX_PCLK4, 0, GATE_STGENRO, SECF_STGENRO), ++ PCLK(TZPC, "tzpc", IDX_PCLK5, 0, GATE_TZC, SECF_TZC), ++ PCLK(IWDG1, "iwdg1", IDX_PCLK5, 0, GATE_IWDG1APB, SECF_IWDG1), ++ PCLK(BSEC, "bsec", IDX_PCLK5, 0, GATE_BSEC, SECF_BSEC), + #ifndef CONFIG_XPL_BUILD +- PCLK(DMA1, "dma1", "ck_mlahb", 0, GATE_DMA1, SECF_NONE), +- PCLK(DMA2, "dma2", "ck_mlahb", 0, GATE_DMA2, SECF_NONE), +- PCLK(DMAMUX1, "dmamux1", "ck_mlahb", 0, GATE_DMAMUX1, SECF_NONE), +- PCLK(DMAMUX2, "dmamux2", "ck_mlahb", 0, GATE_DMAMUX2, SECF_DMAMUX2), +- PCLK(ADC1, "adc1", "ck_mlahb", 0, GATE_ADC1, SECF_ADC1), +- PCLK(ADC2, "adc2", "ck_mlahb", 0, GATE_ADC2, SECF_ADC2), ++ PCLK(DMA1, "dma1", IDX_MLAHB, 0, GATE_DMA1, SECF_NONE), ++ PCLK(DMA2, "dma2", IDX_MLAHB, 0, GATE_DMA2, SECF_NONE), ++ PCLK(DMAMUX1, "dmamux1", IDX_MLAHB, 0, GATE_DMAMUX1, SECF_NONE), ++ PCLK(DMAMUX2, "dmamux2", IDX_MLAHB, 0, GATE_DMAMUX2, SECF_DMAMUX2), ++ PCLK(ADC1, "adc1", IDX_MLAHB, 0, GATE_ADC1, SECF_ADC1), ++ PCLK(ADC2, "adc2", IDX_MLAHB, 0, GATE_ADC2, SECF_ADC2), + #endif +- PCLK(GPIOA, "gpioa", "pclk4", 0, GATE_GPIOA, SECF_NONE), +- PCLK(GPIOB, "gpiob", "pclk4", 0, GATE_GPIOB, SECF_NONE), +- PCLK(GPIOC, "gpioc", "pclk4", 0, GATE_GPIOC, SECF_NONE), +- PCLK(GPIOD, "gpiod", "pclk4", 0, GATE_GPIOD, SECF_NONE), +- PCLK(GPIOE, "gpioe", "pclk4", 0, GATE_GPIOE, SECF_NONE), +- PCLK(GPIOF, "gpiof", "pclk4", 0, GATE_GPIOF, SECF_NONE), +- PCLK(GPIOG, "gpiog", "pclk4", 0, GATE_GPIOG, SECF_NONE), +- PCLK(GPIOH, "gpioh", "pclk4", 0, GATE_GPIOH, SECF_NONE), +- PCLK(GPIOI, "gpioi", "pclk4", 0, GATE_GPIOI, SECF_NONE), +- PCLK(TSC, "tsc", "pclk4", 0, GATE_TSC, SECF_TZC), +- PCLK(PKA, "pka", "ck_axi", 0, GATE_PKA, SECF_PKA), +- PCLK(CRYP1, "cryp1", "ck_axi", 0, GATE_CRYP1, SECF_CRYP1), +- PCLK(HASH1, "hash1", "ck_axi", 0, GATE_HASH1, SECF_HASH1), +- PCLK(BKPSRAM, "bkpsram", "ck_axi", 0, GATE_BKPSRAM, SECF_BKPSRAM), +- PCLK(MDMA, "mdma", "ck_axi", 0, GATE_MDMA, SECF_NONE), ++ PCLK(GPIOA, "gpioa", IDX_PCLK4, 0, GATE_GPIOA, SECF_NONE), ++ PCLK(GPIOB, "gpiob", IDX_PCLK4, 0, GATE_GPIOB, SECF_NONE), ++ PCLK(GPIOC, "gpioc", IDX_PCLK4, 0, GATE_GPIOC, SECF_NONE), ++ PCLK(GPIOD, "gpiod", IDX_PCLK4, 0, GATE_GPIOD, SECF_NONE), ++ PCLK(GPIOE, "gpioe", IDX_PCLK4, 0, GATE_GPIOE, SECF_NONE), ++ PCLK(GPIOF, "gpiof", IDX_PCLK4, 0, GATE_GPIOF, SECF_NONE), ++ PCLK(GPIOG, "gpiog", IDX_PCLK4, 0, GATE_GPIOG, SECF_NONE), ++ PCLK(GPIOH, "gpioh", IDX_PCLK4, 0, GATE_GPIOH, SECF_NONE), ++ PCLK(GPIOI, "gpioi", IDX_PCLK4, 0, GATE_GPIOI, SECF_NONE), ++ PCLK(TSC, "tsc", IDX_PCLK4, 0, GATE_TSC, SECF_TZC), ++ PCLK(PKA, "pka", IDX_AXI, 0, GATE_PKA, SECF_PKA), ++ PCLK(CRYP1, "cryp1", IDX_AXI, 0, GATE_CRYP1, SECF_CRYP1), ++ PCLK(HASH1, "hash1", IDX_AXI, 0, GATE_HASH1, SECF_HASH1), ++ PCLK(BKPSRAM, "bkpsram", IDX_AXI, 0, GATE_BKPSRAM, SECF_BKPSRAM), ++ PCLK(MDMA, "mdma", IDX_AXI, 0, GATE_MDMA, SECF_NONE), + #ifndef CONFIG_XPL_BUILD +- PCLK(ETH1TX, "eth1tx", "ck_axi", 0, GATE_ETH1TX, SECF_ETH1TX), +- PCLK(ETH1RX, "eth1rx", "ck_axi", 0, GATE_ETH1RX, SECF_ETH1RX), +- PCLK(ETH1MAC, "eth1mac", "ck_axi", 0, GATE_ETH1MAC, SECF_ETH1MAC), +- PCLK(ETH2TX, "eth2tx", "ck_axi", 0, GATE_ETH2TX, SECF_ETH2TX), +- PCLK(ETH2RX, "eth2rx", "ck_axi", 0, GATE_ETH2RX, SECF_ETH2RX), +- PCLK(ETH2MAC, "eth2mac", "ck_axi", 0, GATE_ETH2MAC, SECF_ETH2MAC), ++ PCLK(ETH1TX, "eth1tx", IDX_AXI, 0, GATE_ETH1TX, SECF_ETH1TX), ++ PCLK(ETH1RX, "eth1rx", IDX_AXI, 0, GATE_ETH1RX, SECF_ETH1RX), ++ PCLK(ETH1MAC, "eth1mac", IDX_AXI, 0, GATE_ETH1MAC, SECF_ETH1MAC), ++ PCLK(ETH2TX, "eth2tx", IDX_AXI, 0, GATE_ETH2TX, SECF_ETH2TX), ++ PCLK(ETH2RX, "eth2rx", IDX_AXI, 0, GATE_ETH2RX, SECF_ETH2RX), ++ PCLK(ETH2MAC, "eth2mac", IDX_AXI, 0, GATE_ETH2MAC, SECF_ETH2MAC), + #endif +- PCLK(CRC1, "crc1", "ck_axi", 0, GATE_CRC1, SECF_NONE), ++ PCLK(CRC1, "crc1", IDX_AXI, 0, GATE_CRC1, SECF_NONE), + #ifndef CONFIG_XPL_BUILD +- PCLK(USBH, "usbh", "ck_axi", 0, GATE_USBH, SECF_NONE), ++ PCLK(USBH, "usbh", IDX_AXI, 0, GATE_USBH, SECF_NONE), + #endif +- PCLK(DDRPERFM, "ddrperfm", "pclk4", 0, GATE_DDRPERFM, SECF_NONE), ++ PCLK(DDRPERFM, "ddrperfm", IDX_PCLK4, 0, GATE_DDRPERFM, SECF_NONE), + #ifndef CONFIG_XPL_BUILD +- PCLK(ETH1STP, "eth1stp", "ck_axi", 0, GATE_ETH1STP, SECF_ETH1STP), +- PCLK(ETH2STP, "eth2stp", "ck_axi", 0, GATE_ETH2STP, SECF_ETH2STP), ++ PCLK(ETH1STP, "eth1stp", IDX_AXI, 0, GATE_ETH1STP, SECF_ETH1STP), ++ PCLK(ETH2STP, "eth2stp", IDX_AXI, 0, GATE_ETH2STP, SECF_ETH2STP), + #endif + + /* Kernel clocks */ +@@ -730,11 +855,11 @@ static const struct clock_config stm32mp13_clock_cfg[] = { + KCLK(ETH2CK_K, "eth2ck_k", 0, GATE_ETH2CK, MUX_ETH2, SECF_ETH2CK), + KCLK(SAES_K, "saes_k", 0, GATE_SAES, MUX_SAES, SECF_SAES), + +- STM32_GATE(DFSDM_K, "dfsdm_k", "ck_mlahb", 0, GATE_DFSDM, SECF_NONE), +- STM32_GATE(LTDC_PX, "ltdc_px", "pll4_q", CLK_SET_RATE_PARENT, ++ STM32_GATE(DFSDM_K, "dfsdm_k", IDX_MLAHB, 0, GATE_DFSDM, SECF_NONE), ++ STM32_GATE(LTDC_PX, "ltdc_px", IDX_PLL4_Q, CLK_SET_RATE_PARENT, + GATE_LTDC, SECF_NONE), + +- STM32_GATE(DTS_K, "dts_k", "ck_lse", 0, GATE_DTS, SECF_NONE), ++ STM32_GATE(DTS_K, "dts_k", IDX_LSE, 0, GATE_DTS, SECF_NONE), + #endif + + STM32_COMPOSITE(ETH1PTP_K, "eth1ptp_k", CLK_OPS_PARENT_ENABLE | +@@ -755,23 +880,23 @@ static const struct clock_config stm32mp13_clock_cfg[] = { + GATE_MCO2, MUX_MCO2, DIV_MCO2), + + /* Debug clocks */ +- STM32_GATE(CK_DBG, "ck_sys_dbg", "ck_axi", CLK_IGNORE_UNUSED, ++ STM32_GATE(CK_DBG, "ck_sys_dbg", IDX_AXI, CLK_IGNORE_UNUSED, + GATE_DBGCK, SECF_NONE), + +- STM32_COMPOSITE_NOMUX(CK_TRACE, "ck_trace", "ck_axi", ++ STM32_COMPOSITE_NOMUX(CK_TRACE, "ck_trace", IDX_AXI, + CLK_OPS_PARENT_ENABLE, SECF_NONE, + GATE_TRACECK, DIV_TRACE), + + #ifdef CONFIG_XPL_BUILD +- STM32_GATE(AXIDCG, "axidcg", "ck_axi", CLK_IGNORE_UNUSED, ++ STM32_GATE(AXIDCG, "axidcg", IDX_AXI, CLK_IGNORE_UNUSED, + GATE_AXIDCG, SECF_NONE), +- STM32_GATE(DDRC1, "ddrc1", "ck_axi", CLK_IGNORE_UNUSED, ++ STM32_GATE(DDRC1, "ddrc1", IDX_AXI, CLK_IGNORE_UNUSED, + GATE_DDRC1, SECF_NONE), +- STM32_GATE(DDRPHYC, "ddrphyc", "pll2_r", CLK_IGNORE_UNUSED, ++ STM32_GATE(DDRPHYC, "ddrphyc", IDX_PLL2_R, CLK_IGNORE_UNUSED, + GATE_DDRPHYC, SECF_NONE), +- STM32_GATE(DDRCAPB, "ddrcapb", "pclk4", CLK_IGNORE_UNUSED, ++ STM32_GATE(DDRCAPB, "ddrcapb", IDX_PCLK4, CLK_IGNORE_UNUSED, + GATE_DDRCAPB, SECF_NONE), +- STM32_GATE(DDRPHYCAPB, "ddrphycapb", "pclk4", CLK_IGNORE_UNUSED, ++ STM32_GATE(DDRPHYCAPB, "ddrphycapb", IDX_PCLK4, CLK_IGNORE_UNUSED, + GATE_DDRPHYCAPB, SECF_NONE), + #endif + }; +@@ -792,6 +917,44 @@ static int stm32mp13_check_security(struct udevice *dev, void __iomem *base, + + return secured; + } ++#else ++static char * const stm32mp13_clk_parent_name[IDX_PARENT_NB] = { ++ [IDX_HSE] = "ck_hse", ++ [IDX_HSI] = "ck_hsi", ++ [IDX_CSI] = "ck_csi", ++ [IDX_LSE] = "ck_lse", ++ [IDX_LSI] = "ck_lsi", ++ [IDX_HSE_DIV2] = "clk-hse-div2", ++ [IDX_PLL2_Q] = "pll2_q", ++ [IDX_PLL2_R] = "pll2_r", ++ [IDX_PLL3_P] = "pll3_p", ++ [IDX_PLL3_Q] = "pll3_q", ++ [IDX_PLL3_R] = "pll3_r", ++ [IDX_PLL4_P] = "pll4_p", ++ [IDX_PLL4_Q] = "pll4_q", ++ [IDX_PLL4_R] = "pll4_r", ++ [IDX_MPU] = "ck_mpu", ++ [IDX_AXI] = "ck_axi", ++ [IDX_MLAHB] = "ck_mlahb", ++ [IDX_CKPER] = "ck_per", ++ [IDX_PCLK1] = "pclk1", ++ [IDX_PCLK2] = "pclk2", ++ [IDX_PCLK3] = "pclk3", ++ [IDX_PCLK4] = "pclk4", ++ [IDX_PCLK5] = "pclk5", ++ [IDX_PCLK6] = "pclk6", ++ [IDX_CKTIMG1] = "tim1_k", ++ [IDX_CKTIMG2] = "tim2_k", ++ [IDX_CKTIMG3] = "tim3_k", ++}; ++ ++static const char *stm32mp13_get_clock_name(u8 index) ++{ ++ if (index >= IDX_PARENT_NB) ++ return NULL; ++ ++ return stm32mp13_clk_parent_name[index]; ++} + #endif + + static const struct stm32_clock_match_data stm32mp13_data = { +@@ -805,6 +968,8 @@ static const struct stm32_clock_match_data stm32mp13_data = { + }, + #ifdef CONFIG_TFABOOT + .check_security = stm32mp13_check_security, ++#else ++ .get_clock_name = stm32mp13_get_clock_name, + #endif + }; + +@@ -2006,11 +2171,11 @@ static int stm32mp1_clk_probe(struct udevice *dev) + if (err) + return err; + +- gd->cpu_clk = clk_stm32_get_rate_by_name("ck_mpu"); +- gd->bus_clk = clk_stm32_get_rate_by_name("ck_axi"); ++ gd->cpu_clk = clk_stm32_get_rate_by_index(dev, IDX_MPU); ++ gd->bus_clk = clk_stm32_get_rate_by_index(dev, IDX_AXI); + + /* DDRPHYC father */ +- gd->mem_clk = clk_stm32_get_rate_by_name("pll2_r"); ++ gd->mem_clk = clk_stm32_get_rate_by_index(dev, IDX_PLL2_R); + + #ifndef CONFIG_XPL_BUILD + if (IS_ENABLED(CONFIG_DISPLAY_CPUINFO)) { +@@ -2021,7 +2186,7 @@ static int stm32mp1_clk_probe(struct udevice *dev) + log_info("- MPU : %s MHz\n", strmhz(buf, gd->cpu_clk)); + log_info("- AXI : %s MHz\n", strmhz(buf, gd->bus_clk)); + log_info("- PER : %s MHz\n", +- strmhz(buf, clk_stm32_get_rate_by_name("ck_per"))); ++ strmhz(buf, clk_stm32_get_rate_by_index(dev, IDX_CKPER))); + log_info("- DDR : %s MHz\n", strmhz(buf, gd->mem_clk)); + } + } +diff --git a/drivers/clk/stm32/clk-stm32mp25.c b/drivers/clk/stm32/clk-stm32mp25.c +index b487f33b6c7..93ee38ed59e 100644 +--- a/drivers/clk/stm32/clk-stm32mp25.c ++++ b/drivers/clk/stm32/clk-stm32mp25.c +@@ -43,48 +43,143 @@ + #define SEC_RIFRCC(_id) (STM32MP25_RIFRCC_##_id##_ID) + #define SEC_RIFSC(_id) ((_id) | SEC_RIFSC_FLAG) + +-static const char * const adc12_src[] = { +- "ck_flexgen_46", "ck_icn_ls_mcu" ++/* must match scmi clock order found in DT */ ++enum { ++ IDX_HSE, ++ IDX_HSI, ++ IDX_MSI, ++ IDX_LSE, ++ IDX_LSI, ++ IDX_HSE_DIV2, ++ IDX_ICN_HS_MCU, ++ IDX_ICN_LS_MCU, ++ IDX_ICN_SDMMC, ++ IDX_ICN_DDR, ++ IDX_ICN_DISPLAY, ++ IDX_ICN_HSL, ++ IDX_ICN_NIC, ++ IDX_ICN_VID, ++ IDX_FLEXGEN_07, ++ IDX_FLEXGEN_08, ++ IDX_FLEXGEN_09, ++ IDX_FLEXGEN_10, ++ IDX_FLEXGEN_11, ++ IDX_FLEXGEN_12, ++ IDX_FLEXGEN_13, ++ IDX_FLEXGEN_14, ++ IDX_FLEXGEN_15, ++ IDX_FLEXGEN_16, ++ IDX_FLEXGEN_17, ++ IDX_FLEXGEN_18, ++ IDX_FLEXGEN_19, ++ IDX_FLEXGEN_20, ++ IDX_FLEXGEN_21, ++ IDX_FLEXGEN_22, ++ IDX_FLEXGEN_23, ++ IDX_FLEXGEN_24, ++ IDX_FLEXGEN_25, ++ IDX_FLEXGEN_26, ++ IDX_FLEXGEN_27, ++ IDX_FLEXGEN_28, ++ IDX_FLEXGEN_29, ++ IDX_FLEXGEN_30, ++ IDX_FLEXGEN_31, ++ IDX_FLEXGEN_32, ++ IDX_FLEXGEN_33, ++ IDX_FLEXGEN_34, ++ IDX_FLEXGEN_35, ++ IDX_FLEXGEN_36, ++ IDX_FLEXGEN_37, ++ IDX_FLEXGEN_38, ++ IDX_FLEXGEN_39, ++ IDX_FLEXGEN_40, ++ IDX_FLEXGEN_41, ++ IDX_FLEXGEN_42, ++ IDX_FLEXGEN_43, ++ IDX_FLEXGEN_44, ++ IDX_FLEXGEN_45, ++ IDX_FLEXGEN_46, ++ IDX_FLEXGEN_47, ++ IDX_FLEXGEN_48, ++ IDX_FLEXGEN_49, ++ IDX_FLEXGEN_50, ++ IDX_FLEXGEN_51, ++ IDX_FLEXGEN_52, ++ IDX_FLEXGEN_53, ++ IDX_FLEXGEN_54, ++ IDX_FLEXGEN_55, ++ IDX_FLEXGEN_56, ++ IDX_FLEXGEN_57, ++ IDX_FLEXGEN_58, ++ IDX_FLEXGEN_59, ++ IDX_FLEXGEN_60, ++ IDX_FLEXGEN_61, ++ IDX_FLEXGEN_62, ++ IDX_FLEXGEN_63, ++ IDX_ICN_APB1, ++ IDX_ICN_APB2, ++ IDX_ICN_APB3, ++ IDX_ICN_APB4, ++ IDX_ICN_APBDBG, ++ IDX_TIMG1, ++ IDX_TIMG2, ++ IDX_PLL3, ++ DSI_TXBYTE, + }; + +-static const char * const adc3_src[] = { +- "ck_flexgen_47", "ck_icn_ls_mcu", "ck_flexgen_46" ++static const struct clk_parent_data adc12_src[] = { ++ { .index = IDX_FLEXGEN_46 }, ++ { .index = IDX_ICN_LS_MCU }, + }; + +-static const char * const usb2phy1_src[] = { +- "ck_flexgen_57", "hse_div2_ck" ++static const struct clk_parent_data adc3_src[] = { ++ { .index = IDX_FLEXGEN_47 }, ++ { .index = IDX_ICN_LS_MCU }, ++ { .index = IDX_FLEXGEN_46 }, + }; + +-static const char * const usb2phy2_src[] = { +- "ck_flexgen_58", "hse_div2_ck" ++static const struct clk_parent_data usb2phy1_src[] = { ++ { .index = IDX_FLEXGEN_57 }, ++ { .index = IDX_HSE_DIV2 }, + }; + +-static const char * const usb3pciphy_src[] = { +- "ck_flexgen_34", "hse_div2_ck" ++static const struct clk_parent_data usb2phy2_src[] = { ++ { .index = IDX_FLEXGEN_58 }, ++ { .index = IDX_HSE_DIV2 }, + }; + +-static const char * const dsiblane_src[] = { +- "txbyteclk", "ck_ker_ltdc" ++static const struct clk_parent_data usb3pciphy_src[] = { ++ { .index = IDX_FLEXGEN_34 }, ++ { .index = IDX_HSE_DIV2 }, + }; + +-static const char * const dsiphy_src[] = { +- "ck_flexgen_28", "hse_ck" ++static const struct clk_parent_data dsiblane_src[] = { ++ { .index = DSI_TXBYTE }, ++ { .name = "ck_ker_ltdc" }, + }; + +-static const char * const lvdsphy_src[] = { +- "ck_flexgen_32", "hse_ck" ++static const struct clk_parent_data dsiphy_src[] = { ++ { .index = IDX_FLEXGEN_28 }, ++ { .index = IDX_HSE }, + }; + +-static const char * const dts_src[] = { +- "hsi_ck", "hse_ck", "msi_ck" ++static const struct clk_parent_data lvdsphy_src[] = { ++ { .index = IDX_FLEXGEN_32 }, ++ { .index = IDX_HSE }, + }; + +-static const char * const mco1_src[] = { +- "ck_flexgen_61", "ck_obs0" ++static const struct clk_parent_data dts_src[] = { ++ { .index = IDX_HSI }, ++ { .index = IDX_HSE }, ++ { .index = IDX_MSI }, + }; + +-static const char * const mco2_src[] = { +- "ck_flexgen_62", "ck_obs1" ++static const struct clk_parent_data mco1_src[] = { ++ { .index = IDX_FLEXGEN_61 }, ++}; ++ ++static const struct clk_parent_data mco2_src[] = { ++ { .index = IDX_FLEXGEN_62 }, + }; + + enum enum_mux_cfg { +@@ -104,7 +199,7 @@ enum enum_mux_cfg { + + #define MUX_CFG(id, src, _offset, _shift, _witdh)[id] = {\ + .num_parents = ARRAY_SIZE(src),\ +- .parent_names = src,\ ++ .parent_data = src,\ + .reg_off = (_offset),\ + .shift = (_shift),\ + .width = (_witdh),\ +@@ -443,42 +538,42 @@ static int stm32mp25_check_security(struct udevice *dev, void __iomem *base, + + static const struct clock_config stm32mp25_clock_cfg[] = { + /* ADC */ +- STM32_GATE(CK_BUS_ADC12, "ck_icn_p_adc12", "ck_icn_ls_mcu", 0, GATE_ADC12, ++ STM32_GATE(CK_BUS_ADC12, "ck_icn_p_adc12", IDX_ICN_LS_MCU, 0, GATE_ADC12, + SEC_RIFSC(58)), + STM32_COMPOSITE_NODIV(CK_KER_ADC12, "ck_ker_adc12", 0, SEC_RIFSC(58), + GATE_ADC12, MUX_ADC12), +- STM32_GATE(CK_BUS_ADC3, "ck_icn_p_adc3", "ck_icn_ls_mcu", 0, GATE_ADC3, SEC_RIFSC(59)), ++ STM32_GATE(CK_BUS_ADC3, "ck_icn_p_adc3", IDX_ICN_LS_MCU, 0, GATE_ADC3, SEC_RIFSC(59)), + STM32_COMPOSITE_NODIV(CK_KER_ADC3, "ck_ker_adc3", 0, SEC_RIFSC(59), GATE_ADC3, MUX_ADC3), + + /* ADF */ +- STM32_GATE(CK_BUS_ADF1, "ck_icn_p_adf1", "ck_icn_ls_mcu", 0, GATE_ADF1, SEC_RIFSC(55)), +- STM32_GATE(CK_KER_ADF1, "ck_ker_adf1", "ck_flexgen_42", 0, GATE_ADF1, SEC_RIFSC(55)), ++ STM32_GATE(CK_BUS_ADF1, "ck_icn_p_adf1", IDX_ICN_LS_MCU, 0, GATE_ADF1, SEC_RIFSC(55)), ++ STM32_GATE(CK_KER_ADF1, "ck_ker_adf1", IDX_FLEXGEN_42, 0, GATE_ADF1, SEC_RIFSC(55)), + + /* Camera */ + /* DCMI */ +- STM32_GATE(CK_BUS_CCI, "ck_icn_p_cci", "ck_icn_ls_mcu", 0, GATE_CCI, SEC_RIFSC(88)), ++ STM32_GATE(CK_BUS_CCI, "ck_icn_p_cci", IDX_ICN_LS_MCU, 0, GATE_CCI, SEC_RIFSC(88)), + + /* CSI-HOST */ +- STM32_GATE(CK_BUS_CSI, "ck_icn_p_csi", "ck_icn_apb4", 0, GATE_CSI, SEC_RIFSC(86)), +- STM32_GATE(CK_KER_CSI, "ck_ker_csi", "ck_flexgen_29", 0, GATE_CSI, SEC_RIFSC(86)), +- STM32_GATE(CK_KER_CSITXESC, "ck_ker_csitxesc", "ck_flexgen_30", 0, GATE_CSI, ++ STM32_GATE(CK_BUS_CSI, "ck_icn_p_csi", IDX_ICN_APB4, 0, GATE_CSI, SEC_RIFSC(86)), ++ STM32_GATE(CK_KER_CSI, "ck_ker_csi", IDX_FLEXGEN_29, 0, GATE_CSI, SEC_RIFSC(86)), ++ STM32_GATE(CK_KER_CSITXESC, "ck_ker_csitxesc", IDX_FLEXGEN_30, 0, GATE_CSI, + SEC_RIFSC(86)), + + /* CSI-PHY */ +- STM32_GATE(CK_KER_CSIPHY, "ck_ker_csiphy", "ck_flexgen_31", 0, GATE_CSI, ++ STM32_GATE(CK_KER_CSIPHY, "ck_ker_csiphy", IDX_FLEXGEN_31, 0, GATE_CSI, + SEC_RIFSC(86)), + + /* DCMIPP */ +- STM32_GATE(CK_BUS_DCMIPP, "ck_icn_p_dcmipp", "ck_icn_apb4", 0, GATE_DCMIPP, ++ STM32_GATE(CK_BUS_DCMIPP, "ck_icn_p_dcmipp", IDX_ICN_APB4, 0, GATE_DCMIPP, + SEC_RIFSC(87)), + + /* CRC */ +- STM32_GATE(CK_BUS_CRC, "ck_icn_p_crc", "ck_icn_ls_mcu", 0, GATE_CRC, SEC_RIFSC(109)), ++ STM32_GATE(CK_BUS_CRC, "ck_icn_p_crc", IDX_ICN_LS_MCU, 0, GATE_CRC, SEC_RIFSC(109)), + + /* CRYP */ +- STM32_GATE(CK_BUS_CRYP1, "ck_icn_p_cryp1", "ck_icn_ls_mcu", 0, GATE_CRYP1, ++ STM32_GATE(CK_BUS_CRYP1, "ck_icn_p_cryp1", IDX_ICN_LS_MCU, 0, GATE_CRYP1, + SEC_RIFSC(96)), +- STM32_GATE(CK_BUS_CRYP2, "ck_icn_p_cryp2", "ck_icn_ls_mcu", 0, GATE_CRYP2, ++ STM32_GATE(CK_BUS_CRYP2, "ck_icn_p_cryp2", IDX_ICN_LS_MCU, 0, GATE_CRYP2, + SEC_RIFSC(97)), + + /* DBG & TRACE*/ +@@ -486,17 +581,17 @@ static const struct clock_config stm32mp25_clock_cfg[] = { + + /* Display subsystem */ + /* LTDC */ +- STM32_GATE(CK_BUS_LTDC, "ck_icn_p_ltdc", "ck_icn_apb4", 0, GATE_LTDC, SEC_RIFSC(80)), +- STM32_GATE(CK_KER_LTDC, "ck_ker_ltdc", "ck_flexgen_27", CLK_SET_RATE_PARENT, GATE_LTDC, ++ STM32_GATE(CK_BUS_LTDC, "ck_icn_p_ltdc", IDX_ICN_APB4, 0, GATE_LTDC, SEC_RIFSC(80)), ++ STM32_GATE(CK_KER_LTDC, "ck_ker_ltdc", IDX_FLEXGEN_27, CLK_SET_RATE_PARENT, GATE_LTDC, + SEC_RIFSC(80)), + + /* DSI */ +- STM32_GATE(CK_BUS_DSI, "ck_icn_p_dsi", "ck_icn_apb4", 0, GATE_DSI, SEC_RIFSC(81)), ++ STM32_GATE(CK_BUS_DSI, "ck_icn_p_dsi", IDX_ICN_APB4, 0, GATE_DSI, SEC_RIFSC(81)), + STM32_COMPOSITE_NODIV(CK_KER_DSIBLANE, "clk_lanebyte", 0, SEC_RIFSC(81), + GATE_DSI, MUX_DSIBLANE), + + /* LVDS */ +- STM32_GATE(CK_BUS_LVDS, "ck_icn_p_lvds", "ck_icn_apb4", 0, GATE_LVDS, SEC_RIFSC(84)), ++ STM32_GATE(CK_BUS_LVDS, "ck_icn_p_lvds", IDX_ICN_APB4, 0, GATE_LVDS, SEC_RIFSC(84)), + + /* DSI PHY */ + STM32_COMPOSITE_NODIV(CK_KER_DSIPHY, "ck_ker_dsiphy", 0, SEC_RIFSC(81), +@@ -510,88 +605,88 @@ static const struct clock_config stm32mp25_clock_cfg[] = { + STM32_COMPOSITE_NODIV(CK_KER_DTS, "ck_ker_dts", 0, SEC_RIFSC(107), GATE_DTS, MUX_DTS), + + /* ETHERNET */ +- STM32_GATE(CK_BUS_ETH1, "ck_icn_p_eth1", "ck_icn_ls_mcu", 0, GATE_ETH1, SEC_RIFSC(60)), +- STM32_GATE(CK_ETH1_STP, "ck_ker_eth1stp", "ck_icn_ls_mcu", 0, GATE_ETH1STP, ++ STM32_GATE(CK_BUS_ETH1, "ck_icn_p_eth1", IDX_ICN_LS_MCU, 0, GATE_ETH1, SEC_RIFSC(60)), ++ STM32_GATE(CK_ETH1_STP, "ck_ker_eth1stp", IDX_ICN_LS_MCU, 0, GATE_ETH1STP, + SEC_RIFSC(60)), +- STM32_GATE(CK_KER_ETH1, "ck_ker_eth1", "ck_flexgen_54", 0, GATE_ETH1, SEC_RIFSC(60)), +- STM32_GATE(CK_KER_ETH1, "ck_ker_eth1ptp", "ck_flexgen_56", 0, GATE_ETH1, SEC_RIFSC(60)), +- STM32_GATE(CK_ETH1_MAC, "ck_ker_eth1mac", "ck_icn_ls_mcu", 0, GATE_ETH1MAC, ++ STM32_GATE(CK_KER_ETH1, "ck_ker_eth1", IDX_FLEXGEN_54, 0, GATE_ETH1, SEC_RIFSC(60)), ++ STM32_GATE(CK_KER_ETH1, "ck_ker_eth1ptp", IDX_FLEXGEN_56, 0, GATE_ETH1, SEC_RIFSC(60)), ++ STM32_GATE(CK_ETH1_MAC, "ck_ker_eth1mac", IDX_ICN_LS_MCU, 0, GATE_ETH1MAC, + SEC_RIFSC(60)), +- STM32_GATE(CK_ETH1_TX, "ck_ker_eth1tx", "ck_icn_ls_mcu", 0, GATE_ETH1TX, SEC_RIFSC(60)), +- STM32_GATE(CK_ETH1_RX, "ck_ker_eth1rx", "ck_icn_ls_mcu", 0, GATE_ETH1RX, SEC_RIFSC(60)), ++ STM32_GATE(CK_ETH1_TX, "ck_ker_eth1tx", IDX_ICN_LS_MCU, 0, GATE_ETH1TX, SEC_RIFSC(60)), ++ STM32_GATE(CK_ETH1_RX, "ck_ker_eth1rx", IDX_ICN_LS_MCU, 0, GATE_ETH1RX, SEC_RIFSC(60)), + +- STM32_GATE(CK_BUS_ETH2, "ck_icn_p_eth2", "ck_icn_ls_mcu", 0, GATE_ETH2, SEC_RIFSC(61)), +- STM32_GATE(CK_ETH2_STP, "ck_ker_eth2stp", "ck_icn_ls_mcu", 0, GATE_ETH2STP, ++ STM32_GATE(CK_BUS_ETH2, "ck_icn_p_eth2", IDX_ICN_LS_MCU, 0, GATE_ETH2, SEC_RIFSC(61)), ++ STM32_GATE(CK_ETH2_STP, "ck_ker_eth2stp", IDX_ICN_LS_MCU, 0, GATE_ETH2STP, + SEC_RIFSC(61)), +- STM32_GATE(CK_KER_ETH2, "ck_ker_eth2", "ck_flexgen_54", 0, GATE_ETH2, SEC_RIFSC(61)), +- STM32_GATE(CK_KER_ETH2, "ck_ker_eth2ptp", "ck_flexgen_56", 0, GATE_ETH2, SEC_RIFSC(61)), +- STM32_GATE(CK_ETH2_MAC, "ck_ker_eth2mac", "ck_icn_ls_mcu", 0, GATE_ETH2MAC, ++ STM32_GATE(CK_KER_ETH2, "ck_ker_eth2", IDX_FLEXGEN_54, 0, GATE_ETH2, SEC_RIFSC(61)), ++ STM32_GATE(CK_KER_ETH2, "ck_ker_eth2ptp", IDX_FLEXGEN_56, 0, GATE_ETH2, SEC_RIFSC(61)), ++ STM32_GATE(CK_ETH2_MAC, "ck_ker_eth2mac", IDX_ICN_LS_MCU, 0, GATE_ETH2MAC, + SEC_RIFSC(61)), +- STM32_GATE(CK_ETH2_TX, "ck_ker_eth2tx", "ck_icn_ls_mcu", 0, GATE_ETH2TX, SEC_RIFSC(61)), +- STM32_GATE(CK_ETH2_RX, "ck_ker_eth2rx", "ck_icn_ls_mcu", 0, GATE_ETH2RX, SEC_RIFSC(61)), ++ STM32_GATE(CK_ETH2_TX, "ck_ker_eth2tx", IDX_ICN_LS_MCU, 0, GATE_ETH2TX, SEC_RIFSC(61)), ++ STM32_GATE(CK_ETH2_RX, "ck_ker_eth2rx", IDX_ICN_LS_MCU, 0, GATE_ETH2RX, SEC_RIFSC(61)), + +- STM32_GATE(CK_BUS_ETHSW, "ck_icn_p_ethsw", "ck_icn_ls_mcu", 0, GATE_ETHSWMAC, ++ STM32_GATE(CK_BUS_ETHSW, "ck_icn_p_ethsw", IDX_ICN_LS_MCU, 0, GATE_ETHSWMAC, + SEC_RIFSC(70)), +- STM32_GATE(CK_KER_ETHSW, "ck_ker_ethsw", "ck_flexgen_54", 0, GATE_ETHSW, ++ STM32_GATE(CK_KER_ETHSW, "ck_ker_ethsw", IDX_FLEXGEN_54, 0, GATE_ETHSW, + SEC_RIFSC(70)), +- STM32_GATE(CK_KER_ETHSWREF, "ck_ker_ethswref", "ck_flexgen_60", 0, GATE_ETHSWREF, ++ STM32_GATE(CK_KER_ETHSWREF, "ck_ker_ethswref", IDX_FLEXGEN_60, 0, GATE_ETHSWREF, + SEC_RIFSC(70)), + + /* FDCAN */ +- STM32_GATE(CK_BUS_FDCAN, "ck_icn_p_fdcan", "ck_icn_apb2", 0, GATE_FDCAN, SEC_RIFSC(56)), +- STM32_GATE(CK_KER_FDCAN, "ck_ker_fdcan", "ck_flexgen_26", 0, GATE_FDCAN, SEC_RIFSC(56)), ++ STM32_GATE(CK_BUS_FDCAN, "ck_icn_p_fdcan", IDX_ICN_APB2, 0, GATE_FDCAN, SEC_RIFSC(56)), ++ STM32_GATE(CK_KER_FDCAN, "ck_ker_fdcan", IDX_FLEXGEN_26, 0, GATE_FDCAN, SEC_RIFSC(56)), + + /* GPU */ +- STM32_GATE(CK_BUS_GPU, "ck_icn_m_gpu", "ck_flexgen_59", 0, GATE_GPU, SEC_RIFSC(79)), +- STM32_GATE(CK_KER_GPU, "ck_ker_gpu", "ck_pll3", 0, GATE_GPU, SEC_RIFSC(79)), ++ STM32_GATE(CK_BUS_GPU, "ck_icn_m_gpu", IDX_FLEXGEN_59, 0, GATE_GPU, SEC_RIFSC(79)), ++ STM32_GATE(CK_KER_GPU, "ck_ker_gpu", IDX_PLL3, 0, GATE_GPU, SEC_RIFSC(79)), + + /* HASH */ +- STM32_GATE(CK_BUS_HASH, "ck_icn_p_hash", "ck_icn_ls_mcu", 0, GATE_HASH, SEC_RIFSC(95)), ++ STM32_GATE(CK_BUS_HASH, "ck_icn_p_hash", IDX_ICN_LS_MCU, 0, GATE_HASH, SEC_RIFSC(95)), + + /* HDP */ +- STM32_GATE(CK_BUS_HDP, "ck_icn_p_hdp", "ck_icn_apb3", 0, GATE_HDP, SEC_RIFSC(57)), ++ STM32_GATE(CK_BUS_HDP, "ck_icn_p_hdp", IDX_ICN_APB3, 0, GATE_HDP, SEC_RIFSC(57)), + + /* I2C */ +- STM32_GATE(CK_KER_I2C1, "ck_ker_i2c1", "ck_flexgen_12", 0, GATE_I2C1, SEC_RIFSC(41)), +- STM32_GATE(CK_KER_I2C2, "ck_ker_i2c2", "ck_flexgen_12", 0, GATE_I2C2, SEC_RIFSC(42)), +- STM32_GATE(CK_KER_I2C3, "ck_ker_i2c3", "ck_flexgen_13", 0, GATE_I2C3, SEC_RIFSC(43)), +- STM32_GATE(CK_KER_I2C5, "ck_ker_i2c5", "ck_flexgen_13", 0, GATE_I2C5, SEC_RIFSC(45)), +- STM32_GATE(CK_KER_I2C4, "ck_ker_i2c4", "ck_flexgen_14", 0, GATE_I2C4, SEC_RIFSC(44)), +- STM32_GATE(CK_KER_I2C6, "ck_ker_i2c6", "ck_flexgen_14", 0, GATE_I2C6, SEC_RIFSC(46)), +- STM32_GATE(CK_KER_I2C7, "ck_ker_i2c7", "ck_flexgen_15", 0, GATE_I2C7, SEC_RIFSC(47)), +- STM32_GATE(CK_KER_I2C8, "ck_ker_i2c8", "ck_flexgen_38", 0, GATE_I2C8, SEC_RIFSC(48)), ++ STM32_GATE(CK_KER_I2C1, "ck_ker_i2c1", IDX_FLEXGEN_12, 0, GATE_I2C1, SEC_RIFSC(41)), ++ STM32_GATE(CK_KER_I2C2, "ck_ker_i2c2", IDX_FLEXGEN_12, 0, GATE_I2C2, SEC_RIFSC(42)), ++ STM32_GATE(CK_KER_I2C3, "ck_ker_i2c3", IDX_FLEXGEN_13, 0, GATE_I2C3, SEC_RIFSC(43)), ++ STM32_GATE(CK_KER_I2C5, "ck_ker_i2c5", IDX_FLEXGEN_13, 0, GATE_I2C5, SEC_RIFSC(45)), ++ STM32_GATE(CK_KER_I2C4, "ck_ker_i2c4", IDX_FLEXGEN_14, 0, GATE_I2C4, SEC_RIFSC(44)), ++ STM32_GATE(CK_KER_I2C6, "ck_ker_i2c6", IDX_FLEXGEN_14, 0, GATE_I2C6, SEC_RIFSC(46)), ++ STM32_GATE(CK_KER_I2C7, "ck_ker_i2c7", IDX_FLEXGEN_15, 0, GATE_I2C7, SEC_RIFSC(47)), ++ STM32_GATE(CK_KER_I2C8, "ck_ker_i2c8", IDX_FLEXGEN_38, 0, GATE_I2C8, SEC_RIFSC(48)), + + /* I3C */ +- STM32_GATE(CK_KER_I3C1, "ck_ker_i3c1", "ck_flexgen_12", 0, GATE_I3C1, SEC_RIFSC(114)), +- STM32_GATE(CK_KER_I3C2, "ck_ker_i3c2", "ck_flexgen_12", 0, GATE_I3C2, SEC_RIFSC(115)), +- STM32_GATE(CK_KER_I3C3, "ck_ker_i3c3", "ck_flexgen_13", 0, GATE_I3C3, SEC_RIFSC(116)), +- STM32_GATE(CK_KER_I3C4, "ck_ker_i3c4", "ck_flexgen_36", 0, GATE_I3C4, SEC_RIFSC(117)), ++ STM32_GATE(CK_KER_I3C1, "ck_ker_i3c1", IDX_FLEXGEN_12, 0, GATE_I3C1, SEC_RIFSC(114)), ++ STM32_GATE(CK_KER_I3C2, "ck_ker_i3c2", IDX_FLEXGEN_12, 0, GATE_I3C2, SEC_RIFSC(115)), ++ STM32_GATE(CK_KER_I3C3, "ck_ker_i3c3", IDX_FLEXGEN_13, 0, GATE_I3C3, SEC_RIFSC(116)), ++ STM32_GATE(CK_KER_I3C4, "ck_ker_i3c4", IDX_FLEXGEN_36, 0, GATE_I3C4, SEC_RIFSC(117)), + + /* I2S */ +- STM32_GATE(CK_BUS_IS2M, "ck_icn_p_is2m", "ck_icn_apb3", 0, GATE_IS2M, SEC_RIFRCC(IS2M)), ++ STM32_GATE(CK_BUS_IS2M, "ck_icn_p_is2m", IDX_ICN_APB3, 0, GATE_IS2M, SEC_RIFRCC(IS2M)), + + /* IWDG */ +- STM32_GATE(CK_BUS_IWDG1, "ck_icn_p_iwdg1", "ck_icn_apb3", 0, GATE_IWDG1, SEC_RIFSC(98)), +- STM32_GATE(CK_BUS_IWDG2, "ck_icn_p_iwdg2", "ck_icn_apb3", 0, GATE_IWDG2, SEC_RIFSC(99)), +- STM32_GATE(CK_BUS_IWDG3, "ck_icn_p_iwdg3", "ck_icn_apb3", 0, GATE_IWDG3, SEC_RIFSC(100)), +- STM32_GATE(CK_BUS_IWDG4, "ck_icn_p_iwdg4", "ck_icn_apb3", 0, GATE_IWDG4, SEC_RIFSC(101)), +- STM32_GATE(CK_BUS_IWDG5, "ck_icn_p_iwdg5", "ck_icn_ls_mcu", 0, GATE_IWDG5, ++ STM32_GATE(CK_BUS_IWDG1, "ck_icn_p_iwdg1", IDX_ICN_APB3, 0, GATE_IWDG1, SEC_RIFSC(98)), ++ STM32_GATE(CK_BUS_IWDG2, "ck_icn_p_iwdg2", IDX_ICN_APB3, 0, GATE_IWDG2, SEC_RIFSC(99)), ++ STM32_GATE(CK_BUS_IWDG3, "ck_icn_p_iwdg3", IDX_ICN_APB3, 0, GATE_IWDG3, SEC_RIFSC(100)), ++ STM32_GATE(CK_BUS_IWDG4, "ck_icn_p_iwdg4", IDX_ICN_APB3, 0, GATE_IWDG4, SEC_RIFSC(101)), ++ STM32_GATE(CK_BUS_IWDG5, "ck_icn_p_iwdg5", IDX_ICN_LS_MCU, 0, GATE_IWDG5, + SEC_RIFSC(102)), + + /* LPTIM */ +- STM32_GATE(CK_KER_LPTIM1, "ck_ker_lptim1", "ck_flexgen_07", 0, GATE_LPTIM1, ++ STM32_GATE(CK_KER_LPTIM1, "ck_ker_lptim1", IDX_FLEXGEN_07, 0, GATE_LPTIM1, + SEC_RIFSC(17)), +- STM32_GATE(CK_KER_LPTIM2, "ck_ker_lptim2", "ck_flexgen_07", 0, GATE_LPTIM2, ++ STM32_GATE(CK_KER_LPTIM2, "ck_ker_lptim2", IDX_FLEXGEN_07, 0, GATE_LPTIM2, + SEC_RIFSC(18)), +- STM32_GATE(CK_KER_LPTIM3, "ck_ker_lptim3", "ck_flexgen_40", 0, GATE_LPTIM3, ++ STM32_GATE(CK_KER_LPTIM3, "ck_ker_lptim3", IDX_FLEXGEN_40, 0, GATE_LPTIM3, + SEC_RIFSC(19)), +- STM32_GATE(CK_KER_LPTIM4, "ck_ker_lptim4", "ck_flexgen_41", 0, GATE_LPTIM4, ++ STM32_GATE(CK_KER_LPTIM4, "ck_ker_lptim4", IDX_FLEXGEN_41, 0, GATE_LPTIM4, + SEC_RIFSC(20)), +- STM32_GATE(CK_KER_LPTIM5, "ck_ker_lptim5", "ck_flexgen_41", 0, GATE_LPTIM5, ++ STM32_GATE(CK_KER_LPTIM5, "ck_ker_lptim5", IDX_FLEXGEN_41, 0, GATE_LPTIM5, + SEC_RIFSC(21)), + + /* LPUART */ +- STM32_GATE(CK_KER_LPUART1, "ck_ker_lpuart1", "ck_flexgen_39", 0, GATE_LPUART1, ++ STM32_GATE(CK_KER_LPUART1, "ck_ker_lpuart1", IDX_FLEXGEN_39, 0, GATE_LPUART1, + SEC_RIFSC(40)), + + /* MCO1 & MCO2 */ +@@ -599,102 +694,102 @@ static const struct clock_config stm32mp25_clock_cfg[] = { + STM32_COMPOSITE_NODIV(CK_MCO2, "ck_mco2", 0, SEC_RIFRCC(MCO2), GATE_MCO2, MUX_MCO2), + + /* MDF */ +- STM32_GATE(CK_KER_MDF1, "ck_ker_mdf1", "ck_flexgen_23", 0, GATE_MDF1, SEC_RIFSC(54)), ++ STM32_GATE(CK_KER_MDF1, "ck_ker_mdf1", IDX_FLEXGEN_23, 0, GATE_MDF1, SEC_RIFSC(54)), + + /* OCTOSPI */ +- STM32_GATE(CK_BUS_OSPIIOM, "ck_icn_p_ospiiom", "ck_icn_ls_mcu", 0, GATE_OSPIIOM, ++ STM32_GATE(CK_BUS_OSPIIOM, "ck_icn_p_ospiiom", IDX_ICN_LS_MCU, 0, GATE_OSPIIOM, + SEC_RIFSC(111)), + + /* PCIE */ +- STM32_GATE(CK_BUS_PCIE, "ck_icn_p_pcie", "ck_icn_ls_mcu", 0, GATE_PCIE, SEC_RIFSC(68)), ++ STM32_GATE(CK_BUS_PCIE, "ck_icn_p_pcie", IDX_ICN_LS_MCU, 0, GATE_PCIE, SEC_RIFSC(68)), + + /* PKA */ +- STM32_GATE(CK_BUS_PKA, "ck_icn_p_pka", "ck_icn_ls_mcu", 0, GATE_PKA, SEC_RIFSC(93)), ++ STM32_GATE(CK_BUS_PKA, "ck_icn_p_pka", IDX_ICN_LS_MCU, 0, GATE_PKA, SEC_RIFSC(93)), + + /* RNG */ +- STM32_GATE(CK_BUS_RNG, "ck_icn_p_rng", "ck_icn_ls_mcu", CLK_IGNORE_UNUSED, GATE_RNG, ++ STM32_GATE(CK_BUS_RNG, "ck_icn_p_rng", IDX_ICN_LS_MCU, CLK_IGNORE_UNUSED, GATE_RNG, + SEC_RIFSC(92)), + + /* SAES */ +- STM32_GATE(CK_BUS_SAES, "ck_icn_p_saes", "ck_icn_ls_mcu", 0, GATE_SAES, SEC_RIFSC(94)), ++ STM32_GATE(CK_BUS_SAES, "ck_icn_p_saes", IDX_ICN_LS_MCU, 0, GATE_SAES, SEC_RIFSC(94)), + + /* SAI [1..4] */ +- STM32_GATE(CK_BUS_SAI1, "ck_icn_p_sai1", "ck_icn_apb2", 0, GATE_SAI1, SEC_RIFSC(49)), +- STM32_GATE(CK_BUS_SAI2, "ck_icn_p_sai2", "ck_icn_apb2", 0, GATE_SAI2, SEC_RIFSC(50)), +- STM32_GATE(CK_BUS_SAI3, "ck_icn_p_sai3", "ck_icn_apb2", 0, GATE_SAI3, SEC_RIFSC(51)), +- STM32_GATE(CK_BUS_SAI4, "ck_icn_p_sai4", "ck_icn_apb2", 0, GATE_SAI4, SEC_RIFSC(52)), +- STM32_GATE(CK_KER_SAI1, "ck_ker_sai1", "ck_flexgen_23", 0, GATE_SAI1, SEC_RIFSC(49)), +- STM32_GATE(CK_KER_SAI2, "ck_ker_sai2", "ck_flexgen_24", 0, GATE_SAI2, SEC_RIFSC(50)), +- STM32_GATE(CK_KER_SAI3, "ck_ker_sai3", "ck_flexgen_25", 0, GATE_SAI3, SEC_RIFSC(51)), +- STM32_GATE(CK_KER_SAI4, "ck_ker_sai4", "ck_flexgen_25", 0, GATE_SAI4, SEC_RIFSC(52)), ++ STM32_GATE(CK_BUS_SAI1, "ck_icn_p_sai1", IDX_ICN_APB2, 0, GATE_SAI1, SEC_RIFSC(49)), ++ STM32_GATE(CK_BUS_SAI2, "ck_icn_p_sai2", IDX_ICN_APB2, 0, GATE_SAI2, SEC_RIFSC(50)), ++ STM32_GATE(CK_BUS_SAI3, "ck_icn_p_sai3", IDX_ICN_APB2, 0, GATE_SAI3, SEC_RIFSC(51)), ++ STM32_GATE(CK_BUS_SAI4, "ck_icn_p_sai4", IDX_ICN_APB2, 0, GATE_SAI4, SEC_RIFSC(52)), ++ STM32_GATE(CK_KER_SAI1, "ck_ker_sai1", IDX_FLEXGEN_23, 0, GATE_SAI1, SEC_RIFSC(49)), ++ STM32_GATE(CK_KER_SAI2, "ck_ker_sai2", IDX_FLEXGEN_24, 0, GATE_SAI2, SEC_RIFSC(50)), ++ STM32_GATE(CK_KER_SAI3, "ck_ker_sai3", IDX_FLEXGEN_25, 0, GATE_SAI3, SEC_RIFSC(51)), ++ STM32_GATE(CK_KER_SAI4, "ck_ker_sai4", IDX_FLEXGEN_25, 0, GATE_SAI4, SEC_RIFSC(52)), + + /* SDMMC */ +- STM32_GATE(CK_KER_SDMMC1, "ck_ker_sdmmc1", "ck_flexgen_51", 0, GATE_SDMMC1, ++ STM32_GATE(CK_KER_SDMMC1, "ck_ker_sdmmc1", IDX_FLEXGEN_51, 0, GATE_SDMMC1, + SEC_RIFSC(76)), +- STM32_GATE(CK_KER_SDMMC2, "ck_ker_sdmmc2", "ck_flexgen_52", 0, GATE_SDMMC2, ++ STM32_GATE(CK_KER_SDMMC2, "ck_ker_sdmmc2", IDX_FLEXGEN_52, 0, GATE_SDMMC2, + SEC_RIFSC(77)), +- STM32_GATE(CK_KER_SDMMC3, "ck_ker_sdmmc3", "ck_flexgen_53", 0, GATE_SDMMC3, ++ STM32_GATE(CK_KER_SDMMC3, "ck_ker_sdmmc3", IDX_FLEXGEN_53, 0, GATE_SDMMC3, + SEC_RIFSC(78)), + + /* SERC */ +- STM32_GATE(CK_BUS_SERC, "ck_icn_p_serc", "ck_icn_apb3", 0, GATE_SERC, SEC_RIFSC(110)), ++ STM32_GATE(CK_BUS_SERC, "ck_icn_p_serc", IDX_ICN_APB3, 0, GATE_SERC, SEC_RIFSC(110)), + + /* SPDIF */ +- STM32_GATE(CK_KER_SPDIFRX, "ck_ker_spdifrx", "ck_flexgen_11", 0, GATE_SPDIFRX, ++ STM32_GATE(CK_KER_SPDIFRX, "ck_ker_spdifrx", IDX_FLEXGEN_11, 0, GATE_SPDIFRX, + SEC_RIFSC(30)), + + /* SPI */ +- STM32_GATE(CK_KER_SPI1, "ck_ker_spi1", "ck_flexgen_16", 0, GATE_SPI1, SEC_RIFSC(22)), +- STM32_GATE(CK_KER_SPI2, "ck_ker_spi2", "ck_flexgen_10", 0, GATE_SPI2, SEC_RIFSC(23)), +- STM32_GATE(CK_KER_SPI3, "ck_ker_spi3", "ck_flexgen_10", 0, GATE_SPI3, SEC_RIFSC(24)), +- STM32_GATE(CK_KER_SPI4, "ck_ker_spi4", "ck_flexgen_17", 0, GATE_SPI4, SEC_RIFSC(25)), +- STM32_GATE(CK_KER_SPI5, "ck_ker_spi5", "ck_flexgen_17", 0, GATE_SPI5, SEC_RIFSC(26)), +- STM32_GATE(CK_KER_SPI6, "ck_ker_spi6", "ck_flexgen_18", 0, GATE_SPI6, SEC_RIFSC(27)), +- STM32_GATE(CK_KER_SPI7, "ck_ker_spi7", "ck_flexgen_18", 0, GATE_SPI7, SEC_RIFSC(28)), +- STM32_GATE(CK_KER_SPI8, "ck_ker_spi8", "ck_flexgen_37", 0, GATE_SPI8, SEC_RIFSC(29)), ++ STM32_GATE(CK_KER_SPI1, "ck_ker_spi1", IDX_FLEXGEN_16, 0, GATE_SPI1, SEC_RIFSC(22)), ++ STM32_GATE(CK_KER_SPI2, "ck_ker_spi2", IDX_FLEXGEN_10, 0, GATE_SPI2, SEC_RIFSC(23)), ++ STM32_GATE(CK_KER_SPI3, "ck_ker_spi3", IDX_FLEXGEN_10, 0, GATE_SPI3, SEC_RIFSC(24)), ++ STM32_GATE(CK_KER_SPI4, "ck_ker_spi4", IDX_FLEXGEN_17, 0, GATE_SPI4, SEC_RIFSC(25)), ++ STM32_GATE(CK_KER_SPI5, "ck_ker_spi5", IDX_FLEXGEN_17, 0, GATE_SPI5, SEC_RIFSC(26)), ++ STM32_GATE(CK_KER_SPI6, "ck_ker_spi6", IDX_FLEXGEN_18, 0, GATE_SPI6, SEC_RIFSC(27)), ++ STM32_GATE(CK_KER_SPI7, "ck_ker_spi7", IDX_FLEXGEN_18, 0, GATE_SPI7, SEC_RIFSC(28)), ++ STM32_GATE(CK_KER_SPI8, "ck_ker_spi8", IDX_FLEXGEN_37, 0, GATE_SPI8, SEC_RIFSC(29)), + + /* STGEN */ +- STM32_GATE(CK_KER_STGEN, "ck_ker_stgen", "ck_flexgen_33", CLK_IGNORE_UNUSED, GATE_STGEN, ++ STM32_GATE(CK_KER_STGEN, "ck_ker_stgen", IDX_FLEXGEN_33, CLK_IGNORE_UNUSED, GATE_STGEN, + SEC_RIFSC(73)), + + /* Timers */ +- STM32_GATE(CK_KER_TIM2, "ck_ker_tim2", "timg1_ck", 0, GATE_TIM2, SEC_RIFSC(1)), +- STM32_GATE(CK_KER_TIM3, "ck_ker_tim3", "timg1_ck", 0, GATE_TIM3, SEC_RIFSC(2)), +- STM32_GATE(CK_KER_TIM4, "ck_ker_tim4", "timg1_ck", 0, GATE_TIM4, SEC_RIFSC(3)), +- STM32_GATE(CK_KER_TIM5, "ck_ker_tim5", "timg1_ck", 0, GATE_TIM5, SEC_RIFSC(4)), +- STM32_GATE(CK_KER_TIM6, "ck_ker_tim6", "timg1_ck", 0, GATE_TIM6, SEC_RIFSC(5)), +- STM32_GATE(CK_KER_TIM7, "ck_ker_tim7", "timg1_ck", 0, GATE_TIM7, SEC_RIFSC(6)), +- STM32_GATE(CK_KER_TIM10, "ck_ker_tim10", "timg1_ck", 0, GATE_TIM10, SEC_RIFSC(8)), +- STM32_GATE(CK_KER_TIM11, "ck_ker_tim11", "timg1_ck", 0, GATE_TIM11, SEC_RIFSC(9)), +- STM32_GATE(CK_KER_TIM12, "ck_ker_tim12", "timg1_ck", 0, GATE_TIM12, SEC_RIFSC(10)), +- STM32_GATE(CK_KER_TIM13, "ck_ker_tim13", "timg1_ck", 0, GATE_TIM13, SEC_RIFSC(11)), +- STM32_GATE(CK_KER_TIM14, "ck_ker_tim14", "timg1_ck", 0, GATE_TIM14, SEC_RIFSC(12)), +- +- STM32_GATE(CK_KER_TIM1, "ck_ker_tim1", "timg2_ck", 0, GATE_TIM1, SEC_RIFSC(0)), +- STM32_GATE(CK_KER_TIM8, "ck_ker_tim8", "timg2_ck", 0, GATE_TIM8, SEC_RIFSC(7)), +- STM32_GATE(CK_KER_TIM15, "ck_ker_tim15", "timg2_ck", 0, GATE_TIM15, SEC_RIFSC(13)), +- STM32_GATE(CK_KER_TIM16, "ck_ker_tim16", "timg2_ck", 0, GATE_TIM16, SEC_RIFSC(14)), +- STM32_GATE(CK_KER_TIM17, "ck_ker_tim17", "timg2_ck", 0, GATE_TIM17, SEC_RIFSC(15)), +- STM32_GATE(CK_KER_TIM20, "ck_ker_tim20", "timg2_ck", 0, GATE_TIM20, SEC_RIFSC(20)), ++ STM32_GATE(CK_KER_TIM2, "ck_ker_tim2", IDX_TIMG1, 0, GATE_TIM2, SEC_RIFSC(1)), ++ STM32_GATE(CK_KER_TIM3, "ck_ker_tim3", IDX_TIMG1, 0, GATE_TIM3, SEC_RIFSC(2)), ++ STM32_GATE(CK_KER_TIM4, "ck_ker_tim4", IDX_TIMG1, 0, GATE_TIM4, SEC_RIFSC(3)), ++ STM32_GATE(CK_KER_TIM5, "ck_ker_tim5", IDX_TIMG1, 0, GATE_TIM5, SEC_RIFSC(4)), ++ STM32_GATE(CK_KER_TIM6, "ck_ker_tim6", IDX_TIMG1, 0, GATE_TIM6, SEC_RIFSC(5)), ++ STM32_GATE(CK_KER_TIM7, "ck_ker_tim7", IDX_TIMG1, 0, GATE_TIM7, SEC_RIFSC(6)), ++ STM32_GATE(CK_KER_TIM10, "ck_ker_tim10", IDX_TIMG1, 0, GATE_TIM10, SEC_RIFSC(8)), ++ STM32_GATE(CK_KER_TIM11, "ck_ker_tim11", IDX_TIMG1, 0, GATE_TIM11, SEC_RIFSC(9)), ++ STM32_GATE(CK_KER_TIM12, "ck_ker_tim12", IDX_TIMG1, 0, GATE_TIM12, SEC_RIFSC(10)), ++ STM32_GATE(CK_KER_TIM13, "ck_ker_tim13", IDX_TIMG1, 0, GATE_TIM13, SEC_RIFSC(11)), ++ STM32_GATE(CK_KER_TIM14, "ck_ker_tim14", IDX_TIMG1, 0, GATE_TIM14, SEC_RIFSC(12)), ++ ++ STM32_GATE(CK_KER_TIM1, "ck_ker_tim1", IDX_TIMG2, 0, GATE_TIM1, SEC_RIFSC(0)), ++ STM32_GATE(CK_KER_TIM8, "ck_ker_tim8", IDX_TIMG2, 0, GATE_TIM8, SEC_RIFSC(7)), ++ STM32_GATE(CK_KER_TIM15, "ck_ker_tim15", IDX_TIMG2, 0, GATE_TIM15, SEC_RIFSC(13)), ++ STM32_GATE(CK_KER_TIM16, "ck_ker_tim16", IDX_TIMG2, 0, GATE_TIM16, SEC_RIFSC(14)), ++ STM32_GATE(CK_KER_TIM17, "ck_ker_tim17", IDX_TIMG2, 0, GATE_TIM17, SEC_RIFSC(15)), ++ STM32_GATE(CK_KER_TIM20, "ck_ker_tim20", IDX_TIMG2, 0, GATE_TIM20, SEC_RIFSC(20)), + + /* UART/USART */ +- STM32_GATE(CK_KER_USART2, "ck_ker_usart2", "ck_flexgen_08", 0, GATE_USART2, ++ STM32_GATE(CK_KER_USART2, "ck_ker_usart2", IDX_FLEXGEN_08, 0, GATE_USART2, + SEC_RIFSC(32)), +- STM32_GATE(CK_KER_UART4, "ck_ker_uart4", "ck_flexgen_08", 0, GATE_UART4, ++ STM32_GATE(CK_KER_UART4, "ck_ker_uart4", IDX_FLEXGEN_08, 0, GATE_UART4, + SEC_RIFSC(34)), +- STM32_GATE(CK_KER_USART3, "ck_ker_usart3", "ck_flexgen_09", 0, GATE_USART3, ++ STM32_GATE(CK_KER_USART3, "ck_ker_usart3", IDX_FLEXGEN_09, 0, GATE_USART3, + SEC_RIFSC(33)), +- STM32_GATE(CK_KER_UART5, "ck_ker_uart5", "ck_flexgen_09", 0, GATE_UART5, ++ STM32_GATE(CK_KER_UART5, "ck_ker_uart5", IDX_FLEXGEN_09, 0, GATE_UART5, + SEC_RIFSC(35)), +- STM32_GATE(CK_KER_USART1, "ck_ker_usart1", "ck_flexgen_19", 0, GATE_USART1, ++ STM32_GATE(CK_KER_USART1, "ck_ker_usart1", IDX_FLEXGEN_19, 0, GATE_USART1, + SEC_RIFSC(31)), +- STM32_GATE(CK_KER_USART6, "ck_ker_usart6", "ck_flexgen_20", 0, GATE_USART6, ++ STM32_GATE(CK_KER_USART6, "ck_ker_usart6", IDX_FLEXGEN_20, 0, GATE_USART6, + SEC_RIFSC(36)), +- STM32_GATE(CK_KER_UART7, "ck_ker_uart7", "ck_flexgen_21", 0, GATE_UART7, ++ STM32_GATE(CK_KER_UART7, "ck_ker_uart7", IDX_FLEXGEN_21, 0, GATE_UART7, + SEC_RIFSC(37)), +- STM32_GATE(CK_KER_UART8, "ck_ker_uart8", "ck_flexgen_21", 0, GATE_UART8, ++ STM32_GATE(CK_KER_UART8, "ck_ker_uart8", IDX_FLEXGEN_21, 0, GATE_UART8, + SEC_RIFSC(38)), +- STM32_GATE(CK_KER_UART9, "ck_ker_uart9", "ck_flexgen_22", 0, GATE_UART9, ++ STM32_GATE(CK_KER_UART9, "ck_ker_uart9", IDX_FLEXGEN_22, 0, GATE_UART9, + SEC_RIFSC(39)), + + /* USB2PHY1 */ +@@ -702,9 +797,9 @@ static const struct clock_config stm32mp25_clock_cfg[] = { + GATE_USB2PHY1, MUX_USB2PHY1), + + /* USBH */ +- STM32_GATE(CK_BUS_USB2OHCI, "ck_icn_m_usb2ohci", "ck_icn_hsl", 0, GATE_USBH, ++ STM32_GATE(CK_BUS_USB2OHCI, "ck_icn_m_usb2ohci", IDX_ICN_HSL, 0, GATE_USBH, + SEC_RIFSC(63)), +- STM32_GATE(CK_BUS_USB2EHCI, "ck_icn_m_usb2ehci", "ck_icn_hsl", 0, GATE_USBH, ++ STM32_GATE(CK_BUS_USB2EHCI, "ck_icn_m_usb2ehci", IDX_ICN_HSL, 0, GATE_USBH, + SEC_RIFSC(63)), + + /* USB2PHY2 */ +@@ -712,36 +807,36 @@ static const struct clock_config stm32mp25_clock_cfg[] = { + GATE_USB2PHY2, MUX_USB2PHY2), + + /* USB3 PCIe COMBOPHY */ +- STM32_GATE(CK_BUS_USB3PCIEPHY, "ck_icn_p_usb3pciephy", "ck_icn_apb4", 0, GATE_USB3PCIEPHY, +- SEC_RIFSC(67)), ++ STM32_GATE(CK_BUS_USB3PCIEPHY, "ck_icn_p_usb3pciephy", IDX_ICN_APB4, 0, ++ GATE_USB3PCIEPHY, SEC_RIFSC(67)), + + STM32_COMPOSITE_NODIV(CK_KER_USB3PCIEPHY, "ck_ker_usb3pciephy", 0, SEC_RIFSC(67), + GATE_USB3PCIEPHY, MUX_USB3PCIEPHY), + + /* USB3 DRD */ +- STM32_GATE(CK_BUS_USB3DR, "ck_icn_m_usb3dr", "ck_icn_hsl", 0, GATE_USB3DR, ++ STM32_GATE(CK_BUS_USB3DR, "ck_icn_m_usb3dr", IDX_ICN_HSL, 0, GATE_USB3DR, + SEC_RIFSC(66)), +- STM32_GATE(CK_KER_USB2PHY2, "ck_ker_usb2phy2", "ck_flexgen_58", 0, GATE_USB3DR, ++ STM32_GATE(CK_KER_USB2PHY2, "ck_ker_usb2phy2", IDX_FLEXGEN_58, 0, GATE_USB3DR, + SEC_RIFSC(66)), + + /* UCPD */ +- STM32_GATE(CK_BUS_USBTC, "ck_icn_p_usbtc", "ck_flexgen_35", 0, GATE_USBTC, ++ STM32_GATE(CK_BUS_USBTC, "ck_icn_p_usbtc", IDX_FLEXGEN_35, 0, GATE_USBTC, + SEC_RIFSC(69)), +- STM32_GATE(CK_KER_USBTC, "ck_ker_usbtc", "ck_flexgen_35", 0, GATE_USBTC, ++ STM32_GATE(CK_KER_USBTC, "ck_ker_usbtc", IDX_FLEXGEN_35, 0, GATE_USBTC, + SEC_RIFSC(69)), + + /* VDEC / VENC */ +- STM32_GATE(CK_BUS_VDEC, "ck_icn_p_vdec", "ck_icn_apb4", 0, GATE_VDEC, SEC_RIFSC(89)), +- STM32_GATE(CK_BUS_VENC, "ck_icn_p_venc", "ck_icn_apb4", 0, GATE_VENC, SEC_RIFSC(90)), ++ STM32_GATE(CK_BUS_VDEC, "ck_icn_p_vdec", IDX_ICN_APB4, 0, GATE_VDEC, SEC_RIFSC(89)), ++ STM32_GATE(CK_BUS_VENC, "ck_icn_p_venc", IDX_ICN_APB4, 0, GATE_VENC, SEC_RIFSC(90)), + + /* VREF */ +- STM32_GATE(CK_BUS_VREF, "ck_icn_p_vref", "ck_icn_apb3", 0, RCC_VREFCFGR, ++ STM32_GATE(CK_BUS_VREF, "ck_icn_p_vref", IDX_ICN_APB3, 0, RCC_VREFCFGR, + SEC_RIFSC(106)), + + /* WWDG */ +- STM32_GATE(CK_BUS_WWDG1, "ck_icn_p_wwdg1", "ck_icn_apb3", 0, GATE_WWDG1, ++ STM32_GATE(CK_BUS_WWDG1, "ck_icn_p_wwdg1", IDX_ICN_APB3, 0, GATE_WWDG1, + SEC_RIFSC(103)), +- STM32_GATE(CK_BUS_WWDG2, "ck_icn_p_wwdg2", "ck_icn_ls_mcu", 0, GATE_WWDG2, ++ STM32_GATE(CK_BUS_WWDG2, "ck_icn_p_wwdg2", IDX_ICN_LS_MCU, 0, GATE_WWDG2, + SEC_RIFSC(104)), + }; + +-- +2.51.0 + diff --git a/board/versal2/post-image.sh b/board/versal2/post-image.sh index 17746271e174..af50909fb1fb 100755 --- a/board/versal2/post-image.sh +++ b/board/versal2/post-image.sh @@ -3,7 +3,7 @@ # By default U-Boot loads DTB from a file named "system.dtb", and # with versal2, the Linux DTB is the same as the U-Boot DTB, so # let's use a symlink since the DTB is the same. -ln -fs "${BINARIES_DIR}/u-boot.dtb" "${BINARIES_DIR}/system.dtb" +ln -fs "u-boot.dtb" "${BINARIES_DIR}/system.dtb" BOARD_DIR="$(dirname "$0")" diff --git a/docs/manual/customize-outside-br.adoc b/docs/manual/customize-outside-br.adoc index 78065489d465..8a76f3a99870 100644 --- a/docs/manual/customize-outside-br.adoc +++ b/docs/manual/customize-outside-br.adoc @@ -58,10 +58,11 @@ We can switch to another br2-external tree at any time: buildroot/ $ make BR2_EXTERNAL=/where/we/have/bar xconfig ---- -We can also use multiple br2-external trees: +We can also use multiple br2-external trees, by specifying a space-separated +list of paths to use: ---- -buildroot/ $ make BR2_EXTERNAL=/path/to/foo:/where/we/have/bar menuconfig +buildroot/ $ make BR2_EXTERNAL="/path/to/foo /where/we/have/bar" menuconfig ---- Or disable the usage of any br2-external tree: diff --git a/package/ccache/ccache.hash b/package/ccache/ccache.hash index 1c666c9293fc..d408836c4e4a 100644 --- a/package/ccache/ccache.hash +++ b/package/ccache/ccache.hash @@ -1,5 +1,5 @@ -# From https://github.com/ccache/ccache/releases/tag/v4.12.3 -sha256 c8e3ef79531966ecfa05bd1666c483b473df9af00896935cc468cb5ed573c16e ccache-4.12.3.tar.xz +# From https://github.com/ccache/ccache/releases/tag/v4.13.1 +sha256 85638df95c4d3907d9dd686583f2e0b2bd4c232d36e025a5c48e91524b491c4b ccache-4.13.1.tar.xz # sha256 computed locally sha256 80b5112739a423dfac7bed1ca8a1df3cccda3d794425441997d4462b83db4dd5 GPL-3.0.txt -sha256 afe4bea7c75355e3a1c7bf6eec6f95fab01f2e8116d8e495e5af4c3a45513ae9 LICENSE.adoc +sha256 072c40891d4ec8e1bcc93420031ebbbeb90b8f2c49fcd7c872d1bb05564c345c LICENSE.adoc diff --git a/package/ccache/ccache.mk b/package/ccache/ccache.mk index 30f87f7d9003..1f12123164f4 100644 --- a/package/ccache/ccache.mk +++ b/package/ccache/ccache.mk @@ -4,7 +4,7 @@ # ################################################################################ -CCACHE_VERSION = 4.12.3 +CCACHE_VERSION = 4.13.1 CCACHE_SITE = https://github.com/ccache/ccache/releases/download/v$(CCACHE_VERSION) CCACHE_SOURCE = ccache-$(CCACHE_VERSION).tar.xz CCACHE_LICENSE = GPL-3.0+, others diff --git a/package/cjson/cjson.mk b/package/cjson/cjson.mk index cb4525d1a4b3..fb43994aeddc 100644 --- a/package/cjson/cjson.mk +++ b/package/cjson/cjson.mk @@ -31,4 +31,11 @@ else CJSON_CONF_OPTS += -DENABLE_CJSON_UTILS=OFF endif +HOST_CJSON_CONF_OPTS = \ + -DENABLE_CJSON_TEST=OFF \ + -DENABLE_CUSTOM_COMPILER_FLAGS=OFF \ + -DBUILD_SHARED_AND_STATIC_LIBS=OFF \ + -DENABLE_CJSON_UTILS=OFF + $(eval $(cmake-package)) +$(eval $(host-cmake-package)) diff --git a/package/harfbuzz/harfbuzz.hash b/package/harfbuzz/harfbuzz.hash index a6247282a8cc..e9683f19b0b6 100644 --- a/package/harfbuzz/harfbuzz.hash +++ b/package/harfbuzz/harfbuzz.hash @@ -1,4 +1,4 @@ -# From https://github.com/harfbuzz/harfbuzz/releases/tag/13.0.1 -sha256 3553d943401c34ab9b8c75f35cdb8452ca660233b0e9d4a22395ce5245484bd7 harfbuzz-13.0.1.tar.xz +# From https://github.com/harfbuzz/harfbuzz/releases/tag/13.1.1 +sha256 e7f3b8bac3fdcc529985be8e84fbd65c675ac47ee58512b15a5dd620c79ffe2a harfbuzz-13.1.1.tar.xz # Locally computed sha256 ba8f810f2455c2f08e2d56bb49b72f37fcf68f1f4fade38977cfd7372050ad64 COPYING diff --git a/package/harfbuzz/harfbuzz.mk b/package/harfbuzz/harfbuzz.mk index 51bef1a68aed..6cedcc0fd83c 100644 --- a/package/harfbuzz/harfbuzz.mk +++ b/package/harfbuzz/harfbuzz.mk @@ -4,7 +4,7 @@ # ################################################################################ -HARFBUZZ_VERSION = 13.0.1 +HARFBUZZ_VERSION = 13.1.1 HARFBUZZ_SITE = https://github.com/harfbuzz/harfbuzz/releases/download/$(HARFBUZZ_VERSION) HARFBUZZ_SOURCE = harfbuzz-$(HARFBUZZ_VERSION).tar.xz HARFBUZZ_LICENSE = MIT, ISC (ucdn library) diff --git a/package/mosquitto/0001-Fix-CMake-builds-with-WITH_TLS-OFF.patch b/package/mosquitto/0001-Fix-CMake-builds-with-WITH_TLS-OFF.patch deleted file mode 100644 index 9445148f44c3..000000000000 --- a/package/mosquitto/0001-Fix-CMake-builds-with-WITH_TLS-OFF.patch +++ /dev/null @@ -1,50 +0,0 @@ -From 1ecc94d7b4ff495afd7f32c42072cdf4ea5407aa Mon Sep 17 00:00:00 2001 -From: Ben Marsh -Date: Mon, 21 Jul 2025 17:46:16 +0100 -Subject: [PATCH] Fix CMake builds with WITH_TLS=OFF - -Recent CMake changes caused CMake builds with the WITH_TLS option set to OFF to fail. The OpenSSL package is only found (find_package()) if WITH_TLS is ON, but linking to OpenSSL for the broker and library is not guarded by WITH_TLS. The build therefore fails. - -Guard linking to OpenSSL, only linking if WITH_TLS is set. - -Upstream: https://github.com/eclipse-mosquitto/mosquitto/pull/3321 -Signed-off-by: Scott Fan ---- - lib/CMakeLists.txt | 4 +++- - src/CMakeLists.txt | 5 ++++- - 2 files changed, 7 insertions(+), 2 deletions(-) - -diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt -index 21b61497..e6b8235b 100644 ---- a/lib/CMakeLists.txt -+++ b/lib/CMakeLists.txt -@@ -60,7 +60,9 @@ set(C_SRC - util_mosq.c util_topic.c util_mosq.h - will_mosq.c will_mosq.h) - --set (LIBRARIES OpenSSL::SSL) -+if (WITH_TLS) -+ set (LIBRARIES OpenSSL::SSL) -+endif() - - if (UNIX AND NOT APPLE AND NOT ANDROID) - find_library(LIBRT rt) -diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt -index d4bae7cd..6fd0ee53 100644 ---- a/src/CMakeLists.txt -+++ b/src/CMakeLists.txt -@@ -163,7 +163,10 @@ if (WITH_DLT) - set (MOSQ_LIBS ${MOSQ_LIBS} ${DLT_LIBRARIES}) - endif (WITH_DLT) - --set (MOSQ_LIBS ${MOSQ_LIBS} OpenSSL::SSL) -+if (WITH_TLS) -+ set (MOSQ_LIBS ${MOSQ_LIBS} OpenSSL::SSL) -+endif() -+ - # Check for getaddrinfo_a - include(CheckLibraryExists) - check_library_exists(anl getaddrinfo_a "" HAVE_GETADDRINFO_A) --- -2.43.0 - diff --git a/package/mosquitto/0001-Fix-MOSQ_EVT_DISCONNECT-being-called-before-MOSQ_EVT.patch b/package/mosquitto/0001-Fix-MOSQ_EVT_DISCONNECT-being-called-before-MOSQ_EVT.patch new file mode 100644 index 000000000000..23345183ddf8 --- /dev/null +++ b/package/mosquitto/0001-Fix-MOSQ_EVT_DISCONNECT-being-called-before-MOSQ_EVT.patch @@ -0,0 +1,40 @@ +From 7ee523213c30b86ff723c192462f55b84d7714b9 Mon Sep 17 00:00:00 2001 +From: "Roger A. Light" +Date: Tue, 10 Feb 2026 18:42:36 +0000 +Subject: [PATCH] Fix MOSQ_EVT_DISCONNECT being called before + MOSQ_EVT_ACL_CHECK + +This occurs for the will of that client. + +Closes #3487. Thanks to ChrisBFX. + +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/5f2a45d96a52e1e0135b48aec281d612aa1ecdea +[yann.morin@orange.com: drop the Changelog.txt entry] +Signed-off-by: Yann E. MORIN +--- + src/context.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/src/context.c b/src/context.c +index ca4784d9..6b397d47 100644 +--- a/src/context.c ++++ b/src/context.c +@@ -269,13 +269,14 @@ void context__disconnect(struct mosquitto *context, int reason) + } + } + ++ context__send_will(context); ++ + if(context->session_expiry_interval == MQTT_SESSION_EXPIRY_IMMEDIATE){ + plugin__handle_disconnect(context, reason); + }else{ + plugin__handle_client_offline(context, reason); + } + +- context__send_will(context); + net__socket_close(context); + #ifdef WITH_BRIDGE + if(context->bridge == NULL) +-- +2.34.1 + diff --git a/package/mosquitto/0002-Add-configure-time-check-for-lanl.patch b/package/mosquitto/0002-Add-configure-time-check-for-lanl.patch deleted file mode 100644 index b67164123a09..000000000000 --- a/package/mosquitto/0002-Add-configure-time-check-for-lanl.patch +++ /dev/null @@ -1,47 +0,0 @@ -From 447a6aa8df882a67ca3df6f5e95be42e1463eaf0 Mon Sep 17 00:00:00 2001 -From: Titouan Christophe -Date: Fri, 29 Aug 2025 19:47:34 +0200 -Subject: [PATCH] Add configure-time check for -lanl - -Since glibc 2.34, libanl features have been integrated directly into libc [1]. -For backward compatibility, some toolchains still provide a shim for -libanl as a separate .so, but new toolchains (for example for new archs -like loongarch) do not provide it anymore. - -In such a case, building mosquitto fails at link time with (see [2]) - > cannot find -lanl: No such file or directory - -To fix this problem while maintaining compatibility with older toolchains, -check if a simple program that uses libanl can be compiled without -lanl, -and only add the linker flag otherwise. - -[1] https://sourceware.org/pipermail/libc-alpha/2021-August/129718.html -[2] https://autobuild.buildroot.org/results/16223cd838876abc9b6f941f7dc20d23afa32c3b/build-end.log - -Upstream: https://github.com/eclipse-mosquitto/mosquitto/pull/3358 - -Signed-off-by: Titouan Christophe ---- - config.mk | 5 ++++- - 1 file changed, 4 insertions(+), 1 deletion(-) - -diff --git a/config.mk b/config.mk -index 34d5163f..cc7987c4 100644 ---- a/config.mk -+++ b/config.mk -@@ -318,8 +318,11 @@ ifeq ($(WITH_EC),yes) - endif - - ifeq ($(WITH_ADNS),yes) -- BROKER_LDADD:=$(BROKER_LDADD) -lanl - BROKER_CPPFLAGS:=$(BROKER_CPPFLAGS) -DWITH_ADNS -+ NEED_LIBANL := $(shell printf '#include \n#include \nint main(){return getaddrinfo_a(0, NULL, 0, NULL);}'| $(CC) -D_GNU_SOURCE -o /dev/null -x c - 2>/dev/null || echo YES) -+ ifeq ($(NEED_LIBANL),YES) -+ BROKER_LDADD:=$(BROKER_LDADD) -lanl -+ endif - endif - - ifeq ($(WITH_CONTROL),yes) --- -2.50.1 - diff --git a/package/mosquitto/0002-Fix-potential-crash-if-group-id-has-no-group-name.patch b/package/mosquitto/0002-Fix-potential-crash-if-group-id-has-no-group-name.patch new file mode 100644 index 000000000000..4c62644cfe1d --- /dev/null +++ b/package/mosquitto/0002-Fix-potential-crash-if-group-id-has-no-group-name.patch @@ -0,0 +1,33 @@ +From 6834ff7b8304f74c044b8399f23fe69455bfeda8 Mon Sep 17 00:00:00 2001 +From: "Roger A. Light" +Date: Fri, 13 Feb 2026 00:36:47 +0000 +Subject: [PATCH] Fix potential crash if group id has no group name. + +This can occur if reading a file in restricted mode and the group id +does not have an entry in /etc/groups. + +Closes #3498. Thanks to Stefan Kranich. + +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/7958a85bae06c22c3beff2942b8c1ac04f6a6353 +[yann.morin@orange.com: drop the Changelog.txt entry] +Signed-off-by: Yann E. MORIN +--- + libcommon/file_common.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/libcommon/file_common.c b/libcommon/file_common.c +index 1998e6d0..8bde3009 100644 +--- a/libcommon/file_common.c ++++ b/libcommon/file_common.c +@@ -235,7 +235,7 @@ FILE *mosquitto_fopen(const char *path, const char *mode, bool restrict_read) + char buf[4096]; + struct group grp, *result; + +- if(getgrgid_r(getgid(), &grp, buf, sizeof(buf), &result) == 0){ ++ if(getgrgid_r(getgid(), &grp, buf, sizeof(buf), &result) == 0 && result){ + libcommon_printf( + "Warning: File %s group is not %s. Future versions will refuse to load this file.\n", + path, result->gr_name); +-- +2.34.1 + diff --git a/package/mosquitto/0003-Fix-mosquitto_loop_start-leaving-the-mosq-struct-in-.patch b/package/mosquitto/0003-Fix-mosquitto_loop_start-leaving-the-mosq-struct-in-.patch new file mode 100644 index 000000000000..026cb0c0d3b3 --- /dev/null +++ b/package/mosquitto/0003-Fix-mosquitto_loop_start-leaving-the-mosq-struct-in-.patch @@ -0,0 +1,59 @@ +From cf74866a6d707d7bd2d76831f60af789e4f3ce77 Mon Sep 17 00:00:00 2001 +From: "Roger A. Light" +Date: Fri, 13 Feb 2026 08:33:32 +0000 +Subject: [PATCH] Fix mosquitto_loop_start() leaving the mosq struct in an + invalid state + +This occurs if thread creation fails. + +Closes #3496. Thanks to ehoffman2. + +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/da7d02690b4c998ec4b842ae066fa642f59eb509 +[yann.morin@orange.com: drop the Changelog.txt entry] +Signed-off-by: Yann E. MORIN +--- + ChangeLog.txt | 4 ++-- + lib/thread_mosq.c | 2 +- + 2 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/ChangeLog.txt b/ChangeLog.txt +index 7d6a92cf..a76fc6e1 100644 +--- a/ChangeLog.txt ++++ b/ChangeLog.txt +@@ -1,11 +1,11 @@ + 2.1.2 - 2026-02-09 + ================== + +-Broker: ++# Broker + - Forbid running with `persistence true` and with a persistence plugin at the + same time. + +-Build: ++# Build + - Build fixes for OpenBSD. Closes #3474. + - Add missing libedit to docker builds. Closes #3476. + - Fix static/shared linking of libwebsockets under cmake. +diff --git a/lib/thread_mosq.c b/lib/thread_mosq.c +index 931bf9eb..62ddadb7 100644 +--- a/lib/thread_mosq.c ++++ b/lib/thread_mosq.c +@@ -48,7 +48,6 @@ int mosquitto_loop_start(struct mosquitto *mosq) + return MOSQ_ERR_INVAL; + } + +- mosq->threaded = mosq_ts_self; + if(!COMPAT_pthread_create(&mosq->thread_id, NULL, mosquitto__thread_main, mosq)){ + #if defined(__linux__) + pthread_setname_np(mosq->thread_id, "mosquitto loop"); +@@ -57,6 +56,7 @@ int mosquitto_loop_start(struct mosquitto *mosq) + #elif defined(__FreeBSD__) || defined(__OpenBSD__) + pthread_set_name_np(mosq->thread_id, "mosquitto loop"); + #endif ++ mosq->threaded = mosq_ts_self; + return MOSQ_ERR_SUCCESS; + }else{ + return MOSQ_ERR_ERRNO; +-- +2.34.1 + diff --git a/package/mosquitto/0004-Fix-missing-SONAME.patch b/package/mosquitto/0004-Fix-missing-SONAME.patch new file mode 100644 index 000000000000..9ce6c143380c --- /dev/null +++ b/package/mosquitto/0004-Fix-missing-SONAME.patch @@ -0,0 +1,136 @@ +From cef817f226637fe3ca07a0e154fcdb9bd7759682 Mon Sep 17 00:00:00 2001 +From: "Roger A. Light" +Date: Fri, 13 Feb 2026 11:21:28 +0000 +Subject: [PATCH] Fix missing SONAME. + +Closes #3483. Thanks to Matt Turner. + +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/64ccdc712df212b370858acff881ed884c97b715 +[yann.morin@orange.com: drop the Changelog.txt entry] +Signed-off-by: Yann E. MORIN +--- + libcommon/Makefile | 2 +- + libcommon/linker.version | 98 ++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 99 insertions(+), 1 deletion(-) + create mode 100644 libcommon/linker.version + +diff --git a/libcommon/Makefile b/libcommon/Makefile +index d0a467af..e45e45cb 100644 +--- a/libcommon/Makefile ++++ b/libcommon/Makefile +@@ -3,7 +3,7 @@ include ${R}/config.mk + + LOCAL_CFLAGS+=-fPIC + LOCAL_CPPFLAGS+= +-LOCAL_LDFLAGS+=-fPIC ++LOCAL_LDFLAGS+=-Wl,--version-script=linker.version -Wl,-soname,libmosquitto_common.so.$(SOVERSION) -fPIC + LOCAL_LIBADD+=-lcjson + + ifeq ($(WITH_MEMORY_TRACKING),yes) +diff --git a/libcommon/linker.version b/libcommon/linker.version +new file mode 100644 +index 00000000..583d9663 +--- /dev/null ++++ b/libcommon/linker.version +@@ -0,0 +1,98 @@ ++/* Linker version script - currently used here primarily to control which ++ * symbols are exported. ++ */ ++ ++MOSQ_2.1 { ++ global: ++ libcommon_printf; ++ mosquitto_base64_decode; ++ mosquitto_base64_encode; ++ mosquitto_calloc; ++ mosquitto_connack_string; ++ mosquitto_fgets; ++ mosquitto_fopen; ++ mosquitto_free; ++ mosquitto_free; ++ mosquitto_getrandom; ++ mosquitto_malloc; ++ mosquitto_malloc; ++ mosquitto_max_memory_used; ++ mosquitto_memory_set_limit; ++ mosquitto_memory_used; ++ mosquitto_properties_to_json; ++ mosquitto_property_next; ++ mosquitto_property_read_binary; ++ mosquitto_property_read_byte; ++ mosquitto_property_read_int16; ++ mosquitto_property_read_int32; ++ mosquitto_property_read_string; ++ mosquitto_property_read_string_pair; ++ mosquitto_property_read_varint; ++ mosquitto_property_add_binary; ++ mosquitto_property_add_byte; ++ mosquitto_property_add_int16; ++ mosquitto_property_add_int32; ++ mosquitto_property_add_string; ++ mosquitto_property_add_string_pair; ++ mosquitto_property_add_varint; ++ mosquitto_property_binary_value; ++ mosquitto_property_binary_value_length; ++ mosquitto_property_byte_value; ++ mosquitto_property_check_all; ++ mosquitto_property_check_command; ++ mosquitto_property_copy_all; ++ mosquitto_property_free; ++ mosquitto_property_free_all; ++ mosquitto_property_get_length; ++ mosquitto_property_get_length_all; ++ mosquitto_property_get_remaining_length; ++ mosquitto_property_identifier; ++ mosquitto_property_identifier_to_string; ++ mosquitto_property_int16_value; ++ mosquitto_property_int32_value; ++ mosquitto_property_remove; ++ mosquitto_property_string_name; ++ mosquitto_property_string_name_length; ++ mosquitto_property_string_value; ++ mosquitto_property_string_value_length; ++ mosquitto_property_type; ++ mosquitto_property_varint_value; ++ mosquitto_pub_topic_check; ++ mosquitto_pub_topic_check2; ++ mosquitto_pw_cleanup; ++ mosquitto_pw_decode; ++ mosquitto_pw_get_encoded; ++ mosquitto_pw_hash_encoded; ++ mosquitto_pw_is_valid; ++ mosquitto_pw_new; ++ mosquitto_pw_set_param; ++ mosquitto_pw_set_valid; ++ mosquitto_pw_verify; ++ mosquitto_read_file; ++ mosquitto_realloc; ++ mosquitto_realloc; ++ mosquitto_reason_string; ++ mosquitto_strdup; ++ mosquitto_strerror; ++ mosquitto_string_to_command; ++ mosquitto_string_to_property_info; ++ mosquitto_strndup; ++ mosquitto_sub_matches_acl; ++ mosquitto_sub_matches_acl_with_pattern; ++ mosquitto_sub_topic_check; ++ mosquitto_sub_topic_check2; ++ mosquitto_sub_topic_tokenise; ++ mosquitto_sub_topic_tokens_free; ++ mosquitto_time; ++ mosquitto_time_cmp; ++ mosquitto_time_init; ++ mosquitto_time_ns; ++ mosquitto_topic_matches_sub; ++ mosquitto_topic_matches_sub2; ++ mosquitto_topic_matches_sub_with_pattern; ++ mosquitto_trimblanks; ++ mosquitto_validate_utf8; ++ mosquitto_varint_bytes; ++ mosquitto_write_file; ++ local: *; ++}; +-- +2.34.1 + diff --git a/package/mosquitto/0005-Fix-password-length-not-being-passed-to-MOSQ_EVT_BAS.patch b/package/mosquitto/0005-Fix-password-length-not-being-passed-to-MOSQ_EVT_BAS.patch new file mode 100644 index 000000000000..45231fbafa37 --- /dev/null +++ b/package/mosquitto/0005-Fix-password-length-not-being-passed-to-MOSQ_EVT_BAS.patch @@ -0,0 +1,231 @@ +From 5a9562e74bc59facd351c183fe085f55dc370fbf Mon Sep 17 00:00:00 2001 +From: "Roger A. Light" +Date: Fri, 13 Feb 2026 12:18:47 +0000 +Subject: [PATCH] Fix password length not being passed to MOSQ_EVT_BASIC_AUTH + events. + +Closes #3490. Thanks to thehouseisonfire. + +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/43c271504277941a4423a7e8c6b07bbcb611080b +[yann.morin@orange.com: drop the Changelog.txt entry] +Signed-off-by: Yann E. MORIN +--- + include/mosquitto/broker.h | 7 ++++++- + lib/mosquitto_internal.h | 1 + + src/handle_connect.c | 16 +++++++++------- + src/plugin_basic_auth.c | 1 + + test/broker/09-plugin-auth-unpwd-fail.py | 11 ++++++++++- + test/broker/09-plugin-auth-unpwd-success.py | 7 ++++++- + test/broker/c/auth_plugin_v5.c | 17 ++++++++++++++++- + 7 files changed, 49 insertions(+), 11 deletions(-) + +diff --git a/include/mosquitto/broker.h b/include/mosquitto/broker.h +index 9a4cd1f1..00be4b5e 100644 +--- a/include/mosquitto/broker.h ++++ b/include/mosquitto/broker.h +@@ -198,7 +198,12 @@ struct mosquitto_evt_basic_auth { + struct mosquitto *client; + char *username; + char *password; +- void *future2[4]; ++ union{ ++ void *future2[4]; ++ struct { ++ uint16_t password_len; ++ }; ++ }; + }; + + /* Data for the MOSQ_EVT_PSK_KEY event */ +diff --git a/lib/mosquitto_internal.h b/lib/mosquitto_internal.h +index 0dd27b31..93323891 100644 +--- a/lib/mosquitto_internal.h ++++ b/lib/mosquitto_internal.h +@@ -322,6 +322,7 @@ struct mosquitto { + unsigned id_hashv; + uint16_t keepalive; + uint16_t last_mid; ++ uint16_t password_len; + enum mosquitto_client_state state; + uint8_t transport; + time_t last_msg_in; +diff --git a/src/handle_connect.c b/src/handle_connect.c +index 47bb12c0..9a5b9f14 100644 +--- a/src/handle_connect.c ++++ b/src/handle_connect.c +@@ -776,11 +776,11 @@ static int set_username_from_packet(struct mosquitto *context, char **username, + } + + +-static int set_password_from_packet(struct mosquitto *context, char **password, const char *clientid) ++static int set_password_from_packet(struct mosquitto *context, char **password, uint16_t *password_len, const char *clientid) + { + int rc; + +- rc = packet__read_binary(&context->in_packet, (uint8_t **)password, &(uint16_t){0}); ++ rc = packet__read_binary(&context->in_packet, (uint8_t **)password, password_len); + if(rc == MOSQ_ERR_NOMEM){ + return MOSQ_ERR_NOMEM; + } +@@ -801,7 +801,7 @@ static int set_password_from_packet(struct mosquitto *context, char **password, + + static int read_and_verify_client_credentials_from_packet(struct mosquitto *context, + char **username, uint8_t username_flag, +- char **password, uint8_t password_flag, ++ char **password, uint16_t *password_len, uint8_t password_flag, + const char *clientid) + { + int rc; +@@ -821,7 +821,7 @@ static int read_and_verify_client_credentials_from_packet(struct mosquitto *cont + } + } + if(password_flag){ +- rc = set_password_from_packet(context, password, clientid); ++ rc = set_password_from_packet(context, password, password_len, clientid); + if(rc != MOSQ_ERR_SUCCESS){ + return rc; + } +@@ -971,7 +971,7 @@ static int set_username_from_cert_subject_name(struct mosquitto *context) + #endif + + +-static int handle_username_from_cert_options(struct mosquitto *context, char **username, char **password) ++static int handle_username_from_cert_options(struct mosquitto *context, char **username, char **password, uint16_t password_len) + { + int rc; + +@@ -1020,6 +1020,7 @@ static int handle_username_from_cert_options(struct mosquitto *context, char **u + * mosquitto_client_username() functions work, but is hacky */ + context->username = *username; + context->password = *password; ++ context->password_len = password_len; + *username = NULL; /* Avoid free() in error: below. */ + *password = NULL; + } +@@ -1059,6 +1060,7 @@ int handle__connect(struct mosquitto *context) + uint8_t will, will_retain, will_qos, clean_start; + uint8_t username_flag, password_flag; + char *username = NULL, *password = NULL; ++ uint16_t password_len = 0; + int rc; + mosquitto_property *properties = NULL; + void *auth_data = NULL; +@@ -1176,7 +1178,7 @@ int handle__connect(struct mosquitto *context) + // Client credentials + password_flag = connect_flags & 0x40; + username_flag = connect_flags & 0x80; +- rc = read_and_verify_client_credentials_from_packet(context, &username, username_flag, &password, password_flag, clientid); ++ rc = read_and_verify_client_credentials_from_packet(context, &username, username_flag, &password, &password_len, password_flag, clientid); + if(rc != MOSQ_ERR_SUCCESS){ + goto handle_connect_error; + } +@@ -1193,7 +1195,7 @@ int handle__connect(struct mosquitto *context) + clientid = NULL; + + /* use_identity_as_username or use_subject_as_username */ +- rc = handle_username_from_cert_options(context, &username, &password); ++ rc = handle_username_from_cert_options(context, &username, &password, password_len); + if(rc != MOSQ_ERR_SUCCESS){ + goto handle_connect_error; + } +diff --git a/src/plugin_basic_auth.c b/src/plugin_basic_auth.c +index dfc0a57d..49d4f508 100644 +--- a/src/plugin_basic_auth.c ++++ b/src/plugin_basic_auth.c +@@ -40,6 +40,7 @@ static int plugin__basic_auth(struct mosquitto__security_options *opts, struct m + event_data.client = context; + event_data.username = context->username; + event_data.password = context->password; ++ event_data.password_len = context->password_len; + rc = cb_base->cb(MOSQ_EVT_BASIC_AUTH, &event_data, cb_base->userdata); + if(rc == MOSQ_ERR_PLUGIN_IGNORE){ + /* Do nothing, this is as if the plugin doesn't exist */ +diff --git a/test/broker/09-plugin-auth-unpwd-fail.py b/test/broker/09-plugin-auth-unpwd-fail.py +index bdbf8b54..14520aa5 100755 +--- a/test/broker/09-plugin-auth-unpwd-fail.py ++++ b/test/broker/09-plugin-auth-unpwd-fail.py +@@ -20,13 +20,22 @@ def do_test(plugin_ver): + connect_packet = mosq_test.gen_connect("connect-uname-pwd-test", username="test-username", password="wrong") + connack_packet = mosq_test.gen_connack(rc=5) + ++ connect_packet_binary_pw1 = mosq_test.gen_connect("connect-uname-pwd-test", username="binary-password", password="\x00\x01\x02\x03\x04\x05\x06\x08") ++ connect_packet_binary_pw2 = mosq_test.gen_connect("connect-uname-pwd-test", username="binary-password", password="\x00\x01\x02\x03\x04\x05\x06") ++ + broker = mosq_test.start_broker(filename=os.path.basename(__file__), use_conf=True, port=port) + + try: + sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port) ++ sock.close() ++ ++ if plugin_ver == 5: ++ sock = mosq_test.do_client_connect(connect_packet_binary_pw1, connack_packet, port=port) ++ sock.close() ++ sock = mosq_test.do_client_connect(connect_packet_binary_pw2, connack_packet, port=port) ++ sock.close() + rc = 0 + +- sock.close() + except mosq_test.TestError: + pass + finally: +diff --git a/test/broker/09-plugin-auth-unpwd-success.py b/test/broker/09-plugin-auth-unpwd-success.py +index 1eaf4e5f..91c7b80c 100755 +--- a/test/broker/09-plugin-auth-unpwd-success.py ++++ b/test/broker/09-plugin-auth-unpwd-success.py +@@ -20,12 +20,17 @@ def do_test(plugin_ver): + connect_packet = mosq_test.gen_connect("connect-uname-pwd-test", username="test-username", password="cnwTICONIURW") + connack_packet = mosq_test.gen_connack(rc=0) + ++ connect_packet_binary_pw = mosq_test.gen_connect("connect-uname-pwd-test", username="binary-password", password="\x00\x01\x02\x03\x04\x05\x06\x07") ++ + broker = mosq_test.start_broker(filename=os.path.basename(__file__), use_conf=True, port=port) + + try: + sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port) +- rc = 0 + sock.close() ++ if plugin_ver == 5: ++ sock = mosq_test.do_client_connect(connect_packet_binary_pw, connack_packet, port=port) ++ sock.close() ++ rc = 0 + except mosq_test.TestError: + pass + finally: +diff --git a/test/broker/c/auth_plugin_v5.c b/test/broker/c/auth_plugin_v5.c +index 4fbb622c..0f72a0da 100644 +--- a/test/broker/c/auth_plugin_v5.c ++++ b/test/broker/c/auth_plugin_v5.c +@@ -82,6 +82,7 @@ int mosquitto_auth_acl_check_v5(int event, void *event_data, void *user_data) + int mosquitto_auth_unpwd_check_v5(int event, void *event_data, void *user_data) + { + struct mosquitto_evt_basic_auth *ed = event_data; ++ const char binary_pw[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; + + (void)user_data; + +@@ -89,7 +90,21 @@ int mosquitto_auth_unpwd_check_v5(int event, void *event_data, void *user_data) + abort(); + } + +- if(ed->username && !strcmp(ed->username, "test-username") && ed->password && !strcmp(ed->password, "cnwTICONIURW")){ ++ if(ed->username ++ && !strcmp(ed->username, "test-username") ++ && ed->password ++ && !strcmp(ed->password, "cnwTICONIURW") ++ && strlen("cnwTICONIURW") == ed->password_len ++ ){ ++ ++ return MOSQ_ERR_SUCCESS; ++ }else if(ed->username ++ && !strcmp(ed->username, "binary-password") ++ && ed->password ++ && ed->password_len == sizeof(binary_pw) ++ && !memcmp(ed->password, binary_pw, ed->password_len) ++ ){ ++ + return MOSQ_ERR_SUCCESS; + }else if(ed->username && (!strcmp(ed->username, "readonly") || !strcmp(ed->username, "readwrite"))){ + return MOSQ_ERR_SUCCESS; +-- +2.34.1 + diff --git a/package/mosquitto/0006-Fix-outgoing-maximum-packet-size-limit-check.patch b/package/mosquitto/0006-Fix-outgoing-maximum-packet-size-limit-check.patch new file mode 100644 index 000000000000..968dd85b6905 --- /dev/null +++ b/package/mosquitto/0006-Fix-outgoing-maximum-packet-size-limit-check.patch @@ -0,0 +1,152 @@ +From ea6d1c5847f16b3fe8877ff4e90cc33b36b0b511 Mon Sep 17 00:00:00 2001 +From: "Roger A. Light" +Date: Sun, 15 Feb 2026 21:39:51 +0000 +Subject: [PATCH] Fix outgoing maximum-packet-size limit check. + +Closes #3503. Thanks to Julian Graf. + +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/3a0f46aa209c4b2d15b36f866b23e9a0df696810 +[yann.morin@orange.com: drop the Changelog.txt entry] +Signed-off-by: Yann E. MORIN +--- + lib/packet_mosq.c | 2 +- + ...12-prop-maximum-packet-size-publish-qos1.py | 18 +++++++++++++----- + ...12-prop-maximum-packet-size-publish-qos2.py | 4 ++-- + test/lib/11-prop-oversize-packet.py | 4 ++-- + test/lib/c/11-prop-oversize-packet.c | 4 ++-- + test/lib/cpp/11-prop-oversize-packet.cpp | 4 ++-- + 6 files changed, 22 insertions(+), 14 deletions(-) + +diff --git a/lib/packet_mosq.c b/lib/packet_mosq.c +index d1379d3d..48b0efbd 100644 +--- a/lib/packet_mosq.c ++++ b/lib/packet_mosq.c +@@ -238,7 +238,7 @@ int packet__check_oversize(struct mosquitto *mosq, uint32_t remaining_length) + return MOSQ_ERR_SUCCESS; + } + +- len = remaining_length + mosquitto_varint_bytes(remaining_length); ++ len = 1 + remaining_length + mosquitto_varint_bytes(remaining_length); + if(len > mosq->maximum_packet_size){ + return MOSQ_ERR_OVERSIZE_PACKET; + }else{ +diff --git a/test/broker/12-prop-maximum-packet-size-publish-qos1.py b/test/broker/12-prop-maximum-packet-size-publish-qos1.py +index 2900c3c7..2530a377 100755 +--- a/test/broker/12-prop-maximum-packet-size-publish-qos1.py ++++ b/test/broker/12-prop-maximum-packet-size-publish-qos1.py +@@ -17,13 +17,18 @@ def do_test(start_broker): + suback_packet = mosq_test.gen_suback(mid, 1, proto_ver=5) + + mid=1 +- publish1_packet = mosq_test.gen_publish(topic="12/max/publish/qos1/test/topic", mid=mid, qos=1, payload="12345678901234567890", proto_ver=5) ++ publish1_packet = mosq_test.gen_publish(topic="12/max/publish/qos1/test/topic", mid=mid, qos=1, payload="1234", proto_ver=5) + puback1_packet = mosq_test.gen_puback(mid, proto_ver=5) + + mid=2 +- publish2_packet = mosq_test.gen_publish(topic="12/max/publish/qos1/test/topic", mid=mid, qos=1, payload="7890", proto_ver=5) ++ props = mqtt5_props.gen_byte_prop(mqtt5_props.PAYLOAD_FORMAT_INDICATOR, 1) ++ publish2_packet = mosq_test.gen_publish(topic="12/max/publish/qos1/test/topic", mid=mid, qos=1, payload="56", proto_ver=5, properties=props) + puback2_packet = mosq_test.gen_puback(mid, proto_ver=5) + ++ mid=3 ++ publish3_packet = mosq_test.gen_publish(topic="12/max/publish/qos1/test/topic", mid=mid, qos=1, payload="789", proto_ver=5) ++ puback3_packet = mosq_test.gen_puback(mid, proto_ver=5) ++ + port = mosq_test.get_port() + if start_broker: + broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) +@@ -33,12 +38,15 @@ def do_test(start_broker): + mosq_test.do_send_receive(sock, subscribe_packet, suback_packet) + + mosq_test.do_send_receive(sock, publish1_packet, puback1_packet, "puback 1") +- + # We shouldn't receive the publish here because it is > MAXIMUM_PACKET_SIZE + mosq_test.do_ping(sock) + +- sock.send(publish2_packet) +- mosq_test.receive_unordered(sock, puback2_packet, publish2_packet, "puback 2/publish2") ++ mosq_test.do_send_receive(sock, publish2_packet, puback2_packet, "puback 2") ++ # We shouldn't receive the publish here because it is > MAXIMUM_PACKET_SIZE ++ mosq_test.do_ping(sock) ++ ++ sock.send(publish3_packet) ++ mosq_test.receive_unordered(sock, puback3_packet, publish3_packet, "puback 3/publish3") + rc = 0 + except mosq_test.TestError: + pass +diff --git a/test/broker/12-prop-maximum-packet-size-publish-qos2.py b/test/broker/12-prop-maximum-packet-size-publish-qos2.py +index e0ad9343..7256d254 100755 +--- a/test/broker/12-prop-maximum-packet-size-publish-qos2.py ++++ b/test/broker/12-prop-maximum-packet-size-publish-qos2.py +@@ -17,13 +17,13 @@ def do_test(start_broker): + suback_packet = mosq_test.gen_suback(mid, 2, proto_ver=5) + + mid=1 +- publish1_packet = mosq_test.gen_publish(topic="12/max/publish/qos2/test/topic", mid=mid, qos=2, payload="12345678901234567890", proto_ver=5) ++ publish1_packet = mosq_test.gen_publish(topic="12/max/publish/qos2/test/topic", mid=mid, qos=2, payload="1234", proto_ver=5) + pubrec1_packet = mosq_test.gen_pubrec(mid, proto_ver=5) + pubrel1_packet = mosq_test.gen_pubrel(mid, proto_ver=5) + pubcomp1_packet = mosq_test.gen_pubcomp(mid, proto_ver=5) + + mid=2 +- publish2_packet = mosq_test.gen_publish(topic="12/max/publish/qos2/test/topic", mid=mid, qos=2, payload="7890", proto_ver=5) ++ publish2_packet = mosq_test.gen_publish(topic="12/max/publish/qos2/test/topic", mid=mid, qos=2, payload="789", proto_ver=5) + pubrec2_packet = mosq_test.gen_pubrec(mid, proto_ver=5) + pubrel2_packet = mosq_test.gen_pubrel(mid, proto_ver=5) + pubcomp2_packet = mosq_test.gen_pubcomp(mid, proto_ver=5) +diff --git a/test/lib/11-prop-oversize-packet.py b/test/lib/11-prop-oversize-packet.py +index f8f56697..e537eef3 100755 +--- a/test/lib/11-prop-oversize-packet.py ++++ b/test/lib/11-prop-oversize-packet.py +@@ -13,8 +13,8 @@ def do_test(conn, data): + props += mqtt5_props.gen_uint16_prop(mqtt5_props.RECEIVE_MAXIMUM, 20) + connack_packet = mosq_test.gen_connack(rc=0, proto_ver=5, properties=props, property_helper=False) + +- bad_publish_packet = mosq_test.gen_publish("pub/test", qos=0, payload="0123456789012345678", proto_ver=5) +- publish_packet = mosq_test.gen_publish("pub/test", qos=0, payload="012345678901234567", proto_ver=5) ++ bad_publish_packet = mosq_test.gen_publish("pub/test", qos=0, payload="123456789012345678", proto_ver=5) ++ publish_packet = mosq_test.gen_publish("pub/test", qos=0, payload="12345678901234567", proto_ver=5) + + disconnect_packet = mosq_test.gen_disconnect() + +diff --git a/test/lib/c/11-prop-oversize-packet.c b/test/lib/c/11-prop-oversize-packet.c +index 6f9624a8..a857e936 100644 +--- a/test/lib/c/11-prop-oversize-packet.c ++++ b/test/lib/c/11-prop-oversize-packet.c +@@ -27,12 +27,12 @@ static void on_connect(struct mosquitto *mosq, void *obj, int rc) + exit(1); + } + +- rc = mosquitto_publish(mosq, &sent_mid, "pub/test", strlen("0123456789012345678"), "0123456789012345678", 0, false); ++ rc = mosquitto_publish(mosq, &sent_mid, "pub/test", strlen("123456789012345678"), "123456789012345678", 0, false); + if(rc != MOSQ_ERR_OVERSIZE_PACKET){ + printf("Fail on publish 1\n"); + exit(1); + } +- rc = mosquitto_publish(mosq, &sent_mid, "pub/test", strlen("012345678901234567"), "012345678901234567", 0, false); ++ rc = mosquitto_publish(mosq, &sent_mid, "pub/test", strlen("12345678901234567"), "12345678901234567", 0, false); + if(rc != MOSQ_ERR_SUCCESS){ + printf("Fail on publish 2\n"); + exit(1); +diff --git a/test/lib/cpp/11-prop-oversize-packet.cpp b/test/lib/cpp/11-prop-oversize-packet.cpp +index 880df48e..abd76186 100644 +--- a/test/lib/cpp/11-prop-oversize-packet.cpp ++++ b/test/lib/cpp/11-prop-oversize-packet.cpp +@@ -36,12 +36,12 @@ void mosquittopp_test::on_connect(int rc) + exit(1); + } + +- rc = publish(&sent_mid, "pub/test", strlen("0123456789012345678"), "0123456789012345678", 0, false); ++ rc = publish(&sent_mid, "pub/test", strlen("123456789012345678"), "123456789012345678", 0, false); + if(rc != MOSQ_ERR_OVERSIZE_PACKET){ + printf("Fail on publish 1\n"); + exit(1); + } +- rc = publish(&sent_mid, "pub/test", strlen("012345678901234567"), "012345678901234567", 0, false); ++ rc = publish(&sent_mid, "pub/test", strlen("12345678901234567"), "12345678901234567", 0, false); + if(rc != MOSQ_ERR_SUCCESS){ + printf("Fail on publish 2\n"); + exit(1); +-- +2.34.1 + diff --git a/package/mosquitto/0007-Fix-will-messages-being-incorrectly-delayed.patch b/package/mosquitto/0007-Fix-will-messages-being-incorrectly-delayed.patch new file mode 100644 index 000000000000..b76c422b639b --- /dev/null +++ b/package/mosquitto/0007-Fix-will-messages-being-incorrectly-delayed.patch @@ -0,0 +1,212 @@ +From 910971ffe895ea96862857b94a26c92d3a24f4f6 Mon Sep 17 00:00:00 2001 +From: "Roger A. Light" +Date: Mon, 16 Feb 2026 00:11:20 +0000 +Subject: [PATCH] Fix will messages being incorrectly delayed. + +This occured if a client set session-expiry-interval=0 when using +will-delay-interval>0. + +Closes #3505. Thanks to Julian Graf. + +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/d0152406e32afc6a014097de0714fbb371c2b902 +[yann.morin@orange.com: drop the Changelog.txt entry] +Signed-off-by: Yann E. MORIN +--- + src/context.c | 2 +- + test/broker/07-will-delay-reconnect.py | 9 +++-- + test/broker/07-will-delay-recover.py | 11 +++++- + ...y.py => 07-will-delay-session-expiry-0.py} | 37 +++++++++---------- + test/broker/07-will-delay.py | 5 ++- + test/broker/Makefile | 1 + + test/broker/test.py | 1 + + 7 files changed, 37 insertions(+), 29 deletions(-) + copy test/broker/{07-will-delay.py => 07-will-delay-session-expiry-0.py} (51%) + +diff --git a/src/context.c b/src/context.c +index 6b397d47..bb3dae96 100644 +--- a/src/context.c ++++ b/src/context.c +@@ -216,7 +216,7 @@ void context__cleanup(struct mosquitto *context, bool force_free) + void context__send_will(struct mosquitto *ctxt) + { + if(ctxt->state != mosq_cs_disconnecting && ctxt->will){ +- if(ctxt->will_delay_interval > 0){ ++ if(ctxt->session_expiry_interval > 0 && ctxt->will_delay_interval > 0){ + will_delay__add(ctxt); + return; + } +diff --git a/test/broker/07-will-delay-reconnect.py b/test/broker/07-will-delay-reconnect.py +index e0355a48..504c074e 100755 +--- a/test/broker/07-will-delay-reconnect.py ++++ b/test/broker/07-will-delay-reconnect.py +@@ -14,12 +14,13 @@ def do_test(start_broker): + connect1_packet = mosq_test.gen_connect("will-delay-reconnect-test", proto_ver=5) + connack1_packet = mosq_test.gen_connack(rc=0, proto_ver=5) + +- props = mqtt5_props.gen_uint32_prop(mqtt5_props.WILL_DELAY_INTERVAL, 3) +- connect2a_packet = mosq_test.gen_connect("will-delay-reconnect-helper", proto_ver=5, will_topic="will/delay/reconnect/test", will_payload=b"will delay", will_properties=props, clean_session=False) ++ props = mqtt5_props.gen_uint32_prop(mqtt5_props.SESSION_EXPIRY_INTERVAL, 60) ++ will_props = mqtt5_props.gen_uint32_prop(mqtt5_props.WILL_DELAY_INTERVAL, 3) ++ connect2a_packet = mosq_test.gen_connect("will-delay-reconnect-helper", proto_ver=5, will_topic="will/delay/reconnect/test", will_payload=b"will delay", will_properties=will_props, clean_session=False, properties=props) + connack2a_packet = mosq_test.gen_connack(rc=0, proto_ver=5) + +- connect2b_packet = mosq_test.gen_connect("will-delay-reconnect-helper", proto_ver=5, clean_session=True) +- connack2b_packet = mosq_test.gen_connack(rc=0, proto_ver=5) ++ connect2b_packet = mosq_test.gen_connect("will-delay-reconnect-helper", proto_ver=5, clean_session=False) ++ connack2b_packet = mosq_test.gen_connack(rc=0, flags=1, proto_ver=5) + + subscribe_packet = mosq_test.gen_subscribe(mid, "will/delay/reconnect/test", 0, proto_ver=5) + suback_packet = mosq_test.gen_suback(mid, 0, proto_ver=5) +diff --git a/test/broker/07-will-delay-recover.py b/test/broker/07-will-delay-recover.py +index ffdb9612..7e5c196d 100755 +--- a/test/broker/07-will-delay-recover.py ++++ b/test/broker/07-will-delay-recover.py +@@ -27,6 +27,8 @@ def do_test(start_broker, clean_session): + + connect2_packet_clear = mosq_test.gen_connect("will-delay-recovery-helper", proto_ver=5) + ++ will_packet = mosq_test.gen_publish(topic="will/delay/recovery/test", payload="will delay", qos=0, proto_ver=5) ++ + port = mosq_test.get_port() + if start_broker: + broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) +@@ -43,8 +45,13 @@ def do_test(start_broker, clean_session): + time.sleep(3) + + # The client2 has reconnected within the will delay interval, which has now +- # passed. We should not have received the will at this point. +- mosq_test.do_ping(sock1) ++ # passed. ++ if clean_session: ++ # The old session has ended, so we should receive the will ++ mosq_test.expect_packet(sock1, "will", will_packet) ++ else: ++ # We should not have received the will at this point. ++ mosq_test.do_ping(sock1) + rc = 0 + + sock1.close() +diff --git a/test/broker/07-will-delay.py b/test/broker/07-will-delay-session-expiry-0.py +similarity index 51% +copy from test/broker/07-will-delay.py +copy to test/broker/07-will-delay-session-expiry-0.py +index d1e39828..eded4be9 100755 +--- a/test/broker/07-will-delay.py ++++ b/test/broker/07-will-delay-session-expiry-0.py +@@ -1,42 +1,45 @@ + #!/usr/bin/env python3 + +-# Test whether a client will is transmitted with a delay correctly. ++# Test whether a client that connects with a will delay that is longer than ++# their session expiry interval has their will published. + # MQTT 5 ++# https://github.com/eclipse/mosquitto/issues/1401 + + from mosq_test_helper import * + +-def do_test(start_broker, clean_session): ++def do_test(start_broker): + rc = 1 + + mid = 1 +- connect1_packet = mosq_test.gen_connect("will-delay-test", proto_ver=5) ++ connect1_packet = mosq_test.gen_connect("will-session-exp", proto_ver=5) + connack1_packet = mosq_test.gen_connack(rc=0, proto_ver=5) + +- props = mqtt5_props.gen_uint32_prop(mqtt5_props.WILL_DELAY_INTERVAL, 3) +- connect2_packet = mosq_test.gen_connect("will-delay-helper", proto_ver=5, will_topic="will/delay/test", will_payload=b"will delay", will_qos=2, will_properties=props, clean_session=clean_session) ++ will_props = mqtt5_props.gen_uint32_prop(mqtt5_props.WILL_DELAY_INTERVAL, 60) ++ connect_props = mqtt5_props.gen_uint32_prop(mqtt5_props.SESSION_EXPIRY_INTERVAL, 0) ++ ++ connect2_packet = mosq_test.gen_connect("will-session-exp-helper", proto_ver=5, properties=connect_props, will_topic="will/session-expiry/test", will_payload=b"will delay", will_qos=2, will_properties=will_props) + connack2_packet = mosq_test.gen_connack(rc=0, proto_ver=5) + +- subscribe_packet = mosq_test.gen_subscribe(mid, "will/delay/test", 0, proto_ver=5) ++ subscribe_packet = mosq_test.gen_subscribe(mid, "will/session-expiry/test", 0, proto_ver=5) + suback_packet = mosq_test.gen_suback(mid, 0, proto_ver=5) + +- publish_packet = mosq_test.gen_publish("will/delay/test", qos=0, payload="will delay", proto_ver=5) ++ publish_packet = mosq_test.gen_publish("will/session-expiry/test", qos=0, payload="will delay", proto_ver=5) + + port = mosq_test.get_port() + if start_broker: + broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) + + try: +- sock1 = mosq_test.do_client_connect(connect1_packet, connack1_packet, timeout=30, port=port) ++ sock1 = mosq_test.do_client_connect(connect1_packet, connack1_packet, timeout=5, port=port, connack_error="connack1") + mosq_test.do_send_receive(sock1, subscribe_packet, suback_packet, "suback") + +- sock2 = mosq_test.do_client_connect(connect2_packet, connack2_packet, timeout=30, port=port) ++ sock2 = mosq_test.do_client_connect(connect2_packet, connack2_packet, timeout=5, port=port, connack_error="connack2") ++ time.sleep(1) + sock2.close() + +- t_start = time.time() ++ # Will should be sent immediately due to session-expiry-interval=0. If not, the read will timeout + mosq_test.expect_packet(sock1, "publish", publish_packet) +- t_finish = time.time() +- if t_finish - t_start > 2 and t_finish - t_start < 5: +- rc = 0 ++ rc = 0 + + sock1.close() + except mosq_test.TestError: +@@ -56,13 +59,7 @@ def do_test(start_broker, clean_session): + + + def all_tests(start_broker=False): +- rc = do_test(start_broker, clean_session=True) +- if rc: +- return rc +- rc = do_test(start_broker, clean_session=False) +- if rc: +- return rc +- return 0 ++ return do_test(start_broker) + + if __name__ == '__main__': + all_tests(True) +diff --git a/test/broker/07-will-delay.py b/test/broker/07-will-delay.py +index d1e39828..e148ea1e 100755 +--- a/test/broker/07-will-delay.py ++++ b/test/broker/07-will-delay.py +@@ -12,8 +12,9 @@ def do_test(start_broker, clean_session): + connect1_packet = mosq_test.gen_connect("will-delay-test", proto_ver=5) + connack1_packet = mosq_test.gen_connack(rc=0, proto_ver=5) + +- props = mqtt5_props.gen_uint32_prop(mqtt5_props.WILL_DELAY_INTERVAL, 3) +- connect2_packet = mosq_test.gen_connect("will-delay-helper", proto_ver=5, will_topic="will/delay/test", will_payload=b"will delay", will_qos=2, will_properties=props, clean_session=clean_session) ++ props = mqtt5_props.gen_uint32_prop(mqtt5_props.SESSION_EXPIRY_INTERVAL, 60) ++ will_props = mqtt5_props.gen_uint32_prop(mqtt5_props.WILL_DELAY_INTERVAL, 3) ++ connect2_packet = mosq_test.gen_connect("will-delay-helper", proto_ver=5, properties=props, will_topic="will/delay/test", will_payload=b"will delay", will_qos=2, will_properties=will_props, clean_session=clean_session) + connack2_packet = mosq_test.gen_connack(rc=0, proto_ver=5) + + subscribe_packet = mosq_test.gen_subscribe(mid, "will/delay/test", 0, proto_ver=5) +diff --git a/test/broker/Makefile b/test/broker/Makefile +index f2a6fb7c..fb6eef22 100644 +--- a/test/broker/Makefile ++++ b/test/broker/Makefile +@@ -148,6 +148,7 @@ msg_sequence_test: + ./07-will-delay-invalid-573191.py + ./07-will-delay-reconnect.py + ./07-will-delay-recover.py ++ ./07-will-delay-session-expiry-0.py + ./07-will-delay-session-expiry.py + ./07-will-delay-session-expiry2.py + ./07-will-delay.py +diff --git a/test/broker/test.py b/test/broker/test.py +index 02bcae26..4c8003d5 100755 +--- a/test/broker/test.py ++++ b/test/broker/test.py +@@ -125,6 +125,7 @@ tests = [ + (1, './07-will-delay-invalid-573191.py'), + (1, './07-will-delay-reconnect.py'), + (1, './07-will-delay-recover.py'), ++ (1, './07-will-delay-session-expiry-0.py'), + (1, './07-will-delay-session-expiry.py'), + (1, './07-will-delay-session-expiry2.py'), + (1, './07-will-delay.py'), +-- +2.34.1 + diff --git a/package/mosquitto/0008-Fix-incorrect-parsing-of-unix-socket-address-in-prox.patch b/package/mosquitto/0008-Fix-incorrect-parsing-of-unix-socket-address-in-prox.patch new file mode 100644 index 000000000000..521391fcec4b --- /dev/null +++ b/package/mosquitto/0008-Fix-incorrect-parsing-of-unix-socket-address-in-prox.patch @@ -0,0 +1,27 @@ +From 5ff7991df2743afaa7777822b7b4ffa471cf9b97 Mon Sep 17 00:00:00 2001 +From: "Roger A. Light" +Date: Wed, 18 Feb 2026 09:05:44 +0000 +Subject: [PATCH] Fix incorrect parsing of unix socket address in proxy v2 + +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/b21c9f2c9af97ac4bc90efea388ca27ce7f6e73a +Signed-off-by: Yann E. MORIN +--- + src/proxy_v2.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/proxy_v2.c b/src/proxy_v2.c +index 97932ad3..47adb302 100644 +--- a/src/proxy_v2.c ++++ b/src/proxy_v2.c +@@ -280,7 +280,7 @@ int proxy_v2__read(struct mosquitto *context) + union proxy_addr *addr = (union proxy_addr *)context->proxy.buf; + context->address = mosquitto_strndup((char *)addr->unix_addr.src_addr, sizeof(addr->unix_addr.src_addr)); + context->remote_port = 0; +- context->proxy.pos = (uint16_t)(strlen(context->address) + 1); ++ context->proxy.pos = (uint16_t)(sizeof(addr->unix_addr.src_addr) + 1); + }else{ + /* Must be LOCAL */ + /* Ignore address */ +-- +2.34.1 + diff --git a/package/mosquitto/0009-Fix-incorrect-maximum-packet-size-restriction-for-in.patch b/package/mosquitto/0009-Fix-incorrect-maximum-packet-size-restriction-for-in.patch new file mode 100644 index 000000000000..dbf8d42aa81e --- /dev/null +++ b/package/mosquitto/0009-Fix-incorrect-maximum-packet-size-restriction-for-in.patch @@ -0,0 +1,116 @@ +From bb023cc9f6aceddbb77cd854659eac0a200ab017 Mon Sep 17 00:00:00 2001 +From: "Roger A. Light" +Date: Mon, 23 Feb 2026 18:45:34 +0000 +Subject: [PATCH] Fix incorrect maximum-packet-size restriction for incoming + packets. + +Closes #3515. Thanks to Julian Graf. + +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/7a1905006a629f264d3657abf335d09cb5555980 +[yann.morin@orange.com: drop the Changelog.txt entry] +Signed-off-by: Yann E. MORIN +--- + lib/packet_mosq.c | 14 ++++++++------ + test/broker/12-prop-maximum-packet-size-broker.py | 11 +++++++---- + 2 files changed, 15 insertions(+), 10 deletions(-) + +diff --git a/lib/packet_mosq.c b/lib/packet_mosq.c +index 48b0efbd..64651b73 100644 +--- a/lib/packet_mosq.c ++++ b/lib/packet_mosq.c +@@ -399,9 +399,11 @@ static int read_header(struct mosquitto *mosq, ssize_t (*func_read)(struct mosqu + + static int packet__check_in_packet_oversize(struct mosquitto *mosq) + { ++ uint32_t packet_length = 1 + mosquitto_varint_bytes(mosq->in_packet.remaining_length) + mosq->in_packet.remaining_length; ++ + switch(mosq->in_packet.command & 0xF0){ + case CMD_CONNECT: +- if(mosq->in_packet.remaining_length > db.config->packet_max_connect){ ++ if(packet_length > db.config->packet_max_connect){ + return MOSQ_ERR_OVERSIZE_PACKET; + } + break; +@@ -412,7 +414,7 @@ static int packet__check_in_packet_oversize(struct mosquitto *mosq) + case CMD_PUBCOMP: + case CMD_UNSUBACK: + if(mosq->protocol == mosq_p_mqtt5){ +- if(mosq->in_packet.remaining_length > db.config->packet_max_simple){ ++ if(packet_length > db.config->packet_max_simple){ + return MOSQ_ERR_OVERSIZE_PACKET; + } + }else{ +@@ -431,7 +433,7 @@ static int packet__check_in_packet_oversize(struct mosquitto *mosq) + + case CMD_DISCONNECT: + if(mosq->protocol == mosq_p_mqtt5){ +- if(mosq->in_packet.remaining_length > db.config->packet_max_simple){ ++ if(packet_length > db.config->packet_max_simple){ + return MOSQ_ERR_OVERSIZE_PACKET; + } + }else{ +@@ -443,20 +445,20 @@ static int packet__check_in_packet_oversize(struct mosquitto *mosq) + + case CMD_SUBSCRIBE: + case CMD_UNSUBSCRIBE: +- if(mosq->protocol == mosq_p_mqtt5 && mosq->in_packet.remaining_length > db.config->packet_max_sub){ ++ if(mosq->protocol == mosq_p_mqtt5 && packet_length > db.config->packet_max_sub){ + return MOSQ_ERR_OVERSIZE_PACKET; + } + break; + + case CMD_AUTH: +- if(mosq->in_packet.remaining_length > db.config->packet_max_auth){ ++ if(packet_length > db.config->packet_max_auth){ + return MOSQ_ERR_OVERSIZE_PACKET; + } + break; + + } + +- if(db.config->max_packet_size > 0 && mosq->in_packet.remaining_length+1 > db.config->max_packet_size){ ++ if(db.config->max_packet_size > 0 && packet_length > db.config->max_packet_size){ + if(mosq->protocol == mosq_p_mqtt5){ + send__disconnect(mosq, MQTT_RC_PACKET_TOO_LARGE, NULL); + } +diff --git a/test/broker/12-prop-maximum-packet-size-broker.py b/test/broker/12-prop-maximum-packet-size-broker.py +index 9df91b68..73be989c 100755 +--- a/test/broker/12-prop-maximum-packet-size-broker.py ++++ b/test/broker/12-prop-maximum-packet-size-broker.py +@@ -8,7 +8,7 @@ def write_config(filename, port): + with open(filename, 'w') as f: + f.write("listener %d\n" % (port)) + f.write("allow_anonymous true\n") +- f.write("max_packet_size 40\n") ++ f.write("max_packet_size 50\n") + + port = mosq_test.get_port() + conf_file = os.path.basename(__file__).replace('.py', '.conf') +@@ -18,18 +18,21 @@ rc = 1 + + connect_packet = mosq_test.gen_connect("12-max-packet-broker", proto_ver=5) + props = mqtt5_props.gen_uint16_prop(mqtt5_props.TOPIC_ALIAS_MAXIMUM, 10) +-props += mqtt5_props.gen_uint32_prop(mqtt5_props.MAXIMUM_PACKET_SIZE, 40) ++props += mqtt5_props.gen_uint32_prop(mqtt5_props.MAXIMUM_PACKET_SIZE, 50) + props += mqtt5_props.gen_uint16_prop(mqtt5_props.RECEIVE_MAXIMUM, 20) + connack_packet = mosq_test.gen_connack(rc=0, proto_ver=5, properties=props, property_helper=False) + +-publish_packet = mosq_test.gen_publish("12/max/packet/size/broker/test/topic", qos=0, payload="0123456789012345678901234567890", proto_ver=5) ++publish_packet_ok = mosq_test.gen_publish("12/max/packet/size/broker/test/topic", qos=0, payload="012345678", proto_ver=5) ++publish_packet_bad = mosq_test.gen_publish("12/max/packet/size/broker/test/topic", qos=0, payload="0123456789", proto_ver=5) + disconnect_packet = mosq_test.gen_disconnect(reason_code=149, proto_ver=5) + + broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port, use_conf=True) + + try: + sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port) +- mosq_test.do_send_receive(sock, publish_packet, disconnect_packet, "disconnect") ++ sock.send(publish_packet_ok) ++ mosq_test.do_ping(sock) ++ mosq_test.do_send_receive(sock, publish_packet_bad, disconnect_packet, "disconnect") + rc = 0 + except mosq_test.TestError: + pass +-- +2.34.1 + diff --git a/package/mosquitto/0010-broker-properly-check-for-getaddrinfo_a.patch b/package/mosquitto/0010-broker-properly-check-for-getaddrinfo_a.patch new file mode 100644 index 000000000000..6c73495113b6 --- /dev/null +++ b/package/mosquitto/0010-broker-properly-check-for-getaddrinfo_a.patch @@ -0,0 +1,35 @@ +From bc830cffee22a3498700f9038a4ceea47efe45de Mon Sep 17 00:00:00 2001 +From: "Yann E. MORIN" +Date: Tue, 10 Feb 2026 09:21:11 +0100 +Subject: [PATCH] broker: properly check for getaddrinfo_a() + +getaddrinfo_a( is protected by _GNU_SOURCE. + +This is properly accounted for in the source code, in lib/net_mosq.c, +but the check in the CmakeList is missing that define, which causes +the check to actually fail. + +Add that define when checking; this fixes builds on various C libraries, +like uClibc-ng, musl, or newer/older glibc. + +Signed-off-by: Yann E. MORIN +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/8c3bc32689346d7b86e2dad954ff482b5ad7aef1 +--- + src/CMakeLists.txt | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt +index 8ac47d87..8576fea9 100644 +--- a/src/CMakeLists.txt ++++ b/src/CMakeLists.txt +@@ -184,6 +184,7 @@ endif() + if(WITH_ADNS) + cmake_push_check_state() + set(ANL_CODE " ++ #define _GNU_SOURCE + #include + #include + int main(){ +-- +2.34.1 + diff --git a/package/mosquitto/0011-cmake-Only-include-C-support-when-required.patch b/package/mosquitto/0011-cmake-Only-include-C-support-when-required.patch new file mode 100644 index 000000000000..6cf1bc2fa95c --- /dev/null +++ b/package/mosquitto/0011-cmake-Only-include-C-support-when-required.patch @@ -0,0 +1,56 @@ +From 8db331b93053debfb2c0e42982847eeacd571aee Mon Sep 17 00:00:00 2001 +From: "Roger A. Light" +Date: Tue, 24 Feb 2026 10:26:50 +0000 +Subject: [PATCH] cmake: Only include C++ support when required + +Thanks to Yann Morin + +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/ae19460c132ec7b2b62c0703e1fafd3a0a3527aa) +Signed-off-by: Yann E. MORIN +--- + CMakeLists.txt | 8 +++++++- + lib/CMakeLists.txt | 1 - + 2 files changed, 7 insertions(+), 2 deletions(-) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 6c68bb9c..b3e28300 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -10,7 +10,7 @@ set (VERSION 2.1.2) + project(mosquitto + VERSION ${VERSION} + DESCRIPTION "Eclipse Mosquitto" +- LANGUAGES C CXX ++ LANGUAGES C + ) + + set(CMAKE_C_STANDARD 99) +@@ -46,10 +46,16 @@ include(CMakePushCheckState) + include(CheckSourceCompiles) + + option(WITH_BUNDLED_DEPS "Build with bundled dependencies?" ON) ++option(WITH_LIB_CPP "Build C++ library?" ON) + option(WITH_TLS "Include SSL/TLS support?" ON) + option(WITH_TLS_PSK "Include TLS-PSK support (requires WITH_TLS)?" ON) + option(WITH_TESTS "Enable tests" ON) + option(INC_MEMTRACK "Include memory tracking support?" ON) ++ ++if (WITH_LIB_CPP OR WITH_TESTS) ++ ENABLE_LANGUAGE(CXX) ++endif() ++ + if (WITH_TLS) + find_package(OpenSSL REQUIRED) + add_definitions("-DWITH_TLS") +diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt +index 4585a51a..d8bb3d8b 100644 +--- a/lib/CMakeLists.txt ++++ b/lib/CMakeLists.txt +@@ -1,4 +1,3 @@ +-option(WITH_LIB_CPP "Build C++ library?" ON) + if(WITH_LIB_CPP) + add_subdirectory(cpp) + endif() +-- +2.34.1 + diff --git a/package/mosquitto/0012-libcommon-check-for-getrandom.patch b/package/mosquitto/0012-libcommon-check-for-getrandom.patch new file mode 100644 index 000000000000..46b104657a3f --- /dev/null +++ b/package/mosquitto/0012-libcommon-check-for-getrandom.patch @@ -0,0 +1,90 @@ +From a1d0c56984f8a65d5ffb7fbde7f200b36b5ddae5 Mon Sep 17 00:00:00 2001 +From: "Yann E. MORIN" +Date: Tue, 10 Feb 2026 12:01:32 +0100 +Subject: [PATCH] libcommon: check for getrandom() + +Not all C libraries are glibc, or impersonating it; for example, musl +does not pretend to be any version of glibc. Thus, building on musl +fails when openssl is disabled, because no random-providing function is +detected, although musl does provide getrandom(). + +uClibc-ng on the other hand, can impersonate glibc, but availability of +getrandom() is not guatranteed there: getrandom() can be compiled out of +uClinbc-ng, or uClibc-ng can be too old to have it. + +Add a configure-time check that getrandom() is available, as a fallback +when TLS is not enabled (and thus openssl is not used), and when not on +Win32 (where getting random numbers is always possible, at least from a +build perspective). + +However, building with the plain Makefiles should keep working, so +slightly rework the defines checks in the code to account for the fact +that HAVE_GETRANDOM may already be defined at configure time. + +Signed-off-by: Yann E. MORIN +Upstream: https://github.com/eclipse-mosquitto/mosquitto/commit/a487cd4f8f56a9352eec1b6e05592a73794b162b) +--- + libcommon/CMakeLists.txt | 8 ++++++++ + libcommon/random_common.c | 14 +++++++------- + 2 files changed, 15 insertions(+), 7 deletions(-) + +diff --git a/libcommon/CMakeLists.txt b/libcommon/CMakeLists.txt +index 8f3474a0..7b9118bc 100644 +--- a/libcommon/CMakeLists.txt ++++ b/libcommon/CMakeLists.txt +@@ -57,6 +57,14 @@ if (WITH_TLS) + PUBLIC + OpenSSL::SSL + ) ++elseif(NOT WIN32) ++ include(CheckSymbolExists) ++ check_symbol_exists(getrandom "sys/random.h" GETRANDOM_FOUND) ++ if(GETRANDOM_FOUND) ++ add_definitions("-DHAVE_GETRANDOM") ++ else() ++ message(FATAL_ERROR "C library does not provide getrandom(); enable WITH_TLS instead") ++ endif() + endif() + + if(INC_MEMTRACK) +diff --git a/libcommon/random_common.c b/libcommon/random_common.c +index 555bd801..e2c8d23a 100644 +--- a/libcommon/random_common.c ++++ b/libcommon/random_common.c +@@ -26,18 +26,18 @@ Contributors: + # include + #endif + +-#if !defined(WITH_TLS) && defined(__linux__) && defined(__GLIBC__) ++#ifdef WITH_TLS ++# include ++# include ++#elif defined(HAVE_GETRANDOM) /* From CMakeLists.txt */ ++# include ++#elif defined(__linux__) && defined(__GLIBC__) /* For legacy Makefiles */ + # if __GLIBC_PREREQ(2, 25) + # include + # define HAVE_GETRANDOM 1 + # endif + #endif + +-#ifdef WITH_TLS +-# include +-# include +-#endif +- + #include "mosquitto.h" + + +@@ -65,7 +65,7 @@ int mosquitto_getrandom(void *bytes, int count) + } + + CryptReleaseContext(provider, 0); +-#else ++#else /* For legacy Makefiles */ + # error "No suitable random function found." + #endif + return rc; +-- +2.34.1 + diff --git a/package/mosquitto/Config.in b/package/mosquitto/Config.in index 339df8fddb70..08223bc5db86 100644 --- a/package/mosquitto/Config.in +++ b/package/mosquitto/Config.in @@ -1,5 +1,8 @@ config BR2_PACKAGE_MOSQUITTO bool "mosquitto" + depends on BR2_USE_MMU # lib peeks in malloc() internals; broker fork()s + depends on !BR2_STATIC_LIBS + select BR2_PACKAGE_CJSON help Eclipse Mosquitto is an open source (EPL/EDL licensed) message broker that implements the MQTT protocol versions 5.0, 3.1.1 @@ -19,26 +22,123 @@ config BR2_PACKAGE_MOSQUITTO https://mosquitto.org/ +if BR2_PACKAGE_MOSQUITTO + +choice + prompt "Websockets support" + help + Choose what websocket implementation to use. Note that + the mosquitto_{sub,pub,rr} clients (above) only support + websockets with the builtin implementation, while the + broker supports websockets with either libwebsockets + or the builtin implementation. + +config BR2_PACKAGE_MOSQUITTO_WS_NONE + bool "none" + +config BR2_PACKAGE_MOSQUITTO_WS_LIBWS + bool "with libwebsockets" + select BR2_PACKAGE_OPENSSL + select BR2_PACKAGE_LIBWEBSOCKETS + select BR2_PACKAGE_LIBWEBSOCKETS_EXT_POLL + +config BR2_PACKAGE_MOSQUITTO_WS_BUILTIN + bool "with builtin implementation" + select BR2_PACKAGE_OPENSSL + +endchoice + +config BR2_PACKAGE_MOSQUITTO_CLIENTS + bool "install clients" + default y # Backward compatibility + help + Install CLI tools to publish/subscribe to the broker: + mosquitto_pub + mosquitto_sub + mosquitto_rr + +config BR2_PACKAGE_MOSQUITTO_APPS + bool "install apps" + default y if BR2_PACKAGE_MOSQUITTO_BROKER # Backward compatibility + depends on BR2_USE_WCHAR # libedit + # For mosquitto_ctrl shell feature, mandatorily enabled: + select BR2_PACKAGE_READLINE if !BR2_PACKAGE_LIBEDIT + help + Those apps can be used to interact with the broker: + mosquitto_db_dump + mosquitto_signal + + Additionally, when openssl is enabled, the following apps are + also installed: + mosquitto_ctrl + mosquitto_passwd + config BR2_PACKAGE_MOSQUITTO_BROKER bool "install the mosquitto broker" default y - depends on BR2_USE_MMU # fork() - depends on !BR2_STATIC_LIBS # include - depends on BR2_PACKAGE_MOSQUITTO - select BR2_PACKAGE_LIBWEBSOCKETS_EXT_POLL if BR2_PACKAGE_LIBWEBSOCKETS help Build and install the mosquitto broker onto target. +if BR2_PACKAGE_MOSQUITTO_BROKER + +config BR2_PACKAGE_MOSQUITTO_BROKER_HTTP_API + bool "http_api" + select BR2_PACKAGE_LIBMICROHTTPD + help + Add support for simple webserver as a listener to serve + some of the HTTP API. + +config BR2_PACKAGE_MOSQUITTO_BROKER_BRIDGE + bool "bridge support" + default y # legacy + help + Include bridge support for connecting to other brokers + +config BR2_PACKAGE_MOSQUITTO_BROKER_SYS + bool "$SYS tree support" + default y # legacy + help + Enable the $SYS/# tree structure, to export broker status as + MQTT topics. + +config BR2_PACKAGE_MOSQUITTO_BROKER_CONTROL + bool "$CONTROL tree support" + default y # legacy + help + Enable the $CONTROL/# tree structure, to control the broker + via messages posted to, or retrieved from, MQTT topics. + +config BR2_PACKAGE_MOSQUITTO_BROKER_PLUGIN_STATIC_PASSWD + bool "static password file plugin" + default y + help + Add support for authentication based on static files. using + a plugin rather than the legacy builtin support. + +config BR2_PACKAGE_MOSQUITTO_BROKER_PLUGIN_STATIC_ACL + bool "static ACL file plugin" + default y + help + Add support for authorization (ACL) based on static files, + using a plugin rather than the legacy builtin support. + config BR2_PACKAGE_MOSQUITTO_BROKER_DYNAMIC_SECURITY_PLUGIN bool "dynamic security plugin" - depends on BR2_PACKAGE_MOSQUITTO_BROKER - select BR2_PACKAGE_CJSON select BR2_PACKAGE_OPENSSL help Build and install the dynamic security plugin for mosquitto broker onto target. -comment "mosquitto broker needs a toolchain w/ dynamic library" +config BR2_PACKAGE_MOSQUITTO_BROKER_PLUGIN_PERSIST_SQLITE + bool "persist-sqlite plugin" + select BR2_PACKAGE_SQLITE + help + Add the persist-sqlite plugin, to persist the broker + state across restarts. + +endif +endif + +comment "mosquitto needs a toolchain w/ dynamic library" depends on BR2_USE_MMU depends on BR2_STATIC_LIBS - depends on BR2_PACKAGE_MOSQUITTO diff --git a/package/mosquitto/mosquitto.hash b/package/mosquitto/mosquitto.hash index cf031f91e51b..c0306161c7cb 100644 --- a/package/mosquitto/mosquitto.hash +++ b/package/mosquitto/mosquitto.hash @@ -1,8 +1,7 @@ -# Locally calculated after checking gpg signature -# from https://mosquitto.org/files/source/mosquitto-2.0.22.tar.gz.asc -sha256 2f752589ef7db40260b633fbdb536e9a04b446a315138d64a7ff3c14e2de6b68 mosquitto-2.0.22.tar.gz +# Locally calculated +sha256 fd905380691ac65ea5a93779e8214941829e3d6e038d5edff9eac5fd74cbed02 mosquitto-2.1.2.tar.gz # License files -sha256 d3c4ccace4e5d3cc89d34cf2a0bc85b8596bfc0a32b815d0d77f9b7c41b5350c LICENSE.txt +sha256 33d1851e40fddba7eff95bcc01d1a178a87340a1126893012892913d5e6fdfa6 LICENSE.txt sha256 8c349f80764d0648e645f41ef23772a70c995a0924b5235f735f4a3d09df127c epl-v20 sha256 86fc4a3f97cb769c04e8da557036c1066eb8bb22b2d0a5dd31464990fe84047c edl-v10 diff --git a/package/mosquitto/mosquitto.mk b/package/mosquitto/mosquitto.mk index 8539f28d080f..06de7fc2af5a 100644 --- a/package/mosquitto/mosquitto.mk +++ b/package/mosquitto/mosquitto.mk @@ -4,119 +4,120 @@ # ################################################################################ -MOSQUITTO_VERSION = 2.0.22 +MOSQUITTO_VERSION = 2.1.2 MOSQUITTO_SITE = https://mosquitto.org/files/source MOSQUITTO_LICENSE = EPL-2.0 or EDLv1.0 MOSQUITTO_LICENSE_FILES = LICENSE.txt epl-v20 edl-v10 MOSQUITTO_CPE_ID_VENDOR = eclipse MOSQUITTO_INSTALL_STAGING = YES -MOSQUITTO_MAKE_OPTS = \ - CLIENT_STATIC_LDADD="$(MOSQUITTO_STATIC_LIBS)" \ - UNAME=Linux \ - STRIP=true \ - prefix=/usr \ - WITH_WRAP=no \ - WITH_DOCS=no +MOSQUITTO_DEPENDENCIES = cjson -ifeq ($(BR2_SHARED_LIBS),y) -MOSQUITTO_MAKE_OPTS += WITH_STATIC_LIBRARIES=no -else -MOSQUITTO_MAKE_OPTS += WITH_STATIC_LIBRARIES=yes -endif - -ifeq ($(BR2_STATIC_LIBS),y) -MOSQUITTO_MAKE_OPTS += WITH_SHARED_LIBRARIES=no -else -MOSQUITTO_MAKE_OPTS += WITH_SHARED_LIBRARIES=yes -endif - -ifeq ($(BR2_PACKAGE_SYSTEMD),y) -MOSQUITTO_MAKE_OPTS += WITH_SYSTEMD=yes -MOSQUITTO_DEPENDENCIES += systemd -endif +MOSQUITTO_CONF_OPTS = \ + -DUSE_LIBWRAP=OFF \ + -DWITH_DOCS=OFF \ + -DWITH_TESTS=OFF \ + -DWITH_STATIC_LIBRARIES=OFF \ + -DWITH_BUNDLED_DEPS=ON # adns uses getaddrinfo_a ifeq ($(BR2_TOOLCHAIN_USES_GLIBC),y) -MOSQUITTO_MAKE_OPTS += WITH_ADNS=yes +MOSQUITTO_CONF_OPTS += -DWITH_ADNS=ON else -MOSQUITTO_MAKE_OPTS += WITH_ADNS=no +MOSQUITTO_CONF_OPTS += -DWITH_ADNS=OFF endif # threaded API uses pthread_setname_np ifeq ($(BR2_TOOLCHAIN_HAS_THREADS_NPTL),y) -MOSQUITTO_MAKE_OPTS += WITH_THREADING=yes +MOSQUITTO_CONF_OPTS += -DWITH_THREADING=ON else -MOSQUITTO_MAKE_OPTS += WITH_THREADING=no +MOSQUITTO_CONF_OPTS += -DWITH_THREADING=OFF endif ifeq ($(BR2_PACKAGE_OPENSSL),y) MOSQUITTO_DEPENDENCIES += host-pkgconf openssl -MOSQUITTO_MAKE_OPTS += WITH_TLS=yes -MOSQUITTO_STATIC_LIBS += `$(PKG_CONFIG_HOST_BINARY) --libs openssl` +MOSQUITTO_CONF_OPTS += \ + -DWITH_TLS=ON \ + -DWITH_TLS_PSK=ON + +ifeq ($(BR2_PACKAGE_MOSQUITTO_WS_LIBWS),y) +MOSQUITTO_DEPENDENCIES += libwebsockets +MOSQUITTO_CONF_OPTS += -DWITH_WEBSOCKETS=ON -DWITH_WEBSOCKETS_BUILTIN=OFF +else ifeq ($(BR2_PACKAGE_MOSQUITTO_WS_BUILTIN),y) +MOSQUITTO_CONF_OPTS += -DWITH_WEBSOCKETS=ON -DWITH_WEBSOCKETS_BUILTIN=ON else -MOSQUITTO_MAKE_OPTS += WITH_TLS=no +MOSQUITTO_CONF_OPTS += -DWITH_WEBSOCKETS=OFF -DWITH_WEBSOCKETS_BUILTIN=OFF endif -ifeq ($(BR2_PACKAGE_CJSON),y) -MOSQUITTO_DEPENDENCIES += cjson -MOSQUITTO_MAKE_OPTS += WITH_CJSON=yes -MOSQUITTO_STATIC_LIBS += -lcjson -else -MOSQUITTO_MAKE_OPTS += WITH_CJSON=no +else # !OPENSSL +MOSQUITTO_CONF_OPTS += \ + -DWITH_TLS=OFF \ + -DWITH_TLS_PSK=OFF \ + -DWITH_WEBSOCKETS=OFF endif ifeq ($(BR2_PACKAGE_C_ARES),y) MOSQUITTO_DEPENDENCIES += c-ares -MOSQUITTO_MAKE_OPTS += WITH_SRV=yes +MOSQUITTO_CONF_OPTS += -DWITH_SRV=ON else -MOSQUITTO_MAKE_OPTS += WITH_SRV=no +MOSQUITTO_CONF_OPTS += -DWITH_SRV=OFF endif -ifeq ($(BR2_PACKAGE_LIBWEBSOCKETS),y) -MOSQUITTO_DEPENDENCIES += libwebsockets -MOSQUITTO_MAKE_OPTS += WITH_WEBSOCKETS=yes +ifeq ($(BR2_INSTALL_LIBSTDCPP),y) +MOSQUITTO_CONF_OPTS += -DWITH_LIB_CPP=ON else -MOSQUITTO_MAKE_OPTS += WITH_WEBSOCKETS=no +MOSQUITTO_CONF_OPTS += -DWITH_LIB_CPP=OFF endif -# C++ support is only used to create a wrapper library -ifneq ($(BR2_INSTALL_LIBSTDCPP),y) -define MOSQUITTO_DISABLE_CPP - $(SED) '/-C cpp/d' $(@D)/lib/Makefile -endef +ifeq ($(BR2_PACKAGE_MOSQUITTO_CLIENTS),y) +MOSQUITTO_CONF_OPTS += -DWITH_CLIENTS=ON +else +MOSQUITTO_CONF_OPTS += -DWITH_CLIENTS=OFF +endif -MOSQUITTO_POST_PATCH_HOOKS += MOSQUITTO_DISABLE_CPP +ifeq ($(BR2_PACKAGE_MOSQUITTO_APPS),y) +MOSQUITTO_DEPENDENCIES += $(if $(BR2_PACKAGE_LIBEDIT),libedit,readline) +MOSQUITTO_CONF_OPTS += -DWITH_APPS=ON -DWITH_CTRL_SHELL=ON +else +MOSQUITTO_CONF_OPTS += -DWITH_APPS=OFF -DWITH_CTRL_SHELL=OFF endif -MOSQUITTO_MAKE_DIRS = lib client ifeq ($(BR2_PACKAGE_MOSQUITTO_BROKER),y) -MOSQUITTO_MAKE_DIRS += src apps/mosquitto_ctrl apps/mosquitto_passwd -endif -ifeq ($(BR2_PACKAGE_MOSQUITTO_BROKER_DYNAMIC_SECURITY_PLUGIN),y) -MOSQUITTO_MAKE_DIRS += plugins/dynamic-security +MOSQUITTO_CONF_OPTS += \ + -DCMAKE_INSTALL_SYSCONFDIR=/etc \ + -DWITH_BROKER=ON \ + -DWITH_PLUGINS=ON \ + -DWITH_PLUGIN_EXAMPLES=OFF \ + -DWITH_PLUGIN_SPARKPLUG_AWARE=OFF \ + -DWITH_PLUGIN_PASSWORD_FILE=$(if $(BR2_PACKAGE_MOSQUITTO_BROKER_PLUGIN_STATIC_PASSWD),ON,OFF) \ + -DWITH_PLUGIN_ACL_FILE=$(if $(BR2_PACKAGE_MOSQUITTO_BROKER_PLUGIN_STATIC_ACL),ON,OFF) \ + -DWITH_PLUGIN_DYNAMIC_SECURITY=$(if $(BR2_PACKAGE_MOSQUITTO_BROKER_DYNAMIC_SECURITY_PLUGIN),ON,OFF) \ + -DINC_BRIDGE_SUPPORT=$(if $(BR2_PACKAGE_MOSQUITTO_BROKER_BRIDGE),ON,OFF) \ + -DWITH_SYS_TREE=$(if $(BR2_PACKAGE_MOSQUITTO_BROKER_SYS),ON,OFF) \ + -DWITH_CONTROL=$(if $(BR2_PACKAGE_MOSQUITTO_BROKER_CONTROL),ON,OFF) + +ifeq ($(BR2_PACKAGE_MOSQUITTO_BROKER_HTTP_API),y) +MOSQUITTO_DEPENDENCIES += libmicrohttpd +MOSQUITTO_CONF_OPTS += -DWITH_HTTP_API=ON +else +MOSQUITTO_CONF_OPTS += -DWITH_HTTP_API=OFF endif -define MOSQUITTO_BUILD_CMDS - $(MAKE) -C $(@D) $(TARGET_CONFIGURE_OPTS) DIRS="$(MOSQUITTO_MAKE_DIRS)" \ - $(MOSQUITTO_MAKE_OPTS) -endef - -define MOSQUITTO_INSTALL_STAGING_CMDS - $(MAKE) -C $(@D) $(TARGET_CONFIGURE_OPTS) DIRS="$(MOSQUITTO_MAKE_DIRS)" \ - $(MOSQUITTO_MAKE_OPTS) DESTDIR=$(STAGING_DIR) install -endef +ifeq ($(BR2_PACKAGE_MOSQUITTO_BROKER_PLUGIN_PERSIST_SQLITE),y) +MOSQUITTO_DEPENDENCIES += sqlite +MOSQUITTO_CONF_OPTS += -DWITH_PLUGIN_PERSIST_SQLITE=ON +else +MOSQUITTO_CONF_OPTS += -DWITH_PLUGIN_PERSIST_SQLITE=OFF +endif -define MOSQUITTO_INSTALL_TARGET_CMDS - $(MAKE) -C $(@D) $(TARGET_CONFIGURE_OPTS) DIRS="$(MOSQUITTO_MAKE_DIRS)" \ - $(MOSQUITTO_MAKE_OPTS) DESTDIR=$(TARGET_DIR) install - rm -f $(TARGET_DIR)/etc/mosquitto/*.example - $(INSTALL) -D -m 0644 $(@D)/mosquitto.conf \ - $(TARGET_DIR)/etc/mosquitto/mosquitto.conf -endef +ifeq ($(BR2_PACKAGE_SYSTEMD),y) +MOSQUITTO_DEPENDENCIES += systemd +MOSQUITTO_CONF_OPTS += -DWITH_SYSTEMD=ON +else +MOSQUITTO_CONF_OPTS += -DWITH_SYSTEMD=OFF +endif -ifeq ($(BR2_PACKAGE_MOSQUITTO_BROKER),y) define MOSQUITTO_INSTALL_INIT_SYSV $(INSTALL) -D -m 0755 package/mosquitto/S50mosquitto \ $(TARGET_DIR)/etc/init.d/S50mosquitto @@ -130,26 +131,41 @@ endef define MOSQUITTO_USERS mosquitto -1 mosquitto -1 * - - - Mosquitto user endef -endif - -HOST_MOSQUITTO_DEPENDENCIES = host-pkgconf host-openssl - -HOST_MOSQUITTO_MAKE_OPTS = \ - $(HOST_CONFIGURE_OPTS) \ - UNAME=Linux \ - STRIP=true \ - prefix=$(HOST_DIR) \ - WITH_WRAP=no \ - WITH_DOCS=no \ - WITH_TLS=yes -define HOST_MOSQUITTO_BUILD_CMDS - $(MAKE) -C $(@D)/apps/mosquitto_passwd $(HOST_MOSQUITTO_MAKE_OPTS) +define MOSQUITTO_INSTALL_TARGET_CONF + rm -f $(TARGET_DIR)/etc/mosquitto/*.example + $(INSTALL) -D -m 0644 $(@D)/mosquitto.conf \ + $(TARGET_DIR)/etc/mosquitto/mosquitto.conf endef +MOSQUITTO_POST_INSTALL_TARGET_HOOKS += MOSQUITTO_INSTALL_TARGET_CONF + +else # !BR2_PACKAGE_MOSQUITTO_BROKER +MOSQUITTO_CONF_OPTS += \ + -DWITH_BROKER=OFF \ + -DWITH_PLUGINS=OFF +endif +HOST_MOSQUITTO_DEPENDENCIES = \ + host-cjson \ + host-openssl \ + host-pkgconf + +HOST_MOSQUITTO_CONF_OPTS = \ + -DWITH_DOCS=OFF \ + -DWITH_BUNDLED_DEPS=ON \ + -DWITH_CLIENTS=OFF \ + -DWITH_BROKER=OFF \ + -DWITH_PLUGINS=OFF \ + -DWITH_TESTS=OFF \ + -DWITH_APPS=ON \ + -DWITH_TLS=ON + +# Manually install just the one tool we need define HOST_MOSQUITTO_INSTALL_CMDS - $(MAKE) -C $(@D)/apps/mosquitto_passwd $(HOST_MOSQUITTO_MAKE_OPTS) install + $(INSTALL) -D -m 0755 \ + $(@D)/apps/mosquitto_passwd/mosquitto_passwd \ + $(HOST_DIR)/bin/mosquitto_passwd endef -$(eval $(generic-package)) -$(eval $(host-generic-package)) +$(eval $(cmake-package)) +$(eval $(host-cmake-package)) diff --git a/package/php/php.hash b/package/php/php.hash index 5747e153f2b5..7fdb76b01a20 100644 --- a/package/php/php.hash +++ b/package/php/php.hash @@ -1,5 +1,5 @@ # From https://www.php.net/downloads.php?source=Y -sha256 ce65725b8af07356b69a6046d21487040b11f2acfde786de38b2bfb712c36eb9 php-8.5.3.tar.xz +sha256 c1569f1f543f6b025c583cdc0e730e5c5833c603618613f1aa8e75d1524b8c91 php-8.5.4.tar.xz # License file sha256 b42e4df5e50e6ecda1047d503d6d91d71032d09ed1027ba1ef29eed26f890c5a LICENSE diff --git a/package/php/php.mk b/package/php/php.mk index 4cba87a06ec3..220fb8c5c000 100644 --- a/package/php/php.mk +++ b/package/php/php.mk @@ -4,7 +4,7 @@ # ################################################################################ -PHP_VERSION = 8.5.3 +PHP_VERSION = 8.5.4 PHP_SITE = https://www.php.net/distributions PHP_SOURCE = php-$(PHP_VERSION).tar.xz PHP_INSTALL_STAGING = YES diff --git a/support/scripts/br2-external b/support/scripts/br2-external index 8aea479d205e..641f8e18ae81 100755 --- a/support/scripts/br2-external +++ b/support/scripts/br2-external @@ -30,10 +30,14 @@ main() { error "no output directory specified (-d)\n" fi - # Trap any unexpected error to generate a meaningful error message - trap "error 'unexpected error while generating ${ofile}\n'" ERR + if ! mkdir -p "${outputdir}"; then + error "Cannot create output directory '%s'\n" "${outputdir}" + fi - mkdir -p "${outputdir}" + # Historically, BR2_EXTERNAL could also be colon-separated, so for + # backward compatibility, keep splitting on colons (in addition to + # spaces). + # shellcheck disable=SC2068 # We do want to split on spaces do_validate "${outputdir}" ${@//:/ } do_mk "${outputdir}" do_kconfig "${outputdir}" @@ -71,7 +75,7 @@ do_validate_one() { if [ ! -d "${br2_ext}" ]; then error "'%s': no such file or directory\n" "${br2_ext}" fi - if [ ! -r "${br2_ext}" -o ! -x "${br2_ext}" ]; then + if [ ! -r "${br2_ext}" ] || [ ! -x "${br2_ext}" ]; then error "'%s': permission denied\n" "${br2_ext}" fi if [ ! -f "${br2_ext}/external.desc" ]; then @@ -106,9 +110,9 @@ do_validate_one() { br2_ext="$( cd "${br2_ext}"; pwd )" br2_ver="$( support/scripts/setlocalversion "${br2_ext}" )" BR2_EXT_NAMES+=( "${br2_name}" ) - eval BR2_EXT_PATHS_${br2_name}="\"\${br2_ext}\"" - eval BR2_EXT_VERS_${br2_name}="\"\${br2_ver}\"" - eval BR2_EXT_DESCS_${br2_name}="\"\${br2_desc:-\${br2_name}}\"" + eval "BR2_EXT_PATHS_${br2_name}=\"\${br2_ext}\"" + eval "BR2_EXT_VERS_${br2_name}=\"\${br2_ver}\"" + eval "BR2_EXT_DESCS_${br2_name}=\"\${br2_desc:-\${br2_name}}\"" } # Generate the .mk snippet that defines makefile variables @@ -272,7 +276,7 @@ do_kconfig() { printf 'endmenu\n' >>"${outputdir}/.br2-external.in.menus" } +# shellcheck disable=SC2059 # fmt *is* a format error() { local fmt="${1}"; shift; printf "BR2_EXTERNAL_ERROR = ${fmt}" "${@}"; exit 1; } -my_name="${0##*/}" main "${@}"