On Fri, 02 Dec 2016, Benjamin Gaignard wrote:

This hardware block could at used at same time for PWM generation and IIO timer for other IPs like DAC, ADC or other timers. PWM and IIO timer configuration are mixed in the same registers so we need a multi fonction driver to be able to share those registers.

version 2:

• rename driver "stm32-gptimer" to be align with SoC documentation
• only keep one compatible
• use of_platform_populate() instead of devm_mfd_add_devices()

Signed-off-by: Benjamin Gaignard benjamin.gaignard@st.com

drivers/mfd/Kconfig | 10 ++++++ drivers/mfd/Makefile | 2 ++ drivers/mfd/stm32-gptimer.c | 73 +++++++++++++++++++++++++++++++++++++++ include/linux/mfd/stm32-gptimer.h | 62 +++++++++++++++++++++++++++++++++ 4 files changed, 147 insertions(+) create mode 100644 drivers/mfd/stm32-gptimer.c create mode 100644 include/linux/mfd/stm32-gptimer.h

diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index c6df644..e75abcb 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -1607,6 +1607,15 @@ config MFD_STW481X in various ST Microelectronics and ST-Ericsson embedded Nomadik series. +config MFD_STM32_GP_TIMER

• tristate "Support for STM32 General Purpose Timer"
• select MFD_CORE
• select REGMAP
• depends on ARCH_STM32
• depends on OF

"|| COMPILE_TEST"?

• help

•  Select this option to enable stm32 general purpose timer
  

I can see that. Tell us more about the device and what it does.

s/stm32/STM32/

menu "Multimedia Capabilities Port drivers" depends on ARCH_SA1100 @@ -1644,4 +1653,5 @@ config MFD_VEXPRESS_SYSREG on the ARM Ltd. Versatile Express board. endmenu

Please remove this change. It has nothing to do with the set.

endif diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile index 9834e66..86353b9 100644 --- a/drivers/mfd/Makefile +++ b/drivers/mfd/Makefile @@ -211,3 +211,5 @@ obj-$(CONFIG_INTEL_SOC_PMIC) += intel-soc-pmic.o obj-$(CONFIG_MFD_MT6397) += mt6397-core.o obj-$(CONFIG_MFD_ALTERA_A10SR) += altera-a10sr.o

+obj-$(CONFIG_MFD_STM32_GP_TIMER) += stm32-gptimer.o diff --git a/drivers/mfd/stm32-gptimer.c b/drivers/mfd/stm32-gptimer.c new file mode 100644 index 0000000..54fb95c --- /dev/null +++ b/drivers/mfd/stm32-gptimer.c @@ -0,0 +1,73 @@ +/*

• • stm32-gptimer.c

Swap this out for a description.

• • Copyright (C) STMicroelectronics 2016

'\n'

• • Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.
• • License terms: GNU General Public License (GPL), version 2
• */

+#include <linux/module.h> +#include <linux/of_platform.h> +#include <linux/reset.h>

+#include <linux/mfd/stm32-gptimer.h>

+static const struct regmap_config stm32_gptimer_regmap_cfg = {

• .reg_bits = 32,
• .val_bits = 32,
• .reg_stride = sizeof(u32),
• .max_register = 0x400,
• .fast_io = true,

+};

+static int stm32_gptimer_probe(struct platform_device *pdev) +{

• struct device *dev = &pdev->dev;
• struct stm32_gptimer_dev *mfd;

s/mfd/ddata/

• struct resource *res;
• void __iomem *mmio;
• mfd = devm_kzalloc(dev, sizeof(*mfd), GFP_KERNEL);
• if (!mfd)

• return -ENOMEM;
  

• res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
• if (!res)

• return -ENOMEM;
  

Remove this 3 lines.

devm_ioremap_resource() does the checking and error printing for you.

• mmio = devm_ioremap_resource(dev, res);
• if (IS_ERR(mmio))

• return PTR_ERR(mmio);
  

• mfd->regmap = devm_regmap_init_mmio_clk(dev, "clk_int", mmio,

• 				&stm32_gptimer_regmap_cfg);
  

• if (IS_ERR(mfd->regmap))

• return PTR_ERR(mfd->regmap);
  

• mfd->clk = devm_clk_get(dev, NULL);
• if (IS_ERR(mfd->clk))

• return PTR_ERR(mfd->clk);
  

• platform_set_drvdata(pdev, mfd);
• return of_platform_populate(pdev->dev.of_node, NULL, NULL, &pdev->dev);

+}

+static const struct of_device_id stm32_gptimer_of_match[] = {

• {

• .compatible = "st,stm32-gptimer",
  

• },

One line:

{ .compatible = "st,stm32-gptimer" },

+}; +MODULE_DEVICE_TABLE(of, stm32_gptimer_of_match);

+static struct platform_driver stm32_gptimer_driver = {

• .probe = stm32_gptimer_probe,
• .driver = {

• .name	= "stm32-gptimer",
  

• .of_match_table = stm32_gptimer_of_match,
  

• },

Remove tabs before the '='s.

+module_platform_driver(stm32_gptimer_driver);

+MODULE_DESCRIPTION("STMicroelectronics STM32 general purpose timer");

"General Purpose Timer"

+MODULE_LICENSE("GPL");

"GPL v2"

diff --git a/include/linux/mfd/stm32-gptimer.h b/include/linux/mfd/stm32-gptimer.h new file mode 100644 index 0000000..f8c92de --- /dev/null +++ b/include/linux/mfd/stm32-gptimer.h @@ -0,0 +1,62 @@ +/*

• • stm32-gptimer.h
• • Copyright (C) STMicroelectronics 2016
• • Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.
• • License terms: GNU General Public License (GPL), version 2
• */

Same comments as before.

+#ifndef _LINUX_STM32_GPTIMER_H_ +#define _LINUX_STM32_GPTIMER_H_

+#include <linux/clk.h> +#include <linux/regmap.h>

+#define TIM_CR1 0x00 /* Control Register 1 */ +#define TIM_CR2 0x04 /* Control Register 2 */ +#define TIM_SMCR 0x08 /* Slave mode control reg */ +#define TIM_DIER 0x0C /* DMA/interrupt register */ +#define TIM_SR 0x10 /* Status register */ +#define TIM_EGR 0x14 /* Event Generation Reg */ +#define TIM_CCMR1 0x18 /* Capt/Comp 1 Mode Reg */ +#define TIM_CCMR2 0x1C /* Capt/Comp 2 Mode Reg */ +#define TIM_CCER 0x20 /* Capt/Comp Enable Reg */ +#define TIM_PSC 0x28 /* Prescaler */ +#define TIM_ARR 0x2c /* Auto-Reload Register */ +#define TIM_CCR1 0x34 /* Capt/Comp Register 1 */ +#define TIM_CCR2 0x38 /* Capt/Comp Register 2 */ +#define TIM_CCR3 0x3C /* Capt/Comp Register 3 */ +#define TIM_CCR4 0x40 /* Capt/Comp Register 4 */ +#define TIM_BDTR 0x44 /* Break and Dead-Time Reg */

+#define TIM_CR1_CEN BIT(0) /* Counter Enable */ +#define TIM_CR1_ARPE BIT(7) /* Auto-reload Preload Ena */ +#define TIM_CR2_MMS (BIT(4) | BIT(5) | BIT(6)) /* Master mode selection */ +#define TIM_SMCR_SMS (BIT(0) | BIT(1) | BIT(2)) /* Slave mode selection */ +#define TIM_SMCR_TS (BIT(4) | BIT(5) | BIT(6)) /* Trigger selection */ +#define TIM_DIER_UIE BIT(0) /* Update interrupt */ +#define TIM_SR_UIF BIT(0) /* Update interrupt flag */ +#define TIM_EGR_UG BIT(0) /* Update Generation */ +#define TIM_CCMR_PE BIT(3) /* Channel Preload Enable */ +#define TIM_CCMR_M1 (BIT(6) | BIT(5)) /* Channel PWM Mode 1 */ +#define TIM_CCER_CC1E BIT(0) /* Capt/Comp 1 out Ena */ +#define TIM_CCER_CC1P BIT(1) /* Capt/Comp 1 Polarity */ +#define TIM_CCER_CC1NE BIT(2) /* Capt/Comp 1N out Ena */ +#define TIM_CCER_CC1NP BIT(3) /* Capt/Comp 1N Polarity */ +#define TIM_CCER_CCXE (BIT(0) | BIT(4) | BIT(8) | BIT(12)) +#define TIM_BDTR_BKE BIT(12) /* Break input enable */ +#define TIM_BDTR_BKP BIT(13) /* Break input polarity */ +#define TIM_BDTR_AOE BIT(14) /* Automatic Output Enable */ +#define TIM_BDTR_MOE BIT(15) /* Main Output Enable */

+#define MAX_TIM_PSC 0xFFFF

+struct stm32_gptimer_dev {

Drop the "_dev" or replace with ddata.

• /* Device data */

No need for this.

• struct clk *clk;
• /* Registers mapping */

No need for this.

• struct regmap *regmap;

+};

+#endif

On Fri, 02 Dec 2016, Benjamin Gaignard wrote:

Define bindings for pwm-stm32

version 2:

• use parameters instead of compatible of handle the hardware configuration

Signed-off-by: Benjamin Gaignard benjamin.gaignard@st.com

.../devicetree/bindings/pwm/pwm-stm32.txt | 38 ++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 Documentation/devicetree/bindings/pwm/pwm-stm32.txt

diff --git a/Documentation/devicetree/bindings/pwm/pwm-stm32.txt b/Documentation/devicetree/bindings/pwm/pwm-stm32.txt new file mode 100644 index 0000000..575b9fb --- /dev/null +++ b/Documentation/devicetree/bindings/pwm/pwm-stm32.txt @@ -0,0 +1,38 @@ +STMicroelectronics PWM driver bindings for STM32

+Must be a sub-node of STM32 general purpose timer driver +Parent node properties are describe in ../mfd/stm32-general-purpose-timer.txt

+Required parameters: +- compatible: Must be "st,stm32-pwm" +- pinctrl-names: Set to "default". +- pinctrl-0: List of phandles pointing to pin configuration nodes

• 	for PWM module.
  

• 	For Pinctrl properties, please refer to [1].
  

+Optional parameters: +- st,breakinput: Set if the hardware have break input capabilities +- st,breakinput-polarity: Set break input polarity. Default is 0

• 	 The value define the active polarity:
  

• 	  - 0 (active LOW)
  

• 	  - 1 (active HIGH)
  

+- st,breakinput-polarity-high

Then assume the default if the property is not present.

+- st,pwm-num-chan: Number of available PWM channels. Default is 0.

What's the point in having a PWM device with no channels?

Best to make this a compulsory property.

+- st,32bits-counter: Set if the hardware have a 32 bits counter +- st,complementary: Set if the hardware have complementary output channels

+[1] Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt

Use relative path.

../pinctrl/pinctrl-bindings.txt

+Example:

• gptimer1: gptimer1@40010000 {

• compatible = "st,stm32-gptimer";
  

• reg = <0x40010000 0x400>;
  

• clocks = <&rcc 0 160>;
  

• clock-names = "clk_int";
  

• pwm1@0 {
  

Don't number the node name.

pwm@xx

• 	compatible = "st,stm32-pwm";
  

• 	st,pwm-num-chan = <4>;
  

• 	st,breakinput;
  

• 	st,complementary;
  

• };
  

• };

On Mon, 05 Dec 2016, Thierry Reding wrote:

On Fri, Dec 02, 2016 at 11:17:18AM +0100, Benjamin Gaignard wrote:

...

Define bindings for pwm-stm32

version 2:

• use parameters instead of compatible of handle the hardware configuration

Signed-off-by: Benjamin Gaignard benjamin.gaignard@st.com

.../devicetree/bindings/pwm/pwm-stm32.txt | 38 ++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 Documentation/devicetree/bindings/pwm/pwm-stm32.txt

diff --git a/Documentation/devicetree/bindings/pwm/pwm-stm32.txt b/Documentation/devicetree/bindings/pwm/pwm-stm32.txt new file mode 100644 index 0000000..575b9fb --- /dev/null +++ b/Documentation/devicetree/bindings/pwm/pwm-stm32.txt @@ -0,0 +1,38 @@ +STMicroelectronics PWM driver bindings for STM32

Technically this bindings describe devices, so "driver binding" is a somewhat odd wording. Perhaps:

STMicroelectronics STM32 General Purpose Timer PWM bindings

?

...

+Must be a sub-node of STM32 general purpose timer driver +Parent node properties are describe in ../mfd/stm32-general-purpose-timer.txt

Again, "driver parent node" is odd. Perhaps:

Must be a sub-node of an STM32 General Purpose Timer device tree node. See ../mfd/stm32-general-purpose-timer.txt for details about the parent node.

?

...

+Required parameters: +- compatible: Must be "st,stm32-pwm" +- pinctrl-names: Set to "default". +- pinctrl-0: List of phandles pointing to pin configuration nodes

• 	for PWM module.
  

• 	For Pinctrl properties, please refer to [1].
  

Your indentation and capitalization are inconsistent. Also, please refer to the pinctrl bindings by relative path and inline, rather than as a footnote reference.

...

+Optional parameters: +- st,breakinput: Set if the hardware have break input capabilities +- st,breakinput-polarity: Set break input polarity. Default is 0

• 	 The value define the active polarity:
  

• 	  - 0 (active LOW)
  

• 	  - 1 (active HIGH)
  

Could we fold these into a single property? If st,breakinput-polarity is not present it could simply mean that there is no break input, and if it is present you don't have to rely on a default.

...

+- st,pwm-num-chan: Number of available PWM channels. Default is 0.

The pwm- prefix is rather redundant since the node is already named pwm. Why not simply st,channels? Or simply channels, since it's not really anything specific to this hardware.

Come to think of it, might be worth having a discussion with our DT gurus about what their stance is on using the # as prefix for numbers (such as in #address-cells or #size-cells). This could be #channels to mark it more explicitly as representing a count.

Unfortunately that ship has sailed.

st,pwm-num-chan already exists (with your blessing). It's usually suggested to reuse exiting properties when writing new bindings.

...

+- st,32bits-counter: Set if the hardware have a 32 bits counter +- st,complementary: Set if the hardware have complementary output channels

"hardware has" and also maybe mention explicitly that this is a boolean property. Otherwise people might be left wondering what it should be set to. Or maybe word this differently to imply that it's boolean:

• st,32bits-counter: if present, the hardware has a 32 bit counter
• st,complementary: if present, the hardware has a complementary output channel

Thierry

2016-12-05 7:53 GMT+01:00 Thierry Reding thierry.reding@gmail.com:

On Fri, Dec 02, 2016 at 11:17:18AM +0100, Benjamin Gaignard wrote:

...

Define bindings for pwm-stm32

version 2:

• use parameters instead of compatible of handle the hardware configuration

Signed-off-by: Benjamin Gaignard benjamin.gaignard@st.com

.../devicetree/bindings/pwm/pwm-stm32.txt | 38 ++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 Documentation/devicetree/bindings/pwm/pwm-stm32.txt

diff --git a/Documentation/devicetree/bindings/pwm/pwm-stm32.txt b/Documentation/devicetree/bindings/pwm/pwm-stm32.txt new file mode 100644 index 0000000..575b9fb --- /dev/null +++ b/Documentation/devicetree/bindings/pwm/pwm-stm32.txt @@ -0,0 +1,38 @@ +STMicroelectronics PWM driver bindings for STM32

Technically this bindings describe devices, so "driver binding" is a somewhat odd wording. Perhaps:

    STMicroelectronics STM32 General Purpose Timer PWM bindings

?

done

...

+Must be a sub-node of STM32 general purpose timer driver +Parent node properties are describe in ../mfd/stm32-general-purpose-timer.txt

Again, "driver parent node" is odd. Perhaps:

    Must be a sub-node of an STM32 General Purpose Timer device tree
    node. See ../mfd/stm32-general-purpose-timer.txt for details about
    the parent node.

?

done

...

+Required parameters: +- compatible: Must be "st,stm32-pwm" +- pinctrl-names: Set to "default". +- pinctrl-0: List of phandles pointing to pin configuration nodes

•                 for PWM module.
  

•                 For Pinctrl properties, please refer to [1].
  

Your indentation and capitalization are inconsistent. Also, please refer to the pinctrl bindings by relative path and inline, rather than as a footnote reference.

OK

...

+Optional parameters: +- st,breakinput: Set if the hardware have break input capabilities +- st,breakinput-polarity: Set break input polarity. Default is 0

•                  The value define the active polarity:
  

•                   - 0 (active LOW)
  

•                   - 1 (active HIGH)
  

Could we fold these into a single property? If st,breakinput-polarity is not present it could simply mean that there is no break input, and if it is present you don't have to rely on a default.

I need to know if I have to activate breakinput feature and on which level I will rewrite it like that: Optional parameters: - st,breakinput-polarity-high: Set if break input polarity is active on high level. - st,breakinput-polarity-high: Set if break input polarity is active on low level.

...

+- st,pwm-num-chan: Number of available PWM channels. Default is 0.

The pwm- prefix is rather redundant since the node is already named pwm. Why not simply st,channels? Or simply channels, since it's not really anything specific to this hardware.

Come to think of it, might be worth having a discussion with our DT gurus about what their stance is on using the # as prefix for numbers (such as in #address-cells or #size-cells). This could be #channels to mark it more explicitly as representing a count.

...

+- st,32bits-counter: Set if the hardware have a 32 bits counter +- st,complementary: Set if the hardware have complementary output channels

"hardware has" and also maybe mention explicitly that this is a boolean property. Otherwise people might be left wondering what it should be set to. Or maybe word this differently to imply that it's boolean:

    - st,32bits-counter: if present, the hardware has a 32 bit counter
    - st,complementary: if present, the hardware has a complementary
                        output channel

I found a way to detect, at probe time, the number of channels, counter size, break input capability and complementary channels so I will remove "st,breakinput", "st,32bits-counter", "st,complementary" and "st,pwm-num-chan" parameters

Thierry

2016-12-05 12:23 GMT+01:00 Thierry Reding thierry.reding@gmail.com:

On Mon, Dec 05, 2016 at 12:08:32PM +0100, Benjamin Gaignard wrote:

...

2016-12-05 7:53 GMT+01:00 Thierry Reding thierry.reding@gmail.com:

...

On Fri, Dec 02, 2016 at 11:17:18AM +0100, Benjamin Gaignard wrote:

...

Define bindings for pwm-stm32

version 2:

• use parameters instead of compatible of handle the hardware configuration

Signed-off-by: Benjamin Gaignard benjamin.gaignard@st.com

.../devicetree/bindings/pwm/pwm-stm32.txt | 38 ++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 Documentation/devicetree/bindings/pwm/pwm-stm32.txt

diff --git a/Documentation/devicetree/bindings/pwm/pwm-stm32.txt b/Documentation/devicetree/bindings/pwm/pwm-stm32.txt new file mode 100644 index 0000000..575b9fb --- /dev/null +++ b/Documentation/devicetree/bindings/pwm/pwm-stm32.txt @@ -0,0 +1,38 @@ +STMicroelectronics PWM driver bindings for STM32

Technically this bindings describe devices, so "driver binding" is a somewhat odd wording. Perhaps:

    STMicroelectronics STM32 General Purpose Timer PWM bindings

?

done

...

...

+Must be a sub-node of STM32 general purpose timer driver +Parent node properties are describe in ../mfd/stm32-general-purpose-timer.txt

Again, "driver parent node" is odd. Perhaps:

    Must be a sub-node of an STM32 General Purpose Timer device tree
    node. See ../mfd/stm32-general-purpose-timer.txt for details about
    the parent node.

?

done

...

...

+Required parameters: +- compatible: Must be "st,stm32-pwm" +- pinctrl-names: Set to "default". +- pinctrl-0: List of phandles pointing to pin configuration nodes

•                 for PWM module.
  

•                 For Pinctrl properties, please refer to [1].
  

Your indentation and capitalization are inconsistent. Also, please refer to the pinctrl bindings by relative path and inline, rather than as a footnote reference.

OK

...

...

+Optional parameters: +- st,breakinput: Set if the hardware have break input capabilities +- st,breakinput-polarity: Set break input polarity. Default is 0

•                  The value define the active polarity:
  

•                   - 0 (active LOW)
  

•                   - 1 (active HIGH)
  

Could we fold these into a single property? If st,breakinput-polarity is not present it could simply mean that there is no break input, and if it is present you don't have to rely on a default.

I need to know if I have to activate breakinput feature and on which level I will rewrite it like that: Optional parameters:

• st,breakinput-polarity-high: Set if break input polarity is active

on high level.

• st,breakinput-polarity-high: Set if break input polarity is active

on low level.

How is that different from a single property:

    Optional properties:
    - st,breakinput-polarity: If present, a break input is available
        for the channel. In that case the property value denotes the
        polarity of the break input:
        - 0: active low
        - 1: active high

?

For break input feature I need two information: do I have to active it and if activated on which level. I have two solutions: - one parameter with a value (0 or 1) -> st,breakinput-polarity - two parameters without value -> st,breakinput-active-high and st,breakinput-active-low

By default break input feature is disabled

...

...

The pwm- prefix is rather redundant since the node is already named pwm. Why not simply st,channels? Or simply channels, since it's not really anything specific to this hardware.

Come to think of it, might be worth having a discussion with our DT gurus about what their stance is on using the # as prefix for numbers (such as in #address-cells or #size-cells). This could be #channels to mark it more explicitly as representing a count.

...

+- st,32bits-counter: Set if the hardware have a 32 bits counter +- st,complementary: Set if the hardware have complementary output channels

"hardware has" and also maybe mention explicitly that this is a boolean property. Otherwise people might be left wondering what it should be set to. Or maybe word this differently to imply that it's boolean:

    - st,32bits-counter: if present, the hardware has a 32 bit counter
    - st,complementary: if present, the hardware has a complementary
                        output channel

I found a way to detect, at probe time, the number of channels, counter size, break input capability and complementary channels so I will remove "st,breakinput", "st,32bits-counter", "st,complementary" and "st,pwm-num-chan" parameters

Oh hey, that's very neat. I suppose in that case my comment above about the break input polarity is somewhat obsoleted. Still I think you won't need two properties. Instead you can follow what other similar properties have done: choose a default (often low-active) and have a single optional property to override the default (often high-active).

In your case:

    - st,breakinput-active-high: Some channels have a break input,
        whose polarity will be active low by default. If this
        property is present, the channel will be configured with an
        active high polarity for the break input.

Thierry

On Mon, 05 Dec 2016, Thierry Reding wrote:

On Fri, Dec 02, 2016 at 11:17:19AM +0100, Benjamin Gaignard wrote:

...

This driver add support for pwm driver on stm32 platform.

"adds". Also please use PWM in prose because it's an abbreviation.

...

The SoC have multiple instances of the hardware IP and each of them could have small differences: number of channels, complementary output, counter register size... Use DT parameters to handle those differentes configuration

"different configurations"

...

version 2:

• only keep one comptatible
• use DT paramaters to discover hardware block configuration

"parameters"

...

Signed-off-by: Benjamin Gaignard benjamin.gaignard@st.com

drivers/pwm/Kconfig | 8 ++ drivers/pwm/Makefile | 1 + drivers/pwm/pwm-stm32.c | 285 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 294 insertions(+) create mode 100644 drivers/pwm/pwm-stm32.c

diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig index bf01288..a89fdba 100644 --- a/drivers/pwm/Kconfig +++ b/drivers/pwm/Kconfig @@ -388,6 +388,14 @@ config PWM_STI To compile this driver as a module, choose M here: the module will be called pwm-sti. +config PWM_STM32

• bool "STMicroelectronics STM32 PWM"
• depends on ARCH_STM32
• depends on OF
• select MFD_STM32_GP_TIMER

Should that be a "depends on"?

...

• help

•  Generic PWM framework driver for STM32 SoCs.
  

config PWM_STMPE bool "STMPE expander PWM export" depends on MFD_STMPE diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile index 1194c54..5aa9308 100644 --- a/drivers/pwm/Makefile +++ b/drivers/pwm/Makefile @@ -37,6 +37,7 @@ obj-$(CONFIG_PWM_ROCKCHIP) += pwm-rockchip.o obj-$(CONFIG_PWM_SAMSUNG) += pwm-samsung.o obj-$(CONFIG_PWM_SPEAR) += pwm-spear.o obj-$(CONFIG_PWM_STI) += pwm-sti.o +obj-$(CONFIG_PWM_STM32) += pwm-stm32.o obj-$(CONFIG_PWM_STMPE) += pwm-stmpe.o obj-$(CONFIG_PWM_SUN4I) += pwm-sun4i.o obj-$(CONFIG_PWM_TEGRA) += pwm-tegra.o diff --git a/drivers/pwm/pwm-stm32.c b/drivers/pwm/pwm-stm32.c new file mode 100644 index 0000000..a362f63 --- /dev/null +++ b/drivers/pwm/pwm-stm32.c @@ -0,0 +1,285 @@ +/*

• • Copyright (C) STMicroelectronics 2016
• • Author: Gerald Baeza gerald.baeza@st.com

Could use a blank line between the above. Also, please use a single space after : for consistency.

...

• • License terms: GNU General Public License (GPL), version 2

Here too.

...

• • Inspired by timer-stm32.c from Maxime Coquelin

• •         pwm-atmel.c from Bo Shen
    

• */

+#include <linux/of.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/pwm.h>

Please sort these alphabetically.

...

+#include <linux/mfd/stm32-gptimer.h>

+#define DRIVER_NAME "stm32-pwm"

+#define CAP_COMPLEMENTARY BIT(0) +#define CAP_32BITS_COUNTER BIT(1) +#define CAP_BREAKINPUT BIT(2) +#define CAP_BREAKINPUT_POLARITY BIT(3)

Just make these boolean. Makes the conditionals a lot simpler to read.

...

+struct stm32_pwm_dev {

No need for the _dev suffix.

I usually like ddata (short for device data, which is what it is).

I'll be asking for the same in the MFD driver too.

...

• struct device *dev;
• struct clk *clk;
• struct regmap *regmap;
• struct pwm_chip chip;

It's slightly more efficient to put this as first field because then to_stm32_pwm() becomes a no-op.

Niiiice!

...

• int caps;
• int npwm;

unsigned int, please.

...

• u32 polarity;

Maybe use a prefix here to stress that it is the polarity of the complementary output. Otherwise one might take it for the PWM signal's polarity that's already part of the PWM state.

...

+};

+#define to_stm32_pwm_dev(x) container_of(chip, struct stm32_pwm_dev, chip)

Please turn this into a static inline.

...

+static u32 __active_channels(struct stm32_pwm_dev *pwm_dev)

No need for a __ prefix.

...

+{

• u32 ccer;
• regmap_read(pwm_dev->regmap, TIM_CCER, &ccer);
• return ccer & TIM_CCER_CCXE;

+}

+static int write_ccrx(struct stm32_pwm_dev *dev, struct pwm_device *pwm,

•       u32 ccr)
  

u32 value, perhaps? I first mistook this to be a register offset.

...

+{

• switch (pwm->hwpwm) {
• case 0:

• return regmap_write(dev->regmap, TIM_CCR1, ccr);
  

• case 1:

• return regmap_write(dev->regmap, TIM_CCR2, ccr);
  

• case 2:

• return regmap_write(dev->regmap, TIM_CCR3, ccr);
  

• case 3:

• return regmap_write(dev->regmap, TIM_CCR4, ccr);
  

• }
• return -EINVAL;

+}

+static int stm32_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

• 	    int duty_ns, int period_ns)
  

Please implement this as an atomic PWM driver, I don't want new drivers to use the legacy callbacks.

...

+{

• struct stm32_pwm_dev *dev = to_stm32_pwm_dev(chip);

I think something like "stm", or "priv" would be more appropriate here. If you ever need access to a struct device, you'll be hard-pressed to find a good name for it.

See above.

...

• unsigned long long prd, div, dty;
• int prescaler = 0;

If this can never be negative, please make it unsigned int.

...

• u32 max_arr = 0xFFFF, ccmr, mask, shift, bdtr;
• if (dev->caps & CAP_32BITS_COUNTER)

• max_arr = 0xFFFFFFFF;
  

I prefer lower-case hexadecimal digits.

Even better to define the max values.

...

• /* Period and prescaler values depends of clock rate */

"depend on"

...

• div = (unsigned long long)clk_get_rate(dev->clk) * period_ns;
• do_div(div, NSEC_PER_SEC);
• prd = div;
• while (div > max_arr) {

• prescaler++;
  

• div = prd;
  

• do_div(div, (prescaler + 1));
  

• }
• prd = div;

Blank line after blocks, please.

... unless directly related to the block, which I think this is. It's the '\n' *before* the block which confuses me.

...

• if (prescaler > MAX_TIM_PSC) {

• dev_err(chip->dev, "prescaler exceeds the maximum value\n");
  

• return -EINVAL;
  

• }
• /* All channels share the same prescaler and counter so

• * when two channels are active at the same we can't change them
  

• */
  

This isn't proper block comment style. Also, please use all of the columns at your disposal.

...

• if (__active_channels(dev) & ~(1 << pwm->hwpwm * 4)) {

• u32 psc, arr;
  

• regmap_read(dev->regmap, TIM_PSC, &psc);
  

• regmap_read(dev->regmap, TIM_ARR, &arr);
  

• if ((psc != prescaler) || (arr != prd - 1))
  

• 	return -EINVAL;
  

Maybe -EBUSY to differentiate from other error cases?

...

• }
• regmap_write(dev->regmap, TIM_PSC, prescaler);
• regmap_write(dev->regmap, TIM_ARR, prd - 1);
• regmap_update_bits(dev->regmap, TIM_CR1, TIM_CR1_ARPE, TIM_CR1_ARPE);
• /* Calculate the duty cycles */
• dty = prd * duty_ns;
• do_div(dty, period_ns);
• write_ccrx(dev, pwm, dty);
• /* Configure output mode */
• shift = (pwm->hwpwm & 0x1) * 8;
• ccmr = (TIM_CCMR_PE | TIM_CCMR_M1) << shift;
• mask = 0xFF << shift;
• if (pwm->hwpwm & 0x2)

This looks as though TIM_CCMR1 is used for channels 0 and 1, while TIM_CCMR2 is used for channels 2 and 3. Wouldn't it be more natural to make the conditional above:

if (pwm->hwpwm >= 2)

? Or perhaps better yet:

if (pwm->hwpwm < 2) /* update TIM_CCMR1 */ else /* update TIM_CCMR2 */

And please define the magic numbers.

*_MASK *_SHIFT

The other alternative, which might make the code slightly more readable, would be to get rid of all these conditionals by parameterizing the offsets per PWM channel. The PWM subsystem has a means of storing per- channel chip-specific data (see pwm_{set,get}_chip_data()). It might be a little overkill for this particular driver, given that the number of conditionals is fairly small.

...

• regmap_update_bits(dev->regmap, TIM_CCMR2, mask, ccmr);
  

• else

• regmap_update_bits(dev->regmap, TIM_CCMR1, mask, ccmr);
  

• if (!(dev->caps & CAP_BREAKINPUT))

• return 0;
  

If you make these capabilities boolean, it becomes much more readable, especially for negations:

if (!dev->has_breakinput)

+1

...

• bdtr = TIM_BDTR_MOE | TIM_BDTR_AOE;
• if (dev->caps & CAP_BREAKINPUT_POLARITY)

• bdtr |= TIM_BDTR_BKE;
  

• if (dev->polarity)

• bdtr |= TIM_BDTR_BKP;
  

• regmap_update_bits(dev->regmap, TIM_BDTR,

• 	   TIM_BDTR_MOE | TIM_BDTR_AOE |
  

• 	   TIM_BDTR_BKP | TIM_BDTR_BKE,
  

• 	   bdtr);
  

• return 0;

+}

+static int stm32_pwm_set_polarity(struct pwm_chip *chip, struct pwm_device *pwm,

• 		  enum pwm_polarity polarity)
  

+{

• u32 mask;
• struct stm32_pwm_dev *dev = to_stm32_pwm_dev(chip);
• mask = TIM_CCER_CC1P << (pwm->hwpwm * 4);
• if (dev->caps & CAP_COMPLEMENTARY)

• mask |= TIM_CCER_CC1NP << (pwm->hwpwm * 4);
  

• regmap_update_bits(dev->regmap, TIM_CCER, mask,

• 	   polarity == PWM_POLARITY_NORMAL ? 0 : mask);
  

• return 0;

+}

+static int stm32_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm) +{

• u32 mask;
• struct stm32_pwm_dev *dev = to_stm32_pwm_dev(chip);
• clk_enable(dev->clk);
• /* Enable channel */
• mask = TIM_CCER_CC1E << (pwm->hwpwm * 4);
• if (dev->caps & CAP_COMPLEMENTARY)

• mask |= TIM_CCER_CC1NE << (pwm->hwpwm * 4);
  

• regmap_update_bits(dev->regmap, TIM_CCER, mask, mask);
• /* Make sure that registers are updated */
• regmap_update_bits(dev->regmap, TIM_EGR, TIM_EGR_UG, TIM_EGR_UG);
• /* Enable controller */
• regmap_update_bits(dev->regmap, TIM_CR1, TIM_CR1_CEN, TIM_CR1_CEN);
• return 0;

+}

+static void stm32_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm) +{

• u32 mask;
• struct stm32_pwm_dev *dev = to_stm32_pwm_dev(chip);
• /* Disable channel */
• mask = TIM_CCER_CC1E << (pwm->hwpwm * 4);
• if (dev->caps & CAP_COMPLEMENTARY)

• mask |= TIM_CCER_CC1NE << (pwm->hwpwm * 4);
  

• regmap_update_bits(dev->regmap, TIM_CCER, mask, 0);
• /* When all channels are disabled, we can disable the controller */
• if (!__active_channels(dev))

• regmap_update_bits(dev->regmap, TIM_CR1, TIM_CR1_CEN, 0);
  

• clk_disable(dev->clk);

+}

All of the above can be folded into the ->apply() hook for atomic PWM support.

Also, in the above you use clk_enable() in the ->enable() callback and clk_disable() in ->disable(). If you need the clock to access registers you'll have to enabled it in the others as well because there are no guarantees that configuration will only happen between ->enable() and ->disable(). Atomic PWM simplifies this a bit, but you still need to be careful about when to enable the clock in your ->apply() hook.

...

+static const struct pwm_ops stm32pwm_ops = {

• .config = stm32_pwm_config,
• .set_polarity = stm32_pwm_set_polarity,
• .enable = stm32_pwm_enable,
• .disable = stm32_pwm_disable,

+};

You need to set the .owner field as well.

...

+static int stm32_pwm_probe(struct platform_device *pdev) +{

• struct device *dev = &pdev->dev;
• struct device_node *np = dev->of_node;
• struct stm32_gptimer_dev *mfd = dev_get_drvdata(pdev->dev.parent);
• struct stm32_pwm_dev *pwm;

pwm is okay. Please also consider using ddata for consistency across the driver-set.

...

• int ret;
• pwm = devm_kzalloc(dev, sizeof(*pwm), GFP_KERNEL);
• if (!pwm)

• return -ENOMEM;
  

• pwm->regmap = mfd->regmap;
• pwm->clk = mfd->clk;
• if (!pwm->regmap || !pwm->clk)

• return -EINVAL;
  

• if (of_property_read_bool(np, "st,complementary"))

• pwm->caps |= CAP_COMPLEMENTARY;
  

• if (of_property_read_bool(np, "st,32bits-counter"))

• pwm->caps |= CAP_32BITS_COUNTER;
  

• if (of_property_read_bool(np, "st,breakinput"))

• pwm->caps |= CAP_BREAKINPUT;
  

• if (!of_property_read_u32(np, "st,breakinput-polarity", &pwm->polarity))

• pwm->caps |= CAP_BREAKINPUT_POLARITY;
  

• of_property_read_u32(np, "st,pwm-num-chan", &pwm->npwm);
• pwm->chip.base = -1;
• pwm->chip.dev = dev;
• pwm->chip.ops = &stm32pwm_ops;
• pwm->chip.npwm = pwm->npwm;
• ret = pwmchip_add(&pwm->chip);
• if (ret < 0)

• return ret;
  

• platform_set_drvdata(pdev, pwm);
• return 0;

+}

+static int stm32_pwm_remove(struct platform_device *pdev) +{

• struct stm32_pwm_dev *pwm = platform_get_drvdata(pdev);
• int i;

unsigned int, please.

...

• for (i = 0; i < pwm->npwm; i++)

• pwm_disable(&pwm->chip.pwms[i]);
  

• pwmchip_remove(&pwm->chip);
• return 0;

+}

+static const struct of_device_id stm32_pwm_of_match[] = {

• {

• .compatible = "st,stm32-pwm",
  

• },

The above can be collapsed into a single line.

+1

...

+}; +MODULE_DEVICE_TABLE(of, stm32_pwm_of_match);

+static struct platform_driver stm32_pwm_driver = {

• .probe = stm32_pwm_probe,
• .remove = stm32_pwm_remove,
• .driver = {

• .name	= DRIVER_NAME,
  

• .of_match_table = stm32_pwm_of_match,
  

• },

+};

Please don't use tabs for padding within the structure definition since it doesn't align properly anyway.

+1

...

+module_platform_driver(stm32_pwm_driver);

+MODULE_ALIAS("platform:" DRIVER_NAME); +MODULE_DESCRIPTION("STMicroelectronics STM32 PWM driver"); +MODULE_LICENSE("GPL");

According to the header comment this should be "GPL v2".

+1

On Mon, Dec 05, 2016 at 12:02:45PM +0100, Benjamin Gaignard wrote:

2016-12-05 8:23 GMT+01:00 Thierry Reding thierry.reding@gmail.com:

...

On Fri, Dec 02, 2016 at 11:17:19AM +0100, Benjamin Gaignard wrote:

...

This driver add support for pwm driver on stm32 platform.

"adds". Also please use PWM in prose because it's an abbreviation.

...

The SoC have multiple instances of the hardware IP and each of them could have small differences: number of channels, complementary output, counter register size... Use DT parameters to handle those differentes configuration

"different configurations"

ok

...

...

version 2:

• only keep one comptatible
• use DT paramaters to discover hardware block configuration

"parameters"

ok

...

...

Signed-off-by: Benjamin Gaignard benjamin.gaignard@st.com

drivers/pwm/Kconfig | 8 ++ drivers/pwm/Makefile | 1 + drivers/pwm/pwm-stm32.c | 285 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 294 insertions(+) create mode 100644 drivers/pwm/pwm-stm32.c

diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig index bf01288..a89fdba 100644 --- a/drivers/pwm/Kconfig +++ b/drivers/pwm/Kconfig @@ -388,6 +388,14 @@ config PWM_STI To compile this driver as a module, choose M here: the module will be called pwm-sti.

+config PWM_STM32

• bool "STMicroelectronics STM32 PWM"
  

• depends on ARCH_STM32
  

• depends on OF
  

• select MFD_STM32_GP_TIMER
  

Should that be a "depends on"?

I think select is fine because the wanted feature is PWM not the mfd part

I think in that case you may want to hide the MFD Kconfig option. See Documentation/kbuild/kconfig-language.txt (notes about select) for the details.

[...]

...

...

+};

+#define to_stm32_pwm_dev(x) container_of(chip, struct stm32_pwm_dev, chip)

Please turn this into a static inline.

with putting struct pwm_chip as first filed I will just cast the structure

Don't do that, please. container_of() is still preferred because it is correct and won't break even if you (or somebody else) changes the order in the future. The fact that it might be optimized away is a detail, or a micro-optimization. Force-casting is a bad idea because it won't catch errors if for some reason the field doesn't remain in the first position forever.

...

...

+static void stm32_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm) +{

• u32 mask;
  

• struct stm32_pwm_dev *dev = to_stm32_pwm_dev(chip);
  

• /* Disable channel */
  

• mask = TIM_CCER_CC1E << (pwm->hwpwm * 4);
  

• if (dev->caps & CAP_COMPLEMENTARY)
  

•         mask |= TIM_CCER_CC1NE << (pwm->hwpwm * 4);
  

• regmap_update_bits(dev->regmap, TIM_CCER, mask, 0);
  

• /* When all channels are disabled, we can disable the controller */
  

• if (!__active_channels(dev))
  

•         regmap_update_bits(dev->regmap, TIM_CR1, TIM_CR1_CEN, 0);
  

• clk_disable(dev->clk);
  

+}

All of the above can be folded into the ->apply() hook for atomic PWM support.

Also, in the above you use clk_enable() in the ->enable() callback and clk_disable() in ->disable(). If you need the clock to access registers you'll have to enabled it in the others as well because there are no guarantees that configuration will only happen between ->enable() and ->disable(). Atomic PWM simplifies this a bit, but you still need to be careful about when to enable the clock in your ->apply() hook.

I have used regmap functions enable/disable clk for me when accessing to the registers. I only have to take care of clk enable/disable when PWM state change.

Okay, that's fine then.

Thierry

On Fri, 02 Dec 2016, Benjamin Gaignard wrote:

Define bindings for stm32 timer trigger

version 3:

• change file name
• add cross reference with mfd bindings

version 2:

• only keep one compatible
• add DT parameters to set lists of the triggers: one list describe the triggers created by the device another one give the triggers accepted by the device

Signed-off-by: Benjamin Gaignard benjamin.gaignard@st.com

.../bindings/iio/timer/stm32-timer-trigger.txt | 39 ++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 Documentation/devicetree/bindings/iio/timer/stm32-timer-trigger.txt

diff --git a/Documentation/devicetree/bindings/iio/timer/stm32-timer-trigger.txt b/Documentation/devicetree/bindings/iio/timer/stm32-timer-trigger.txt new file mode 100644 index 0000000..858816d --- /dev/null +++ b/Documentation/devicetree/bindings/iio/timer/stm32-timer-trigger.txt @@ -0,0 +1,39 @@ +timer trigger bindings for STM32

+Must be a sub-node of STM32 general purpose timer driver +Parent node properties are describe in ../mfd/stm32-general-purpose-timer.txt

+Required parameters: +- compatible: must be "st,stm32-iio-timer" +- interrupts: Interrupt for this device

• 	See ../interrupt-controller/st,stm32-exti.txt
  

+Optional parameters: +- st,input-triggers-names: List of the possible input triggers for

• 		the device
  

+- st,output-triggers-names: List of the possible output triggers for

• 		the device
  

+Possible triggers are defined in include/dt-bindings/iio/timer/st,stm32-timer-trigger.h

+Example:

• gptimer1: gptimer1@40010000 {

• compatible = "st,stm32-gptimer";
  

• reg = <0x40010000 0x400>;
  

• clocks = <&rcc 0 160>;
  

• clock-names = "clk_int";
  

• timer1@0 {
  

• 	compatible = "st,stm32-timer-trigger";
  

• 	interrupts = <27>;
  

• 	st,input-triggers-names = TIM5_TRGO,
  

• 				  TIM2_TRGO,
  

• 				  TIM4_TRGO,
  

• 				  TIM3_TRGO;
  

• 	st,output-triggers-names = TIM1_TRGO,
  

• 				   TIM1_CH1,
  

• 				   TIM1_CH2,
  

• 				   TIM1_CH3,
  

• 				   TIM1_CH4;
  

I see why you've done it like this now ... because it makes things easier for you in the driver, since the IIO subsystem matches on names such as these.

BUT, this is a Linux-implementation-ism. Just use pairs of integers and create the Linux-ism strings in the driver.

• };
  

• };

On 02/12/16 14:23, Benjamin Gaignard wrote:

2016-12-02 14:59 GMT+01:00 Lee Jones lee.jones@linaro.org:

...

On Fri, 02 Dec 2016, Benjamin Gaignard wrote:

...

Define bindings for stm32 timer trigger

version 3:

• change file name
• add cross reference with mfd bindings

version 2:

• only keep one compatible
• add DT parameters to set lists of the triggers: one list describe the triggers created by the device another one give the triggers accepted by the device

Signed-off-by: Benjamin Gaignard benjamin.gaignard@st.com

.../bindings/iio/timer/stm32-timer-trigger.txt | 39 ++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 Documentation/devicetree/bindings/iio/timer/stm32-timer-trigger.txt

diff --git a/Documentation/devicetree/bindings/iio/timer/stm32-timer-trigger.txt b/Documentation/devicetree/bindings/iio/timer/stm32-timer-trigger.txt new file mode 100644 index 0000000..858816d --- /dev/null +++ b/Documentation/devicetree/bindings/iio/timer/stm32-timer-trigger.txt @@ -0,0 +1,39 @@ +timer trigger bindings for STM32

+Must be a sub-node of STM32 general purpose timer driver +Parent node properties are describe in ../mfd/stm32-general-purpose-timer.txt

+Required parameters: +- compatible: must be "st,stm32-iio-timer" +- interrupts: Interrupt for this device

•                 See ../interrupt-controller/st,stm32-exti.txt
  

+Optional parameters: +- st,input-triggers-names: List of the possible input triggers for

•                         the device
  

+- st,output-triggers-names: List of the possible output triggers for

•                         the device
  

+Possible triggers are defined in include/dt-bindings/iio/timer/st,stm32-timer-trigger.h

+Example:

• gptimer1: gptimer1@40010000 {
  

•         compatible = "st,stm32-gptimer";
  

•         reg = <0x40010000 0x400>;
  

•         clocks = <&rcc 0 160>;
  

•         clock-names = "clk_int";
  

•         timer1@0 {
  

•                 compatible = "st,stm32-timer-trigger";
  

•                 interrupts = <27>;
  

•                 st,input-triggers-names = TIM5_TRGO,
  

•                                           TIM2_TRGO,
  

•                                           TIM4_TRGO,
  

•                                           TIM3_TRGO;
  

•                 st,output-triggers-names = TIM1_TRGO,
  

•                                            TIM1_CH1,
  

•                                            TIM1_CH2,
  

•                                            TIM1_CH3,
  

•                                            TIM1_CH4;
  

I see why you've done it like this now ... because it makes things easier for you in the driver, since the IIO subsystem matches on names such as these.

BUT, this is a Linux-implementation-ism. Just use pairs of integers and create the Linux-ism strings in the driver.

The goal is not to make things easier in driver but to be able to share the triggers names with other drivers like DAC or ADC. If each driver have to create it own triggers names it will more difficult to keep them coherent than it they share the same definitions

Do it by documentation. This will be effectively ABI going forward so fixed once it is defined. Should be fairly easy to tell during testing if someone has messed it up ;)

Jonathan

...

...

•         };
  

• };
  

-- Lee Jones Linaro STMicroelectronics Landing Team Lead Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog

-- To unsubscribe from this list: send the line "unsubscribe linux-iio" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

On Fri, 02 Dec 2016, Benjamin Gaignard wrote:

Timers IPs can be used to generate triggers for other IPs like DAC, ADC or other timers. Each trigger may result of timer internals signals like counter enable, reset or edge, this configuration could be done through "master_mode" device attribute.

A timer device could be triggered by other timers, we use the trigger name and is_stm32_iio_timer_trigger() function to distinguish them and configure IP input switch.

Timer may also decide on which event (edge, level) they could be activated by a trigger, this configuration is done by writing in "slave_mode" device attribute.

Since triggers could also be used by DAC or ADC their names are defined in include/dt-bindings/iio/timer/st,stm32-iio-timer.h so those IPs will be able to configure themselves in valid_trigger function

Trigger have a "sampling_frequency" attribute which allow to configure timer sampling frequency without using pwm interface

version 3:

• change compatible to "st,stm32-timer-trigger"
• fix attributes access right
• use string instead of int for master_mode and slave_mode
• document device attributes in sysfs-bus-iio-timer-stm32

version 2:

• keep only one compatible
• use st,input-triggers-names and st,output-triggers-names to know which triggers are accepted and/or create by the device

Signed-off-by: Benjamin Gaignard benjamin.gaignard@st.com

.../ABI/testing/sysfs-bus-iio-timer-stm32 | 47 ++ drivers/iio/Kconfig | 2 +- drivers/iio/Makefile | 1 + drivers/iio/timer/Kconfig | 15 + drivers/iio/timer/Makefile | 1 + drivers/iio/timer/stm32-timer-trigger.c | 477 +++++++++++++++++++++ drivers/iio/trigger/Kconfig | 1 - .../iio/timer/st,stm32-timer-triggers.h | 60 +++ include/linux/iio/timer/stm32-timer-trigger.h | 16 + 9 files changed, 618 insertions(+), 2 deletions(-) create mode 100644 Documentation/ABI/testing/sysfs-bus-iio-timer-stm32 create mode 100644 drivers/iio/timer/Kconfig create mode 100644 drivers/iio/timer/Makefile create mode 100644 drivers/iio/timer/stm32-timer-trigger.c create mode 100644 include/dt-bindings/iio/timer/st,stm32-timer-triggers.h create mode 100644 include/linux/iio/timer/stm32-timer-trigger.h

diff --git a/Documentation/ABI/testing/sysfs-bus-iio-timer-stm32 b/Documentation/ABI/testing/sysfs-bus-iio-timer-stm32 new file mode 100644 index 0000000..b70bb2a --- /dev/null +++ b/Documentation/ABI/testing/sysfs-bus-iio-timer-stm32 @@ -0,0 +1,47 @@ +What: /sys/bus/iio/devices/iio:deviceX/master_mode_available +KernelVersion: 4.10 +Contact: benjamin.gaignard@st.com +Description:

• Reading returns the list possible master modes which are:
  

• - "reset"     :	The UG bit from the TIMx_EGR register is used as trigger output (TRGO).
  

• - "enable"    : The Counter Enable signal CNT_EN is used as trigger output.
  

• - "update"    : The update event is selected as trigger output.
  

• 		For instance a master timer can then be used as a prescaler for a slave timer.
  

• - "compare_pulse" : The trigger output send a positive pulse when the CC1IF flag is to be set.
  

• - "OC1REF"    : OC1REF signal is used as trigger output.
  

• - "OC2REF"    : OC2REF signal is used as trigger output.
  

• - "OC3REF"    : OC3REF signal is used as trigger output.
  

• - "OC4REF"    : OC4REF signal is used as trigger output.
  

+What: /sys/bus/iio/devices/iio:deviceX/master_mode +KernelVersion: 4.10 +Contact: benjamin.gaignard@st.com +Description:

• Reading returns the current master modes.
  

• Writing set the master mode
  

+What: /sys/bus/iio/devices/iio:deviceX/slave_mode_available +KernelVersion: 4.10 +Contact: benjamin.gaignard@st.com +Description:

• Reading returns the list possible slave modes which are:
  

• - "disabled"  : The prescaler is clocked directly by the internal clock.
  

• - "encoder_1" : Counter counts up/down on TI2FP1 edge depending on TI1FP2 level.
  

• - "encoder_2" : Counter counts up/down on TI1FP2 edge depending on TI2FP1 level.
  

• - "encoder_3" : Counter counts up/down on both TI1FP1 and TI2FP2 edges depending
  

• 		on the level of the other input.
  

• - "reset"     : Rising edge of the selected trigger input reinitializes the counter
  

• 		and generates an update of the registers.
  

• - "gated"     : The counter clock is enabled when the trigger input is high.
  

• 		The counter stops (but is not reset) as soon as the trigger becomes low.
  

• 		Both start and stop of the counter are controlled.
  

• - "trigger"   : The counter starts at a rising edge of the trigger TRGI (but it is not
  

• 		reset). Only the start of the counter is controlled.
  

• - "external_clock": Rising edges of the selected trigger (TRGI) clock the counter.
  

+What: /sys/bus/iio/devices/iio:deviceX/slave_mode +KernelVersion: 4.10 +Contact: benjamin.gaignard@st.com +Description:

• Reading returns the current slave mode.
  

• Writing set the slave mode
  

diff --git a/drivers/iio/Kconfig b/drivers/iio/Kconfig index 6743b18..2de2a80 100644 --- a/drivers/iio/Kconfig +++ b/drivers/iio/Kconfig @@ -90,5 +90,5 @@ source "drivers/iio/potentiometer/Kconfig" source "drivers/iio/pressure/Kconfig" source "drivers/iio/proximity/Kconfig" source "drivers/iio/temperature/Kconfig"

+source "drivers/iio/timer/Kconfig" endif # IIO diff --git a/drivers/iio/Makefile b/drivers/iio/Makefile index 87e4c43..b797c08 100644 --- a/drivers/iio/Makefile +++ b/drivers/iio/Makefile @@ -32,4 +32,5 @@ obj-y += potentiometer/ obj-y += pressure/ obj-y += proximity/ obj-y += temperature/ +obj-y += timer/ obj-y += trigger/ diff --git a/drivers/iio/timer/Kconfig b/drivers/iio/timer/Kconfig new file mode 100644 index 0000000..149a917 --- /dev/null +++ b/drivers/iio/timer/Kconfig @@ -0,0 +1,15 @@ +# +# Timers drivers

+menu "Timers"

+config IIO_STM32_TIMER_TRIGGER

• tristate "stm32 timer trigger"

"STM32 Timer Trigger"

• depends on ARCH_STM32
• depends on OF

Are these build or run time dependencies?

If they are only run-time, add "|| COMPILE_TEST".

• select IIO_TRIGGERED_EVENT
• select MFD_STM32_GP_TIMER
• help

•  Select this option to enable stm32 timer trigger
  

+endmenu diff --git a/drivers/iio/timer/Makefile b/drivers/iio/timer/Makefile new file mode 100644 index 0000000..4ad95ec9 --- /dev/null +++ b/drivers/iio/timer/Makefile @@ -0,0 +1 @@ +obj-$(CONFIG_IIO_STM32_TIMER_TRIGGER) += stm32-timer-trigger.o diff --git a/drivers/iio/timer/stm32-timer-trigger.c b/drivers/iio/timer/stm32-timer-trigger.c new file mode 100644 index 0000000..0c51601 --- /dev/null +++ b/drivers/iio/timer/stm32-timer-trigger.c @@ -0,0 +1,477 @@ +/*

• • stm32-iio-timer.c

Swap this out for a description.

Filenames have a habit of becoming out-of-date.

• • Copyright (C) STMicroelectronics 2016

'\n'

• • Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.

You don't need to put the "for" bit. That's just what we do when Linaro are writing drivers for other companies. Your email address says enough.

• • License terms: GNU General Public License (GPL), version 2
• */

+#include <linux/iio/iio.h> +#include <linux/iio/sysfs.h> +#include <linux/iio/timer/stm32-timer-trigger.h> +#include <linux/iio/trigger.h> +#include <linux/iio/triggered_event.h> +#include <linux/interrupt.h> +#include <linux/mfd/stm32-gptimer.h> +#include <linux/module.h> +#include <linux/platform_device.h>

+#define DRIVER_NAME "stm32-timer-trigger"

Just use the name in the correct places. Defining device names is an ugly practice IMHO.

+#define MAX_MODES 8

+struct stm32_timer_trigger_dev {

• struct device *dev;
• struct regmap *regmap;
• struct clk *clk;
• int irq;
• bool own_timer;
• unsigned int sampling_frequency;
• struct iio_trigger *active_trigger;

+};

+static ssize_t _store_frequency(struct device *dev,

What's with the '_' naming scheme?

• 		struct device_attribute *attr,
  

• 		const char *buf, size_t len)
  

+{

• struct iio_trigger *trig = to_iio_trigger(dev);
• struct stm32_timer_trigger_dev *stm32 = iio_trigger_get_drvdata(trig);
• unsigned int freq;
• int ret;
• ret = kstrtouint(buf, 10, &freq);
• if (ret)

• return ret;
  

No bounds checking required?

• stm32->sampling_frequency = freq;

Where is this value placed into the registers?

• return len;

+}

+static ssize_t _read_frequency(struct device *dev,

• 	       struct device_attribute *attr, char *buf)
  

+{

• struct iio_trigger *trig = to_iio_trigger(dev);
• struct stm32_timer_trigger_dev *stm32 = iio_trigger_get_drvdata(trig);
• unsigned long long freq = stm32->sampling_frequency;
• u32 psc, arr, cr1;
• regmap_read(stm32->regmap, TIM_CR1, &cr1);
• regmap_read(stm32->regmap, TIM_PSC, &psc);
• regmap_read(stm32->regmap, TIM_ARR, &arr);
• if (psc && arr && (cr1 & TIM_CR1_CEN)) {

• freq = (unsigned long long)clk_get_rate(stm32->clk);
  

• do_div(freq, psc);
  

• do_div(freq, arr);
  

• }
• return sprintf(buf, "%d\n", (unsigned int)freq);

+}

+static IIO_DEV_ATTR_SAMP_FREQ(0660, _read_frequency, _store_frequency);

+static struct attribute *stm32_trigger_attrs[] = {

• &iio_dev_attr_sampling_frequency.dev_attr.attr,
• NULL,

+};

+static const struct attribute_group stm32_trigger_attr_group = {

• .attrs = stm32_trigger_attrs,

+};

+static const struct attribute_group *stm32_trigger_attr_groups[] = {

• &stm32_trigger_attr_group,
• NULL,

+};

A lot of generic code here.

Are there macros that could help with this?

+static char *master_mode_table[] = {

• "reset",
• "enable",
• "update",
• "compare_pulse",
• "OC1REF",
• "OC2REF",
• "OC3REF",
• "OC4REF"

+};

+static

Why the line break here?

[and the ones below]

+ssize_t _show_master_mode(struct device *dev,

• 	  struct device_attribute *attr, char *buf)
  

+{

• struct iio_dev *indio_dev = dev_to_iio_dev(dev);
• struct stm32_timer_trigger_dev *stm32 = iio_priv(indio_dev);
• u32 cr2;
• regmap_read(stm32->regmap, TIM_CR2, &cr2);
• cr2 = (cr2 >> 4) & 0x7;

Define these SHIFT and MASK values.

• return snprintf(buf, PAGE_SIZE, "%s\n", master_mode_table[cr2]);

+}

+static +ssize_t _store_master_mode(struct device *dev,

• 	   struct device_attribute *attr,
  

• 	   const char *buf, size_t len)
  

+{

• struct iio_dev *indio_dev = dev_to_iio_dev(dev);
• struct stm32_timer_trigger_dev *stm32 = iio_priv(indio_dev);
• int i;
• for (i = 0; i < ARRAY_SIZE(master_mode_table); i++) {

• if (!strncmp(master_mode_table[i], buf,
  

• 	     strlen(master_mode_table[i]))) {
  

• 	regmap_update_bits(stm32->regmap, TIM_CR2,
  

• 			   TIM_CR2_MMS, i << 4);
  

Define all of the SHIFT and MASK values in this set.

• 	return len;
  

• }
  

• }
• return -EINVAL;

+}

+static IIO_CONST_ATTR(master_mode_available,

• "reset enable update compare_pulse OC1REF OC2REF OC3REF OC4REF");

+static IIO_DEVICE_ATTR(master_mode, 0660,

•        _show_master_mode,
  

•        _store_master_mode,
  

•        0);
  

+static char *slave_mode_table[] = {

• "disabled",
• "encoder_1",
• "encoder_2",
• "encoder_3",
• "reset",
• "gated",
• "trigger",
• "external_clock",

+};

+static +ssize_t _show_slave_mode(struct device *dev,

• 	 struct device_attribute *attr, char *buf)
  

+{

• struct iio_dev *indio_dev = dev_to_iio_dev(dev);
• struct stm32_timer_trigger_dev *stm32 = iio_priv(indio_dev);
• u32 smcr;
• regmap_read(stm32->regmap, TIM_SMCR, &smcr);
• smcr &= 0x7;
• return snprintf(buf, PAGE_SIZE, "%s\n", slave_mode_table[smcr]);

+}

+static +ssize_t _store_slave_mode(struct device *dev,

• 	  struct device_attribute *attr,
  

• 	  const char *buf, size_t len)
  

+{

• struct iio_dev *indio_dev = dev_to_iio_dev(dev);
• struct stm32_timer_trigger_dev *stm32 = iio_priv(indio_dev);
• int i;
• for (i = 0; i < ARRAY_SIZE(slave_mode_table); i++) {

• if (!strncmp(slave_mode_table[i], buf,
  

• 	     strlen(slave_mode_table[i]))) {
  

• 	regmap_update_bits(stm32->regmap,
  

• 			   TIM_SMCR, TIM_SMCR_SMS, i);
  

• 	return len;
  

• }
  

• }
• return -EINVAL;

+}

+static IIO_CONST_ATTR(slave_mode_available,

•   "disabled encoder_1 encoder_2 encoder_3 reset gated trigger external_clock");
  

+static IIO_DEVICE_ATTR(slave_mode, 0660,

•        _show_slave_mode,
  

•        _store_slave_mode,
  

•        0);
  

+static struct attribute *stm32_timer_attrs[] = {

• &iio_dev_attr_master_mode.dev_attr.attr,
• &iio_const_attr_master_mode_available.dev_attr.attr,
• &iio_dev_attr_slave_mode.dev_attr.attr,
• &iio_const_attr_slave_mode_available.dev_attr.attr,
• NULL,

+};

+static const struct attribute_group stm32_timer_attr_group = {

• .attrs = stm32_timer_attrs,

+};

+static int stm32_timer_start(struct stm32_timer_trigger_dev *stm32) +{

• unsigned long long prd, div;
• int prescaler = 0;
• u32 max_arr = 0xFFFF, cr1;

Since this is const, it'll be better of as a define.

• if (stm32->sampling_frequency == 0)

• return 0;
  

Is this okay? Or is this an error?

• /* Period and prescaler values depends of clock rate */
• div = (unsigned long long)clk_get_rate(stm32->clk);
• do_div(div, stm32->sampling_frequency);
• prd = div;
• while (div > max_arr) {

• prescaler++;
  

• div = prd;
  

• do_div(div, (prescaler + 1));
  

• }
• prd = div;

Best to place a comment here. Saves the reader having to work it out.

• if (prescaler > MAX_TIM_PSC) {

• dev_err(stm32->dev, "prescaler exceeds the maximum value\n");
  

• return -EINVAL;
  

• }
• /* Check that we own the timer */
• regmap_read(stm32->regmap, TIM_CR1, &cr1);
• if ((cr1 & TIM_CR1_CEN) && !stm32->own_timer)

• return -EBUSY;
  

What happens if the timer is already enabled and you do own it?

I guess this *re*-starts it?

• if (!stm32->own_timer) {

• stm32->own_timer = true;
  

• clk_enable(stm32->clk);
  

• }

At the very least you're going to require some shared locking here.

At best you should have a shared "device held" flag.

• regmap_write(stm32->regmap, TIM_PSC, prescaler);
• regmap_write(stm32->regmap, TIM_ARR, prd - 1);
• regmap_update_bits(stm32->regmap, TIM_CR1, TIM_CR1_ARPE, TIM_CR1_ARPE);
• /* Force master mode to update mode */
• regmap_update_bits(stm32->regmap, TIM_CR2, TIM_CR2_MMS, 0x20);
• /* Make sure that registers are updated */
• regmap_update_bits(stm32->regmap, TIM_EGR, TIM_EGR_UG, TIM_EGR_UG);
• /* Enable interrupt */
• regmap_write(stm32->regmap, TIM_SR, 0);
• regmap_update_bits(stm32->regmap, TIM_DIER, TIM_DIER_UIE, TIM_DIER_UIE);
• /* Enable controller */
• regmap_update_bits(stm32->regmap, TIM_CR1, TIM_CR1_CEN, TIM_CR1_CEN);
• return 0;

+}

+static int stm32_timer_stop(struct stm32_timer_trigger_dev *stm32) +{

• if (!stm32->own_timer)

• return 0;
  

• /* Stop timer */
• regmap_update_bits(stm32->regmap, TIM_DIER, TIM_DIER_UIE, 0);
• regmap_update_bits(stm32->regmap, TIM_CR1, TIM_CR1_CEN, 0);
• regmap_write(stm32->regmap, TIM_PSC, 0);
• regmap_write(stm32->regmap, TIM_ARR, 0);
• clk_disable(stm32->clk);
• stm32->own_timer = false;
• stm32->active_trigger = NULL;
• return 0;

+}

+static int stm32_set_trigger_state(struct iio_trigger *trig, bool state) +{

• struct stm32_timer_trigger_dev *stm32 = iio_trigger_get_drvdata(trig);
• stm32->active_trigger = trig;
• if (state)

• return stm32_timer_start(stm32);
  

• else

• return stm32_timer_stop(stm32);
  

+}

+static irqreturn_t stm32_timer_irq_handler(int irq, void *private) +{

• struct stm32_timer_trigger_dev *stm32 = private;
• u32 sr;
• regmap_read(stm32->regmap, TIM_SR, &sr);
• regmap_write(stm32->regmap, TIM_SR, 0);
• if ((sr & TIM_SR_UIF) && stm32->active_trigger)

• iio_trigger_poll(stm32->active_trigger);
  

• return IRQ_HANDLED;

+}

+static const struct iio_trigger_ops timer_trigger_ops = {

• .owner = THIS_MODULE,
• .set_trigger_state = stm32_set_trigger_state,

+};

+static int stm32_setup_iio_triggers(struct stm32_timer_trigger_dev *stm32) +{

• int ret;
• struct property *p;
• const char *cur = NULL;
• p = of_find_property(stm32->dev->of_node,

• 	     "st,output-triggers-names", NULL);
  

• while ((cur = of_prop_next_string(p, cur)) != NULL) {

• struct iio_trigger *trig;
  

• trig = devm_iio_trigger_alloc(stm32->dev, "%s", cur);
  

• if  (!trig)
  

• 	return -ENOMEM;
  

• trig->dev.parent = stm32->dev->parent;
  

• trig->ops = &timer_trigger_ops;
  

• trig->dev.groups = stm32_trigger_attr_groups;
  

• iio_trigger_set_drvdata(trig, stm32);
  

• ret = devm_iio_trigger_register(stm32->dev, trig);
  

• if (ret)
  

• 	return ret;
  

• }
• return 0;

+}

+/**

• • is_stm32_timer_trigger
• • @trig: trigger to be checked
• • return true if the trigger is a valid stm32 iio timer trigger
• • either return false
• */

+bool is_stm32_timer_trigger(struct iio_trigger *trig) +{

• return (trig->ops == &timer_trigger_ops);

+} +EXPORT_SYMBOL(is_stm32_timer_trigger);

+static int stm32_validate_trigger(struct iio_dev *indio_dev,

• 		  struct iio_trigger *trig)
  

+{

• struct stm32_timer_trigger_dev *dev = iio_priv(indio_dev);
• int ret;
• if (!is_stm32_timer_trigger(trig))

• return -EINVAL;
  

• ret = of_property_match_string(dev->dev->of_node,

• 		       "st,input-triggers-names",
  

• 		       trig->name);
  

• if (ret < 0)

• return ret;
  

• regmap_update_bits(dev->regmap, TIM_SMCR, TIM_SMCR_TS, ret << 4);
• return 0;

+}

+static const struct iio_info stm32_trigger_info = {

• .driver_module = THIS_MODULE,
• .validate_trigger = stm32_validate_trigger,
• .attrs = &stm32_timer_attr_group,

+};

+static struct stm32_timer_trigger_dev *stm32_setup_iio_device(struct device *dev) +{

• struct iio_dev *indio_dev;
• int ret;

• indio_dev = devm_iio_device_alloc(dev, sizeof(struct stm32_timer_trigger_dev));

Did you run checkpatch.pl?

• if (!indio_dev)

• return NULL;
  

• indio_dev->name = dev_name(dev);
• indio_dev->dev.parent = dev;
• indio_dev->info = &stm32_trigger_info;
• indio_dev->modes = INDIO_EVENT_TRIGGERED;
• indio_dev->num_channels = 0;
• indio_dev->dev.of_node = dev->of_node;
• ret = iio_triggered_event_setup(indio_dev,

• 			NULL,
  

• 			stm32_timer_irq_handler);
  

• if (ret)

• return NULL;
  

Return ERR_PTR(ret).

• ret = devm_iio_device_register(dev, indio_dev);
• if (ret) {

• iio_triggered_event_cleanup(indio_dev);
  

• return NULL;
  

Return ERR_PTR(ret).

• }
• return iio_priv(indio_dev);

+}

+static int stm32_timer_trigger_probe(struct platform_device *pdev) +{

• struct device *dev = &pdev->dev;
• struct stm32_timer_trigger_dev *stm32;
• struct stm32_gptimer_dev *mfd = dev_get_drvdata(pdev->dev.parent);
• int ret;
• stm32 = stm32_setup_iio_device(dev);
• if (!stm32)

• return -ENOMEM;
  

Return stm32.

• stm32->dev = dev;
• stm32->regmap = mfd->regmap;
• stm32->clk = mfd->clk;
• stm32->irq = platform_get_irq(pdev, 0);
• if (stm32->irq < 0)

• return -EINVAL;
  

return stm32->irq.

• ret = devm_request_irq(stm32->dev, stm32->irq,

• 	       stm32_timer_irq_handler, IRQF_SHARED,
  

• 	       "timer_event", stm32);
  

• if (ret)

• return ret;
  

• ret = stm32_setup_iio_triggers(stm32);
• if (ret)

• return ret;
  

• platform_set_drvdata(pdev, stm32);
• return 0;

+}

+static int stm32_timer_trigger_remove(struct platform_device *pdev) +{

• struct stm32_timer_trigger_dev *stm32 = platform_get_drvdata(pdev);
• iio_triggered_event_cleanup((struct iio_dev *)stm32);
• return 0;

+}

+static const struct of_device_id stm32_trig_of_match[] = {

• {

• .compatible = "st,stm32-timer-trigger",
  

• },

+};

Make this one line.

{ .compatible = "st,stm32-timer-trigger" },

+MODULE_DEVICE_TABLE(of, stm32_trig_of_match);

+static struct platform_driver stm32_timer_trigger_driver = {

• .probe = stm32_timer_trigger_probe,
• .remove = stm32_timer_trigger_remove,
• .driver = {

• .name = DRIVER_NAME,
  

Yuk!

• .of_match_table = stm32_trig_of_match,
  

• },

+}; +module_platform_driver(stm32_timer_trigger_driver);

+MODULE_ALIAS("platform:" DRIVER_NAME); +MODULE_DESCRIPTION("STMicroelectronics STM32 timer trigger driver"); +MODULE_LICENSE("GPL");

I thought this was "GPL v2"?

diff --git a/drivers/iio/trigger/Kconfig b/drivers/iio/trigger/Kconfig index 809b2e7..f2af4fe 100644 --- a/drivers/iio/trigger/Kconfig +++ b/drivers/iio/trigger/Kconfig @@ -46,5 +46,4 @@ config IIO_SYSFS_TRIGGER To compile this driver as a module, choose M here: the module will be called iio-trig-sysfs.

endmenu diff --git a/include/dt-bindings/iio/timer/st,stm32-timer-triggers.h b/include/dt-bindings/iio/timer/st,stm32-timer-triggers.h new file mode 100644 index 0000000..a13db63 --- /dev/null +++ b/include/dt-bindings/iio/timer/st,stm32-timer-triggers.h @@ -0,0 +1,60 @@ +/*

• • st,stm32-timer-triggers.h
• • Copyright (C) STMicroelectronics 2016
• • Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.
• • License terms: GNU General Public License (GPL), version 2
• */

Same comments as the top header.

+#ifndef _DT_BINDINGS_STM32_TIMER_TRIGGERS_H_ +#define _DT_BINDINGS_STM32_TIMER_TRIGGERS_H_

+#define TIM1_TRGO "tim1_trgo" +#define TIM1_CH1 "tim1_ch1" +#define TIM1_CH2 "tim1_ch2" +#define TIM1_CH3 "tim1_ch3" +#define TIM1_CH4 "tim1_ch4"

+#define TIM2_TRGO "tim2_trgo" +#define TIM2_CH1 "tim2_ch1" +#define TIM2_CH2 "tim2_ch2" +#define TIM2_CH3 "tim2_ch3" +#define TIM2_CH4 "tim2_ch4"

+#define TIM3_TRGO "tim3_trgo" +#define TIM3_CH1 "tim3_ch1" +#define TIM3_CH2 "tim3_ch2" +#define TIM3_CH3 "tim3_ch3" +#define TIM3_CH4 "tim3_ch4"

+#define TIM4_TRGO "tim4_trgo" +#define TIM4_CH1 "tim4_ch1" +#define TIM4_CH2 "tim4_ch2" +#define TIM4_CH3 "tim4_ch3" +#define TIM4_CH4 "tim4_ch4"

+#define TIM5_TRGO "tim5_trgo" +#define TIM5_CH1 "tim5_ch1" +#define TIM5_CH2 "tim5_ch2" +#define TIM5_CH3 "tim5_ch3" +#define TIM5_CH4 "tim5_ch4"

+#define TIM6_TRGO "tim6_trgo"

+#define TIM7_TRGO "tim7_trgo"

+#define TIM8_TRGO "tim8_trgo" +#define TIM8_CH1 "tim8_ch1" +#define TIM8_CH2 "tim8_ch2" +#define TIM8_CH3 "tim8_ch3" +#define TIM8_CH4 "tim8_ch4"

+#define TIM9_TRGO "tim9_trgo" +#define TIM9_CH1 "tim9_ch1" +#define TIM9_CH2 "tim9_ch2"

+#define TIM12_TRGO "tim12_trgo" +#define TIM12_CH1 "tim12_ch1" +#define TIM12_CH2 "tim12_ch2"

Grim!

uint8 valid_timers[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 12 }; uint8 valid_channels[] = { 0, 1, 2, 3, 4 };

+#endif diff --git a/include/linux/iio/timer/stm32-timer-trigger.h b/include/linux/iio/timer/stm32-timer-trigger.h new file mode 100644 index 0000000..c22fb3b --- /dev/null +++ b/include/linux/iio/timer/stm32-timer-trigger.h @@ -0,0 +1,16 @@ +/*

• • stm32-timer-trigger.h
• • Copyright (C) STMicroelectronics 2016
• • Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.
• • License terms: GNU General Public License (GPL), version 2
• */

Same comments as the top header.

+#ifndef _STM32_TIMER_TRIGGER_H_ +#define _STM32_TIMER_TRIGGER_H_

+#include <dt-bindings/iio/timer/st,stm32-timer-triggers.h>

+bool is_stm32_timer_trigger(struct iio_trigger *trig);

+#endif

On Fri, 02 Dec 2016, Benjamin Gaignard wrote:

Add general purpose timers and it sub-nodes into DT for stm32f4. Define and enable pwm1 and pwm3 for stm32f469 discovery board

version 3:

• use "st,stm32-timer-trigger" in DT

version 2:

• use parameters to describe hardware capabilities
• do not use references for pwm and iio timer subnodes

Signed-off-by: Benjamin Gaignard benjamin.gaignard@st.com

arch/arm/boot/dts/stm32f429.dtsi | 333 +++++++++++++++++++++++++++++++++- arch/arm/boot/dts/stm32f469-disco.dts | 28 +++ 2 files changed, 360 insertions(+), 1 deletion(-)

diff --git a/arch/arm/boot/dts/stm32f429.dtsi b/arch/arm/boot/dts/stm32f429.dtsi index bca491d..8c50d03 100644 --- a/arch/arm/boot/dts/stm32f429.dtsi +++ b/arch/arm/boot/dts/stm32f429.dtsi @@ -48,7 +48,7 @@ #include "skeleton.dtsi" #include "armv7-m.dtsi" #include <dt-bindings/pinctrl/stm32f429-pinfunc.h>

+#include <dt-bindings/iio/timer/st,stm32-timer-triggers.h> / { clocks { clk_hse: clk-hse { @@ -355,6 +355,21 @@ slew-rate = <2>; }; };

• 	pwm1_pins: pwm@1 {
  

• 		pins {
  

• 			pinmux = <STM32F429_PA8_FUNC_TIM1_CH1>,
  

• 				 <STM32F429_PB13_FUNC_TIM1_CH1N>,
  

• 				 <STM32F429_PB12_FUNC_TIM1_BKIN>;
  

• 		};
  

• 	};
  

• 	pwm3_pins: pwm@3 {
  

• 		pins {
  

• 			pinmux = <STM32F429_PB4_FUNC_TIM3_CH1>,
  

• 				 <STM32F429_PB5_FUNC_TIM3_CH2>;
  

• 		};
  

• 	};
  

  };

rcc: rcc@40023810 { @@ -426,6 +441,322 @@ interrupts = <80>; clocks = <&rcc 0 38>; };

• gptimer1: gptimer1@40010000 {
  

timer@xxxxxxx

Node names should be generic and not numbered.

I suggest that this isn't actually a timer either. Is contains a timer (and a PWM), but in it's completeness it is not a timer per say.

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40010000 0x400>;
  

• 	clocks = <&rcc 0 160>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm1@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <4>;
  

• 		st,breakinput;
  

• 		st,complementary;
  

• 		status = "disabled";
  

• 	};
  

• 	timer1@0 {
  

• 		compatible = "st,stm32-timer-trigger";
  

• 		interrupts = <27>;
  

• 		st,input-triggers-names = TIM5_TRGO,
  

• 					  TIM2_TRGO,
  

• 					  TIM4_TRGO,
  

• 					  TIM3_TRGO;
  

I'm still dubious with matching by strings.

I'll take a look at the C code to see what the alternatives could be.

• 		st,output-triggers-names = TIM1_TRGO,
  

• 					   TIM1_CH1,
  

• 					   TIM1_CH2,
  

• 					   TIM1_CH3,
  

• 					   TIM1_CH4;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer2: gptimer2@40000000 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40000000 0x400>;
  

• 	clocks = <&rcc 0 128>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm2@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <4>;
  

• 		st,32bits-counter;
  

• 		status = "disabled";
  

• 	};
  

• 	timer2@0 {
  

• 		compatible = "st,stm32-timer-trigger";
  

• 		interrupts = <28>;
  

• 		st,input-triggers-names = TIM1_TRGO,
  

• 					  TIM8_TRGO,
  

• 					  TIM3_TRGO,
  

• 					  TIM4_TRGO;
  

• 		st,output-triggers-names = TIM2_TRGO,
  

• 					   TIM2_CH1,
  

• 					   TIM2_CH2,
  

• 					   TIM2_CH3,
  

• 					   TIM2_CH4;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer3: gptimer3@40000400 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40000400 0x400>;
  

• 	clocks = <&rcc 0 129>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm3@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <4>;
  

• 		status = "disabled";
  

• 	};
  

• 	timer3@0 {
  

• 		compatible = "st,stm32-timer-trigger";
  

• 		interrupts = <29>;
  

• 		st,input-triggers-names = TIM1_TRGO,
  

• 					  TIM8_TRGO,
  

• 					  TIM5_TRGO,
  

• 					  TIM4_TRGO;
  

• 		st,output-triggers-names = TIM3_TRGO,
  

• 					   TIM3_CH1,
  

• 					   TIM3_CH2,
  

• 					   TIM3_CH3,
  

• 					   TIM3_CH4;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer4: gptimer4@40000800 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40000800 0x400>;
  

• 	clocks = <&rcc 0 130>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm4@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <4>;
  

• 		status = "disabled";
  

• 	};
  

• 	timer4@0 {
  

• 		compatible = "st,stm32-timer-trigger";
  

• 		interrupts = <30>;
  

• 		st,input-triggers-names = TIM1_TRGO,
  

• 					  TIM2_TRGO,
  

• 					  TIM3_TRGO,
  

• 					  TIM8_TRGO;
  

• 		st,output-triggers-names = TIM4_TRGO,
  

• 					   TIM4_CH1,
  

• 					   TIM4_CH2,
  

• 					   TIM4_CH3,
  

• 					   TIM4_CH4;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer5: gptimer5@40000C00 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40000C00 0x400>;
  

• 	clocks = <&rcc 0 131>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm5@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <4>;
  

• 		st,32bits-counter;
  

• 		status = "disabled";
  

• 	};
  

• 	timer5@0 {
  

• 		compatible = "st,stm32-timer-trigger";
  

• 		interrupts = <50>;
  

• 		st,input-triggers-names = TIM2_TRGO,
  

• 					  TIM3_TRGO,
  

• 					  TIM4_TRGO,
  

• 					  TIM8_TRGO;
  

• 		st,output-triggers-names = TIM5_TRGO,
  

• 					   TIM5_CH1,
  

• 					   TIM5_CH2,
  

• 					   TIM5_CH3,
  

• 					   TIM5_CH4;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer6: gptimer6@40001000 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40001000 0x400>;
  

• 	clocks = <&rcc 0 132>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	timer6@0 {
  

• 		compatible = "st,stm32-timer-trigger";
  

• 		interrupts = <54>;
  

• 		st,output-triggers-names = TIM6_TRGO;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer7: gptimer7@40001400 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40001400 0x400>;
  

• 	clocks = <&rcc 0 133>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	timer7@0 {
  

• 		compatible = "st,stm32-timer-trigger";
  

• 		interrupts = <55>;
  

• 		st,output-triggers-names = TIM7_TRGO;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer8: gptimer8@40010400 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40010400 0x400>;
  

• 	clocks = <&rcc 0 161>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm8@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <4>;
  

• 		st,complementary;
  

• 		st,breakinput;
  

• 		status = "disabled";
  

• 	};
  

• 	timer8@0 {
  

• 		compatible = "st,stm32-timer-trigger";
  

• 		interrupts = <46>;
  

• 		st,input-triggers-names = TIM1_TRGO,
  

• 					  TIM2_TRGO,
  

• 					  TIM4_TRGO,
  

• 					  TIM5_TRGO;
  

• 		st,output-triggers-names = TIM8_TRGO,
  

• 					   TIM8_CH1,
  

• 					   TIM8_CH2,
  

• 					   TIM8_CH3,
  

• 					   TIM8_CH4;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer9: gptimer9@40014000 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40014000 0x400>;
  

• 	clocks = <&rcc 0 176>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm9@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <2>;
  

• 		status = "disabled";
  

• 	};
  

• 	timer9@0 {
  

• 		compatible = "st,stm32-timer-trigger";
  

• 		interrupts = <24>;
  

• 		st,input-triggers-names = TIM2_TRGO,
  

• 					  TIM3_TRGO;
  

• 		st,output-triggers-names = TIM9_TRGO,
  

• 					   TIM9_CH1,
  

• 					   TIM9_CH2;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer10: gptimer10@40014400 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40014400 0x400>;
  

• 	clocks = <&rcc 0 177>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm10@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <1>;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer11: gptimer11@40014800 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40014800 0x400>;
  

• 	clocks = <&rcc 0 178>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm11@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <1>;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer12: gptimer12@40001800 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40001800 0x400>;
  

• 	clocks = <&rcc 0 134>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm12@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <2>;
  

• 		status = "disabled";
  

• 	};
  

• 	timer12@0 {
  

• 		compatible = "st,stm32-timer-trigger";
  

• 		interrupts = <43>;
  

• 		st,input-triggers-names = TIM4_TRGO,
  

• 					  TIM5_TRGO;
  

• 		st,output-triggers-names = TIM12_TRGO,
  

• 					   TIM12_CH1,
  

• 					   TIM12_CH2;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer13: gptimer13@40001C00 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40001C00 0x400>;
  

• 	clocks = <&rcc 0 135>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm13@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <1>;
  

• 		status = "disabled";
  

• 	};
  

• };
  

• gptimer14: gptimer14@40002000 {
  

• 	compatible = "st,stm32-gptimer";
  

• 	reg = <0x40002000 0x400>;
  

• 	clocks = <&rcc 0 136>;
  

• 	clock-names = "clk_int";
  

• 	status = "disabled";
  

• 	pwm14@0 {
  

• 		compatible = "st,stm32-pwm";
  

• 		st,pwm-num-chan = <1>;
  

• 		status = "disabled";
  

• 	};
  

• };
  

  };

}; diff --git a/arch/arm/boot/dts/stm32f469-disco.dts b/arch/arm/boot/dts/stm32f469-disco.dts index 8a163d7..df4ca7e 100644 --- a/arch/arm/boot/dts/stm32f469-disco.dts +++ b/arch/arm/boot/dts/stm32f469-disco.dts @@ -81,3 +81,31 @@ &usart3 { status = "okay"; };

+&gptimer1 {

• status = "okay";
• pwm1@0 {

• pinctrl-0	= <&pwm1_pins>;
  

• pinctrl-names	= "default";
  

• status = "okay";
  

• };
• timer1@0 {

• status = "okay";
  

• };

+};

This is a much *better* format than before.

I still don't like the '&' syntax though.

+&gptimer3 {

• status = "okay";
• pwm3@0 {

• pinctrl-0	= <&pwm3_pins>;
  

• pinctrl-names	= "default";
  

• status = "okay";
  

• };
• timer3@0 {

• status = "okay";
  

• };

+};