/**
* 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;
}
