1 // SPDX-License-Identifier: GPL-2.0 OR MIT 2 3 /* 4 * Xen para-virtual DRM device 5 * 6 * Copyright (C) 2016-2018 EPAM Systems Inc. 7 * 8 * Author: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com> 9 */ 10 11 #include <drm/drm_atomic.h> 12 #include <drm/drm_atomic_helper.h> 13 #include <drm/drm_drv.h> 14 #include <drm/drm_fourcc.h> 15 #include <drm/drm_gem.h> 16 #include <drm/drm_gem_atomic_helper.h> 17 #include <drm/drm_gem_framebuffer_helper.h> 18 #include <drm/drm_probe_helper.h> 19 #include <drm/drm_vblank.h> 20 21 #include "xen_drm_front.h" 22 #include "xen_drm_front_conn.h" 23 #include "xen_drm_front_kms.h" 24 25 /* 26 * Timeout in ms to wait for frame done event from the backend: 27 * must be a bit more than IO time-out 28 */ 29 #define FRAME_DONE_TO_MS (XEN_DRM_FRONT_WAIT_BACK_MS + 100) 30 31 static struct xen_drm_front_drm_pipeline * 32 to_xen_drm_pipeline(struct drm_simple_display_pipe *pipe) 33 { 34 return container_of(pipe, struct xen_drm_front_drm_pipeline, pipe); 35 } 36 37 static void fb_destroy(struct drm_framebuffer *fb) 38 { 39 struct xen_drm_front_drm_info *drm_info = fb->dev->dev_private; 40 int idx; 41 42 if (drm_dev_enter(fb->dev, &idx)) { 43 xen_drm_front_fb_detach(drm_info->front_info, 44 xen_drm_front_fb_to_cookie(fb)); 45 drm_dev_exit(idx); 46 } 47 drm_gem_fb_destroy(fb); 48 } 49 50 static const struct drm_framebuffer_funcs fb_funcs = { 51 .destroy = fb_destroy, 52 }; 53 54 static struct drm_framebuffer * 55 fb_create(struct drm_device *dev, struct drm_file *filp, 56 const struct drm_mode_fb_cmd2 *mode_cmd) 57 { 58 struct xen_drm_front_drm_info *drm_info = dev->dev_private; 59 struct drm_framebuffer *fb; 60 struct drm_gem_object *gem_obj; 61 int ret; 62 63 fb = drm_gem_fb_create_with_funcs(dev, filp, mode_cmd, &fb_funcs); 64 if (IS_ERR(fb)) 65 return fb; 66 67 gem_obj = fb->obj[0]; 68 69 ret = xen_drm_front_fb_attach(drm_info->front_info, 70 xen_drm_front_dbuf_to_cookie(gem_obj), 71 xen_drm_front_fb_to_cookie(fb), 72 fb->width, fb->height, 73 fb->format->format); 74 if (ret < 0) { 75 DRM_ERROR("Back failed to attach FB %p: %d\n", fb, ret); 76 goto fail; 77 } 78 79 return fb; 80 81 fail: 82 drm_gem_fb_destroy(fb); 83 return ERR_PTR(ret); 84 } 85 86 static const struct drm_mode_config_funcs mode_config_funcs = { 87 .fb_create = fb_create, 88 .atomic_check = drm_atomic_helper_check, 89 .atomic_commit = drm_atomic_helper_commit, 90 }; 91 92 static void send_pending_event(struct xen_drm_front_drm_pipeline *pipeline) 93 { 94 struct drm_crtc *crtc = &pipeline->pipe.crtc; 95 struct drm_device *dev = crtc->dev; 96 unsigned long flags; 97 98 spin_lock_irqsave(&dev->event_lock, flags); 99 if (pipeline->pending_event) 100 drm_crtc_send_vblank_event(crtc, pipeline->pending_event); 101 pipeline->pending_event = NULL; 102 spin_unlock_irqrestore(&dev->event_lock, flags); 103 } 104 105 static void display_enable(struct drm_simple_display_pipe *pipe, 106 struct drm_crtc_state *crtc_state, 107 struct drm_plane_state *plane_state) 108 { 109 struct xen_drm_front_drm_pipeline *pipeline = 110 to_xen_drm_pipeline(pipe); 111 struct drm_crtc *crtc = &pipe->crtc; 112 struct drm_framebuffer *fb = plane_state->fb; 113 int ret, idx; 114 115 if (!drm_dev_enter(pipe->crtc.dev, &idx)) 116 return; 117 118 ret = xen_drm_front_mode_set(pipeline, crtc->x, crtc->y, 119 fb->width, fb->height, 120 fb->format->cpp[0] * 8, 121 xen_drm_front_fb_to_cookie(fb)); 122 123 if (ret) { 124 DRM_ERROR("Failed to enable display: %d\n", ret); 125 pipeline->conn_connected = false; 126 } 127 128 drm_dev_exit(idx); 129 } 130 131 static void display_disable(struct drm_simple_display_pipe *pipe) 132 { 133 struct xen_drm_front_drm_pipeline *pipeline = 134 to_xen_drm_pipeline(pipe); 135 int ret = 0, idx; 136 137 if (drm_dev_enter(pipe->crtc.dev, &idx)) { 138 ret = xen_drm_front_mode_set(pipeline, 0, 0, 0, 0, 0, 139 xen_drm_front_fb_to_cookie(NULL)); 140 drm_dev_exit(idx); 141 } 142 if (ret) 143 DRM_ERROR("Failed to disable display: %d\n", ret); 144 145 /* Make sure we can restart with enabled connector next time */ 146 pipeline->conn_connected = true; 147 148 /* release stalled event if any */ 149 send_pending_event(pipeline); 150 } 151 152 void xen_drm_front_kms_on_frame_done(struct xen_drm_front_drm_pipeline *pipeline, 153 u64 fb_cookie) 154 { 155 /* 156 * This runs in interrupt context, e.g. under 157 * drm_info->front_info->io_lock, so we cannot call _sync version 158 * to cancel the work 159 */ 160 cancel_delayed_work(&pipeline->pflip_to_worker); 161 162 send_pending_event(pipeline); 163 } 164 165 static void pflip_to_worker(struct work_struct *work) 166 { 167 struct delayed_work *delayed_work = to_delayed_work(work); 168 struct xen_drm_front_drm_pipeline *pipeline = 169 container_of(delayed_work, 170 struct xen_drm_front_drm_pipeline, 171 pflip_to_worker); 172 173 DRM_ERROR("Frame done timed-out, releasing"); 174 send_pending_event(pipeline); 175 } 176 177 static bool display_send_page_flip(struct drm_simple_display_pipe *pipe, 178 struct drm_plane_state *old_plane_state) 179 { 180 struct drm_plane_state *plane_state = 181 drm_atomic_get_new_plane_state(old_plane_state->state, 182 &pipe->plane); 183 184 /* 185 * If old_plane_state->fb is NULL and plane_state->fb is not, 186 * then this is an atomic commit which will enable display. 187 * If old_plane_state->fb is not NULL and plane_state->fb is, 188 * then this is an atomic commit which will disable display. 189 * Ignore these and do not send page flip as this framebuffer will be 190 * sent to the backend as a part of display_set_config call. 191 */ 192 if (old_plane_state->fb && plane_state->fb) { 193 struct xen_drm_front_drm_pipeline *pipeline = 194 to_xen_drm_pipeline(pipe); 195 struct xen_drm_front_drm_info *drm_info = pipeline->drm_info; 196 int ret; 197 198 schedule_delayed_work(&pipeline->pflip_to_worker, 199 msecs_to_jiffies(FRAME_DONE_TO_MS)); 200 201 ret = xen_drm_front_page_flip(drm_info->front_info, 202 pipeline->index, 203 xen_drm_front_fb_to_cookie(plane_state->fb)); 204 if (ret) { 205 DRM_ERROR("Failed to send page flip request to backend: %d\n", ret); 206 207 pipeline->conn_connected = false; 208 /* 209 * Report the flip not handled, so pending event is 210 * sent, unblocking user-space. 211 */ 212 return false; 213 } 214 /* 215 * Signal that page flip was handled, pending event will be sent 216 * on frame done event from the backend. 217 */ 218 return true; 219 } 220 221 return false; 222 } 223 224 static int display_check(struct drm_simple_display_pipe *pipe, 225 struct drm_plane_state *plane_state, 226 struct drm_crtc_state *crtc_state) 227 { 228 /* 229 * Xen doesn't initialize vblanking via drm_vblank_init(), so 230 * DRM helpers assume that it doesn't handle vblanking and start 231 * sending out fake VBLANK events automatically. 232 * 233 * As xen contains it's own logic for sending out VBLANK events 234 * in send_pending_event(), disable no_vblank (i.e., the xen 235 * driver has vblanking support). 236 */ 237 crtc_state->no_vblank = false; 238 239 return 0; 240 } 241 242 static void display_update(struct drm_simple_display_pipe *pipe, 243 struct drm_plane_state *old_plane_state) 244 { 245 struct xen_drm_front_drm_pipeline *pipeline = 246 to_xen_drm_pipeline(pipe); 247 struct drm_crtc *crtc = &pipe->crtc; 248 struct drm_pending_vblank_event *event; 249 int idx; 250 251 event = crtc->state->event; 252 if (event) { 253 struct drm_device *dev = crtc->dev; 254 unsigned long flags; 255 256 WARN_ON(pipeline->pending_event); 257 258 spin_lock_irqsave(&dev->event_lock, flags); 259 crtc->state->event = NULL; 260 261 pipeline->pending_event = event; 262 spin_unlock_irqrestore(&dev->event_lock, flags); 263 } 264 265 if (!drm_dev_enter(pipe->crtc.dev, &idx)) { 266 send_pending_event(pipeline); 267 return; 268 } 269 270 /* 271 * Send page flip request to the backend *after* we have event cached 272 * above, so on page flip done event from the backend we can 273 * deliver it and there is no race condition between this code and 274 * event from the backend. 275 * If this is not a page flip, e.g. no flip done event from the backend 276 * is expected, then send now. 277 */ 278 if (!display_send_page_flip(pipe, old_plane_state)) 279 send_pending_event(pipeline); 280 281 drm_dev_exit(idx); 282 } 283 284 static enum drm_mode_status 285 display_mode_valid(struct drm_simple_display_pipe *pipe, 286 const struct drm_display_mode *mode) 287 { 288 struct xen_drm_front_drm_pipeline *pipeline = 289 container_of(pipe, struct xen_drm_front_drm_pipeline, 290 pipe); 291 292 if (mode->hdisplay != pipeline->width) 293 return MODE_ERROR; 294 295 if (mode->vdisplay != pipeline->height) 296 return MODE_ERROR; 297 298 return MODE_OK; 299 } 300 301 static const struct drm_simple_display_pipe_funcs display_funcs = { 302 .mode_valid = display_mode_valid, 303 .enable = display_enable, 304 .disable = display_disable, 305 .prepare_fb = drm_gem_simple_display_pipe_prepare_fb, 306 .check = display_check, 307 .update = display_update, 308 }; 309 310 static int display_pipe_init(struct xen_drm_front_drm_info *drm_info, 311 int index, struct xen_drm_front_cfg_connector *cfg, 312 struct xen_drm_front_drm_pipeline *pipeline) 313 { 314 struct drm_device *dev = drm_info->drm_dev; 315 const u32 *formats; 316 int format_count; 317 int ret; 318 319 pipeline->drm_info = drm_info; 320 pipeline->index = index; 321 pipeline->height = cfg->height; 322 pipeline->width = cfg->width; 323 324 INIT_DELAYED_WORK(&pipeline->pflip_to_worker, pflip_to_worker); 325 326 ret = xen_drm_front_conn_init(drm_info, &pipeline->conn); 327 if (ret) 328 return ret; 329 330 formats = xen_drm_front_conn_get_formats(&format_count); 331 332 return drm_simple_display_pipe_init(dev, &pipeline->pipe, 333 &display_funcs, formats, 334 format_count, NULL, 335 &pipeline->conn); 336 } 337 338 int xen_drm_front_kms_init(struct xen_drm_front_drm_info *drm_info) 339 { 340 struct drm_device *dev = drm_info->drm_dev; 341 int i, ret; 342 343 drm_mode_config_init(dev); 344 345 dev->mode_config.min_width = 0; 346 dev->mode_config.min_height = 0; 347 dev->mode_config.max_width = 4095; 348 dev->mode_config.max_height = 2047; 349 dev->mode_config.funcs = &mode_config_funcs; 350 351 for (i = 0; i < drm_info->front_info->cfg.num_connectors; i++) { 352 struct xen_drm_front_cfg_connector *cfg = 353 &drm_info->front_info->cfg.connectors[i]; 354 struct xen_drm_front_drm_pipeline *pipeline = 355 &drm_info->pipeline[i]; 356 357 ret = display_pipe_init(drm_info, i, cfg, pipeline); 358 if (ret) { 359 drm_mode_config_cleanup(dev); 360 return ret; 361 } 362 } 363 364 drm_mode_config_reset(dev); 365 drm_kms_helper_poll_init(dev); 366 return 0; 367 } 368 369 void xen_drm_front_kms_fini(struct xen_drm_front_drm_info *drm_info) 370 { 371 int i; 372 373 for (i = 0; i < drm_info->front_info->cfg.num_connectors; i++) { 374 struct xen_drm_front_drm_pipeline *pipeline = 375 &drm_info->pipeline[i]; 376 377 cancel_delayed_work_sync(&pipeline->pflip_to_worker); 378 379 send_pending_event(pipeline); 380 } 381 } 382