Merge tag 'sunxi-drm-for-4.12' of https://git.kernel.org/pub/scm/linux/kernel/git...
[muen/linux.git] / drivers / gpu / drm / sun4i / sun4i_rgb.c
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);