[PATCH v1 0/2] pinctrl / 8250_dw: Allow drivers to keep init pinctrl state until first open

[PATCH v1 0/2] pinctrl / 8250_dw: Allow drivers to keep init pinctrl state until first open

[Michał Kardaś]

During device probe, pinctrl_bind_pins() binds pins to their "init" state
if specified in Device Tree. When probe finishes, pinctrl_init_done()
automatically transitions the pins from "init" to "default" state.

While this auto-transition works well for devices that are immediately
active upon driver binding, certain peripherals (such as power-sequenced
devices connected over UART, SPI, or other buses) remain unpowered until
userspace explicitly opens the device node or attaches a protocol driver.

On board designs where the connected peripheral is kept unpowered during
boot, auto-selecting "default" pin states (where signals such as TXD or
RTS may be driven high or pulled up) can cause parasitic back-powering
into the unpowered peripheral through its ESD protection diodes.

To address this without requiring new Device Tree binding names, this
series extends the existing "init" pinctrl state mechanism (introduced
in commit ef0eebc05130 ("drivers/pinctrl: Add the concept of an "init"
state")):

1. Patch 1 (pinctrl core):
   Adds pinctrl_keep_init_state(dev). When called during probe,
   pinctrl_init_done() opts out of the automatic "init" -> "default"
   transition, allowing the driver to keep pins in the safe "init" state
   upon probe completion. Updates Documentation/driver-api/pin-control.rst.
   Board configurations that do not define an "init" state are completely
   unaffected.

2. Patch 2 (8250_dw serial driver):
   Updates 8250_dw so that when an "init" state is defined for the port,
   the driver calls pinctrl_keep_init_state() and preserves the "init"
   state until the port is first opened via dw8250_do_pm(), at which point
   it transitions to "default" state and resumes normal operation.

Testing:
- Built and verified with CONFIG_PINCTRL=y and CONFIG_PINCTRL=n on
  upstream tree.
- Verified zero checkpatch warnings (`checkpatch.pl --strict`).
- Note: Functional hardware testing was performed on a downstream kernel
  tree where the physical back-powering issue was reproduced and verified
  fixed. The underlying UART pinctrl lifecycle issue and core logic apply
  identically to upstream.

Michał Kardaś (2):
  pinctrl: core: Allow drivers to keep "init" pinctrl state after probe
  tty: serial: 8250_dw: Keep init pinctrl state until first open

 Documentation/driver-api/pin-control.rst | 10 ++++++----
 drivers/pinctrl/core.c                   | 20 ++++++++++++++++++++
 drivers/tty/serial/8250/8250_dw.c        | 13 ++++++++++++-
 include/linux/pinctrl/consumer.h         |  6 ++++++
 include/linux/pinctrl/devinfo.h          |  2 ++
 5 files changed, 46 insertions(+), 5 deletions(-)

-- 
2.55.0.654.g21b8a5bc05-goog

[PATCH v1 1/2] pinctrl: core: Allow drivers to keep "init" pinctrl state after probe

[Michał Kardaś]

During device probe, pinctrl_bind_pins() binds pins to their "init" state
if specified in Device Tree. When probe finishes, pinctrl_init_done()
automatically transitions the pins from "init" to "default" state.

While this auto-transition works well for devices that are immediately
active upon driver binding, certain peripherals (such as power-sequenced
devices connected over UART, SPI, or other buses) remain unpowered until
userspace explicitly opens the device node or attaches a protocol driver.

On board designs where the connected peripheral is kept unpowered during
boot, auto-selecting "default" or "sleep" pin states (where signals such
as TXD or RTS may be driven high or pulled up) can cause parasitic
back-powering into the unpowered peripheral through its ESD protection
diodes.

Allow drivers to explicitly opt out of the automatic "init" -> "default"
transition by calling pinctrl_keep_init_state(dev) during probe. When this
helper is called, pinctrl_init_done() leaves the pins in their "init"
state upon probe completion. The driver can then transition to the
"default" state when the device is first opened by calling
pinctrl_pm_select_default_state(dev).

Suggested-by: Douglas Anderson <dianders@chromium.org>
Signed-off-by: Michał Kardaś <mkmkl@google.com>
---
 Documentation/driver-api/pin-control.rst | 10 ++++++----
 drivers/pinctrl/core.c                   | 20 ++++++++++++++++++++
 include/linux/pinctrl/consumer.h         |  6 ++++++
 include/linux/pinctrl/devinfo.h          |  2 ++
 4 files changed, 34 insertions(+), 4 deletions(-)

diff --git a/Documentation/driver-api/pin-control.rst b/Documentation/driver-api/pin-control.rst
index 1f585ecca63c..8d52bf74da6c 100644
--- a/Documentation/driver-api/pin-control.rst
+++ b/Documentation/driver-api/pin-control.rst
@@ -1172,7 +1172,8 @@ Possible standard state names are: "default", "init", "sleep" and "idle".
 
 - if ``init`` and ``default`` are defined in the device tree, the "init"
   state is selected before the driver probe and the "default" state is
-  selected after the driver probe.
+  selected after the driver probe, unless the driver explicitly opts out
+  by calling ``pinctrl_keep_init_state()`` during probe.
 
 - the ``sleep`` and ``idle`` states are for power management and can only
   be selected with the PM API bellow.
@@ -1233,9 +1234,10 @@ operation and going to sleep, moving from the ``PINCTRL_STATE_DEFAULT`` to
 current in sleep mode.
 
 Another case is when the pinctrl needs to switch to a certain mode during
-probe and then revert to the default state at the end of probe. For example
-a PINMUX may need to be configured as a GPIO during probe. In this case, use
-``PINCTRL_STATE_INIT`` to switch state before probe, then move to
+probe and then revert to the default state at the end of probe (or remain
+in the init state until activated if ``pinctrl_keep_init_state()`` is called).
+For example a PINMUX may need to be configured as a GPIO during probe. In this
+case, use ``PINCTRL_STATE_INIT`` to switch state before probe, then move to
 ``PINCTRL_STATE_DEFAULT`` at the end of probe for normal operation.
 
 A driver may request a certain control state to be activated, usually just the
diff --git a/drivers/pinctrl/core.c b/drivers/pinctrl/core.c
index 1675dd36bd5c..fd0c91610338 100644
--- a/drivers/pinctrl/core.c
+++ b/drivers/pinctrl/core.c
@@ -1640,6 +1640,9 @@ int pinctrl_init_done(struct device *dev)
 	if (pins->p->state != pins->init_state)
 		return 0; /* Not at init anyway */
 
+	if (pins->keep_init)
+		return 0; /* Driver explicitly requested to stay in init state */
+
 	if (IS_ERR(pins->default_state))
 		return 0; /* No default state */
 
@@ -1678,6 +1681,23 @@ int pinctrl_select_default_state(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(pinctrl_select_default_state);
 
+/**
+ * pinctrl_keep_init_state() - mark pinctrl handle to stay in init state after probe
+ * @dev: device to keep init state for
+ *
+ * Return: true if the device has a valid init state and keep_init flag was set,
+ *         false otherwise.
+ */
+bool pinctrl_keep_init_state(struct device *dev)
+{
+	if (!dev->pins || IS_ERR(dev->pins->init_state))
+		return false;
+
+	dev->pins->keep_init = true;
+	return true;
+}
+EXPORT_SYMBOL_GPL(pinctrl_keep_init_state);
+
 #ifdef CONFIG_PM
 
 /**
diff --git a/include/linux/pinctrl/consumer.h b/include/linux/pinctrl/consumer.h
index 11b8f0b8da0c..4312a098fb4c 100644
--- a/include/linux/pinctrl/consumer.h
+++ b/include/linux/pinctrl/consumer.h
@@ -47,6 +47,7 @@ int pinctrl_select_state(struct pinctrl *p, struct pinctrl_state *s);
 struct pinctrl * __must_check devm_pinctrl_get(struct device *dev);
 void devm_pinctrl_put(struct pinctrl *p);
 int pinctrl_select_default_state(struct device *dev);
+bool pinctrl_keep_init_state(struct device *dev);
 
 #ifdef CONFIG_PM
 int pinctrl_pm_select_default_state(struct device *dev);
@@ -152,6 +153,11 @@ static inline int pinctrl_select_default_state(struct device *dev)
 	return 0;
 }
 
+static inline bool pinctrl_keep_init_state(struct device *dev)
+{
+	return false;
+}
+
 static inline int pinctrl_pm_select_default_state(struct device *dev)
 {
 	return 0;
diff --git a/include/linux/pinctrl/devinfo.h b/include/linux/pinctrl/devinfo.h
index de4228eea90a..13dac33f2df1 100644
--- a/include/linux/pinctrl/devinfo.h
+++ b/include/linux/pinctrl/devinfo.h
@@ -32,6 +32,7 @@ struct pinctrl;
  * @init_state: the state at probe time, if found
  * @sleep_state: the state at suspend time, if found
  * @idle_state: the state at idle (runtime suspend) time, if found
+ * @keep_init: flag indicating if init state should persist after probe
  */
 struct dev_pin_info {
 	struct pinctrl *p;
@@ -41,6 +42,7 @@ struct dev_pin_info {
 	struct pinctrl_state *sleep_state;
 	struct pinctrl_state *idle_state;
 #endif
+	bool keep_init:1;
 };
 
 extern int pinctrl_init_done(struct device *dev);
-- 
2.55.0.654.g21b8a5bc05-goog

Re: [PATCH v1 1/2] pinctrl: core: Allow drivers to keep "init" pinctrl state after probe

[Andy Shevchenko]

On Mon, Aug 10, 2026 at 01:06:34PM +0000, Michał Kardaś wrote:
> During device probe, pinctrl_bind_pins() binds pins to their "init" state
> if specified in Device Tree. When probe finishes, pinctrl_init_done()
> automatically transitions the pins from "init" to "default" state.
> 
> While this auto-transition works well for devices that are immediately
> active upon driver binding, certain peripherals (such as power-sequenced
> devices connected over UART, SPI, or other buses) remain unpowered until
> userspace explicitly opens the device node or attaches a protocol driver.
> 
> On board designs where the connected peripheral is kept unpowered during
> boot, auto-selecting "default" or "sleep" pin states (where signals such
> as TXD or RTS may be driven high or pulled up) can cause parasitic
> back-powering into the unpowered peripheral through its ESD protection
> diodes.
> 
> Allow drivers to explicitly opt out of the automatic "init" -> "default"
> transition by calling pinctrl_keep_init_state(dev) during probe. When this
> helper is called, pinctrl_init_done() leaves the pins in their "init"
> state upon probe completion. The driver can then transition to the
> "default" state when the device is first opened by calling
> pinctrl_pm_select_default_state(dev).

...

> +/**
> + * pinctrl_keep_init_state() - mark pinctrl handle to stay in init state after probe
> + * @dev: device to keep init state for
> + *
> + * Return: true if the device has a valid init state and keep_init flag was set,
> + *         false otherwise.
> + */
> +bool pinctrl_keep_init_state(struct device *dev)
> +{
> +	if (!dev->pins || IS_ERR(dev->pins->init_state))
> +		return false;

The above keeps_init in the initial state which may or may not be wrong.
I would avoid the ambiguity by rewriting this as

> +	dev->pins->keep_init = true;
> +	return true;

	dev->pins->keep_init = dev->pins && !IS_ERR(dev->pins->init_state);

	return dev->pins->keep_init;

But please, check if that is what you want.

> +}

...

> +	bool keep_init:1;

What is ':1' supposed to mean (for boolean)? I understand that for say
unsigned int.

-- 
With Best Regards,
Andy Shevchenko

[PATCH v1 2/2] tty: serial: 8250_dw: Keep init pinctrl state until first open

[Michał Kardaś]

When a UART port is connected to an external peripheral whose power
domain is kept powered off until first use, transitioning the UART
pins from the "init" state to the "default" state prematurely at probe
completion can cause parasitic back-powering into the unpowered
peripheral.

Ensure that on boards specifying an "init" pinctrl state for the port,
the "init" state is preserved until the port is first opened:

1. In dw8250_probe(), call pinctrl_keep_init_state(dev) to opt out of the
   automatic "init" -> "default" transition at probe completion and record
   this in data->in_init_state.
2. In dw8250_do_pm(), when the port is opened (state == 0), transition
   pins from "init" to "default" if data->in_init_state is set, and clear
   the flag.

Suggested-by: Douglas Anderson <dianders@chromium.org>
Co-developed-by: Vic Huang <vich@google.com>
Signed-off-by: Vic Huang <vich@google.com>
Signed-off-by: Michał Kardaś <mkmkl@google.com>
---
 drivers/tty/serial/8250/8250_dw.c | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/drivers/tty/serial/8250/8250_dw.c b/drivers/tty/serial/8250/8250_dw.c
index 5fba913f3301..74e568e2a0d3 100644
--- a/drivers/tty/serial/8250/8250_dw.c
+++ b/drivers/tty/serial/8250/8250_dw.c
@@ -18,6 +18,7 @@
 #include <linux/io.h>
 #include <linux/lockdep.h>
 #include <linux/module.h>
+#include <linux/pinctrl/consumer.h>
 #include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
 #include <linux/property.h>
@@ -77,6 +78,7 @@ struct dw8250_data {
 	unsigned int		skip_autocfg:1;
 	unsigned int		uart_16550_compatible:1;
 	unsigned int		in_idle:1;
+	unsigned int		in_init_state:1;
 
 	u8			no_int_count;
 };
@@ -461,8 +463,15 @@ static int dw8250_handle_irq(struct uart_port *p)
 static void
 dw8250_do_pm(struct uart_port *port, unsigned int state, unsigned int old)
 {
-	if (!state)
+	struct dw8250_data *d = to_dw8250_data(port->private_data);
+
+	if (!state) {
 		pm_runtime_get_sync(port->dev);
+		if (d->in_init_state) {
+			d->in_init_state = false;
+			pinctrl_pm_select_default_state(port->dev);
+		}
+	}
 
 	serial8250_do_pm(port, state, old);
 
@@ -770,6 +779,8 @@ static int dw8250_probe(struct platform_device *pdev)
 	if (data->data.line < 0)
 		return data->data.line;
 
+	data->in_init_state = pinctrl_keep_init_state(dev);
+
 	platform_set_drvdata(pdev, data);
 
 	pm_runtime_enable(dev);
-- 
2.55.0.654.g21b8a5bc05-goog

Re: [PATCH v1 2/2] tty: serial: 8250_dw: Keep init pinctrl state until first open

[Andy Shevchenko]

On Mon, Aug 10, 2026 at 01:06:35PM +0000, Michał Kardaś wrote:
> When a UART port is connected to an external peripheral whose power
> domain is kept powered off until first use, transitioning the UART
> pins from the "init" state to the "default" state prematurely at probe
> completion can cause parasitic back-powering into the unpowered
> peripheral.
> 
> Ensure that on boards specifying an "init" pinctrl state for the port,
> the "init" state is preserved until the port is first opened:
> 
> 1. In dw8250_probe(), call pinctrl_keep_init_state(dev) to opt out of the
>    automatic "init" -> "default" transition at probe completion and record
>    this in data->in_init_state.
> 2. In dw8250_do_pm(), when the port is opened (state == 0), transition
>    pins from "init" to "default" if data->in_init_state is set, and clear
>    the flag.

...

>  dw8250_do_pm(struct uart_port *port, unsigned int state, unsigned int old)
>  {
> -	if (!state)
> +	struct dw8250_data *d = to_dw8250_data(port->private_data);
> +
> +	if (!state) {
>  		pm_runtime_get_sync(port->dev);
> +		if (d->in_init_state) {
> +			d->in_init_state = false;

Mistyped assignee. Should be 0.

> +			pinctrl_pm_select_default_state(port->dev);
> +		}
> +	}

Obviously the above needs a good comment in the code explaining why it is doing
that.

...

>  	if (data->data.line < 0)
>  		return data->data.line;

And a good comment explaining what you put in the commit message.

> +	data->in_init_state = pinctrl_keep_init_state(dev);

>  	platform_set_drvdata(pdev, data);
>  
>  	pm_runtime_enable(dev);

...

Wondering if this anyhow affects the future idea of the OOB wakeup for the UART
using its Rx as GPIO wake source in the suspend.

-- 
With Best Regards,
Andy Shevchenko

Re: [PATCH v1 2/2] tty: serial: 8250_dw: Keep init pinctrl state until first open

[Linus Walleij]

Hi Michal,

thanks for your patch!

On Mon, Aug 10, 2026 at 3:06 PM Michał Kardaś <mkmkl@google.com> wrote:

> @@ -77,6 +78,7 @@ struct dw8250_data {
>         unsigned int            skip_autocfg:1;
>         unsigned int            uart_16550_compatible:1;
>         unsigned int            in_idle:1;
> +       unsigned int            in_init_state:1;

Side comment: why are these not bool?

> +       if (!state) {
>                 pm_runtime_get_sync(port->dev);
> +               if (d->in_init_state) {
> +                       d->in_init_state = false;
> +                       pinctrl_pm_select_default_state(port->dev);
> +               }
> +       }

As noticed in 0/2 don't use the default state for this, create and
use a custom but optional "online" state. It needs to be optional
so current users keep working without it.

Yours,
Linus Walleij

Re: [PATCH v1 0/2] pinctrl / 8250_dw: Allow drivers to keep init pinctrl state until first open

[Linus Walleij]

Hi Michal,

thanks for your patches!

On Mon, Aug 10, 2026 at 3:06 PM Michał Kardaś <mkmkl@google.com> wrote:

> During device probe, pinctrl_bind_pins() binds pins to their "init" state
> if specified in Device Tree. When probe finishes, pinctrl_init_done()
> automatically transitions the pins from "init" to "default" state.
(...)
> 1. Patch 1 (pinctrl core):
>    Adds pinctrl_keep_init_state(dev). When called during probe,
>    pinctrl_init_done() opts out of the automatic "init" -> "default"
>    transition, allowing the driver to keep pins in the safe "init" state
>    upon probe completion. Updates Documentation/driver-api/pin-control.rst.
>    Board configurations that do not define an "init" state are completely
>    unaffected.

I think this is the wrong approach to this problem.

You are changing the transition from "init" to "default" for all devices
on the entire system. What if this is not good for all devices?

I think the right approach is to create a new custom pin control
state for 8250dw, something like "active" or "online", and then
actively retrieve this state when the device goes online.
The "init" state can just be the exact same as "default",
or you can just define "default" to be what "init" is and skip
"init" altogether.

Pin control supports any kind of arbitrarily named custom
states.

In wherever the UART is actually opened:

#include <linux/pinctrl/consumer.h>

probe():
mydev->p = devm_pinctrl_get(dev);
mydev->pins_online_state = = pinctrl_lookup_state(dev->pins->p, "online");

open():
ret = pinctrl_select_state(dev->pins->p, mydev->pins_online_state);

close():
ret = pinctrl_pm_select_default_state(dev);

+ all error handling and stuff, see e.g. drivers/base/pinctrl.c for
good coding practice.

Yours,
Linus Walleij