of: add a basic memory driver
Subsystems (3)
RFC PATCH 1/1 of: add a basic memory driver
This driver's only job is to claim and ensure that the necessary clock for memory operation on a DT-enabled machine remains enabled.
---
Hi,
I am currently facing an issue with the clock setup: a critical but unclaimed clock gets disabled as a side effect of disabling one of its children. The clock setup looks something like this:
PLL
|
------------
| |
DDR Others
|periph
The PLL clock is marked with the CLK_IGNORE_UNUSED flag, so on a normal boot it remains on, even after the unused clocks cleanup code runs. The problem occurs when someone enables "periph" and then, later on, disables
it: the framework starts disabling clocks upwards on the tree, eventually switching the PLL off (and that kills the machine, as the memory clock is shut down).
There's two possible solutions I can think of:
1) add some extra checks on the framework to not turn off clocks marked with such a flag on the non-explicit case (ie, when I'm disabling some other clock)
2) create an actual user of the DDR clock, that way it won't get disabled simply because it's being used.
I considered 1) and implemented it, but the result was not pretty. This patch is my take on 2). Please let me know what you think; all feedback is welcome :)
Cheers,
Emilio
drivers/of/Kconfig | 6 ++++++ drivers/of/Makefile | 1 + drivers/of/of_memory.c | 30 ++++++++++++++++++++++++++++++ 3 files changed, 37 insertions(+) create mode 100644 drivers/of/of_memory.c
drivers/of/Kconfig +6 -0
@@ -80,4 +80,10 @@ config OF_RESERVED_MEM help Initialization code for DMA reserved memory +config OF_MEMORY + depends on COMMON_CLK + def_bool y + help + Simple memory initialization + endmenu # OF
drivers/of/Makefile +1 -0
@@ -10,3 +10,4 @@ obj-$(CONFIG_OF_PCI) += of_pci.o obj-$(CONFIG_OF_PCI_IRQ) += of_pci_irq.o obj-$(CONFIG_OF_MTD) += of_mtd.o obj-$(CONFIG_OF_RESERVED_MEM) += of_reserved_mem.o +obj-$(CONFIG_OF_MEMORY) += of_memory.o
drivers/of/of_memory.c new file +30 -0
@@ -0,0 +1,30 @@ +/* +* Simple memory driver +*/ + +#include <linux/of.h> +#include <linux/clk.h> + +static int __init of_memory_enable (void ) +{ +struct device_node *np; +struct clk *clk; + + np =of_find_node_by_path ("/memory" ); +if (!np) { +pr_err ("no /memory on DT!\n" ); +return 0 ; + } + + clk =of_clk_get (np,0 ); +if (!IS_ERR (clk)) { +clk_prepare_enable (clk); +clk_put (clk); + } + +of_node_put (np); + +return 0 ; +} + +device_initcall (of_memory_enable);
Signature · 1 line
1.8.4
RFC PATCH 1/1 of: add a basic memory driver
Hi Emilio,
Quoted 18 lines · Emilio L?pez
This driver's only job is to claim and ensure that the necessary clock for memory operation on a DT-enabled machine remains enabled.
Signed-off-by Emilio L?pez <[email protected]>---
Hi,
I am currently facing an issue with the clock setup: a critical but unclaimed clock gets disabled as a side effect of disabling one of its children. The clock setup looks something like this:
PLL | ------------ | | DDR Others |
Quoted 8 lines
periph
The PLL clock is marked with the
CLK_IGNORE_UNUSEDflag, so on a normal boot it remains on, even after the unused clocks cleanup code runs. The problem occurs when someone enables "periph" and then, later on, disables
it: the framework starts disabling clocks upwards on the tree, eventually switching the PLL off (and that kills the machine, as the memory clock is shut down).
That looks like a bug in the clock framework. I'd expect it to at least behave in the same way when disabling the unused clocks at late startup and when going up disabling some clocks' parent later on.
Quoted 9 lines
There's two possible solutions I can think of:
1) add some extra checks on the framework to not turn off clocks marked with such a flag on the non-explicit case (ie, when I'm disabling some other clock)2) create an actual user of the DDR clock, that way it won't get disabled simply because it's being used.
I considered 1) and implemented it, but the result was not pretty.
What was not pretty about it?
Quoted 63 lines
This patch is my take on 2). Please let me know what you think; all feedback is welcome :)
Cheers,
Emilio
drivers/of/Kconfig | 6 ++++++ drivers/of/Makefile | 1 + drivers/of/of_memory.c | 30 ++++++++++++++++++++++++++++++ 3 files changed, 37 insertions(+) create mode 100644 drivers/of/of_memory.cdrivers/of/Kconfig +6
-0@@ -80,4 +80,10 @@ config OF_RESERVED_MEM help Initialization code for DMA reserved memory +config OF_MEMORY + depends on COMMON_CLK + def_bool y + help + Simple memory initialization + endmenu # OFdrivers/of/Makefile +1
-0@@ -10,3 +10,4 @@ obj-$(CONFIG_OF_PCI) += of_pci.o obj-$(CONFIG_OF_PCI_IRQ) += of_pci_irq.o obj-$(CONFIG_OF_MTD) += of_mtd.o obj-$(CONFIG_OF_RESERVED_MEM) += of_reserved_mem.o +obj-$(CONFIG_OF_MEMORY) += of_memory.odrivers/of/of_memory.c new file +20
-0@@ -0,0 +1,30 @@ +/* +* Simple memory driver +*/ + +#include <linux/of.h> +#include <linux/clk.h> + +static int __init of_memory_enable (void ) +{ +struct device_node *np; +struct clk *clk; + + np =of_find_node_by_path ("/memory" ); +if (!np) { +pr_err ("no /memory on DT!\n" ); +return 0 ; + } + + clk =of_clk_get (np,0 ); +if (!IS_ERR (clk)) {
drivers/of/of_memory.c line 30
Quoted 10 lines
drivers/of/of_memory.c new file +10
-0+clk_prepare_enable (clk); +clk_put (clk); + } + +of_node_put (np); + +return 0 ; +} + +device_initcall (of_memory_enable);
I like this idea as well. But imho, both 1 and 2 should be done. 2) is only about memory devices, while 1) is much more generic.
And fwiw, the Marvell Armada 370 is also in this case of having a gatable clock for the DDR that could potentially be disabled (but is not, since it has no other users than the DDR itself, and as such, no one ever calls clk_disable on it).
Thanks!
Maxime
Signature · 10 lines
Maxime Ripard, Free Electrons Embedded Linux, Kernel and Android engineering http://free-electrons.com -------------- next part -------------- A non-text attachment was scrubbed... Name: signature.asc Type: application/pgp-signature Size: 836 bytes Desc: Digital signature URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20130911/bfe85d37/attachment.sig>
RFC PATCH 1/1 of: add a basic memory driver
Hi Maxime,
El 11/09/13 04:54, Maxime Ripard escribi?:
Quoted 30 lines
Hi Emilio,
Quoted 18 lines · Emilio L?pez
This driver's only job is to claim and ensure that the necessary clock for memory operation on a DT-enabled machine remains enabled.
Signed-off-by Emilio L?pez <[email protected]>---
Hi,
I am currently facing an issue with the clock setup: a critical but unclaimed clock gets disabled as a side effect of disabling one of its children. The clock setup looks something like this:
PLL | ------------ | | DDR Others |Quoted 8 lines
periph
The PLL clock is marked with the
CLK_IGNORE_UNUSEDflag, so on a normal boot it remains on, even after the unused clocks cleanup code runs. The problem occurs when someone enables "periph" and then, later on, disables
it: the framework starts disabling clocks upwards on the tree, eventually switching the PLL off (and that kills the machine, as the memory clock is shut down).
Quoted 3 lines
That looks like a bug in the clock framework. I'd expect it to at least behave in the same way when disabling the unused clocks at late startup and when going up disabling some clocks' parent later on.
Yes, I kind of expected the same, and the flag description seems to imply so too:
#define CLK_IGNORE_UNUSED BIT(3) /* do not gate even if unused */
Quoted 11 lines
Quoted 9 lines
There's two possible solutions I can think of:
1) add some extra checks on the framework to not turn off clocks marked with such a flag on the non-explicit case (ie, when I'm disabling some other clock)2) create an actual user of the DDR clock, that way it won't get disabled simply because it's being used.
I considered 1) and implemented it, but the result was not pretty.
What was not pretty about it?
It required adding an extra parameter to __clk_disable/__clk_unprepare to keep track of the call's explicitness, and ignore the disable/unprepare callback on the implicit case (when __clk_disable/__clk_unprepare is called recursively) if the flag is set. This also means adding a wrapping function to at least __clk_unprepare, so as to to not break callers outside of the clk framework. Overall it felt too hacky for something that could be properly handled by the generic code if it had at least 1 user.
I would like to hear Mike's thoughts on this; maybe CLK_IGNORE_UNUSED is not what we think it should be.
Quoted 77 lines
Quoted 63 lines
This patch is my take on 2). Please let me know what you think; all feedback is welcome :)
Cheers,
Emilio
drivers/of/Kconfig | 6 ++++++ drivers/of/Makefile | 1 + drivers/of/of_memory.c | 30 ++++++++++++++++++++++++++++++ 3 files changed, 37 insertions(+)create mode 100644
drivers/of/of_memory.cdrivers/of/Kconfig +6
-0@@ -80,4 +80,10 @@ config OF_RESERVED_MEM help Initialization code for DMA reserved memory +config OF_MEMORY + depends on COMMON_CLK + def_bool y + help + Simple memory initialization + endmenu # OFdrivers/of/Makefile +1
-0@@ -10,3 +10,4 @@ obj-$(CONFIG_OF_PCI) += of_pci.o obj-$(CONFIG_OF_PCI_IRQ) += of_pci_irq.o obj-$(CONFIG_OF_MTD) += of_mtd.o obj-$(CONFIG_OF_RESERVED_MEM) += of_reserved_mem.o +obj-$(CONFIG_OF_MEMORY) += of_memory.odrivers/of/of_memory.c new file +20
-0@@ -0,0 +1,30 @@ +/* +* Simple memory driver +*/ + +#include <linux/of.h> +#include <linux/clk.h> + +static int __init of_memory_enable (void ) +{ +struct device_node *np; +struct clk *clk; + + np =of_find_node_by_path ("/memory" ); +if (!np) { +pr_err ("no /memory on DT!\n" ); +return 0 ; + } + + clk =of_clk_get (np,0 ); +if (!IS_ERR (clk)) {drivers/of/of_memory.c line 30
Quoted 10 lines
drivers/of/of_memory.c new file +10
-0+clk_prepare_enable (clk); +clk_put (clk); + } + +of_node_put (np); + +return 0 ; +} + +device_initcall (of_memory_enable);I like this idea as well. But imho, both 1 and 2 should be done. 2) is only about memory devices, while 1) is much more generic.
Quoted 4 lines
And fwiw, the Marvell Armada 370 is also in this case of having a gatable clock for the DDR that could potentially be disabled (but is not, since it has no other users than the DDR itself, and as such, no one ever calls
clk_disableon it).
Nice to know, thanks for the information :)
Cheers,
Emilio
RFC PATCH 1/1 of: add a basic memory driver
Quoting Emilio L?pez (2013-09-11 02:34:01)
Quoted 63 lines
Hi Maxime,
El 11/09/13 04:54, Maxime Ripard escribi?:
Quoted 30 lines
Hi Emilio,
Quoted 18 lines · Emilio L?pez
This driver's only job is to claim and ensure that the necessary clock for memory operation on a DT-enabled machine remains enabled.
Signed-off-by Emilio L?pez <[email protected]>---
Hi,
I am currently facing an issue with the clock setup: a critical but unclaimed clock gets disabled as a side effect of disabling one of its children. The clock setup looks something like this:
PLL | ------------ | | DDR Others |Quoted 8 lines
periph
The PLL clock is marked with the
CLK_IGNORE_UNUSEDflag, so on a normal boot it remains on, even after the unused clocks cleanup code runs. The problem occurs when someone enables "periph" and then, later on, disables
it: the framework starts disabling clocks upwards on the tree, eventually switching the PLL off (and that kills the machine, as the memory clock is shut down).Quoted 3 lines
That looks like a bug in the clock framework. I'd expect it to at least behave in the same way when disabling the unused clocks at late startup and when going up disabling some clocks' parent later on.
Yes, I kind of expected the same, and the flag description seems to imply so too:
#define CLK_IGNORE_UNUSED BIT(3) /* do not gate even if unused */Quoted 11 lines
Quoted 9 lines
There's two possible solutions I can think of:
1) add some extra checks on the framework to not turn off clocks marked with such a flag on the non-explicit case (ie, when I'm disabling some other clock)2) create an actual user of the DDR clock, that way it won't get disabled simply because it's being used.
I considered 1) and implemented it, but the result was not pretty.
What was not pretty about it?
It required adding an extra parameter to __clk_disable/__clk_unprepare to keep track of the call's explicitness, and ignore the disable/unprepare callback on the implicit case (when __clk_disable/__clk_unprepare is called recursively) if the flag is set. This also means adding a wrapping function to at least
__clk_unprepare, so as to to not break callers outside of the clk framework. Overall it felt too hacky for something that could be properly handled by the generic code if it had at least 1 user.
Quoted 2 lines
I would like to hear Mike's thoughts on this; maybe
CLK_IGNORE_UNUSEDis not what we think it should be.
CLK_IGNORE_UNUSED was only meant to solve the issue of gating unclaimed clocks during clk_disable_unused that we do not want to gate at that point in time. To that end it is doing the right thing for your platform and I don't see a bug here.
Your issue is that you have a normal clk_disable chain affecting the clock. Always the right way to do this is to have a driver claim that clock with clk_get and call clk_enable on it. That is how the clk API works. This is what your 2) approach does and is probably The Right Thing.
Alternatively a new flag could be added, CLK_ALWON. This flag should be discussed but it could do a number of things:
1) any attempts to disable a clk with this flag set will always fail silently (since clk_disable has void return type).
2) same as 1) above but the clock framework could additionally call clk_enable on it after registering the clock with the CLK_ALWON flag set
Anyways I think a new flag like CLK_ALWON should only really exist to solve this problem for clocks that do not have drivers in Linux. Since you went to the trouble of writing a small driver then I think just claiming the clock and enabling it there is the best solution.
Regards,
Mike
Quoted 88 lines
Quoted 78 lines
Quoted 64 lines
This patch is my take on 2). Please let me know what you think; all feedback is welcome :)
Cheers,
Emilio
drivers/of/Kconfig | 6 ++++++ drivers/of/Makefile | 1 + drivers/of/of_memory.c | 30 ++++++++++++++++++++++++++++++ 3 files changed, 37 insertions(+)create mode 100644
drivers/of/of_memory.cdrivers/of/Kconfig +6
-0@@ -80,4 +80,10 @@ config OF_RESERVED_MEM help Initialization code for DMA reserved memory +config OF_MEMORY + depends on COMMON_CLK + def_bool y + help + Simple memory initialization + endmenu # OFdrivers/of/Makefile +1
-0@@ -10,3 +10,4 @@ obj-$(CONFIG_OF_PCI) += of_pci.o obj-$(CONFIG_OF_PCI_IRQ) += of_pci_irq.o obj-$(CONFIG_OF_MTD) += of_mtd.o obj-$(CONFIG_OF_RESERVED_MEM) += of_reserved_mem.o +obj-$(CONFIG_OF_MEMORY) += of_memory.odrivers/of/of_memory.c new file +20
-0@@ -0,0 +1,30 @@ +/* +* Simple memory driver +*/ + +#include <linux/of.h> +#include <linux/clk.h> + +static int __init of_memory_enable (void ) +{ +struct device_node *np; +struct clk *clk; + + np =of_find_node_by_path ("/memory" ); +if (!np) { +pr_err ("no /memory on DT!\n" ); +return 0 ; + } + + clk =of_clk_get (np,0 ); +if (!IS_ERR (clk)) {drivers/of/of_memory.c line 30
Quoted 10 lines
drivers/of/of_memory.c new file +10
-0+clk_prepare_enable (clk); +clk_put (clk); + } + +of_node_put (np); + +return 0 ; +} + +device_initcall (of_memory_enable);I like this idea as well. But imho, both 1 and 2 should be done. 2) is only about memory devices, while 1) is much more generic.
Quoted 4 lines
And fwiw, the Marvell Armada 370 is also in this case of having a gatable clock for the DDR that could potentially be disabled (but is not, since it has no other users than the DDR itself, and as such, no one ever calls
clk_disableon it).Nice to know, thanks for the information :)
Cheers,
Emilio
RFC PATCH 1/1 of: add a basic memory driver
In reply to Emilio LópezQuoted 12 lines · Emilio L?pez
This driver's only job is to claim and ensure that the necessary clock for memory operation on a DT-enabled machine remains enabled.
Signed-off-by Emilio L?pez <[email protected]>---
Hi,
I am currently facing an issue with the clock setup: a critical but unclaimed clock gets disabled as a side effect of disabling one of its children. The clock setup looks something like this:
Quoted 7 lines
PLL | ------------ | | DDR Others |periph
This would be more accurate:
PLL
|
----------------
| |
DDR Ctrlr Others
|DDR
So having a DDR controller node with a clock is the right way to do this. There are other possible needs for describing the DDR controller such as low power modes and ECC.
Rob
Quoted 90 lines
The PLL clock is marked with the
CLK_IGNORE_UNUSEDflag, so on a normal boot it remains on, even after the unused clocks cleanup code runs. The problem occurs when someone enables "periph" and then, later on, disables
it: the framework starts disabling clocks upwards on the tree, eventually switching the PLL off (and that kills the machine, as the memory clock is shut down).There's two possible solutions I can think of:
1) add some extra checks on the framework to not turn off clocks marked with such a flag on the non-explicit case (ie, when I'm disabling some other clock)
2) create an actual user of the DDR clock, that way it won't get disabled simply because it's being used.I considered 1) and implemented it, but the result was not pretty. This patch is my take on 2). Please let me know what you think; all feedback is welcome :)
Cheers,
Emilio
drivers/of/Kconfig | 6 ++++++ drivers/of/Makefile | 1 + drivers/of/of_memory.c | 30 ++++++++++++++++++++++++++++++ 3 files changed, 37 insertions(+) create mode 100644 drivers/of/of_memory.cdrivers/of/Kconfig +6
-0@@ -80,4 +80,10 @@ config OF_RESERVED_MEM help Initialization code for DMA reserved memory +config OF_MEMORY + depends on COMMON_CLK + def_bool y + help + Simple memory initialization + endmenu # OFdrivers/of/Makefile +1
-0@@ -10,3 +10,4 @@ obj-$(CONFIG_OF_PCI) += of_pci.o obj-$(CONFIG_OF_PCI_IRQ) += of_pci_irq.o obj-$(CONFIG_OF_MTD) += of_mtd.o obj-$(CONFIG_OF_RESERVED_MEM) += of_reserved_mem.o +obj-$(CONFIG_OF_MEMORY) += of_memory.odrivers/of/of_memory.c new file +30
-0@@ -0,0 +1,30 @@ +/* +* Simple memory driver +*/ + +#include <linux/of.h> +#include <linux/clk.h> + +static int __init of_memory_enable (void ) +{ +struct device_node *np; +struct clk *clk; + + np =of_find_node_by_path ("/memory" ); +if (!np) { +pr_err ("no /memory on DT!\n" ); +return 0 ; + } + + clk =of_clk_get (np,0 ); +if (!IS_ERR (clk)) { +clk_prepare_enable (clk); +clk_put (clk); + } + +of_node_put (np); + +return 0 ; +} + +device_initcall (of_memory_enable);
PATCH 1/1 memory: add a basic OF-based memory driver
In reply to Emilio LópezThis driver's only job is to claim and ensure the necessary clock for memory operation on a DT-powered machine remains enabled.
---
I believe this new patch should resolve all the concerns raised; as always, all feedback is welcome :)
Changes from RFC:
- Move from drivers/of to drivers/memory
- Make a proper driver instead of using an initcall
- Binding document for the new "simple-memory-controller"
.../simple-memory-controller.txt | 19 ++++++++ drivers/memory/Kconfig | 11 +++++ drivers/memory/Makefile | 1 + drivers/memory/simple-mc.c | 57 ++++++++++++++++++++++ 4 files changed, 88 insertions(+) create mode 100644 Documentation/devicetree/bindings/memory-controllers/simple-memory-controller.txt create mode 100644 drivers/memory/simple-mc.c
Documentation/devicetree/bindings/memory-controllers/simple-memory-controller.txt new file +19 -0
@@ -0,0 +1,19 @@ +Device Tree Clock binding for a simple memory controller. + +Required properties: +- compatible : shall be "simple-memory-controller" + +Optional properties: +- reg : may contain the register space for the controller. This + property is currently ignored by the driver +- clocks : may contain a phandle to the clock that is currently being + used on the controller. This clock shall remain enabled + during system operation. + +Example: + +mc: mc at 0123000 { + compatible = "simple-memory-controller"; + reg = <0x0123000 0x400>; + clocks = <&pll5 1>; +};
drivers/memory/Kconfig +11 -0
@@ -50,4 +50,15 @@ config TEGRA30_MC analysis, especially for IOMMU/SMMU(System Memory Management Unit) module. +config SIMPLE_MC + bool "Simple memory controller" + default y + depends on OF && COMMON_CLK + help + This driver is able to manage a simple memory controller whose + only needs consist of keeping one clock enabled. The + controller must be defined on the device tree as compatible + with "simple-memory-controller"; see the corresponding binding + document for more details. + endif
drivers/memory/Makefile +1 -0
@@ -9,3 +9,4 @@ obj-$(CONFIG_TI_EMIF) += emif.o obj-$(CONFIG_MVEBU_DEVBUS) += mvebu-devbus.o obj-$(CONFIG_TEGRA20_MC) += tegra20-mc.o obj-$(CONFIG_TEGRA30_MC) += tegra30-mc.o +obj-$(CONFIG_SIMPLE_MC) += simple-mc.o
drivers/memory/simple-mc.c new file +57 -0
57 lines not on this page · raw message
Signature · 1 line
1.8.4
Re: [PATCH] memory: add a basic OF-based memory driver
Quoted 8 lines · Emilio L?pez
This driver's only job is to claim and ensure the necessary clock for memory operation on a DT-powered machine remains enabled.
Signed-off-by Emilio L?pez <[email protected]>---
I believe this new patch should resolve all the concerns raised; as always, all feedback is welcome :)
I think you're going about this the wrong way.
If you have a problem with a clock not staying on, shouldn't you just marking it appropriately in the clock table instead, making sure it's initialized with at least one reference to it? I believe that is how some of the other platforms handle this, and it's a lot cleaner than adding a fake binding and a fake driver just to grab a single clock.
-Olof
Re: [PATCH] memory: add a basic OF-based memory driver
Hi Olof,
El 12/09/13 21:57, Olof Johansson escribi?:
Quoted 7 lines · Emilio L?pez
Quoted 6 lines
This driver's only job is to claim and ensure the necessary clock for memory operation on a DT-powered machine remains enabled.
Signed-off-by Emilio L?pez <[email protected]>---
Quoted 8 lines
Quoted 2 lines
I believe this new patch should resolve all the concerns raised; as always, all feedback is welcome :)
I think you're going about this the wrong way.
If you have a problem with a clock not staying on, shouldn't you just marking it appropriately in the clock table instead, making sure it's initialized with at least one reference to it?
If by "the clock table" you mean the tree as handled by the common clock framework, there is no such flag available as of today; see Mike's reply for more information.
Personally I feel that if the general case can solve our problems (in this case, having a consumer who prepares and enables the clock), we should avoid adding special cases to the framework.
Quoted 3 lines
I believe that is how
some of the other platforms handle this, and it's a lot cleaner than adding a fake binding and a fake driver just to grab a single clock.
The binding doesn't have to be fake; it is actually describing the memory controller hardware:
mc: mc at 0123000 {
compatible = "simple-memory-controller";
reg = <0x0123000 0x400>;
clocks = <&pll5 1>;
};If one day we get docs and/or have any special features we may need from the controller, we can use something like
mc: mc at 0123000 {
compatible = "vendor,awesome-mc", "simple-memory-controller";
reg = <0x0123000 0x400>;
clocks = <&pll5 1>;
};Cheers,
Emilio
Re: [PATCH] memory: add a basic OF-based memory driver
Quoted 47 lines · Emilio L?pez
Hi Olof,
El 12/09/13 21:57, Olof Johansson escribi?:
Quoted 13 lines
Quoted 9 lines · Emilio L?pez
This driver's only job is to claim and ensure the necessary clock for memory operation on a DT-powered machine remains enabled.
Signed-off-by Emilio L?pez <[email protected]>---
I believe this new patch should resolve all the concerns raised; as always, all feedback is welcome :)
Quoted 5 lines
I think you're going about this the wrong way.
If you have a problem with a clock not staying on, shouldn't you just marking it appropriately in the clock table instead, making sure it's initialized with at least one reference to it?
If by "the clock table" you mean the tree as handled by the common clock framework, there is no such flag available as of today; see Mike's reply for more information.
Personally I feel that if the general case can solve our problems (in this case, having a consumer who prepares and enables the clock), we should avoid adding special cases to the framework.
Quoted 3 lines
I believe that is how
some of the other platforms handle this, and it's a lot cleaner than adding a fake binding and a fake driver just to grab a single clock.The binding doesn't have to be fake; it is actually describing the memory controller hardware:
mc: mc at 0123000 { compatible = "simple-memory-controller"; reg = <0x0123000 0x400>; clocks = <&pll5 1>; };
Quoted 8 lines
If one day we get docs and/or have any special features we may need from the controller, we can use something like
mc: mc at 0123000 { compatible = "vendor,awesome-mc", "simple-memory-controller"; reg = <0x0123000 0x400>; clocks = <&pll5 1>; };
Better, but this is still wrong. DT describes the hardware. There is no such h/w as a simple-memory-controller. The fact that you have a simple-memory-ctrlr kernel driver is a kernel feature/artifact/limitation. Describe the h/w with a meaningful compatible string and put that string in the simple memory controller driver match table. If someday we have a real driver for said memory controller, then it is only a kernel change to use a different driver.
Rob
Re: [PATCH] memory: add a basic OF-based memory driver
Quoted 57 lines · Rob Herring
Quoted 47 lines · Emilio L?pez
Hi Olof,
El 12/09/13 21:57, Olof Johansson escribi?:
Quoted 13 lines
Quoted 9 lines · Emilio L?pez
This driver's only job is to claim and ensure the necessary clock for memory operation on a DT-powered machine remains enabled.
Signed-off-by Emilio L?pez <[email protected]>---
I believe this new patch should resolve all the concerns raised; as always, all feedback is welcome :)
Quoted 5 lines
I think you're going about this the wrong way.
If you have a problem with a clock not staying on, shouldn't you just marking it appropriately in the clock table instead, making sure it's initialized with at least one reference to it?
If by "the clock table" you mean the tree as handled by the common clock framework, there is no such flag available as of today; see Mike's reply for more information.
Personally I feel that if the general case can solve our problems (in this case, having a consumer who prepares and enables the clock), we should avoid adding special cases to the framework.
Quoted 3 lines
I believe that is how
some of the other platforms handle this, and it's a lot cleaner than adding a fake binding and a fake driver just to grab a single clock.The binding doesn't have to be fake; it is actually describing the memory controller hardware:
mc: mc at 0123000 { compatible = "simple-memory-controller"; reg = <0x0123000 0x400>; clocks = <&pll5 1>; };Quoted 8 lines
If one day we get docs and/or have any special features we may need from the controller, we can use something like
mc: mc at 0123000 { compatible = "vendor,awesome-mc", "simple-memory-controller"; reg = <0x0123000 0x400>; clocks = <&pll5 1>; };
Quoted 7 lines
Better, but this is still wrong. DT describes the hardware. There is no such h/w as a simple-memory-controller. The fact that you have a simple-memory-ctrlr kernel driver is a kernel feature/artifact/limitation. Describe the h/w with a meaningful compatible string and put that string in the simple memory controller driver match table. If someday we have a real driver for said memory controller, then it is only a kernel change to use a different driver.
We discussed this over IRC last night -- I still think it makes more sense to make the clock driver for sunxi aware of this and just add a reference to the clock at init time.
This is never going to differ from board to board (today the clock name is the same on all sunxi platforms -- pll5_ddr. And the need will likewise be there for all platforms at this time.
If and when it changes in the future, we can reevaluate. But this doesn't have to be driven by device tree at this time, it seems to just make things overly complicated and contrived.
-Olof
PATCH 1/1 memory: add a basic OF-based memory driver
Quoted 71 lines · Olof Johansson
Quoted 57 lines · Rob Herring
Quoted 47 lines · Emilio L??pez
Hi Olof,
El 12/09/13 21:57, Olof Johansson escribi??:
Quoted 13 lines
Quoted 9 lines · Emilio L??pez
This driver's only job is to claim and ensure the necessary clock for memory operation on a DT-powered machine remains enabled.
Signed-off-by Emilio L??pez <[email protected]>---
I believe this new patch should resolve all the concerns raised; as always, all feedback is welcome :)
Quoted 5 lines
I think you're going about this the wrong way.
If you have a problem with a clock not staying on, shouldn't you just marking it appropriately in the clock table instead, making sure it's initialized with at least one reference to it?
If by "the clock table" you mean the tree as handled by the common clock framework, there is no such flag available as of today; see Mike's reply for more information.
Personally I feel that if the general case can solve our problems (in this case, having a consumer who prepares and enables the clock), we should avoid adding special cases to the framework.
Quoted 3 lines
I believe that is how
some of the other platforms handle this, and it's a lot cleaner than adding a fake binding and a fake driver just to grab a single clock.The binding doesn't have to be fake; it is actually describing the memory controller hardware:
mc: mc at 0123000 { compatible = "simple-memory-controller"; reg = <0x0123000 0x400>; clocks = <&pll5 1>; };Quoted 8 lines
If one day we get docs and/or have any special features we may need from the controller, we can use something like
mc: mc at 0123000 { compatible = "vendor,awesome-mc", "simple-memory-controller"; reg = <0x0123000 0x400>; clocks = <&pll5 1>; };Quoted 7 lines
Better, but this is still wrong. DT describes the hardware. There is no such h/w as a simple-memory-controller. The fact that you have a simple-memory-ctrlr kernel driver is a kernel feature/artifact/limitation. Describe the h/w with a meaningful compatible string and put that string in the simple memory controller driver match table. If someday we have a real driver for said memory controller, then it is only a kernel change to use a different driver.
We discussed this over IRC last night -- I still think it makes more sense to make the clock driver for sunxi aware of this and just add a reference to the clock at init time.
Quoted 7 lines
This is never going to differ from board to board (today the clock name is the same on all sunxi platforms --
pll5_ddr. And the need will likewise be there for all platforms at this time.If and when it changes in the future, we can reevaluate. But this doesn't have to be driven by device tree at this time, it seems to just make things overly complicated and contrived.
I agree. Creating a new platform driver + device tree binding just to claim a clock that must not be disables does not look like the right approach to me either.
g.
Re: [PATCH] memory: add a basic OF-based memory driver
Quoted 3 lines · Grant Likely
Quoted 2 lines · Olof Johansson
Quoted 1 line · Rob Herring
On Thu, Sep 12, 2013 at 8:31 PM, Emilio L?pez <[email protected]> wrote:
[snip]
Quoted 17 lines
Quoted 17 lines
Quoted 7 lines
Better, but this is still wrong. DT describes the hardware. There is no such h/w as a simple-memory-controller. The fact that you have a simple-memory-ctrlr kernel driver is a kernel feature/artifact/limitation. Describe the h/w with a meaningful compatible string and put that string in the simple memory controller driver match table. If someday we have a real driver for said memory controller, then it is only a kernel change to use a different driver.
We discussed this over IRC last night -- I still think it makes more sense to make the clock driver for sunxi aware of this and just add a reference to the clock at init time.
This is never going to differ from board to board (today the clock name is the same on all sunxi platforms --
pll5_ddr. And the need will likewise be there for all platforms at this time.
Quoted 7 lines
Quoted 3 lines
If and when it changes in the future, we can reevaluate. But this doesn't have to be driven by device tree at this time, it seems to just make things overly complicated and contrived.
I agree. Creating a new platform driver + device tree binding just to claim a clock that must not be disables does not look like the right approach to me either.
Maybe a driver is overkill, but fully describing the h/w would be a good thing. Only defining the h/w that Linux currently uses is not a good practice (although admittedly hard to avoid).
Rob