/** * Callback for the DRM event queue when a single flip has completed * * Once the flip has been completed on all pipes, notify the * extension code telling it when that happened */ static void ms_flip_handler(uint64_t msc, uint64_t ust, void *data) { struct ms_crtc_pageflip *flip = data; ScreenPtr screen = flip->flipdata->screen; ScrnInfoPtr scrn = xf86ScreenToScrn(screen); modesettingPtr ms = modesettingPTR(scrn); struct ms_flipdata *flipdata = flip->flipdata; DebugPresent(("\t\tms:fh %lld c %d msc %llu ust %llu\n", (long long) flipdata->event->event_id, flipdata->flip_count, (long long) msc, (long long) ust)); if (flip->on_reference_crtc) { flipdata->fe_msc = msc; flipdata->fe_usec = ust; } if (flipdata->flip_count == 1) { DebugPresent(("\t\tms:fc %lld c %d msc %llu ust %llu\n", (long long) flipdata->event->event_id, flipdata->flip_count, (long long) flipdata->fe_msc, (long long) flipdata->fe_usec)); ms_present_vblank_handler(flipdata->fe_msc, flipdata->fe_usec, flipdata->event); drmModeRmFB(ms->fd, flipdata->old_fb_id); } ms_present_flip_free(flip); }
/* * Callback for the DRM queue abort code. A flip has been aborted. */ static void ms_present_flip_abort(void *data) { struct ms_crtc_pageflip *flip = data; struct ms_flipdata *flipdata = flip->flipdata; DebugPresent(("\t\tms:fa %lld c %d\n", (long long) flipdata->event->event_id, flipdata->flip_count)); if (flipdata->flip_count == 1) free(flipdata->event); ms_present_flip_free(flip); }
/* * Queue an event to report back to the Present extension when the specified * MSC has past */ static int intel_present_queue_vblank(RRCrtcPtr crtc, uint64_t event_id, uint64_t msc) { xf86CrtcPtr xf86_crtc = crtc->devPrivate; ScreenPtr screen = crtc->pScreen; ScrnInfoPtr scrn = xf86ScreenToScrn(screen); intel_screen_private *intel = intel_get_screen_private(scrn); int pipe = intel_present_crtc_pipe(screen, crtc); struct intel_present_vblank_event *event; drmVBlank vbl; int ret; uint32_t seq; event = calloc(sizeof(struct intel_present_vblank_event), 1); if (!event) return BadAlloc; event->event_id = event_id; seq = intel_drm_queue_alloc(scrn, xf86_crtc, event, intel_present_vblank_handler, intel_present_vblank_abort); if (!seq) { free(event); return BadAlloc; } vbl.request.type = DRM_VBLANK_ABSOLUTE | DRM_VBLANK_EVENT | pipe_select(pipe); vbl.request.sequence = intel_crtc_msc_to_sequence(scrn, xf86_crtc, msc); vbl.request.signal = seq; for (;;) { ret = drmWaitVBlank(intel->drmSubFD, &vbl); if (!ret) break; if (errno != EBUSY || !intel_present_flush_drm_events(screen)) return BadAlloc; } DebugPresent(("\t\tiq %lld seq %u msc %llu (hw msc %u)\n", (long long) event_id, seq, (long long) msc, vbl.request.sequence)); return Success; }
/* * Flush the DRM event queue when full; makes space for new events. * * Returns a negative value on error, 0 if there was nothing to process, * or 1 if we handled any events. */ static int ms_flush_drm_events(ScreenPtr screen) { ScrnInfoPtr scrn = xf86ScreenToScrn(screen); modesettingPtr ms = modesettingPTR(scrn); struct pollfd p = { .fd = ms->fd, .events = POLLIN }; int r; do { r = poll(&p, 1, 0); } while (r == -1 && (errno == EINTR || errno == EAGAIN)); /* If there was an error, r will be < 0. Return that. If there was * nothing to process, r == 0. Return that. */ if (r <= 0) return r; /* Try to handle the event. If there was an error, return it. */ r = drmHandleEvent(ms->fd, &ms->event_context); if (r < 0) return r; /* Otherwise return 1 to indicate that we handled an event. */ return 1; } /* * Called when the queued vblank event has occurred */ static void ms_present_vblank_handler(uint64_t msc, uint64_t usec, void *data) { struct ms_present_vblank_event *event = data; DebugPresent(("\t\tmh %lld msc %llu\n", (long long) event->event_id, (long long) msc)); present_event_notify(event->event_id, usec, msc); free(event); } /* * Called when the queued vblank is aborted */ static void ms_present_vblank_abort(void *data) { struct ms_present_vblank_event *event = data; DebugPresent(("\t\tma %lld\n", (long long) event->event_id)); free(event); } /* * Queue an event to report back to the Present extension when the specified * MSC has past */ static int ms_present_queue_vblank(RRCrtcPtr crtc, uint64_t event_id, uint64_t msc) { xf86CrtcPtr xf86_crtc = crtc->devPrivate; ScreenPtr screen = crtc->pScreen; ScrnInfoPtr scrn = xf86ScreenToScrn(screen); modesettingPtr ms = modesettingPTR(scrn); drmmode_crtc_private_ptr drmmode_crtc = xf86_crtc->driver_private; struct ms_present_vblank_event *event; drmVBlank vbl; int ret; uint32_t seq; event = calloc(sizeof(struct ms_present_vblank_event), 1); if (!event) return BadAlloc; event->event_id = event_id; seq = ms_drm_queue_alloc(xf86_crtc, event, ms_present_vblank_handler, ms_present_vblank_abort); if (!seq) { free(event); return BadAlloc; } vbl.request.type = DRM_VBLANK_ABSOLUTE | DRM_VBLANK_EVENT | drmmode_crtc->vblank_pipe; vbl.request.sequence = ms_crtc_msc_to_kernel_msc(xf86_crtc, msc); vbl.request.signal = seq; for (;;) { ret = drmWaitVBlank(ms->fd, &vbl); if (!ret) break; /* If we hit EBUSY, then try to flush events. If we can't, then * this is an error. */ if (errno != EBUSY || ms_flush_drm_events(screen) < 0) { ms_drm_abort_seq(scrn, seq); return BadAlloc; } } DebugPresent(("\t\tmq %lld seq %u msc %llu (hw msc %u)\n", (long long) event_id, seq, (long long) msc, vbl.request.sequence)); return Success; }
static Bool queue_flip_on_crtc(ScreenPtr screen, xf86CrtcPtr crtc, struct ms_flipdata *flipdata, int ref_crtc_vblank_pipe, uint32_t flags) { ScrnInfoPtr scrn = xf86ScreenToScrn(screen); modesettingPtr ms = modesettingPTR(scrn); drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private; struct ms_crtc_pageflip *flip; uint32_t seq; int err; flip = calloc(1, sizeof(struct ms_crtc_pageflip)); if (flip == NULL) { xf86DrvMsg(scrn->scrnIndex, X_WARNING, "flip queue: carrier alloc failed.\n"); return FALSE; } /* Only the reference crtc will finally deliver its page flip * completion event. All other crtc's events will be discarded. */ flip->on_reference_crtc = (drmmode_crtc->vblank_pipe == ref_crtc_vblank_pipe); flip->flipdata = flipdata; seq = ms_drm_queue_alloc(crtc, flip, ms_flip_handler, ms_present_flip_abort); if (!seq) { free(flip); return FALSE; } DebugPresent(("\t\tms:fq %lld c %d -> %d seq %llu\n", (long long) flipdata->event->event_id, flipdata->flip_count, flipdata->flip_count + 1, (long long) seq)); /* take a reference on flipdata for use in flip */ flipdata->flip_count++; while (drmModePageFlip(ms->fd, drmmode_crtc->mode_crtc->crtc_id, ms->drmmode.fb_id, flags, (void *) (uintptr_t) seq)) { err = errno; /* We may have failed because the event queue was full. Flush it * and retry. If there was nothing to flush, then we failed for * some other reason and should just return an error. */ if (ms_flush_drm_events(screen) <= 0) { xf86DrvMsg(scrn->scrnIndex, X_WARNING, "flip queue failed: %s\n", strerror(err)); /* Aborting will also decrement flip_count and free(flip). */ ms_drm_abort_seq(scrn, seq); return FALSE; } /* We flushed some events, so try again. */ xf86DrvMsg(scrn->scrnIndex, X_WARNING, "flip queue retry\n"); } /* The page flip succeded. */ return TRUE; }