* [PATCH 0/2] pinctrl: stm32: add suspend/resume management @ 2019-05-10 7:42 ` Alexandre Torgue 0 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-10 7:42 UTC (permalink / raw) To: Linus Walleij, Maxime Coquelin Cc: linux-gpio, alexandre.torgue, linux-kernel, linux-arm-kernel, linux-stm32 During power sequence, GPIO hardware registers could be lost if the power supply is switched off. Each device using pinctrl API is in charge of managing pins during suspend/resume sequences. But for pins used as gpio or irq stm32 pinctrl driver has to save the hardware configuration. Each register will be saved at runtime and restored during resume sequence. Regards Alex Alexandre Torgue (2): pinctrl: stm32: add suspend/resume management pinctrl: stm32: Enable suspend/resume for stm32mp157c SoC drivers/pinctrl/stm32/pinctrl-stm32.c | 132 +++++++++++++++++++++++++++++ drivers/pinctrl/stm32/pinctrl-stm32.h | 2 + drivers/pinctrl/stm32/pinctrl-stm32mp157.c | 5 ++ 3 files changed, 139 insertions(+) -- 2.7.4 ^ permalink raw reply [flat|nested] 17+ messages in thread
* [PATCH 0/2] pinctrl: stm32: add suspend/resume management @ 2019-05-10 7:42 ` Alexandre Torgue 0 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-10 7:42 UTC (permalink / raw) To: Linus Walleij, Maxime Coquelin Cc: linux-gpio, alexandre.torgue, linux-kernel, linux-arm-kernel, linux-stm32 During power sequence, GPIO hardware registers could be lost if the power supply is switched off. Each device using pinctrl API is in charge of managing pins during suspend/resume sequences. But for pins used as gpio or irq stm32 pinctrl driver has to save the hardware configuration. Each register will be saved at runtime and restored during resume sequence. Regards Alex Alexandre Torgue (2): pinctrl: stm32: add suspend/resume management pinctrl: stm32: Enable suspend/resume for stm32mp157c SoC drivers/pinctrl/stm32/pinctrl-stm32.c | 132 +++++++++++++++++++++++++++++ drivers/pinctrl/stm32/pinctrl-stm32.h | 2 + drivers/pinctrl/stm32/pinctrl-stm32mp157.c | 5 ++ 3 files changed, 139 insertions(+) -- 2.7.4 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 17+ messages in thread
* [PATCH 0/2] pinctrl: stm32: add suspend/resume management @ 2019-05-10 7:42 ` Alexandre Torgue 0 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-10 7:42 UTC (permalink / raw) To: Linus Walleij, Maxime Coquelin Cc: linux-kernel, linux-gpio, linux-arm-kernel, linux-stm32, alexandre.torgue During power sequence, GPIO hardware registers could be lost if the power supply is switched off. Each device using pinctrl API is in charge of managing pins during suspend/resume sequences. But for pins used as gpio or irq stm32 pinctrl driver has to save the hardware configuration. Each register will be saved at runtime and restored during resume sequence. Regards Alex Alexandre Torgue (2): pinctrl: stm32: add suspend/resume management pinctrl: stm32: Enable suspend/resume for stm32mp157c SoC drivers/pinctrl/stm32/pinctrl-stm32.c | 132 +++++++++++++++++++++++++++++ drivers/pinctrl/stm32/pinctrl-stm32.h | 2 + drivers/pinctrl/stm32/pinctrl-stm32mp157.c | 5 ++ 3 files changed, 139 insertions(+) -- 2.7.4 ^ permalink raw reply [flat|nested] 17+ messages in thread
* [PATCH 1/2] pinctrl: stm32: add suspend/resume management 2019-05-10 7:42 ` Alexandre Torgue (?) @ 2019-05-10 7:42 ` Alexandre Torgue -1 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-10 7:42 UTC (permalink / raw) To: Linus Walleij, Maxime Coquelin Cc: linux-kernel, linux-gpio, linux-arm-kernel, linux-stm32, alexandre.torgue During power sequence, GPIO hardware registers could be lost if the power supply is switched off. Each device using pinctrl API is in charge of managing pins during suspend/resume sequences. But for pins used as gpio or irq stm32 pinctrl driver has to save the hardware configuration. Signed-off-by: Alexandre Torgue <alexandre.torgue@st.com> diff --git a/drivers/pinctrl/stm32/pinctrl-stm32.c b/drivers/pinctrl/stm32/pinctrl-stm32.c index 2317ccf..335aea5 100644 --- a/drivers/pinctrl/stm32/pinctrl-stm32.c +++ b/drivers/pinctrl/stm32/pinctrl-stm32.c @@ -44,6 +44,18 @@ #define STM32_GPIO_AFRL 0x20 #define STM32_GPIO_AFRH 0x24 +/* custom bitfield to backup pin status */ +#define STM32_GPIO_BKP_MODE_SHIFT 0 +#define STM32_GPIO_BKP_MODE_MASK GENMASK(1, 0) +#define STM32_GPIO_BKP_ALT_SHIFT 2 +#define STM32_GPIO_BKP_ALT_MASK GENMASK(5, 2) +#define STM32_GPIO_BKP_SPEED_SHIFT 6 +#define STM32_GPIO_BKP_SPEED_MASK GENMASK(7, 6) +#define STM32_GPIO_BKP_PUPD_SHIFT 8 +#define STM32_GPIO_BKP_PUPD_MASK GENMASK(9, 8) +#define STM32_GPIO_BKP_TYPE 10 +#define STM32_GPIO_BKP_VAL 11 + #define STM32_GPIO_PINS_PER_BANK 16 #define STM32_GPIO_IRQ_LINE 16 @@ -79,6 +91,7 @@ struct stm32_gpio_bank { struct irq_domain *domain; u32 bank_nr; u32 bank_ioport_nr; + u32 pin_backup[STM32_GPIO_PINS_PER_BANK]; }; struct stm32_pinctrl { @@ -133,11 +146,50 @@ static inline u32 stm32_gpio_get_alt(u32 function) return 0; } +static void stm32_gpio_backup_value(struct stm32_gpio_bank *bank, + u32 offset, u32 value) +{ + bank->pin_backup[offset] &= ~BIT(STM32_GPIO_BKP_VAL); + bank->pin_backup[offset] |= value << STM32_GPIO_BKP_VAL; +} + +static void stm32_gpio_backup_mode(struct stm32_gpio_bank *bank, u32 offset, + u32 mode, u32 alt) +{ + bank->pin_backup[offset] &= ~(STM32_GPIO_BKP_MODE_MASK | + STM32_GPIO_BKP_ALT_MASK); + bank->pin_backup[offset] |= mode << STM32_GPIO_BKP_MODE_SHIFT; + bank->pin_backup[offset] |= alt << STM32_GPIO_BKP_ALT_SHIFT; +} + +static void stm32_gpio_backup_driving(struct stm32_gpio_bank *bank, u32 offset, + u32 drive) +{ + bank->pin_backup[offset] &= ~BIT(STM32_GPIO_BKP_TYPE); + bank->pin_backup[offset] |= drive << STM32_GPIO_BKP_TYPE; +} + +static void stm32_gpio_backup_speed(struct stm32_gpio_bank *bank, u32 offset, + u32 speed) +{ + bank->pin_backup[offset] &= ~STM32_GPIO_BKP_SPEED_MASK; + bank->pin_backup[offset] |= speed << STM32_GPIO_BKP_SPEED_SHIFT; +} + +static void stm32_gpio_backup_bias(struct stm32_gpio_bank *bank, u32 offset, + u32 bias) +{ + bank->pin_backup[offset] &= ~STM32_GPIO_BKP_PUPD_MASK; + bank->pin_backup[offset] |= bias << STM32_GPIO_BKP_PUPD_SHIFT; +} + /* GPIO functions */ static inline void __stm32_gpio_set(struct stm32_gpio_bank *bank, unsigned offset, int value) { + stm32_gpio_backup_value(bank, offset, value); + if (!value) offset += STM32_GPIO_PINS_PER_BANK; @@ -620,6 +672,8 @@ static int stm32_pmx_set_mode(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_mode(bank, pin, mode, alt); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -732,6 +786,8 @@ static int stm32_pconf_set_driving(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_driving(bank, offset, drive); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -784,6 +840,8 @@ static int stm32_pconf_set_speed(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_speed(bank, offset, speed); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -836,6 +894,8 @@ static int stm32_pconf_set_bias(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_bias(bank, offset, bias); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -1369,3 +1429,75 @@ int stm32_pctl_probe(struct platform_device *pdev) return 0; } + +static int __maybe_unused stm32_pinctrl_restore_gpio_regs( + struct stm32_pinctrl *pctl, u32 pin) +{ + const struct pin_desc *desc = pin_desc_get(pctl->pctl_dev, pin); + u32 val, alt, mode, offset = stm32_gpio_pin(pin); + struct pinctrl_gpio_range *range; + struct stm32_gpio_bank *bank; + bool pin_is_irq; + int ret; + + range = pinctrl_find_gpio_range_from_pin(pctl->pctl_dev, pin); + if (!range) + return 0; + + pin_is_irq = gpiochip_line_is_irq(range->gc, offset); + + if (!desc || (!pin_is_irq && !desc->gpio_owner)) + return 0; + + bank = gpiochip_get_data(range->gc); + + alt = bank->pin_backup[offset] & STM32_GPIO_BKP_ALT_MASK; + alt >>= STM32_GPIO_BKP_ALT_SHIFT; + mode = bank->pin_backup[offset] & STM32_GPIO_BKP_MODE_MASK; + mode >>= STM32_GPIO_BKP_MODE_SHIFT; + + ret = stm32_pmx_set_mode(bank, offset, mode, alt); + if (ret) + return ret; + + if (mode == 1) { + val = bank->pin_backup[offset] & BIT(STM32_GPIO_BKP_VAL); + val = val >> STM32_GPIO_BKP_VAL; + __stm32_gpio_set(bank, offset, val); + } + + val = bank->pin_backup[offset] & BIT(STM32_GPIO_BKP_TYPE); + val >>= STM32_GPIO_BKP_TYPE; + ret = stm32_pconf_set_driving(bank, offset, val); + if (ret) + return ret; + + val = bank->pin_backup[offset] & STM32_GPIO_BKP_SPEED_MASK; + val >>= STM32_GPIO_BKP_SPEED_SHIFT; + ret = stm32_pconf_set_speed(bank, offset, val); + if (ret) + return ret; + + val = bank->pin_backup[offset] & STM32_GPIO_BKP_PUPD_MASK; + val >>= STM32_GPIO_BKP_PUPD_SHIFT; + ret = stm32_pconf_set_bias(bank, offset, val); + if (ret) + return ret; + + if (pin_is_irq) + regmap_field_write(pctl->irqmux[offset], bank->bank_ioport_nr); + + return 0; +} + +int __maybe_unused stm32_pinctrl_resume(struct device *dev) +{ + struct stm32_pinctrl *pctl = dev_get_drvdata(dev); + struct stm32_pinctrl_group *g = pctl->groups; + int i; + + for (i = g->pin; i < g->pin + pctl->ngroups; i++) + stm32_pinctrl_restore_gpio_regs(pctl, i); + + return 0; +} diff --git a/drivers/pinctrl/stm32/pinctrl-stm32.h b/drivers/pinctrl/stm32/pinctrl-stm32.h index de5e701..ec0d34c 100644 --- a/drivers/pinctrl/stm32/pinctrl-stm32.h +++ b/drivers/pinctrl/stm32/pinctrl-stm32.h @@ -65,5 +65,7 @@ struct stm32_gpio_bank; int stm32_pctl_probe(struct platform_device *pdev); void stm32_pmx_get_mode(struct stm32_gpio_bank *bank, int pin, u32 *mode, u32 *alt); +int stm32_pinctrl_resume(struct device *dev); + #endif /* __PINCTRL_STM32_H */ -- 2.7.4 ^ permalink raw reply related [flat|nested] 17+ messages in thread
* [PATCH 1/2] pinctrl: stm32: add suspend/resume management @ 2019-05-10 7:42 ` Alexandre Torgue 0 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-10 7:42 UTC (permalink / raw) To: Linus Walleij, Maxime Coquelin Cc: linux-gpio, alexandre.torgue, linux-kernel, linux-arm-kernel, linux-stm32 During power sequence, GPIO hardware registers could be lost if the power supply is switched off. Each device using pinctrl API is in charge of managing pins during suspend/resume sequences. But for pins used as gpio or irq stm32 pinctrl driver has to save the hardware configuration. Signed-off-by: Alexandre Torgue <alexandre.torgue@st.com> diff --git a/drivers/pinctrl/stm32/pinctrl-stm32.c b/drivers/pinctrl/stm32/pinctrl-stm32.c index 2317ccf..335aea5 100644 --- a/drivers/pinctrl/stm32/pinctrl-stm32.c +++ b/drivers/pinctrl/stm32/pinctrl-stm32.c @@ -44,6 +44,18 @@ #define STM32_GPIO_AFRL 0x20 #define STM32_GPIO_AFRH 0x24 +/* custom bitfield to backup pin status */ +#define STM32_GPIO_BKP_MODE_SHIFT 0 +#define STM32_GPIO_BKP_MODE_MASK GENMASK(1, 0) +#define STM32_GPIO_BKP_ALT_SHIFT 2 +#define STM32_GPIO_BKP_ALT_MASK GENMASK(5, 2) +#define STM32_GPIO_BKP_SPEED_SHIFT 6 +#define STM32_GPIO_BKP_SPEED_MASK GENMASK(7, 6) +#define STM32_GPIO_BKP_PUPD_SHIFT 8 +#define STM32_GPIO_BKP_PUPD_MASK GENMASK(9, 8) +#define STM32_GPIO_BKP_TYPE 10 +#define STM32_GPIO_BKP_VAL 11 + #define STM32_GPIO_PINS_PER_BANK 16 #define STM32_GPIO_IRQ_LINE 16 @@ -79,6 +91,7 @@ struct stm32_gpio_bank { struct irq_domain *domain; u32 bank_nr; u32 bank_ioport_nr; + u32 pin_backup[STM32_GPIO_PINS_PER_BANK]; }; struct stm32_pinctrl { @@ -133,11 +146,50 @@ static inline u32 stm32_gpio_get_alt(u32 function) return 0; } +static void stm32_gpio_backup_value(struct stm32_gpio_bank *bank, + u32 offset, u32 value) +{ + bank->pin_backup[offset] &= ~BIT(STM32_GPIO_BKP_VAL); + bank->pin_backup[offset] |= value << STM32_GPIO_BKP_VAL; +} + +static void stm32_gpio_backup_mode(struct stm32_gpio_bank *bank, u32 offset, + u32 mode, u32 alt) +{ + bank->pin_backup[offset] &= ~(STM32_GPIO_BKP_MODE_MASK | + STM32_GPIO_BKP_ALT_MASK); + bank->pin_backup[offset] |= mode << STM32_GPIO_BKP_MODE_SHIFT; + bank->pin_backup[offset] |= alt << STM32_GPIO_BKP_ALT_SHIFT; +} + +static void stm32_gpio_backup_driving(struct stm32_gpio_bank *bank, u32 offset, + u32 drive) +{ + bank->pin_backup[offset] &= ~BIT(STM32_GPIO_BKP_TYPE); + bank->pin_backup[offset] |= drive << STM32_GPIO_BKP_TYPE; +} + +static void stm32_gpio_backup_speed(struct stm32_gpio_bank *bank, u32 offset, + u32 speed) +{ + bank->pin_backup[offset] &= ~STM32_GPIO_BKP_SPEED_MASK; + bank->pin_backup[offset] |= speed << STM32_GPIO_BKP_SPEED_SHIFT; +} + +static void stm32_gpio_backup_bias(struct stm32_gpio_bank *bank, u32 offset, + u32 bias) +{ + bank->pin_backup[offset] &= ~STM32_GPIO_BKP_PUPD_MASK; + bank->pin_backup[offset] |= bias << STM32_GPIO_BKP_PUPD_SHIFT; +} + /* GPIO functions */ static inline void __stm32_gpio_set(struct stm32_gpio_bank *bank, unsigned offset, int value) { + stm32_gpio_backup_value(bank, offset, value); + if (!value) offset += STM32_GPIO_PINS_PER_BANK; @@ -620,6 +672,8 @@ static int stm32_pmx_set_mode(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_mode(bank, pin, mode, alt); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -732,6 +786,8 @@ static int stm32_pconf_set_driving(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_driving(bank, offset, drive); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -784,6 +840,8 @@ static int stm32_pconf_set_speed(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_speed(bank, offset, speed); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -836,6 +894,8 @@ static int stm32_pconf_set_bias(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_bias(bank, offset, bias); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -1369,3 +1429,75 @@ int stm32_pctl_probe(struct platform_device *pdev) return 0; } + +static int __maybe_unused stm32_pinctrl_restore_gpio_regs( + struct stm32_pinctrl *pctl, u32 pin) +{ + const struct pin_desc *desc = pin_desc_get(pctl->pctl_dev, pin); + u32 val, alt, mode, offset = stm32_gpio_pin(pin); + struct pinctrl_gpio_range *range; + struct stm32_gpio_bank *bank; + bool pin_is_irq; + int ret; + + range = pinctrl_find_gpio_range_from_pin(pctl->pctl_dev, pin); + if (!range) + return 0; + + pin_is_irq = gpiochip_line_is_irq(range->gc, offset); + + if (!desc || (!pin_is_irq && !desc->gpio_owner)) + return 0; + + bank = gpiochip_get_data(range->gc); + + alt = bank->pin_backup[offset] & STM32_GPIO_BKP_ALT_MASK; + alt >>= STM32_GPIO_BKP_ALT_SHIFT; + mode = bank->pin_backup[offset] & STM32_GPIO_BKP_MODE_MASK; + mode >>= STM32_GPIO_BKP_MODE_SHIFT; + + ret = stm32_pmx_set_mode(bank, offset, mode, alt); + if (ret) + return ret; + + if (mode == 1) { + val = bank->pin_backup[offset] & BIT(STM32_GPIO_BKP_VAL); + val = val >> STM32_GPIO_BKP_VAL; + __stm32_gpio_set(bank, offset, val); + } + + val = bank->pin_backup[offset] & BIT(STM32_GPIO_BKP_TYPE); + val >>= STM32_GPIO_BKP_TYPE; + ret = stm32_pconf_set_driving(bank, offset, val); + if (ret) + return ret; + + val = bank->pin_backup[offset] & STM32_GPIO_BKP_SPEED_MASK; + val >>= STM32_GPIO_BKP_SPEED_SHIFT; + ret = stm32_pconf_set_speed(bank, offset, val); + if (ret) + return ret; + + val = bank->pin_backup[offset] & STM32_GPIO_BKP_PUPD_MASK; + val >>= STM32_GPIO_BKP_PUPD_SHIFT; + ret = stm32_pconf_set_bias(bank, offset, val); + if (ret) + return ret; + + if (pin_is_irq) + regmap_field_write(pctl->irqmux[offset], bank->bank_ioport_nr); + + return 0; +} + +int __maybe_unused stm32_pinctrl_resume(struct device *dev) +{ + struct stm32_pinctrl *pctl = dev_get_drvdata(dev); + struct stm32_pinctrl_group *g = pctl->groups; + int i; + + for (i = g->pin; i < g->pin + pctl->ngroups; i++) + stm32_pinctrl_restore_gpio_regs(pctl, i); + + return 0; +} diff --git a/drivers/pinctrl/stm32/pinctrl-stm32.h b/drivers/pinctrl/stm32/pinctrl-stm32.h index de5e701..ec0d34c 100644 --- a/drivers/pinctrl/stm32/pinctrl-stm32.h +++ b/drivers/pinctrl/stm32/pinctrl-stm32.h @@ -65,5 +65,7 @@ struct stm32_gpio_bank; int stm32_pctl_probe(struct platform_device *pdev); void stm32_pmx_get_mode(struct stm32_gpio_bank *bank, int pin, u32 *mode, u32 *alt); +int stm32_pinctrl_resume(struct device *dev); + #endif /* __PINCTRL_STM32_H */ -- 2.7.4 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 17+ messages in thread
* [PATCH 1/2] pinctrl: stm32: add suspend/resume management @ 2019-05-10 7:42 ` Alexandre Torgue 0 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-10 7:42 UTC (permalink / raw) To: Linus Walleij, Maxime Coquelin Cc: linux-kernel, linux-gpio, linux-arm-kernel, linux-stm32, alexandre.torgue During power sequence, GPIO hardware registers could be lost if the power supply is switched off. Each device using pinctrl API is in charge of managing pins during suspend/resume sequences. But for pins used as gpio or irq stm32 pinctrl driver has to save the hardware configuration. Signed-off-by: Alexandre Torgue <alexandre.torgue@st.com> diff --git a/drivers/pinctrl/stm32/pinctrl-stm32.c b/drivers/pinctrl/stm32/pinctrl-stm32.c index 2317ccf..335aea5 100644 --- a/drivers/pinctrl/stm32/pinctrl-stm32.c +++ b/drivers/pinctrl/stm32/pinctrl-stm32.c @@ -44,6 +44,18 @@ #define STM32_GPIO_AFRL 0x20 #define STM32_GPIO_AFRH 0x24 +/* custom bitfield to backup pin status */ +#define STM32_GPIO_BKP_MODE_SHIFT 0 +#define STM32_GPIO_BKP_MODE_MASK GENMASK(1, 0) +#define STM32_GPIO_BKP_ALT_SHIFT 2 +#define STM32_GPIO_BKP_ALT_MASK GENMASK(5, 2) +#define STM32_GPIO_BKP_SPEED_SHIFT 6 +#define STM32_GPIO_BKP_SPEED_MASK GENMASK(7, 6) +#define STM32_GPIO_BKP_PUPD_SHIFT 8 +#define STM32_GPIO_BKP_PUPD_MASK GENMASK(9, 8) +#define STM32_GPIO_BKP_TYPE 10 +#define STM32_GPIO_BKP_VAL 11 + #define STM32_GPIO_PINS_PER_BANK 16 #define STM32_GPIO_IRQ_LINE 16 @@ -79,6 +91,7 @@ struct stm32_gpio_bank { struct irq_domain *domain; u32 bank_nr; u32 bank_ioport_nr; + u32 pin_backup[STM32_GPIO_PINS_PER_BANK]; }; struct stm32_pinctrl { @@ -133,11 +146,50 @@ static inline u32 stm32_gpio_get_alt(u32 function) return 0; } +static void stm32_gpio_backup_value(struct stm32_gpio_bank *bank, + u32 offset, u32 value) +{ + bank->pin_backup[offset] &= ~BIT(STM32_GPIO_BKP_VAL); + bank->pin_backup[offset] |= value << STM32_GPIO_BKP_VAL; +} + +static void stm32_gpio_backup_mode(struct stm32_gpio_bank *bank, u32 offset, + u32 mode, u32 alt) +{ + bank->pin_backup[offset] &= ~(STM32_GPIO_BKP_MODE_MASK | + STM32_GPIO_BKP_ALT_MASK); + bank->pin_backup[offset] |= mode << STM32_GPIO_BKP_MODE_SHIFT; + bank->pin_backup[offset] |= alt << STM32_GPIO_BKP_ALT_SHIFT; +} + +static void stm32_gpio_backup_driving(struct stm32_gpio_bank *bank, u32 offset, + u32 drive) +{ + bank->pin_backup[offset] &= ~BIT(STM32_GPIO_BKP_TYPE); + bank->pin_backup[offset] |= drive << STM32_GPIO_BKP_TYPE; +} + +static void stm32_gpio_backup_speed(struct stm32_gpio_bank *bank, u32 offset, + u32 speed) +{ + bank->pin_backup[offset] &= ~STM32_GPIO_BKP_SPEED_MASK; + bank->pin_backup[offset] |= speed << STM32_GPIO_BKP_SPEED_SHIFT; +} + +static void stm32_gpio_backup_bias(struct stm32_gpio_bank *bank, u32 offset, + u32 bias) +{ + bank->pin_backup[offset] &= ~STM32_GPIO_BKP_PUPD_MASK; + bank->pin_backup[offset] |= bias << STM32_GPIO_BKP_PUPD_SHIFT; +} + /* GPIO functions */ static inline void __stm32_gpio_set(struct stm32_gpio_bank *bank, unsigned offset, int value) { + stm32_gpio_backup_value(bank, offset, value); + if (!value) offset += STM32_GPIO_PINS_PER_BANK; @@ -620,6 +672,8 @@ static int stm32_pmx_set_mode(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_mode(bank, pin, mode, alt); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -732,6 +786,8 @@ static int stm32_pconf_set_driving(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_driving(bank, offset, drive); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -784,6 +840,8 @@ static int stm32_pconf_set_speed(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_speed(bank, offset, speed); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -836,6 +894,8 @@ static int stm32_pconf_set_bias(struct stm32_gpio_bank *bank, if (pctl->hwlock) hwspin_unlock(pctl->hwlock); + stm32_gpio_backup_bias(bank, offset, bias); + unlock: spin_unlock_irqrestore(&bank->lock, flags); clk_disable(bank->clk); @@ -1369,3 +1429,75 @@ int stm32_pctl_probe(struct platform_device *pdev) return 0; } + +static int __maybe_unused stm32_pinctrl_restore_gpio_regs( + struct stm32_pinctrl *pctl, u32 pin) +{ + const struct pin_desc *desc = pin_desc_get(pctl->pctl_dev, pin); + u32 val, alt, mode, offset = stm32_gpio_pin(pin); + struct pinctrl_gpio_range *range; + struct stm32_gpio_bank *bank; + bool pin_is_irq; + int ret; + + range = pinctrl_find_gpio_range_from_pin(pctl->pctl_dev, pin); + if (!range) + return 0; + + pin_is_irq = gpiochip_line_is_irq(range->gc, offset); + + if (!desc || (!pin_is_irq && !desc->gpio_owner)) + return 0; + + bank = gpiochip_get_data(range->gc); + + alt = bank->pin_backup[offset] & STM32_GPIO_BKP_ALT_MASK; + alt >>= STM32_GPIO_BKP_ALT_SHIFT; + mode = bank->pin_backup[offset] & STM32_GPIO_BKP_MODE_MASK; + mode >>= STM32_GPIO_BKP_MODE_SHIFT; + + ret = stm32_pmx_set_mode(bank, offset, mode, alt); + if (ret) + return ret; + + if (mode == 1) { + val = bank->pin_backup[offset] & BIT(STM32_GPIO_BKP_VAL); + val = val >> STM32_GPIO_BKP_VAL; + __stm32_gpio_set(bank, offset, val); + } + + val = bank->pin_backup[offset] & BIT(STM32_GPIO_BKP_TYPE); + val >>= STM32_GPIO_BKP_TYPE; + ret = stm32_pconf_set_driving(bank, offset, val); + if (ret) + return ret; + + val = bank->pin_backup[offset] & STM32_GPIO_BKP_SPEED_MASK; + val >>= STM32_GPIO_BKP_SPEED_SHIFT; + ret = stm32_pconf_set_speed(bank, offset, val); + if (ret) + return ret; + + val = bank->pin_backup[offset] & STM32_GPIO_BKP_PUPD_MASK; + val >>= STM32_GPIO_BKP_PUPD_SHIFT; + ret = stm32_pconf_set_bias(bank, offset, val); + if (ret) + return ret; + + if (pin_is_irq) + regmap_field_write(pctl->irqmux[offset], bank->bank_ioport_nr); + + return 0; +} + +int __maybe_unused stm32_pinctrl_resume(struct device *dev) +{ + struct stm32_pinctrl *pctl = dev_get_drvdata(dev); + struct stm32_pinctrl_group *g = pctl->groups; + int i; + + for (i = g->pin; i < g->pin + pctl->ngroups; i++) + stm32_pinctrl_restore_gpio_regs(pctl, i); + + return 0; +} diff --git a/drivers/pinctrl/stm32/pinctrl-stm32.h b/drivers/pinctrl/stm32/pinctrl-stm32.h index de5e701..ec0d34c 100644 --- a/drivers/pinctrl/stm32/pinctrl-stm32.h +++ b/drivers/pinctrl/stm32/pinctrl-stm32.h @@ -65,5 +65,7 @@ struct stm32_gpio_bank; int stm32_pctl_probe(struct platform_device *pdev); void stm32_pmx_get_mode(struct stm32_gpio_bank *bank, int pin, u32 *mode, u32 *alt); +int stm32_pinctrl_resume(struct device *dev); + #endif /* __PINCTRL_STM32_H */ -- 2.7.4 ^ permalink raw reply related [flat|nested] 17+ messages in thread
* [PATCH 2/2] pinctrl: stm32: Enable suspend/resume for stm32mp157c SoC 2019-05-10 7:42 ` Alexandre Torgue (?) @ 2019-05-10 7:42 ` Alexandre Torgue -1 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-10 7:42 UTC (permalink / raw) To: Linus Walleij, Maxime Coquelin Cc: linux-kernel, linux-gpio, linux-arm-kernel, linux-stm32, alexandre.torgue Apply suspend/resume management for stm32mp157c MPU. Signed-off-by: Alexandre Torgue <alexandre.torgue@st.com> diff --git a/drivers/pinctrl/stm32/pinctrl-stm32mp157.c b/drivers/pinctrl/stm32/pinctrl-stm32mp157.c index 320544f..2ccb99d 100644 --- a/drivers/pinctrl/stm32/pinctrl-stm32mp157.c +++ b/drivers/pinctrl/stm32/pinctrl-stm32mp157.c @@ -2342,11 +2342,16 @@ static const struct of_device_id stm32mp157_pctrl_match[] = { { } }; +static const struct dev_pm_ops stm32_pinctrl_dev_pm_ops = { + SET_LATE_SYSTEM_SLEEP_PM_OPS(NULL, stm32_pinctrl_resume) +}; + static struct platform_driver stm32mp157_pinctrl_driver = { .probe = stm32_pctl_probe, .driver = { .name = "stm32mp157-pinctrl", .of_match_table = stm32mp157_pctrl_match, + .pm = &stm32_pinctrl_dev_pm_ops, }, }; -- 2.7.4 ^ permalink raw reply related [flat|nested] 17+ messages in thread
* [PATCH 2/2] pinctrl: stm32: Enable suspend/resume for stm32mp157c SoC @ 2019-05-10 7:42 ` Alexandre Torgue 0 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-10 7:42 UTC (permalink / raw) To: Linus Walleij, Maxime Coquelin Cc: linux-gpio, alexandre.torgue, linux-kernel, linux-arm-kernel, linux-stm32 Apply suspend/resume management for stm32mp157c MPU. Signed-off-by: Alexandre Torgue <alexandre.torgue@st.com> diff --git a/drivers/pinctrl/stm32/pinctrl-stm32mp157.c b/drivers/pinctrl/stm32/pinctrl-stm32mp157.c index 320544f..2ccb99d 100644 --- a/drivers/pinctrl/stm32/pinctrl-stm32mp157.c +++ b/drivers/pinctrl/stm32/pinctrl-stm32mp157.c @@ -2342,11 +2342,16 @@ static const struct of_device_id stm32mp157_pctrl_match[] = { { } }; +static const struct dev_pm_ops stm32_pinctrl_dev_pm_ops = { + SET_LATE_SYSTEM_SLEEP_PM_OPS(NULL, stm32_pinctrl_resume) +}; + static struct platform_driver stm32mp157_pinctrl_driver = { .probe = stm32_pctl_probe, .driver = { .name = "stm32mp157-pinctrl", .of_match_table = stm32mp157_pctrl_match, + .pm = &stm32_pinctrl_dev_pm_ops, }, }; -- 2.7.4 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 17+ messages in thread
* [PATCH 2/2] pinctrl: stm32: Enable suspend/resume for stm32mp157c SoC @ 2019-05-10 7:42 ` Alexandre Torgue 0 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-10 7:42 UTC (permalink / raw) To: Linus Walleij, Maxime Coquelin Cc: linux-kernel, linux-gpio, linux-arm-kernel, linux-stm32, alexandre.torgue Apply suspend/resume management for stm32mp157c MPU. Signed-off-by: Alexandre Torgue <alexandre.torgue@st.com> diff --git a/drivers/pinctrl/stm32/pinctrl-stm32mp157.c b/drivers/pinctrl/stm32/pinctrl-stm32mp157.c index 320544f..2ccb99d 100644 --- a/drivers/pinctrl/stm32/pinctrl-stm32mp157.c +++ b/drivers/pinctrl/stm32/pinctrl-stm32mp157.c @@ -2342,11 +2342,16 @@ static const struct of_device_id stm32mp157_pctrl_match[] = { { } }; +static const struct dev_pm_ops stm32_pinctrl_dev_pm_ops = { + SET_LATE_SYSTEM_SLEEP_PM_OPS(NULL, stm32_pinctrl_resume) +}; + static struct platform_driver stm32mp157_pinctrl_driver = { .probe = stm32_pctl_probe, .driver = { .name = "stm32mp157-pinctrl", .of_match_table = stm32mp157_pctrl_match, + .pm = &stm32_pinctrl_dev_pm_ops, }, }; -- 2.7.4 ^ permalink raw reply related [flat|nested] 17+ messages in thread
* Re: [PATCH 0/2] pinctrl: stm32: add suspend/resume management 2019-05-10 7:42 ` Alexandre Torgue @ 2019-05-24 11:24 ` Linus Walleij -1 siblings, 0 replies; 17+ messages in thread From: Linus Walleij @ 2019-05-24 11:24 UTC (permalink / raw) To: Alexandre Torgue, Benjamin Gaignard Cc: Maxime Coquelin, linux-kernel, open list:GPIO SUBSYSTEM, Linux ARM, linux-stm32 On Fri, May 10, 2019 at 9:42 AM Alexandre Torgue <alexandre.torgue@st.com> wrote: > During power sequence, GPIO hardware registers could be lost if the power > supply is switched off. Each device using pinctrl API is in charge of > managing pins during suspend/resume sequences. But for pins used as gpio or > irq stm32 pinctrl driver has to save the hardware configuration. > Each register will be saved at runtime and restored during resume sequence. Both patches applied. On the same pinctrl devel branch is also Benjamin's patches to support the "link_consumers" property on the pin controller descriptor to enable links from pin control consumers back to their pin controller suppliers, especially important for STMFX. Would you please check if it work fine if you turn on this feature for the SoC STM32 pin controller? I am working a bit on refining the patches, so I want to enable testing with some SoC pin controllers as well and possibly make the behavior default. Yours, Linus Walleij ^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [PATCH 0/2] pinctrl: stm32: add suspend/resume management @ 2019-05-24 11:24 ` Linus Walleij 0 siblings, 0 replies; 17+ messages in thread From: Linus Walleij @ 2019-05-24 11:24 UTC (permalink / raw) To: Alexandre Torgue, Benjamin Gaignard Cc: Linux ARM, open list:GPIO SUBSYSTEM, linux-kernel, Maxime Coquelin, linux-stm32 On Fri, May 10, 2019 at 9:42 AM Alexandre Torgue <alexandre.torgue@st.com> wrote: > During power sequence, GPIO hardware registers could be lost if the power > supply is switched off. Each device using pinctrl API is in charge of > managing pins during suspend/resume sequences. But for pins used as gpio or > irq stm32 pinctrl driver has to save the hardware configuration. > Each register will be saved at runtime and restored during resume sequence. Both patches applied. On the same pinctrl devel branch is also Benjamin's patches to support the "link_consumers" property on the pin controller descriptor to enable links from pin control consumers back to their pin controller suppliers, especially important for STMFX. Would you please check if it work fine if you turn on this feature for the SoC STM32 pin controller? I am working a bit on refining the patches, so I want to enable testing with some SoC pin controllers as well and possibly make the behavior default. Yours, Linus Walleij _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [PATCH 0/2] pinctrl: stm32: add suspend/resume management 2019-05-24 11:24 ` Linus Walleij (?) @ 2019-05-24 12:26 ` Alexandre Torgue -1 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-24 12:26 UTC (permalink / raw) To: Linus Walleij, Benjamin Gaignard Cc: Maxime Coquelin, linux-kernel, open list:GPIO SUBSYSTEM, Linux ARM, linux-stm32 On 5/24/19 1:24 PM, Linus Walleij wrote: > On Fri, May 10, 2019 at 9:42 AM Alexandre Torgue > <alexandre.torgue@st.com> wrote: > >> During power sequence, GPIO hardware registers could be lost if the power >> supply is switched off. Each device using pinctrl API is in charge of >> managing pins during suspend/resume sequences. But for pins used as gpio or >> irq stm32 pinctrl driver has to save the hardware configuration. >> Each register will be saved at runtime and restored during resume sequence. > > Both patches applied. > > On the same pinctrl devel branch is also Benjamin's patches to support > the "link_consumers" property on the pin controller descriptor to > enable links from pin control consumers back to their pin controller > suppliers, especially important for STMFX. > > Would you please check if it work fine if you turn on this feature > for the SoC STM32 pin controller? > Sure. Either today or next Monday. I let you know. regards Alex > I am working a bit on refining the patches, so I want to enable testing > with some SoC pin controllers as well and possibly make the > behavior default. > > Yours, > Linus Walleij > ^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [PATCH 0/2] pinctrl: stm32: add suspend/resume management @ 2019-05-24 12:26 ` Alexandre Torgue 0 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-24 12:26 UTC (permalink / raw) To: Linus Walleij, Benjamin Gaignard Cc: Linux ARM, open list:GPIO SUBSYSTEM, linux-kernel, Maxime Coquelin, linux-stm32 On 5/24/19 1:24 PM, Linus Walleij wrote: > On Fri, May 10, 2019 at 9:42 AM Alexandre Torgue > <alexandre.torgue@st.com> wrote: > >> During power sequence, GPIO hardware registers could be lost if the power >> supply is switched off. Each device using pinctrl API is in charge of >> managing pins during suspend/resume sequences. But for pins used as gpio or >> irq stm32 pinctrl driver has to save the hardware configuration. >> Each register will be saved at runtime and restored during resume sequence. > > Both patches applied. > > On the same pinctrl devel branch is also Benjamin's patches to support > the "link_consumers" property on the pin controller descriptor to > enable links from pin control consumers back to their pin controller > suppliers, especially important for STMFX. > > Would you please check if it work fine if you turn on this feature > for the SoC STM32 pin controller? > Sure. Either today or next Monday. I let you know. regards Alex > I am working a bit on refining the patches, so I want to enable testing > with some SoC pin controllers as well and possibly make the > behavior default. > > Yours, > Linus Walleij > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [PATCH 0/2] pinctrl: stm32: add suspend/resume management @ 2019-05-24 12:26 ` Alexandre Torgue 0 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-24 12:26 UTC (permalink / raw) To: Linus Walleij, Benjamin Gaignard Cc: Maxime Coquelin, linux-kernel, open list:GPIO SUBSYSTEM, Linux ARM, linux-stm32 On 5/24/19 1:24 PM, Linus Walleij wrote: > On Fri, May 10, 2019 at 9:42 AM Alexandre Torgue > <alexandre.torgue@st.com> wrote: > >> During power sequence, GPIO hardware registers could be lost if the power >> supply is switched off. Each device using pinctrl API is in charge of >> managing pins during suspend/resume sequences. But for pins used as gpio or >> irq stm32 pinctrl driver has to save the hardware configuration. >> Each register will be saved at runtime and restored during resume sequence. > > Both patches applied. > > On the same pinctrl devel branch is also Benjamin's patches to support > the "link_consumers" property on the pin controller descriptor to > enable links from pin control consumers back to their pin controller > suppliers, especially important for STMFX. > > Would you please check if it work fine if you turn on this feature > for the SoC STM32 pin controller? > Sure. Either today or next Monday. I let you know. regards Alex > I am working a bit on refining the patches, so I want to enable testing > with some SoC pin controllers as well and possibly make the > behavior default. > > Yours, > Linus Walleij > ^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [PATCH 0/2] pinctrl: stm32: add suspend/resume management 2019-05-24 11:24 ` Linus Walleij (?) @ 2019-05-27 16:17 ` Alexandre Torgue -1 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-27 16:17 UTC (permalink / raw) To: Linus Walleij, Benjamin Gaignard Cc: Maxime Coquelin, linux-kernel, open list:GPIO SUBSYSTEM, Linux ARM, linux-stm32 Hi Linus On 5/24/19 1:24 PM, Linus Walleij wrote: > On Fri, May 10, 2019 at 9:42 AM Alexandre Torgue > <alexandre.torgue@st.com> wrote: > >> During power sequence, GPIO hardware registers could be lost if the power >> supply is switched off. Each device using pinctrl API is in charge of >> managing pins during suspend/resume sequences. But for pins used as gpio or >> irq stm32 pinctrl driver has to save the hardware configuration. >> Each register will be saved at runtime and restored during resume sequence. > > Both patches applied. > > On the same pinctrl devel branch is also Benjamin's patches to support > the "link_consumers" property on the pin controller descriptor to > enable links from pin control consumers back to their pin controller > suppliers, especially important for STMFX. > > Would you please check if it work fine if you turn on this feature > for the SoC STM32 pin controller? I just tested with Benjamin's patches and set "link_consumers" property for STM32 pinctrl. No changes on boot (except extra logs for each probe) and no changes on power tests too. regards alex > > I am working a bit on refining the patches, so I want to enable testing > with some SoC pin controllers as well and possibly make the > behavior default. > > Yours, > Linus Walleij > ^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [PATCH 0/2] pinctrl: stm32: add suspend/resume management @ 2019-05-27 16:17 ` Alexandre Torgue 0 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-27 16:17 UTC (permalink / raw) To: Linus Walleij, Benjamin Gaignard Cc: Linux ARM, open list:GPIO SUBSYSTEM, linux-kernel, Maxime Coquelin, linux-stm32 Hi Linus On 5/24/19 1:24 PM, Linus Walleij wrote: > On Fri, May 10, 2019 at 9:42 AM Alexandre Torgue > <alexandre.torgue@st.com> wrote: > >> During power sequence, GPIO hardware registers could be lost if the power >> supply is switched off. Each device using pinctrl API is in charge of >> managing pins during suspend/resume sequences. But for pins used as gpio or >> irq stm32 pinctrl driver has to save the hardware configuration. >> Each register will be saved at runtime and restored during resume sequence. > > Both patches applied. > > On the same pinctrl devel branch is also Benjamin's patches to support > the "link_consumers" property on the pin controller descriptor to > enable links from pin control consumers back to their pin controller > suppliers, especially important for STMFX. > > Would you please check if it work fine if you turn on this feature > for the SoC STM32 pin controller? I just tested with Benjamin's patches and set "link_consumers" property for STM32 pinctrl. No changes on boot (except extra logs for each probe) and no changes on power tests too. regards alex > > I am working a bit on refining the patches, so I want to enable testing > with some SoC pin controllers as well and possibly make the > behavior default. > > Yours, > Linus Walleij > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [PATCH 0/2] pinctrl: stm32: add suspend/resume management @ 2019-05-27 16:17 ` Alexandre Torgue 0 siblings, 0 replies; 17+ messages in thread From: Alexandre Torgue @ 2019-05-27 16:17 UTC (permalink / raw) To: Linus Walleij, Benjamin Gaignard Cc: Maxime Coquelin, linux-kernel, open list:GPIO SUBSYSTEM, Linux ARM, linux-stm32 Hi Linus On 5/24/19 1:24 PM, Linus Walleij wrote: > On Fri, May 10, 2019 at 9:42 AM Alexandre Torgue > <alexandre.torgue@st.com> wrote: > >> During power sequence, GPIO hardware registers could be lost if the power >> supply is switched off. Each device using pinctrl API is in charge of >> managing pins during suspend/resume sequences. But for pins used as gpio or >> irq stm32 pinctrl driver has to save the hardware configuration. >> Each register will be saved at runtime and restored during resume sequence. > > Both patches applied. > > On the same pinctrl devel branch is also Benjamin's patches to support > the "link_consumers" property on the pin controller descriptor to > enable links from pin control consumers back to their pin controller > suppliers, especially important for STMFX. > > Would you please check if it work fine if you turn on this feature > for the SoC STM32 pin controller? I just tested with Benjamin's patches and set "link_consumers" property for STM32 pinctrl. No changes on boot (except extra logs for each probe) and no changes on power tests too. regards alex > > I am working a bit on refining the patches, so I want to enable testing > with some SoC pin controllers as well and possibly make the > behavior default. > > Yours, > Linus Walleij > ^ permalink raw reply [flat|nested] 17+ messages in thread
end of thread, other threads:[~2019-05-27 16:17 UTC | newest] Thread overview: 17+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2019-05-10 7:42 [PATCH 0/2] pinctrl: stm32: add suspend/resume management Alexandre Torgue 2019-05-10 7:42 ` Alexandre Torgue 2019-05-10 7:42 ` Alexandre Torgue 2019-05-10 7:42 ` [PATCH 1/2] " Alexandre Torgue 2019-05-10 7:42 ` Alexandre Torgue 2019-05-10 7:42 ` Alexandre Torgue 2019-05-10 7:42 ` [PATCH 2/2] pinctrl: stm32: Enable suspend/resume for stm32mp157c SoC Alexandre Torgue 2019-05-10 7:42 ` Alexandre Torgue 2019-05-10 7:42 ` Alexandre Torgue 2019-05-24 11:24 ` [PATCH 0/2] pinctrl: stm32: add suspend/resume management Linus Walleij 2019-05-24 11:24 ` Linus Walleij 2019-05-24 12:26 ` Alexandre Torgue 2019-05-24 12:26 ` Alexandre Torgue 2019-05-24 12:26 ` Alexandre Torgue 2019-05-27 16:17 ` Alexandre Torgue 2019-05-27 16:17 ` Alexandre Torgue 2019-05-27 16:17 ` Alexandre Torgue
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.