dm: core: add a function to decode display timings

The patch adds a function to get display timings from the device tree
node attached to the device.

Signed-off-by: Dario Binacchi <dariobin@libero.it>
Reviewed-by: Simon Glass <sjg@chromium.org>

diff --git a/arch/sandbox/dts/test.dts b/arch/sandbox/dts/test.dts
index efc440a1f8a68b9a32a7fc4bb50e82d39eb0890d..f86cd0d3b27720e7cb0c245dd18691fa394a8cf8 100644 (file)
--- a/arch/sandbox/dts/test.dts
+++ b/arch/sandbox/dts/test.dts
@@ -142,6 +142,52 @@
                               <&muxcontroller1>;
                mux-control-names = "mux0", "mux1", "mux2", "mux3", "mux4";
                mux-syscon = <&syscon3>;
+               display-timings {
+                       timing0: 240x320 {
+                               clock-frequency = <6500000>;
+                               hactive = <240>;
+                               vactive = <320>;
+                               hfront-porch = <6>;
+                               hback-porch = <7>;
+                               hsync-len = <1>;
+                               vback-porch = <5>;
+                               vfront-porch = <8>;
+                               vsync-len = <2>;
+                               hsync-active = <1>;
+                               vsync-active = <0>;
+                               de-active = <1>;
+                               pixelclk-active = <1>;
+                               interlaced;
+                               doublescan;
+                               doubleclk;
+                       };
+                       timing1: 480x800 {
+                               clock-frequency = <9000000>;
+                               hactive = <480>;
+                               vactive = <800>;
+                               hfront-porch = <10>;
+                               hback-porch = <59>;
+                               hsync-len = <12>;
+                               vback-porch = <15>;
+                               vfront-porch = <17>;
+                               vsync-len = <16>;
+                               hsync-active = <0>;
+                               vsync-active = <1>;
+                               de-active = <0>;
+                               pixelclk-active = <0>;
+                       };
+                       timing2: 800x480 {
+                               clock-frequency = <33500000>;
+                               hactive = <800>;
+                               vactive = <480>;
+                               hback-porch = <89>;
+                               hfront-porch = <164>;
+                               vback-porch = <23>;
+                               vfront-porch = <10>;
+                               hsync-len = <11>;
+                               vsync-len = <13>;
+                       };
+               };
        };
 
        junk {

diff --git a/drivers/core/read.c b/drivers/core/read.c
index fc74d64814f8af62655084d56eef1448a9ce263c..4d9b5dd03842ecb09ca5b47018481f429a6fa4ab 100644 (file)
--- a/drivers/core/read.c
+++ b/drivers/core/read.c
@@ -379,3 +379,9 @@ int dev_read_pci_bus_range(const struct udevice *dev,
 
        return 0;
 }
+
+int dev_decode_display_timing(const struct udevice *dev, int index,
+                             struct display_timing *config)
+{
+       return ofnode_decode_display_timing(dev_ofnode(dev), index, config);
+}

diff --git a/include/dm/read.h b/include/dm/read.h
index fc987f775986f6c61a701de479558730759cf495..c875e11a1324ecb8acc58628e0c5faf8dae9e373 100644 (file)
--- a/include/dm/read.h
+++ b/include/dm/read.h
@@ -678,6 +678,23 @@ int dev_get_child_count(const struct udevice *dev);
  */
 int dev_read_pci_bus_range(const struct udevice *dev, struct resource *res);
 
+/**
+ * dev_decode_display_timing() - decode display timings
+ *
+ * Decode display timings from the supplied 'display-timings' node.
+ * See doc/device-tree-bindings/video/display-timing.txt for binding
+ * information.
+ *
+ * @dev: device to read DT display timings from. The node linked to the device
+ *       contains a child node called 'display-timings' which in turn contains
+ *       one or more display timing nodes.
+ * @index: index number to read (0=first timing subnode)
+ * @config: place to put timings
+ * @return 0 if OK, -FDT_ERR_NOTFOUND if not found
+ */
+int dev_decode_display_timing(const struct udevice *dev, int index,
+                             struct display_timing *config);
+
 #else /* CONFIG_DM_DEV_READ_INLINE is enabled */
 
 static inline int dev_read_u32(const struct udevice *dev,
@@ -1000,6 +1017,13 @@ static inline int dev_get_child_count(const struct udevice *dev)
        return ofnode_get_child_count(dev_ofnode(dev));
 }
 
+static inline int dev_decode_display_timing(const struct udevice *dev,
+                                           int index,
+                                           struct display_timing *config)
+{
+       return ofnode_decode_display_timing(dev_ofnode(dev), index, config);
+}
+
 #endif /* CONFIG_DM_DEV_READ_INLINE */
 
 /**

diff --git a/test/dm/test-fdt.c b/test/dm/test-fdt.c
index 31fb6663a25e32c90a9c6d571f917f9d0de485b0..b5ac9bba24eb63f31478048ddd18dab997d6df1f 100644 (file)
--- a/test/dm/test-fdt.c
+++ b/test/dm/test-fdt.c
@@ -1152,3 +1152,83 @@ static int dm_test_ofdata_order(struct unit_test_state *uts)
        return 0;
 }
 DM_TEST(dm_test_ofdata_order, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
+
+/* Test dev_decode_display_timing() */
+static int dm_test_decode_display_timing(struct unit_test_state *uts)
+{
+       struct udevice *dev;
+       struct display_timing timing;
+
+       ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
+       ut_asserteq_str("a-test", dev->name);
+
+       ut_assertok(dev_decode_display_timing(dev, 0, &timing));
+       ut_assert(timing.hactive.typ == 240);
+       ut_assert(timing.hback_porch.typ == 7);
+       ut_assert(timing.hfront_porch.typ == 6);
+       ut_assert(timing.hsync_len.typ == 1);
+       ut_assert(timing.vactive.typ == 320);
+       ut_assert(timing.vback_porch.typ == 5);
+       ut_assert(timing.vfront_porch.typ == 8);
+       ut_assert(timing.vsync_len.typ == 2);
+       ut_assert(timing.pixelclock.typ == 6500000);
+       ut_assert(timing.flags & DISPLAY_FLAGS_HSYNC_HIGH);
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_HSYNC_LOW));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_VSYNC_HIGH));
+       ut_assert(timing.flags & DISPLAY_FLAGS_VSYNC_LOW);
+       ut_assert(timing.flags & DISPLAY_FLAGS_DE_HIGH);
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_DE_LOW));
+       ut_assert(timing.flags & DISPLAY_FLAGS_PIXDATA_POSEDGE);
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_PIXDATA_NEGEDGE));
+       ut_assert(timing.flags & DISPLAY_FLAGS_INTERLACED);
+       ut_assert(timing.flags & DISPLAY_FLAGS_DOUBLESCAN);
+       ut_assert(timing.flags & DISPLAY_FLAGS_DOUBLECLK);
+
+       ut_assertok(dev_decode_display_timing(dev, 1, &timing));
+       ut_assert(timing.hactive.typ == 480);
+       ut_assert(timing.hback_porch.typ == 59);
+       ut_assert(timing.hfront_porch.typ == 10);
+       ut_assert(timing.hsync_len.typ == 12);
+       ut_assert(timing.vactive.typ == 800);
+       ut_assert(timing.vback_porch.typ == 15);
+       ut_assert(timing.vfront_porch.typ == 17);
+       ut_assert(timing.vsync_len.typ == 16);
+       ut_assert(timing.pixelclock.typ == 9000000);
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_HSYNC_HIGH));
+       ut_assert(timing.flags & DISPLAY_FLAGS_HSYNC_LOW);
+       ut_assert(timing.flags & DISPLAY_FLAGS_VSYNC_HIGH);
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_VSYNC_LOW));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_DE_HIGH));
+       ut_assert(timing.flags & DISPLAY_FLAGS_DE_LOW);
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_PIXDATA_POSEDGE));
+       ut_assert(timing.flags & DISPLAY_FLAGS_PIXDATA_NEGEDGE);
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_INTERLACED));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_DOUBLESCAN));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_DOUBLECLK));
+
+       ut_assertok(dev_decode_display_timing(dev, 2, &timing));
+       ut_assert(timing.hactive.typ == 800);
+       ut_assert(timing.hback_porch.typ == 89);
+       ut_assert(timing.hfront_porch.typ == 164);
+       ut_assert(timing.hsync_len.typ == 11);
+       ut_assert(timing.vactive.typ == 480);
+       ut_assert(timing.vback_porch.typ == 23);
+       ut_assert(timing.vfront_porch.typ == 10);
+       ut_assert(timing.vsync_len.typ == 13);
+       ut_assert(timing.pixelclock.typ == 33500000);
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_HSYNC_HIGH));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_HSYNC_LOW));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_VSYNC_HIGH));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_VSYNC_LOW));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_DE_HIGH));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_DE_LOW));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_PIXDATA_POSEDGE));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_PIXDATA_NEGEDGE));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_INTERLACED));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_DOUBLESCAN));
+       ut_assert(!(timing.flags & DISPLAY_FLAGS_DOUBLECLK));
+
+       ut_assert(dev_decode_display_timing(dev, 3, &timing));
+       return 0;
+}
+DM_TEST(dm_test_decode_display_timing, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);