xref: /openbmc/linux/drivers/gpu/drm/sun4i/sun4i_rgb.c (revision a36954f5)
1 /*
2  * Copyright (C) 2015 Free Electrons
3  * Copyright (C) 2015 NextThing Co
4  *
5  * Maxime Ripard <maxime.ripard@free-electrons.com>
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License as
9  * published by the Free Software Foundation; either version 2 of
10  * the License, or (at your option) any later version.
11  */
12 
13 #include <linux/clk.h>
14 
15 #include <drm/drmP.h>
16 #include <drm/drm_atomic_helper.h>
17 #include <drm/drm_crtc_helper.h>
18 #include <drm/drm_of.h>
19 #include <drm/drm_panel.h>
20 
21 #include "sun4i_crtc.h"
22 #include "sun4i_tcon.h"
23 #include "sun4i_rgb.h"
24 
25 struct sun4i_rgb {
26 	struct drm_connector	connector;
27 	struct drm_encoder	encoder;
28 
29 	struct sun4i_tcon	*tcon;
30 };
31 
32 static inline struct sun4i_rgb *
33 drm_connector_to_sun4i_rgb(struct drm_connector *connector)
34 {
35 	return container_of(connector, struct sun4i_rgb,
36 			    connector);
37 }
38 
39 static inline struct sun4i_rgb *
40 drm_encoder_to_sun4i_rgb(struct drm_encoder *encoder)
41 {
42 	return container_of(encoder, struct sun4i_rgb,
43 			    encoder);
44 }
45 
46 static int sun4i_rgb_get_modes(struct drm_connector *connector)
47 {
48 	struct sun4i_rgb *rgb =
49 		drm_connector_to_sun4i_rgb(connector);
50 	struct sun4i_tcon *tcon = rgb->tcon;
51 
52 	return drm_panel_get_modes(tcon->panel);
53 }
54 
55 static int sun4i_rgb_mode_valid(struct drm_connector *connector,
56 				struct drm_display_mode *mode)
57 {
58 	struct sun4i_rgb *rgb = drm_connector_to_sun4i_rgb(connector);
59 	struct sun4i_tcon *tcon = rgb->tcon;
60 	u32 hsync = mode->hsync_end - mode->hsync_start;
61 	u32 vsync = mode->vsync_end - mode->vsync_start;
62 	unsigned long rate = mode->clock * 1000;
63 	long rounded_rate;
64 
65 	DRM_DEBUG_DRIVER("Validating modes...\n");
66 
67 	if (hsync < 1)
68 		return MODE_HSYNC_NARROW;
69 
70 	if (hsync > 0x3ff)
71 		return MODE_HSYNC_WIDE;
72 
73 	if ((mode->hdisplay < 1) || (mode->htotal < 1))
74 		return MODE_H_ILLEGAL;
75 
76 	if ((mode->hdisplay > 0x7ff) || (mode->htotal > 0xfff))
77 		return MODE_BAD_HVALUE;
78 
79 	DRM_DEBUG_DRIVER("Horizontal parameters OK\n");
80 
81 	if (vsync < 1)
82 		return MODE_VSYNC_NARROW;
83 
84 	if (vsync > 0x3ff)
85 		return MODE_VSYNC_WIDE;
86 
87 	if ((mode->vdisplay < 1) || (mode->vtotal < 1))
88 		return MODE_V_ILLEGAL;
89 
90 	if ((mode->vdisplay > 0x7ff) || (mode->vtotal > 0xfff))
91 		return MODE_BAD_VVALUE;
92 
93 	DRM_DEBUG_DRIVER("Vertical parameters OK\n");
94 
95 	rounded_rate = clk_round_rate(tcon->dclk, rate);
96 	if (rounded_rate < rate)
97 		return MODE_CLOCK_LOW;
98 
99 	if (rounded_rate > rate)
100 		return MODE_CLOCK_HIGH;
101 
102 	DRM_DEBUG_DRIVER("Clock rate OK\n");
103 
104 	return MODE_OK;
105 }
106 
107 static struct drm_connector_helper_funcs sun4i_rgb_con_helper_funcs = {
108 	.get_modes	= sun4i_rgb_get_modes,
109 	.mode_valid	= sun4i_rgb_mode_valid,
110 };
111 
112 static void
113 sun4i_rgb_connector_destroy(struct drm_connector *connector)
114 {
115 	struct sun4i_rgb *rgb = drm_connector_to_sun4i_rgb(connector);
116 	struct sun4i_tcon *tcon = rgb->tcon;
117 
118 	drm_panel_detach(tcon->panel);
119 	drm_connector_cleanup(connector);
120 }
121 
122 static struct drm_connector_funcs sun4i_rgb_con_funcs = {
123 	.dpms			= drm_atomic_helper_connector_dpms,
124 	.fill_modes		= drm_helper_probe_single_connector_modes,
125 	.destroy		= sun4i_rgb_connector_destroy,
126 	.reset			= drm_atomic_helper_connector_reset,
127 	.atomic_duplicate_state	= drm_atomic_helper_connector_duplicate_state,
128 	.atomic_destroy_state	= drm_atomic_helper_connector_destroy_state,
129 };
130 
131 static int sun4i_rgb_atomic_check(struct drm_encoder *encoder,
132 				  struct drm_crtc_state *crtc_state,
133 				  struct drm_connector_state *conn_state)
134 {
135 	return 0;
136 }
137 
138 static void sun4i_rgb_encoder_enable(struct drm_encoder *encoder)
139 {
140 	struct sun4i_rgb *rgb = drm_encoder_to_sun4i_rgb(encoder);
141 	struct sun4i_tcon *tcon = rgb->tcon;
142 
143 	DRM_DEBUG_DRIVER("Enabling RGB output\n");
144 
145 	if (!IS_ERR(tcon->panel))
146 		drm_panel_prepare(tcon->panel);
147 
148 	sun4i_tcon_channel_enable(tcon, 0);
149 
150 	if (!IS_ERR(tcon->panel))
151 		drm_panel_enable(tcon->panel);
152 }
153 
154 static void sun4i_rgb_encoder_disable(struct drm_encoder *encoder)
155 {
156 	struct sun4i_rgb *rgb = drm_encoder_to_sun4i_rgb(encoder);
157 	struct sun4i_tcon *tcon = rgb->tcon;
158 
159 	DRM_DEBUG_DRIVER("Disabling RGB output\n");
160 
161 	if (!IS_ERR(tcon->panel))
162 		drm_panel_disable(tcon->panel);
163 
164 	sun4i_tcon_channel_disable(tcon, 0);
165 
166 	if (!IS_ERR(tcon->panel))
167 		drm_panel_unprepare(tcon->panel);
168 }
169 
170 static void sun4i_rgb_encoder_mode_set(struct drm_encoder *encoder,
171 				       struct drm_display_mode *mode,
172 				       struct drm_display_mode *adjusted_mode)
173 {
174 	struct sun4i_rgb *rgb = drm_encoder_to_sun4i_rgb(encoder);
175 	struct sun4i_tcon *tcon = rgb->tcon;
176 
177 	sun4i_tcon0_mode_set(tcon, mode);
178 
179 	clk_set_rate(tcon->dclk, mode->crtc_clock * 1000);
180 
181 	/* FIXME: This seems to be board specific */
182 	clk_set_phase(tcon->dclk, 120);
183 }
184 
185 static struct drm_encoder_helper_funcs sun4i_rgb_enc_helper_funcs = {
186 	.atomic_check	= sun4i_rgb_atomic_check,
187 	.mode_set	= sun4i_rgb_encoder_mode_set,
188 	.disable	= sun4i_rgb_encoder_disable,
189 	.enable		= sun4i_rgb_encoder_enable,
190 };
191 
192 static void sun4i_rgb_enc_destroy(struct drm_encoder *encoder)
193 {
194 	drm_encoder_cleanup(encoder);
195 }
196 
197 static struct drm_encoder_funcs sun4i_rgb_enc_funcs = {
198 	.destroy	= sun4i_rgb_enc_destroy,
199 };
200 
201 int sun4i_rgb_init(struct drm_device *drm, struct sun4i_tcon *tcon)
202 {
203 	struct drm_encoder *encoder;
204 	struct drm_bridge *bridge;
205 	struct sun4i_rgb *rgb;
206 	int ret;
207 
208 	rgb = devm_kzalloc(drm->dev, sizeof(*rgb), GFP_KERNEL);
209 	if (!rgb)
210 		return -ENOMEM;
211 	rgb->tcon = tcon;
212 	encoder = &rgb->encoder;
213 
214 	ret = drm_of_find_panel_or_bridge(tcon->dev->of_node, 1, 0,
215 					  &tcon->panel, &bridge);
216 	if (ret) {
217 		dev_info(drm->dev, "No panel or bridge found... RGB output disabled\n");
218 		return 0;
219 	}
220 
221 	drm_encoder_helper_add(&rgb->encoder,
222 			       &sun4i_rgb_enc_helper_funcs);
223 	ret = drm_encoder_init(drm,
224 			       &rgb->encoder,
225 			       &sun4i_rgb_enc_funcs,
226 			       DRM_MODE_ENCODER_NONE,
227 			       NULL);
228 	if (ret) {
229 		dev_err(drm->dev, "Couldn't initialise the rgb encoder\n");
230 		goto err_out;
231 	}
232 
233 	/* The RGB encoder can only work with the TCON channel 0 */
234 	rgb->encoder.possible_crtcs = BIT(drm_crtc_index(&tcon->crtc->crtc));
235 
236 	if (tcon->panel) {
237 		drm_connector_helper_add(&rgb->connector,
238 					 &sun4i_rgb_con_helper_funcs);
239 		ret = drm_connector_init(drm, &rgb->connector,
240 					 &sun4i_rgb_con_funcs,
241 					 DRM_MODE_CONNECTOR_Unknown);
242 		if (ret) {
243 			dev_err(drm->dev, "Couldn't initialise the rgb connector\n");
244 			goto err_cleanup_connector;
245 		}
246 
247 		drm_mode_connector_attach_encoder(&rgb->connector,
248 						  &rgb->encoder);
249 
250 		ret = drm_panel_attach(tcon->panel, &rgb->connector);
251 		if (ret) {
252 			dev_err(drm->dev, "Couldn't attach our panel\n");
253 			goto err_cleanup_connector;
254 		}
255 	}
256 
257 	if (bridge) {
258 		ret = drm_bridge_attach(encoder, bridge, NULL);
259 		if (ret) {
260 			dev_err(drm->dev, "Couldn't attach our bridge\n");
261 			goto err_cleanup_connector;
262 		}
263 	}
264 
265 	return 0;
266 
267 err_cleanup_connector:
268 	drm_encoder_cleanup(&rgb->encoder);
269 err_out:
270 	return ret;
271 }
272 EXPORT_SYMBOL(sun4i_rgb_init);
273