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