Loading...
1/*
2 * Copyright (C) 2013 Texas Instruments
3 * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 */
14
15#include <linux/device.h>
16#include <linux/err.h>
17#include <linux/module.h>
18#include <linux/of.h>
19#include <linux/seq_file.h>
20
21#include <video/omapdss.h>
22
23#include "dss.h"
24
25struct device_node *
26omapdss_of_get_next_port(const struct device_node *parent,
27 struct device_node *prev)
28{
29 struct device_node *port = NULL;
30
31 if (!parent)
32 return NULL;
33
34 if (!prev) {
35 struct device_node *ports;
36 /*
37 * It's the first call, we have to find a port subnode
38 * within this node or within an optional 'ports' node.
39 */
40 ports = of_get_child_by_name(parent, "ports");
41 if (ports)
42 parent = ports;
43
44 port = of_get_child_by_name(parent, "port");
45
46 /* release the 'ports' node */
47 of_node_put(ports);
48 } else {
49 struct device_node *ports;
50
51 ports = of_get_parent(prev);
52 if (!ports)
53 return NULL;
54
55 do {
56 port = of_get_next_child(ports, prev);
57 if (!port) {
58 of_node_put(ports);
59 return NULL;
60 }
61 prev = port;
62 } while (of_node_cmp(port->name, "port") != 0);
63
64 of_node_put(ports);
65 }
66
67 return port;
68}
69EXPORT_SYMBOL_GPL(omapdss_of_get_next_port);
70
71struct device_node *
72omapdss_of_get_next_endpoint(const struct device_node *parent,
73 struct device_node *prev)
74{
75 struct device_node *ep = NULL;
76
77 if (!parent)
78 return NULL;
79
80 do {
81 ep = of_get_next_child(parent, prev);
82 if (!ep)
83 return NULL;
84 prev = ep;
85 } while (of_node_cmp(ep->name, "endpoint") != 0);
86
87 return ep;
88}
89EXPORT_SYMBOL_GPL(omapdss_of_get_next_endpoint);
90
91struct device_node *dss_of_port_get_parent_device(struct device_node *port)
92{
93 struct device_node *np;
94 int i;
95
96 if (!port)
97 return NULL;
98
99 np = of_get_parent(port);
100
101 for (i = 0; i < 2 && np; ++i) {
102 struct property *prop;
103
104 prop = of_find_property(np, "compatible", NULL);
105
106 if (prop)
107 return np;
108
109 np = of_get_next_parent(np);
110 }
111
112 return NULL;
113}
114
115u32 dss_of_port_get_port_number(struct device_node *port)
116{
117 int r;
118 u32 reg;
119
120 r = of_property_read_u32(port, "reg", ®);
121 if (r)
122 reg = 0;
123
124 return reg;
125}
126
127static struct device_node *omapdss_of_get_remote_port(const struct device_node *node)
128{
129 struct device_node *np;
130
131 np = of_parse_phandle(node, "remote-endpoint", 0);
132 if (!np)
133 return NULL;
134
135 np = of_get_next_parent(np);
136
137 return np;
138}
139
140struct device_node *
141omapdss_of_get_first_endpoint(const struct device_node *parent)
142{
143 struct device_node *port, *ep;
144
145 port = omapdss_of_get_next_port(parent, NULL);
146
147 if (!port)
148 return NULL;
149
150 ep = omapdss_of_get_next_endpoint(port, NULL);
151
152 of_node_put(port);
153
154 return ep;
155}
156EXPORT_SYMBOL_GPL(omapdss_of_get_first_endpoint);
157
158struct omap_dss_device *
159omapdss_of_find_source_for_first_ep(struct device_node *node)
160{
161 struct device_node *ep;
162 struct device_node *src_port;
163 struct omap_dss_device *src;
164
165 ep = omapdss_of_get_first_endpoint(node);
166 if (!ep)
167 return ERR_PTR(-EINVAL);
168
169 src_port = omapdss_of_get_remote_port(ep);
170 if (!src_port) {
171 of_node_put(ep);
172 return ERR_PTR(-EINVAL);
173 }
174
175 of_node_put(ep);
176
177 src = omap_dss_find_output_by_port_node(src_port);
178
179 of_node_put(src_port);
180
181 return src ? src : ERR_PTR(-EPROBE_DEFER);
182}
183EXPORT_SYMBOL_GPL(omapdss_of_find_source_for_first_ep);
1/*
2 * Copyright (C) 2013 Texas Instruments
3 * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 */
14
15#include <linux/device.h>
16#include <linux/err.h>
17#include <linux/module.h>
18#include <linux/of.h>
19#include <linux/seq_file.h>
20
21#include "omapdss.h"
22#include "dss.h"
23
24struct device_node *
25omapdss_of_get_next_port(const struct device_node *parent,
26 struct device_node *prev)
27{
28 struct device_node *port = NULL;
29
30 if (!parent)
31 return NULL;
32
33 if (!prev) {
34 struct device_node *ports;
35 /*
36 * It's the first call, we have to find a port subnode
37 * within this node or within an optional 'ports' node.
38 */
39 ports = of_get_child_by_name(parent, "ports");
40 if (ports)
41 parent = ports;
42
43 port = of_get_child_by_name(parent, "port");
44
45 /* release the 'ports' node */
46 of_node_put(ports);
47 } else {
48 struct device_node *ports;
49
50 ports = of_get_parent(prev);
51 if (!ports)
52 return NULL;
53
54 do {
55 port = of_get_next_child(ports, prev);
56 if (!port) {
57 of_node_put(ports);
58 return NULL;
59 }
60 prev = port;
61 } while (of_node_cmp(port->name, "port") != 0);
62
63 of_node_put(ports);
64 }
65
66 return port;
67}
68EXPORT_SYMBOL_GPL(omapdss_of_get_next_port);
69
70struct device_node *
71omapdss_of_get_next_endpoint(const struct device_node *parent,
72 struct device_node *prev)
73{
74 struct device_node *ep = NULL;
75
76 if (!parent)
77 return NULL;
78
79 do {
80 ep = of_get_next_child(parent, prev);
81 if (!ep)
82 return NULL;
83 prev = ep;
84 } while (of_node_cmp(ep->name, "endpoint") != 0);
85
86 return ep;
87}
88EXPORT_SYMBOL_GPL(omapdss_of_get_next_endpoint);
89
90struct device_node *dss_of_port_get_parent_device(struct device_node *port)
91{
92 struct device_node *np;
93 int i;
94
95 if (!port)
96 return NULL;
97
98 np = of_get_parent(port);
99
100 for (i = 0; i < 2 && np; ++i) {
101 struct property *prop;
102
103 prop = of_find_property(np, "compatible", NULL);
104
105 if (prop)
106 return np;
107
108 np = of_get_next_parent(np);
109 }
110
111 return NULL;
112}
113
114u32 dss_of_port_get_port_number(struct device_node *port)
115{
116 int r;
117 u32 reg;
118
119 r = of_property_read_u32(port, "reg", ®);
120 if (r)
121 reg = 0;
122
123 return reg;
124}
125
126static struct device_node *omapdss_of_get_remote_port(const struct device_node *node)
127{
128 struct device_node *np;
129
130 np = of_parse_phandle(node, "remote-endpoint", 0);
131 if (!np)
132 return NULL;
133
134 np = of_get_next_parent(np);
135
136 return np;
137}
138
139struct device_node *
140omapdss_of_get_first_endpoint(const struct device_node *parent)
141{
142 struct device_node *port, *ep;
143
144 port = omapdss_of_get_next_port(parent, NULL);
145
146 if (!port)
147 return NULL;
148
149 ep = omapdss_of_get_next_endpoint(port, NULL);
150
151 of_node_put(port);
152
153 return ep;
154}
155EXPORT_SYMBOL_GPL(omapdss_of_get_first_endpoint);
156
157struct omap_dss_device *
158omapdss_of_find_source_for_first_ep(struct device_node *node)
159{
160 struct device_node *ep;
161 struct device_node *src_port;
162 struct omap_dss_device *src;
163
164 ep = omapdss_of_get_first_endpoint(node);
165 if (!ep)
166 return ERR_PTR(-EINVAL);
167
168 src_port = omapdss_of_get_remote_port(ep);
169 if (!src_port) {
170 of_node_put(ep);
171 return ERR_PTR(-EINVAL);
172 }
173
174 of_node_put(ep);
175
176 src = omap_dss_find_output_by_port_node(src_port);
177
178 of_node_put(src_port);
179
180 return src ? src : ERR_PTR(-EPROBE_DEFER);
181}
182EXPORT_SYMBOL_GPL(omapdss_of_find_source_for_first_ep);