1 /*
2  * Copyright (C) 2014 Traphandler
3  * Copyright (C) 2014 Free Electrons
4  * Copyright (C) 2014 Atmel
5  *
6  * Author: Jean-Jacques Hiblot <jjhiblot@traphandler.com>
7  * Author: Boris BREZILLON <boris.brezillon@free-electrons.com>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License version 2 as published by
11  * the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along with
19  * this program.  If not, see <http://www.gnu.org/licenses/>.
20  */
21 
22 #include <linux/of_graph.h>
23 
24 #include <drm/drmP.h>
25 #include <drm/drm_panel.h>
26 
27 #include "atmel_hlcdc_dc.h"
28 
29 /**
30  * Atmel HLCDC RGB connector structure
31  *
32  * This structure stores RGB slave device information.
33  *
34  * @connector: DRM connector
35  * @encoder: DRM encoder
36  * @dc: pointer to the atmel_hlcdc_dc structure
37  * @panel: panel connected on the RGB output
38  */
39 struct atmel_hlcdc_rgb_output {
40 	struct drm_connector connector;
41 	struct drm_encoder encoder;
42 	struct atmel_hlcdc_dc *dc;
43 	struct drm_panel *panel;
44 };
45 
46 static inline struct atmel_hlcdc_rgb_output *
47 drm_connector_to_atmel_hlcdc_rgb_output(struct drm_connector *connector)
48 {
49 	return container_of(connector, struct atmel_hlcdc_rgb_output,
50 			    connector);
51 }
52 
53 static inline struct atmel_hlcdc_rgb_output *
54 drm_encoder_to_atmel_hlcdc_rgb_output(struct drm_encoder *encoder)
55 {
56 	return container_of(encoder, struct atmel_hlcdc_rgb_output, encoder);
57 }
58 
59 static void atmel_hlcdc_rgb_encoder_enable(struct drm_encoder *encoder)
60 {
61 	struct atmel_hlcdc_rgb_output *rgb =
62 			drm_encoder_to_atmel_hlcdc_rgb_output(encoder);
63 
64 	if (rgb->panel) {
65 		drm_panel_prepare(rgb->panel);
66 		drm_panel_enable(rgb->panel);
67 	}
68 }
69 
70 static void atmel_hlcdc_rgb_encoder_disable(struct drm_encoder *encoder)
71 {
72 	struct atmel_hlcdc_rgb_output *rgb =
73 			drm_encoder_to_atmel_hlcdc_rgb_output(encoder);
74 
75 	if (rgb->panel) {
76 		drm_panel_disable(rgb->panel);
77 		drm_panel_unprepare(rgb->panel);
78 	}
79 }
80 
81 static const struct drm_encoder_helper_funcs atmel_hlcdc_panel_encoder_helper_funcs = {
82 	.disable = atmel_hlcdc_rgb_encoder_disable,
83 	.enable = atmel_hlcdc_rgb_encoder_enable,
84 };
85 
86 static void atmel_hlcdc_rgb_encoder_destroy(struct drm_encoder *encoder)
87 {
88 	drm_encoder_cleanup(encoder);
89 	memset(encoder, 0, sizeof(*encoder));
90 }
91 
92 static const struct drm_encoder_funcs atmel_hlcdc_panel_encoder_funcs = {
93 	.destroy = atmel_hlcdc_rgb_encoder_destroy,
94 };
95 
96 static int atmel_hlcdc_panel_get_modes(struct drm_connector *connector)
97 {
98 	struct atmel_hlcdc_rgb_output *rgb =
99 			drm_connector_to_atmel_hlcdc_rgb_output(connector);
100 
101 	if (rgb->panel)
102 		return rgb->panel->funcs->get_modes(rgb->panel);
103 
104 	return 0;
105 }
106 
107 static int atmel_hlcdc_rgb_mode_valid(struct drm_connector *connector,
108 				      struct drm_display_mode *mode)
109 {
110 	struct atmel_hlcdc_rgb_output *rgb =
111 			drm_connector_to_atmel_hlcdc_rgb_output(connector);
112 
113 	return atmel_hlcdc_dc_mode_valid(rgb->dc, mode);
114 }
115 
116 
117 
118 static struct drm_encoder *
119 atmel_hlcdc_rgb_best_encoder(struct drm_connector *connector)
120 {
121 	struct atmel_hlcdc_rgb_output *rgb =
122 			drm_connector_to_atmel_hlcdc_rgb_output(connector);
123 
124 	return &rgb->encoder;
125 }
126 
127 static const struct drm_connector_helper_funcs atmel_hlcdc_panel_connector_helper_funcs = {
128 	.get_modes = atmel_hlcdc_panel_get_modes,
129 	.mode_valid = atmel_hlcdc_rgb_mode_valid,
130 	.best_encoder = atmel_hlcdc_rgb_best_encoder,
131 };
132 
133 static enum drm_connector_status
134 atmel_hlcdc_panel_connector_detect(struct drm_connector *connector, bool force)
135 {
136 	struct atmel_hlcdc_rgb_output *rgb =
137 			drm_connector_to_atmel_hlcdc_rgb_output(connector);
138 
139 	if (rgb->panel)
140 		return connector_status_connected;
141 
142 	return connector_status_disconnected;
143 }
144 
145 static void
146 atmel_hlcdc_panel_connector_destroy(struct drm_connector *connector)
147 {
148 	struct atmel_hlcdc_rgb_output *rgb =
149 			drm_connector_to_atmel_hlcdc_rgb_output(connector);
150 
151 	if (rgb->panel)
152 		drm_panel_detach(rgb->panel);
153 
154 	drm_connector_cleanup(connector);
155 }
156 
157 static const struct drm_connector_funcs atmel_hlcdc_panel_connector_funcs = {
158 	.dpms = drm_atomic_helper_connector_dpms,
159 	.detect = atmel_hlcdc_panel_connector_detect,
160 	.fill_modes = drm_helper_probe_single_connector_modes,
161 	.destroy = atmel_hlcdc_panel_connector_destroy,
162 	.reset = drm_atomic_helper_connector_reset,
163 	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
164 	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
165 };
166 
167 static int atmel_hlcdc_check_endpoint(struct drm_device *dev,
168 				      const struct of_endpoint *ep)
169 {
170 	struct device_node *np;
171 	void *obj;
172 
173 	np = of_graph_get_remote_port_parent(ep->local_node);
174 
175 	obj = of_drm_find_panel(np);
176 	if (!obj)
177 		obj = of_drm_find_bridge(np);
178 
179 	of_node_put(np);
180 
181 	return obj ? 0 : -EPROBE_DEFER;
182 }
183 
184 static int atmel_hlcdc_attach_endpoint(struct drm_device *dev,
185 				       const struct of_endpoint *ep)
186 {
187 	struct atmel_hlcdc_dc *dc = dev->dev_private;
188 	struct atmel_hlcdc_rgb_output *output;
189 	struct device_node *np;
190 	struct drm_panel *panel;
191 	struct drm_bridge *bridge;
192 	int ret;
193 
194 	output = devm_kzalloc(dev->dev, sizeof(*output), GFP_KERNEL);
195 	if (!output)
196 		return -EINVAL;
197 
198 	output->dc = dc;
199 
200 	drm_encoder_helper_add(&output->encoder,
201 			       &atmel_hlcdc_panel_encoder_helper_funcs);
202 	ret = drm_encoder_init(dev, &output->encoder,
203 			       &atmel_hlcdc_panel_encoder_funcs,
204 			       DRM_MODE_ENCODER_NONE, NULL);
205 	if (ret)
206 		return ret;
207 
208 	output->encoder.possible_crtcs = 0x1;
209 
210 	np = of_graph_get_remote_port_parent(ep->local_node);
211 
212 	ret = -EPROBE_DEFER;
213 
214 	panel = of_drm_find_panel(np);
215 	if (panel) {
216 		of_node_put(np);
217 		output->connector.dpms = DRM_MODE_DPMS_OFF;
218 		output->connector.polled = DRM_CONNECTOR_POLL_CONNECT;
219 		drm_connector_helper_add(&output->connector,
220 				&atmel_hlcdc_panel_connector_helper_funcs);
221 		ret = drm_connector_init(dev, &output->connector,
222 					 &atmel_hlcdc_panel_connector_funcs,
223 					 DRM_MODE_CONNECTOR_Unknown);
224 		if (ret)
225 			goto err_encoder_cleanup;
226 
227 		drm_mode_connector_attach_encoder(&output->connector,
228 						  &output->encoder);
229 
230 		ret = drm_panel_attach(panel, &output->connector);
231 		if (ret) {
232 			drm_connector_cleanup(&output->connector);
233 			goto err_encoder_cleanup;
234 		}
235 
236 		output->panel = panel;
237 
238 		return 0;
239 	}
240 
241 	bridge = of_drm_find_bridge(np);
242 	of_node_put(np);
243 
244 	if (bridge) {
245 		output->encoder.bridge = bridge;
246 		bridge->encoder = &output->encoder;
247 		ret = drm_bridge_attach(dev, bridge);
248 		if (!ret)
249 			return 0;
250 	}
251 
252 err_encoder_cleanup:
253 	drm_encoder_cleanup(&output->encoder);
254 
255 	return ret;
256 }
257 
258 int atmel_hlcdc_create_outputs(struct drm_device *dev)
259 {
260 	struct device_node *ep_np = NULL;
261 	struct of_endpoint ep;
262 	int ret;
263 
264 	for_each_endpoint_of_node(dev->dev->of_node, ep_np) {
265 		ret = of_graph_parse_endpoint(ep_np, &ep);
266 		if (!ret)
267 			ret = atmel_hlcdc_check_endpoint(dev, &ep);
268 
269 		if (ret) {
270 			of_node_put(ep_np);
271 			return ret;
272 		}
273 	}
274 
275 	for_each_endpoint_of_node(dev->dev->of_node, ep_np) {
276 		ret = of_graph_parse_endpoint(ep_np, &ep);
277 		if (!ret)
278 			ret = atmel_hlcdc_attach_endpoint(dev, &ep);
279 
280 		if (ret) {
281 			of_node_put(ep_np);
282 			return ret;
283 		}
284 	}
285 
286 	return 0;
287 }
288