Linux clock framework development
 help / color / mirror / Atom feed
From: Lorenzo Bianconi <lorenzo.bianconi@oss.qualcomm.com>
To: Alex Elder <elder@riscstar.com>
Cc: sboyd@kernel.org, bmasney+clk@redhat.com,
	jbrunet+clk@baylibre.com, p.zabel@pengutronix.de,
	robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org,
	daniel@riscstar.com, mohd.anwar@oss.qualcomm.com,
	fabrice.gasnier@foss.st.com, alexandre.torgue@foss.st.com,
	marex@nabladev.com, changhuang.liang@starfivetech.com,
	devicetree@vger.kernel.org, linux-clk@vger.kernel.org,
	linux-kernel@vger.kernel.org
Subject: Re: [PATCH v2 2/2] clk: toshiba: introduce a TC9564 clock/reset driver
Date: Sat, 21 Nov 2026 13:33:02 +0100	[thread overview]
Message-ID: <awGPfkiR1ujU4M7i@lore-desk> (raw)
In-Reply-To: <20261120183212.1264522-3-elder@riscstar.com>

[-- Attachment #1: Type: text/plain, Size: 18741 bytes --]

> Define a new platform driver that manages clocks implemented by the
> Toshiba TC9564 SoC.  There are 21 gate clocks that can be enabled
> and disabled, but currently only the clocks that are (or will soon
> be) used are defined to be controllable.

Is it a repetition of the sentences below?

> 
> Two registers manage the state of the clocks.  The registers are
> accessed via a regmap supplied by a system controller.  Access to
> the memory region is provided via a BAR on a PCIe endpoint function
> embedded in the TC9564 SoC.

I guess this is a leftover, right?

> 
> Define the binding for the clock and reset controller that present in
> the Toshiba TC9564 SoC.
> 
> Define a new platform driver that manages clocks and resets implemented
> by the Toshiba TC9564 SoC.  There are 21 gate clocks that can be enabled
> and disabled, but some of these won't be used any time soon by software,
> so they are omitted.
> 
> There are also 13 resets that can be asserted or deasserted, but support
> for some of these is omitted as well.
> 
> The I2C and PCIE clocks and resets are treated as CRITICAL, meaning their
> state should never be changed (and a warning is issued if changing their
> state is attempted).
> 
> Co-developed-by: Daniel Thompson <daniel@riscstar.com>
> Signed-off-by: Daniel Thompson <daniel@riscstar.com>
> Signed-off-by: Alex Elder <elder@riscstar.com>
> ---
> v2: - New driver that combines clock and reset functionality
>     - Map the platform memory resource rather than using a regmap
>     - Kconfig adds COMPILE_TEST, and its help text is simplified
>     - Clock names now defined based on dev_name()
>     - gate_clk_manage() and reset_manage() return 0, so their
>       callers can be made a little simpler
>     - Flex array counted-by field is now explicitly assigned
> 
>  MAINTAINERS              |   1 +
>  drivers/clk/Kconfig      |   8 +
>  drivers/clk/Makefile     |   1 +
>  drivers/clk/clk-tc9564.c | 501 +++++++++++++++++++++++++++++++++++++++
>  4 files changed, 511 insertions(+)
>  create mode 100644 drivers/clk/clk-tc9564.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index af088e1092e63..9503c304c35ed 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -28689,6 +28689,7 @@ M:	Alex Elder <elder@kernel.org>
>  M:	Daniel Thompson <danielt@kernel.org>
>  S:	Maintained
>  F:	Documentation/devicetree/bindings/clock/toshiba,tc9564-clock.yaml
> +F:	drivers/clk/clk-tc9564.c
>  F:	include/dt-bindings/clock/toshiba,tc9564.h
>  
>  TOSHIBA TC9564 PCI DRIVER
> diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig
> index 6bfa2c8fffe1b..b27807ee93863 100644
> --- a/drivers/clk/Kconfig
> +++ b/drivers/clk/Kconfig
> @@ -185,6 +185,14 @@ config COMMON_CLK_CDCE706
>  	help
>  	  This driver supports TI CDCE706 programmable 3-PLL clock synthesizer.
>  
> +config COMMON_CLK_TC9564
> +	tristate "Toshiba TC9564 clock and reset support"
> +	depends on TC9564_PCI || COMPILE_TEST
> +	default TC9564_PCI
> +	help
> +	  This enables support for the clock and reset controllers embedded
> +	  in the Toshiba TC9564 SoC.
> +
>  config COMMON_CLK_TPS68470
>  	tristate "Clock Driver for TI TPS68470 PMIC"
>  	depends on I2C
> diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile
> index 99377a13ebc57..d67cfb6d623d3 100644
> --- a/drivers/clk/Makefile
> +++ b/drivers/clk/Makefile
> @@ -111,6 +111,7 @@ obj-$(CONFIG_COMMON_CLK_SI570)		+= clk-si570.o
>  obj-$(CONFIG_COMMON_CLK_SP7021)		+= clk-sp7021.o
>  obj-$(CONFIG_COMMON_CLK_STM32F)		+= clk-stm32f4.o
>  obj-$(CONFIG_COMMON_CLK_STM32H7)	+= clk-stm32h7.o
> +obj-$(CONFIG_COMMON_CLK_TC9564)		+= clk-tc9564.o
>  obj-$(CONFIG_COMMON_CLK_TPS68470)      += clk-tps68470.o
>  obj-$(CONFIG_CLK_TWL6040)		+= clk-twl6040.o
>  obj-$(CONFIG_CLK_TWL)			+= clk-twl.o
> diff --git a/drivers/clk/clk-tc9564.c b/drivers/clk/clk-tc9564.c
> new file mode 100644
> index 0000000000000..65ed524bf2ee7
> --- /dev/null
> +++ b/drivers/clk/clk-tc9564.c
> @@ -0,0 +1,501 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +
> +/*
> + * Copyright (C) 2026 by RISCstar Solutions Corporation.  All rights reserved.
> + */
> +
> +#include <linux/bits.h>
> +#include <linux/clk-provider.h>
> +#include <linux/io.h>
> +#include <linux/module.h>
> +#include <linux/platform_device.h>
> +#include <linux/reset-controller.h>
> +#include <linux/slab.h>
> +
> +#include <dt-bindings/clock/toshiba,tc9564.h>
> +
> +/*
> + * Two registers implement clock enable/disable bits for all gated clocks.
> + * And two registers implement reset assertion bits for all resets.
> + * These offsets are relative to the address space defined in devicetree.
> + */
> +#define CLOCK0_OFFSET	0x0
> +#define CLOCK1_OFFSET	0x8
> +#define RESET0_OFFSET	0x4
> +#define RESET1_OFFSET	0xc

nit: I guess you can just put these values in clock_init/reset_init structs.

> +
> +struct tc9564_clock {
> +	void __iomem *ioaddr;		/* Mapped clock/reset registers */
> +	struct clk_hw_onecell_data *clk_data;
> +	struct reset_controller_dev rcdev;
> +};
> +
> +struct gate_clock {
> +	const struct clock_init *init;
> +	struct clk_hw hw;
> +};
> +
> +enum clock_type { PLL, FIXED, GATE, CRITICAL_GATE };
> +
> +struct clock_init {
> +	const char *name;
> +	enum clock_type type;
> +	union {
> +		u32 mult;	/* PLL rate multiplier */
> +
> +		struct {	/* Fixed rate clock; parent is PLL */
> +			u32 numerator;	/* 0 is treated as 1 */
> +			u32 denominator;
> +		};
> +
> +		struct {	/* Gated clock; parent is a fixed rate clock */
> +			u16 parent;	/* Parent clock ID, e.g. CLOCK_100M */
> +			u16 offset;	/* Register offset */
> +			u32 mask;	/* Value is 2^n (only one bit set) */
> +		};
> +	};
> +};
> +
> +struct reset_init {
> +	u32 offset;	/* Register offset */
> +	u32 mask;	/* Value is 2^n (only one bit set) */
> +};
> +
> +/*
> + * Clocks are initialized and registered in the order of their IDs.
> + * There is one PLL, and it is initialized first.  Fixed clocks are
> + * initialized after that, and the gated clocks are initialized last
> + * (after their parent clocks have been registered).
> + */

please see the comment below.

> +static const struct clock_init clock_init[] = {
> +	[CLOCK_PLL] = {
> +		.name = "pll",
> +		.type = PLL,
> +		.mult = 50,
> +	},

unnecessary new-line

> +
> +	[CLOCK_62_5M] = {
> +		.name = "62.5MHz",
> +		.type = FIXED,
> +		.denominator = 20,
> +	},
> +	[CLOCK_100M] = {
> +		.name = "100MHz",
> +		.type = FIXED,
> +		.numerator = 2,
> +		.denominator = 25,
> +	},
> +	[CLOCK_125M] = {
> +		.name = "125MHz",
> +		.type = FIXED,
> +		.denominator = 10,
> +	},
> +	[CLOCK_250M] = {
> +		.name = "250MHz",
> +		.type = FIXED,
> +		.denominator = 5,
> +	},
> +	[CLOCK_312_5M] = {
> +		.name = "312.5MHz",
> +		.type = FIXED,
> +		.denominator = 4,
> +	},
> +
> +	[CLOCK_I2C] = {
> +		.name = "i2c",
> +		.type = CRITICAL_GATE,
> +		.parent = CLOCK_100M,
> +		.offset = CLOCK0_OFFSET,
> +		.mask = BIT(12),
> +	},
> +	[CLOCK_PCIE] = {
> +		.name = "PCIe",
> +		.type = CRITICAL_GATE,
> +		.parent = CLOCK_100M,
> +		.offset = CLOCK0_OFFSET,
> +		.mask = BIT(9),
> +	},
> +	[CLOCK_MSIGEN] = {
> +		.name = "msigen",
> +		.type = GATE,
> +		.parent = CLOCK_62_5M,
> +		.offset = CLOCK0_OFFSET,
> +		.mask = BIT(18),
> +	},
> +
> +	[CLOCK_MAC0_TX] = {
> +		.name = "MAC0-TX",
> +		.type = GATE,
> +		.parent = CLOCK_250M,
> +		.offset = CLOCK0_OFFSET,
> +		.mask = BIT(7),
> +	},
> +	[CLOCK_MAC0_RX] = {
> +		.name = "MAC0-RX",
> +		.type = GATE,
> +		.parent = CLOCK_250M,
> +		.offset = CLOCK0_OFFSET,
> +		.mask = BIT(14),
> +	},
> +	[CLOCK_MAC0_125M] = {
> +		.name = "MAC0-125MHz",
> +		.type = GATE,
> +		.parent = CLOCK_125M,
> +		.offset = CLOCK0_OFFSET,
> +		.mask = BIT(29),
> +	},
> +	[CLOCK_MAC0_312_5M] = {
> +		.name = "MAC0-312.5MHz",
> +		.type = GATE,
> +		.parent = CLOCK_312_5M,
> +		.offset = CLOCK0_OFFSET,
> +		.mask = BIT(30),
> +	},
> +	[CLOCK_MAC0_ALL] = {
> +		.name = "MAC0-ALL",
> +		.type = GATE,
> +		.parent = CLOCK_250M,
> +		.offset = CLOCK0_OFFSET,
> +		.mask = BIT(31),
> +	},
> +
> +	[CLOCK_MAC1_TX] = {
> +		.name = "MAC1-TX",
> +		.type = GATE,
> +		.parent = CLOCK_250M,
> +		.offset = CLOCK1_OFFSET,
> +		.mask = BIT(7),
> +	},
> +	[CLOCK_MAC1_RX] = {
> +		.name = "MAC1-RX",
> +		.type = GATE,
> +		.parent = CLOCK_250M,
> +		.offset = CLOCK1_OFFSET,
> +		.mask = BIT(14),
> +	},
> +	[CLOCK_MAC1_125M] = {
> +		.name = "MAC1-125MHz",
> +		.type = GATE,
> +		.parent = CLOCK_125M,
> +		.offset = CLOCK1_OFFSET,
> +		.mask = BIT(29),
> +	},
> +	[CLOCK_MAC1_312_5M] = {
> +		.name = "MAC1-312.5MHz",
> +		.type = GATE,
> +		.parent = CLOCK_312_5M,
> +		.offset = CLOCK1_OFFSET,
> +		.mask = BIT(30),
> +	},
> +	[CLOCK_MAC1_ALL] = {
> +		.name = "MAC1-ALL",
> +		.type = GATE,
> +		.parent = CLOCK_250M,
> +		.offset = CLOCK1_OFFSET,
> +		.mask = BIT(31),
> +	},
> +};
> +#define CLOCK_COUNT	ARRAY_SIZE(clock_init)
> +
> +static const struct reset_init reset_init[] = {
> +	[RESET_I2C] = {
> +		.offset = RESET0_OFFSET,
> +		.mask = BIT(12),
> +	},
> +	[RESET_PCIE] = {
> +		.offset = RESET0_OFFSET,
> +		.mask = BIT(9),
> +	},
> +	[RESET_MSIGEN] = {
> +		.offset = RESET0_OFFSET,
> +		.mask = BIT(18),
> +	},

unnecessary new-line

> +
> +	[RESET_MAC0_MAC] = {
> +		.offset = RESET0_OFFSET,
> +		.mask = BIT(7),
> +	},
> +	[RESET_MAC0_PMA] = {
> +		.offset = RESET0_OFFSET,
> +		.mask = BIT(30),
> +	},
> +	[RESET_MAC0_XPCS] = {
> +		.offset = RESET0_OFFSET,
> +		.mask = BIT(31),
> +	},
> +
> +	[RESET_MAC1_MAC] = {
> +		.offset = RESET1_OFFSET,
> +		.mask = BIT(7),
> +	},
> +	[RESET_MAC1_PMA] = {
> +		.offset = RESET1_OFFSET,
> +		.mask = BIT(30),
> +	},
> +	[RESET_MAC1_XPCS] = {
> +		.offset = RESET1_OFFSET,
> +		.mask = BIT(31),
> +	},
> +};
> +#define RESET_COUNT	ARRAY_SIZE(reset_init)
> +
> +/* Parent is the input oscillator running at 25 MHz; PLL runs at 1250 MHz */
> +static struct clk_hw *pll_register(struct device *dev, const char *name,
> +				   const struct clock_init *init)
> +{
> +	return devm_clk_hw_register_fixed_factor_index(dev, name, 0, 0,
> +						       init->mult, 1);
> +}
> +
> +/* The PLL is the parent of all fixed clocks */
> +static struct clk_hw *fixed_register(struct device *dev, const char *name,
> +				     const struct clock_init *init)
> +{
> +	struct tc9564_clock *tc9564_clock = dev_get_drvdata(dev);
> +	u32 numerator = init->numerator ? : 1;
> +	struct clk_hw *pll_hw;
> +
> +	pll_hw = tc9564_clock->clk_data->hws[CLOCK_PLL];
> +
> +	return devm_clk_hw_register_fixed_factor_parent_hw(dev, name, pll_hw,
> +							   0, numerator,
> +							   init->denominator);
> +}
> +
> +static const struct gate_clock *hw_to_gate_clock(struct clk_hw *hw)
> +{
> +	return container_of_const(hw, struct gate_clock, hw);
> +}
> +
> +static int gate_clk_manage(struct clk_hw *hw, bool enable)
> +{
> +	struct tc9564_clock *tc9564_clock = dev_get_drvdata(clk_hw_get_dev(hw));
> +	const struct gate_clock *clock = hw_to_gate_clock(hw);
> +	u32 mask = clock->init->mask;
> +	void __iomem *ioaddr;
> +	u32 val;
> +
> +	ioaddr = tc9564_clock->ioaddr + clock->init->offset;
> +
> +	val = readl(ioaddr);
> +	if (enable)
> +		val |= mask;
> +	else
> +		val &= ~mask;
> +	writel(val, ioaddr);
> +
> +	return 0;
> +}
> +
> +static int gate_clk_enable(struct clk_hw *hw)
> +{
> +	return gate_clk_manage(hw, true);
> +}
> +
> +static void gate_clk_disable(struct clk_hw *hw)
> +{
> +	(void)gate_clk_manage(hw, false);
> +}
> +
> +static int gate_clk_is_enabled(struct clk_hw *hw)
> +{
> +	struct tc9564_clock *tc9564_clock = dev_get_drvdata(clk_hw_get_dev(hw));
> +	const struct gate_clock *clock = hw_to_gate_clock(hw);
> +	void __iomem *ioaddr;
> +
> +	ioaddr = tc9564_clock->ioaddr + clock->init->offset;
> +
> +	return readl(ioaddr) & clock->init->mask ? 1 : 0;

This is racy with gate_clk_manage() but it is not harmful as for reset (please
see below) but I guess regmap can be helpful for clock as well.

> +}
> +
> +static const struct clk_ops gate_clk_ops = {
> +	.enable = gate_clk_enable,
> +	.disable = gate_clk_disable,
> +	.is_enabled = gate_clk_is_enabled,
> +};
> +
> +static struct clk_hw *gate_register(struct device *dev, const char *name,
> +				    const struct clock_init *init)
> +{
> +	struct tc9564_clock *tc9564_clock = dev_get_drvdata(dev);
> +	struct clk_init_data clk_init = { };
> +	const struct clk_hw *parent_hw;
> +	struct gate_clock *clock;
> +	int ret;
> +
> +	clock = devm_kzalloc_obj(dev, *clock);
> +	if (!clock)
> +		return ERR_PTR(-ENOMEM);
> +
> +	parent_hw = tc9564_clock->clk_data->hws[init->parent];
> +
> +	clk_init.name = name;
> +	clk_init.ops = &gate_clk_ops;
> +	clk_init.parent_hws = &parent_hw;
> +	clk_init.num_parents = 1;
> +	if (init->type == CRITICAL_GATE)
> +		clk_init.flags = CLK_IS_CRITICAL;
> +
> +	clock->hw.init = &clk_init;
> +	clock->init = init;
> +
> +	ret = devm_clk_hw_register(dev, &clock->hw);
> +	if (ret)
> +		return ERR_PTR(ret);
> +
> +	return &clock->hw;
> +}
> +
> +/* Warn on requests to assert or deassert critical resets */
> +static bool reset_is_critical(unsigned long id)
> +{
> +	return WARN_ON(id == RESET_I2C) || WARN_ON(id == RESET_PCIE);
> +}
> +
> +static int reset_manage(struct reset_controller_dev *rcdev,
> +			unsigned long id, bool assert)
> +{
> +	struct tc9564_clock *tc9564_clock = dev_get_drvdata(rcdev->dev);
> +	const struct reset_init *reset = &reset_init[id];
> +	u32 mask = reset->mask;
> +	void __iomem *ioaddr;
> +	u32 val;
> +
> +	if (reset_is_critical(id))
> +		return 0;		/* Just ignore the request */
> +
> +	ioaddr = tc9564_clock->ioaddr + reset->offset;

AFAIK reset framework does not provide any serialization for reset_control_ops.
Since multiple reset lines share the same register, reset_manage() is racy and
multiple calls to reset_control_assert() can write stale values. I think you
should add a spin_lock here or rely on regmap.

> +
> +	val = readl(ioaddr);
> +	if (assert)
> +		val |= mask;
> +	else
> +		val &= ~mask;
> +	writel(val, ioaddr);
> +
> +	return 0;
> +}
> +
> +static int reset_assert(struct reset_controller_dev *rcdev, unsigned long id)
> +{
> +	return reset_manage(rcdev, id, true);
> +}
> +
> +static int reset_deassert(struct reset_controller_dev *rcdev, unsigned long id)
> +{
> +	return reset_manage(rcdev, id, false);
> +}
> +
> +static int reset_status(struct reset_controller_dev *rcdev, unsigned long id)
> +{
> +	struct tc9564_clock *tc9564_clock = dev_get_drvdata(rcdev->dev);
> +	const struct reset_init *reset = &reset_init[id];
> +	void __iomem *ioaddr;
> +
> +	ioaddr = tc9564_clock->ioaddr + reset->offset;
> +
> +	return readl(ioaddr) & reset->mask ? 1 : 0;
> +}
> +
> +static const struct reset_control_ops reset_control_ops = {
> +	.assert = reset_assert,
> +	.deassert = reset_deassert,
> +	.status = reset_status,
> +};
> +
> +static int tc9564_clk_probe(struct platform_device *pdev)
> +{
> +	struct clk_hw_onecell_data *clk_data;
> +	struct reset_controller_dev *rcdev;
> +	struct tc9564_clock *tc9564_clock;
> +	struct device *dev = &pdev->dev;
> +	struct device_node *np;
> +	int ret;
> +
> +	np = dev_of_node(dev);
> +	if (!np)
> +		return dev_err_probe(dev, -EINVAL, "no devicetree node\n");
> +
> +	tc9564_clock = devm_kzalloc_obj(dev, *tc9564_clock);
> +	if (!tc9564_clock)
> +		return -ENOMEM;
> +
> +	tc9564_clock->ioaddr = devm_platform_ioremap_resource(pdev, 0);
> +	if (IS_ERR(tc9564_clock->ioaddr))
> +		return dev_err_probe(dev, PTR_ERR(tc9564_clock->ioaddr),
> +				     "failed to map registers\n");
> +
> +	clk_data = devm_kzalloc_flex(dev, *tc9564_clock->clk_data, hws,
> +				     CLOCK_COUNT);
> +	if (!clk_data)
> +		return -ENOMEM;
> +	clk_data->num = CLOCK_COUNT;
> +
> +	tc9564_clock->clk_data = clk_data;
> +
> +	/* Record the driver data pointer before we register anything */
> +	dev_set_drvdata(dev, tc9564_clock);
> +
> +	/* Initialize all the clocks, then register the provider */
> +	for (u32 i = 0; i < clk_data->num; i++) {
> +		const struct clock_init *init = &clock_init[i];
> +		struct clk_hw *hw;
> +		char *name;
> +
> +		name = kasprintf(GFP_KERNEL, "%s-%s", dev_name(dev), init->name);

nit: I guess you can use devm_kasprintf() here and get rid of the kfree().

> +		if (!name)
> +			return -ENOMEM;
> +
> +		if (init->type == PLL)

nit: I would use a switch here.

> +			hw = pll_register(dev, name, init);
> +		else if (init->type == FIXED)
> +			hw = fixed_register(dev, name, init);
> +		else
> +			hw = gate_register(dev, name, init);

I think this approach is a bit fragile since the clock dependency is guaranteed
by the order defined in include/dt-bindings/clock/toshiba,tc9564.h, right?

PLL clock --> fixed clocks --> gate_clocks

Would it better to enforce it in the code allocating first the PLL out of the
loop, then fixed rate clocks with a specific routine and, at the end, gate clocks?

Regards,
Lorenzo

> +		kfree(name);
> +
> +		if (IS_ERR(hw))
> +			return dev_err_probe(dev, PTR_ERR(hw),
> +					     "failed to register %s\n",
> +					     init->name);
> +		clk_data->hws[i] = hw;
> +	}
> +
> +	ret = devm_of_clk_add_hw_provider(dev, of_clk_hw_onecell_get, clk_data);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "failed to add clock provider\n");
> +
> +	/* Set up and register the reset controller */
> +	rcdev = &tc9564_clock->rcdev;
> +	rcdev->ops = &reset_control_ops;
> +	rcdev->owner = THIS_MODULE;
> +	rcdev->dev = dev;
> +	rcdev->of_node = np;
> +	rcdev->nr_resets = RESET_COUNT;
> +
> +	ret = devm_reset_controller_register(dev, rcdev);
> +	if (ret)
> +		return dev_err_probe(dev, ret,
> +				     "failed to register reset controller\n");
> +
> +	return 0;
> +}
> +
> +static const struct of_device_id tc9564_clock_match[] = {
> +	{ .compatible = "toshiba,tc9564-clock", },
> +	{ }
> +};
> +MODULE_DEVICE_TABLE(of, tc9564_clock_match);
> +
> +static struct platform_driver tc9564_clk_driver = {
> +	.probe = tc9564_clk_probe,
> +	.driver = {
> +		.name = KBUILD_MODNAME,
> +		.of_match_table = tc9564_clock_match,
> +		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
> +	},
> +};
> +module_platform_driver(tc9564_clk_driver);
> +
> +MODULE_DESCRIPTION("Toshiba TC9564 Clock Driver");
> +MODULE_LICENSE("GPL");
> -- 
> 2.53.0
> 

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]

  parent reply	other threads:[~2026-11-21 12:33 UTC|newest]

Thread overview: 8+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-20 18:32 [PATCH v2 0/2] clk: tc9564: introduce a clock and reset driver Alex Elder
2026-11-20 18:32 ` [PATCH v2 1/2] dt-bindings: toshiba: introduce toshiba,tc9564-clock.yaml Alex Elder
2026-11-21 10:20   ` Lorenzo Bianconi
2026-11-20 18:32 ` [PATCH v2 2/2] clk: toshiba: introduce a TC9564 clock/reset driver Alex Elder
2026-11-20 18:42   ` sashiko-bot
2026-11-20 21:33     ` Alex Elder
2026-11-21 12:33   ` Lorenzo Bianconi [this message]
2026-11-20 19:04 ` [PATCH v2 0/2] clk: tc9564: introduce a clock and reset driver Alex Elder

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=awGPfkiR1ujU4M7i@lore-desk \
    --to=lorenzo.bianconi@oss.qualcomm.com \
    --cc=alexandre.torgue@foss.st.com \
    --cc=bmasney+clk@redhat.com \
    --cc=changhuang.liang@starfivetech.com \
    --cc=conor+dt@kernel.org \
    --cc=daniel@riscstar.com \
    --cc=devicetree@vger.kernel.org \
    --cc=elder@riscstar.com \
    --cc=fabrice.gasnier@foss.st.com \
    --cc=jbrunet+clk@baylibre.com \
    --cc=krzk+dt@kernel.org \
    --cc=linux-clk@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=marex@nabladev.com \
    --cc=mohd.anwar@oss.qualcomm.com \
    --cc=p.zabel@pengutronix.de \
    --cc=robh@kernel.org \
    --cc=sboyd@kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox