1
2
3
4
5
6
7
8
9#include <drm/drmP.h>
10#include <drm/drm_atomic_helper.h>
11#include <drm/drm_crtc.h>
12#include <drm/drm_modes.h>
13#include <drm/drm_probe_helper.h>
14
15#include <linux/clk-provider.h>
16#include <linux/ioport.h>
17#include <linux/of_address.h>
18#include <linux/of_graph.h>
19#include <linux/of_irq.h>
20#include <linux/regmap.h>
21
22#include <video/videomode.h>
23
24#include "sun4i_backend.h"
25#include "sun4i_crtc.h"
26#include "sun4i_drv.h"
27#include "sunxi_engine.h"
28#include "sun4i_tcon.h"
29
30
31
32
33
34
35static struct drm_encoder *sun4i_crtc_get_encoder(struct drm_crtc *crtc)
36{
37 struct drm_encoder *encoder;
38
39 drm_for_each_encoder(encoder, crtc->dev)
40 if (encoder->crtc == crtc)
41 return encoder;
42
43 return NULL;
44}
45
46static int sun4i_crtc_atomic_check(struct drm_crtc *crtc,
47 struct drm_crtc_state *state)
48{
49 struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
50 struct sunxi_engine *engine = scrtc->engine;
51 int ret = 0;
52
53 if (engine && engine->ops && engine->ops->atomic_check)
54 ret = engine->ops->atomic_check(engine, state);
55
56 return ret;
57}
58
59static void sun4i_crtc_atomic_begin(struct drm_crtc *crtc,
60 struct drm_crtc_state *old_state)
61{
62 struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
63 struct drm_device *dev = crtc->dev;
64 struct sunxi_engine *engine = scrtc->engine;
65 unsigned long flags;
66
67 if (crtc->state->event) {
68 WARN_ON(drm_crtc_vblank_get(crtc) != 0);
69
70 spin_lock_irqsave(&dev->event_lock, flags);
71 scrtc->event = crtc->state->event;
72 spin_unlock_irqrestore(&dev->event_lock, flags);
73 crtc->state->event = NULL;
74 }
75
76 if (engine->ops->atomic_begin)
77 engine->ops->atomic_begin(engine, old_state);
78}
79
80static void sun4i_crtc_atomic_flush(struct drm_crtc *crtc,
81 struct drm_crtc_state *old_state)
82{
83 struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
84 struct drm_pending_vblank_event *event = crtc->state->event;
85
86 DRM_DEBUG_DRIVER("Committing plane changes\n");
87
88 sunxi_engine_commit(scrtc->engine);
89
90 if (event) {
91 crtc->state->event = NULL;
92
93 spin_lock_irq(&crtc->dev->event_lock);
94 if (drm_crtc_vblank_get(crtc) == 0)
95 drm_crtc_arm_vblank_event(crtc, event);
96 else
97 drm_crtc_send_vblank_event(crtc, event);
98 spin_unlock_irq(&crtc->dev->event_lock);
99 }
100}
101
102static void sun4i_crtc_atomic_disable(struct drm_crtc *crtc,
103 struct drm_crtc_state *old_state)
104{
105 struct drm_encoder *encoder = sun4i_crtc_get_encoder(crtc);
106 struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
107
108 DRM_DEBUG_DRIVER("Disabling the CRTC\n");
109
110 drm_crtc_vblank_off(crtc);
111
112 sun4i_tcon_set_status(scrtc->tcon, encoder, false);
113
114 if (crtc->state->event && !crtc->state->active) {
115 spin_lock_irq(&crtc->dev->event_lock);
116 drm_crtc_send_vblank_event(crtc, crtc->state->event);
117 spin_unlock_irq(&crtc->dev->event_lock);
118
119 crtc->state->event = NULL;
120 }
121}
122
123static void sun4i_crtc_atomic_enable(struct drm_crtc *crtc,
124 struct drm_crtc_state *old_state)
125{
126 struct drm_encoder *encoder = sun4i_crtc_get_encoder(crtc);
127 struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
128
129 DRM_DEBUG_DRIVER("Enabling the CRTC\n");
130
131 sun4i_tcon_set_status(scrtc->tcon, encoder, true);
132
133 drm_crtc_vblank_on(crtc);
134}
135
136static void sun4i_crtc_mode_set_nofb(struct drm_crtc *crtc)
137{
138 struct drm_display_mode *mode = &crtc->state->adjusted_mode;
139 struct drm_encoder *encoder = sun4i_crtc_get_encoder(crtc);
140 struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
141
142 sun4i_tcon_mode_set(scrtc->tcon, encoder, mode);
143}
144
145static const struct drm_crtc_helper_funcs sun4i_crtc_helper_funcs = {
146 .atomic_check = sun4i_crtc_atomic_check,
147 .atomic_begin = sun4i_crtc_atomic_begin,
148 .atomic_flush = sun4i_crtc_atomic_flush,
149 .atomic_enable = sun4i_crtc_atomic_enable,
150 .atomic_disable = sun4i_crtc_atomic_disable,
151 .mode_set_nofb = sun4i_crtc_mode_set_nofb,
152};
153
154static int sun4i_crtc_enable_vblank(struct drm_crtc *crtc)
155{
156 struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
157
158 DRM_DEBUG_DRIVER("Enabling VBLANK on crtc %p\n", crtc);
159
160 sun4i_tcon_enable_vblank(scrtc->tcon, true);
161
162 return 0;
163}
164
165static void sun4i_crtc_disable_vblank(struct drm_crtc *crtc)
166{
167 struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
168
169 DRM_DEBUG_DRIVER("Disabling VBLANK on crtc %p\n", crtc);
170
171 sun4i_tcon_enable_vblank(scrtc->tcon, false);
172}
173
174static const struct drm_crtc_funcs sun4i_crtc_funcs = {
175 .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
176 .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
177 .destroy = drm_crtc_cleanup,
178 .page_flip = drm_atomic_helper_page_flip,
179 .reset = drm_atomic_helper_crtc_reset,
180 .set_config = drm_atomic_helper_set_config,
181 .enable_vblank = sun4i_crtc_enable_vblank,
182 .disable_vblank = sun4i_crtc_disable_vblank,
183};
184
185struct sun4i_crtc *sun4i_crtc_init(struct drm_device *drm,
186 struct sunxi_engine *engine,
187 struct sun4i_tcon *tcon)
188{
189 struct sun4i_crtc *scrtc;
190 struct drm_plane **planes;
191 struct drm_plane *primary = NULL, *cursor = NULL;
192 int ret, i;
193
194 scrtc = devm_kzalloc(drm->dev, sizeof(*scrtc), GFP_KERNEL);
195 if (!scrtc)
196 return ERR_PTR(-ENOMEM);
197 scrtc->engine = engine;
198 scrtc->tcon = tcon;
199
200
201 planes = sunxi_engine_layers_init(drm, engine);
202 if (IS_ERR(planes)) {
203 dev_err(drm->dev, "Couldn't create the planes\n");
204 return NULL;
205 }
206
207
208 for (i = 0; planes[i]; i++) {
209 struct drm_plane *plane = planes[i];
210
211 switch (plane->type) {
212 case DRM_PLANE_TYPE_PRIMARY:
213 primary = plane;
214 break;
215 case DRM_PLANE_TYPE_CURSOR:
216 cursor = plane;
217 break;
218 default:
219 break;
220 }
221 }
222
223 ret = drm_crtc_init_with_planes(drm, &scrtc->crtc,
224 primary,
225 cursor,
226 &sun4i_crtc_funcs,
227 NULL);
228 if (ret) {
229 dev_err(drm->dev, "Couldn't init DRM CRTC\n");
230 return ERR_PTR(ret);
231 }
232
233 drm_crtc_helper_add(&scrtc->crtc, &sun4i_crtc_helper_funcs);
234
235
236 scrtc->crtc.port = of_graph_get_port_by_id(scrtc->tcon->dev->of_node,
237 1);
238
239
240 for (i = 0; planes[i]; i++) {
241 uint32_t possible_crtcs = drm_crtc_mask(&scrtc->crtc);
242 struct drm_plane *plane = planes[i];
243
244 if (plane->type == DRM_PLANE_TYPE_OVERLAY)
245 plane->possible_crtcs = possible_crtcs;
246 }
247
248 return scrtc;
249}
250