xenocara/xserver/hw/xfree86/modes/xf86RandR12.c

/*
 * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the name of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 */

#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#else
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#endif

#include "xf86.h"
#include "os.h"
#include "globals.h"
#include "xf86Priv.h"
#include "xf86DDC.h"
#include "mipointer.h"
#include "windowstr.h"
#include "inputstr.h"
#include <randrstr.h>
#include <X11/extensions/render.h>

#include "xf86Crtc.h"
#include "xf86RandR12.h"

typedef struct _xf86RandR12Info {
    int virtualX;
    int virtualY;
    int mmWidth;
    int mmHeight;
    int maxX;
    int maxY;
    int pointerX;
    int pointerY;
    Rotation rotation;          /* current mode */
    Rotation supported_rotations;       /* driver supported */

    /* Used to wrap EnterVT so we can re-probe the outputs when a laptop unsuspends
     * (actually, any time that we switch back into our VT).
     *
     * See https://bugs.freedesktop.org/show_bug.cgi?id=21554
     */
    xf86EnterVTProc *orig_EnterVT;
} XF86RandRInfoRec, *XF86RandRInfoPtr;

#ifdef RANDR_12_INTERFACE
static Bool xf86RandR12Init12(ScreenPtr pScreen);
static Bool xf86RandR12CreateScreenResources12(ScreenPtr pScreen);
#endif

static int xf86RandR12Generation;

static DevPrivateKeyRec xf86RandR12KeyRec;
static DevPrivateKey xf86RandR12Key;

#define XF86RANDRINFO(p) ((XF86RandRInfoPtr) \
    dixLookupPrivate(&(p)->devPrivates, xf86RandR12Key))

static int
xf86RandR12ModeRefresh(DisplayModePtr mode)
{
    if (mode->VRefresh)
        return (int) (mode->VRefresh + 0.5);
    else
        return (int) (mode->Clock * 1000.0 / mode->HTotal / mode->VTotal + 0.5);
}

/* Adapt panning area; return TRUE if panning area was valid without adaption */
static int
xf86RandR13VerifyPanningArea(xf86CrtcPtr crtc, int screenWidth,
                             int screenHeight)
{
    int ret = TRUE;

    if (crtc->version < 2)
        return FALSE;

    if (crtc->panningTotalArea.x2 <= crtc->panningTotalArea.x1) {
        /* Panning in X is disabled */
        if (crtc->panningTotalArea.x1 || crtc->panningTotalArea.x2)
            /* Illegal configuration -> fail/disable */
            ret = FALSE;
        crtc->panningTotalArea.x1 = crtc->panningTotalArea.x2 = 0;
        crtc->panningTrackingArea.x1 = crtc->panningTrackingArea.x2 = 0;
        crtc->panningBorder[0] = crtc->panningBorder[2] = 0;
    }
    else {
        /* Panning in X is enabled */
        if (crtc->panningTotalArea.x1 < 0) {
            /* Panning region outside screen -> move inside */
            crtc->panningTotalArea.x2 -= crtc->panningTotalArea.x1;
            crtc->panningTotalArea.x1 = 0;
            ret = FALSE;
        }
        if (crtc->panningTotalArea.x2 <
            crtc->panningTotalArea.x1 + crtc->mode.HDisplay) {
            /* Panning region smaller than displayed area -> crop to displayed area */
            crtc->panningTotalArea.x2 =
                crtc->panningTotalArea.x1 + crtc->mode.HDisplay;
            ret = FALSE;
        }
        if (crtc->panningTotalArea.x2 > screenWidth) {
            /* Panning region larger than screen -> move inside, then crop to screen */
            crtc->panningTotalArea.x1 -=
                crtc->panningTotalArea.x2 - screenWidth;
            crtc->panningTotalArea.x2 = screenWidth;
            ret = FALSE;
            if (crtc->panningTotalArea.x1 < 0)
                crtc->panningTotalArea.x1 = 0;
        }
        if (crtc->panningBorder[0] + crtc->panningBorder[2] >
            crtc->mode.HDisplay) {
            /* Borders too large -> set to 0 */
            crtc->panningBorder[0] = crtc->panningBorder[2] = 0;
            ret = FALSE;
        }
    }

    if (crtc->panningTotalArea.y2 <= crtc->panningTotalArea.y1) {
        /* Panning in Y is disabled */
        if (crtc->panningTotalArea.y1 || crtc->panningTotalArea.y2)
            /* Illegal configuration -> fail/disable */
            ret = FALSE;
        crtc->panningTotalArea.y1 = crtc->panningTotalArea.y2 = 0;
        crtc->panningTrackingArea.y1 = crtc->panningTrackingArea.y2 = 0;
        crtc->panningBorder[1] = crtc->panningBorder[3] = 0;
    }
    else {
        /* Panning in Y is enabled */
        if (crtc->panningTotalArea.y1 < 0) {
            /* Panning region outside screen -> move inside */
            crtc->panningTotalArea.y2 -= crtc->panningTotalArea.y1;
            crtc->panningTotalArea.y1 = 0;
            ret = FALSE;
        }
        if (crtc->panningTotalArea.y2 <
            crtc->panningTotalArea.y1 + crtc->mode.VDisplay) {
            /* Panning region smaller than displayed area -> crop to displayed area */
            crtc->panningTotalArea.y2 =
                crtc->panningTotalArea.y1 + crtc->mode.VDisplay;
            ret = FALSE;
        }
        if (crtc->panningTotalArea.y2 > screenHeight) {
            /* Panning region larger than screen -> move inside, then crop to screen */
            crtc->panningTotalArea.y1 -=
                crtc->panningTotalArea.y2 - screenHeight;
            crtc->panningTotalArea.y2 = screenHeight;
            ret = FALSE;
            if (crtc->panningTotalArea.y1 < 0)
                crtc->panningTotalArea.y1 = 0;
        }
        if (crtc->panningBorder[1] + crtc->panningBorder[3] >
            crtc->mode.VDisplay) {
            /* Borders too large -> set to 0 */
            crtc->panningBorder[1] = crtc->panningBorder[3] = 0;
            ret = FALSE;
        }
    }

    return ret;
}

/*
 * The heart of the panning operation:
 *
 * Given a frame buffer position (fb_x, fb_y),
 * and a crtc position (crtc_x, crtc_y),
 * and a transform matrix which maps frame buffer to crtc,
 * compute a panning position (pan_x, pan_y) that
 * makes the resulting transform line those two up
 */

static void
xf86ComputeCrtcPan(Bool transform_in_use,
                   struct pixman_f_transform *m,
                   double screen_x, double screen_y,
                   double crtc_x, double crtc_y,
                   int old_pan_x, int old_pan_y, int *new_pan_x, int *new_pan_y)
{
    if (transform_in_use) {
        /*
         * Given the current transform, M, the current position
         * on the Screen, S, and the desired position on the CRTC,
         * C, compute a translation, T, such that:
         *
         * M T S = C
         *
         * where T is of the form
         *
         * | 1 0 dx |
         * | 0 1 dy |
         * | 0 0 1  |
         *
         * M T S =
         *   | M00 Sx + M01 Sy + M00 dx + M01 dy + M02 |   | Cx F |
         *   | M10 Sx + M11 Sy + M10 dx + M11 dy + M12 | = | Cy F |
         *   | M20 Sx + M21 Sy + M20 dx + M21 dy + M22 |   |  F   |
         *
         * R = M S
         *
         *   Cx F = M00 dx + M01 dy + R0
         *   Cy F = M10 dx + M11 dy + R1
         *      F = M20 dx + M21 dy + R2
         *
         * Zero out dx, then dy
         *
         * F (Cx M10 - Cy M00) =
         *          (M10 M01 - M00 M11) dy + M10 R0 - M00 R1
         * F (M10 - Cy M20) =
         *          (M10 M21 - M20 M11) dy + M10 R2 - M20 R1
         *
         * F (Cx M11 - Cy M01) =
         *          (M11 M00 - M01 M10) dx + M11 R0 - M01 R1
         * F (M11 - Cy M21) =
         *          (M11 M20 - M21 M10) dx + M11 R2 - M21 R1
         *
         * Make some temporaries
         *
         * T = | Cx M10 - Cy M00 |
         *     | Cx M11 - Cy M01 |
         *
         * U = | M10 M01 - M00 M11 |
         *     | M11 M00 - M01 M10 |
         *
         * Q = | M10 R0 - M00 R1 |
         *     | M11 R0 - M01 R1 |
         *
         * P = | M10 - Cy M20 |
         *     | M11 - Cy M21 |
         *
         * W = | M10 M21 - M20 M11 |
         *     | M11 M20 - M21 M10 |
         *
         * V = | M10 R2 - M20 R1 |
         *         | M11 R2 - M21 R1 |
         *
         * Rewrite:
         *
         * F T0 = U0 dy + Q0
         * F P0 = W0 dy + V0
         * F T1 = U1 dx + Q1
         * F P1 = W1 dx + V1
         *
         * Solve for F (two ways)
         *
         * F (W0 T0 - U0 P0)  = W0 Q0 - U0 V0
         *
         *     W0 Q0 - U0 V0
         * F = -------------
         *     W0 T0 - U0 P0
         *
         * F (W1 T1 - U1 P1) = W1 Q1 - U1 V1
         *
         *     W1 Q1 - U1 V1
         * F = -------------
         *     W1 T1 - U1 P1
         *
         * We'll use which ever solution works (denominator != 0)
         *
         * Finally, solve for dx and dy:
         *
         * dx = (F T1 - Q1) / U1
         * dx = (F P1 - V1) / W1
         *
         * dy = (F T0 - Q0) / U0
         * dy = (F P0 - V0) / W0
         */
        double r[3];
        double q[2], u[2], t[2], v[2], w[2], p[2];
        double f;
        struct pict_f_vector d;
        int i;

        /* Get the un-normalized crtc coordinates again */
        for (i = 0; i < 3; i++)
            r[i] = m->m[i][0] * screen_x + m->m[i][1] * screen_y + m->m[i][2];

        /* Combine values into temporaries */
        for (i = 0; i < 2; i++) {
            q[i] = m->m[1][i] * r[0] - m->m[0][i] * r[1];
            u[i] = m->m[1][i] * m->m[0][1 - i] - m->m[0][i] * m->m[1][1 - i];
            t[i] = m->m[1][i] * crtc_x - m->m[0][i] * crtc_y;

            v[i] = m->m[1][i] * r[2] - m->m[2][i] * r[1];
            w[i] = m->m[1][i] * m->m[2][1 - i] - m->m[2][i] * m->m[1][1 - i];
            p[i] = m->m[1][i] - m->m[2][i] * crtc_y;
        }

        /* Find a way to compute f */
        f = 0;
        for (i = 0; i < 2; i++) {
            double a = w[i] * q[i] - u[i] * v[i];
            double b = w[i] * t[i] - u[i] * p[i];

            if (b != 0) {
                f = a / b;
                break;
            }
        }

        /* Solve for the resulting transform vector */
        for (i = 0; i < 2; i++) {
            if (u[i])
                d.v[1 - i] = (t[i] * f - q[i]) / u[i];
            else if (w[1])
                d.v[1 - i] = (p[i] * f - v[i]) / w[i];
            else
                d.v[1 - i] = 0;
        }
        *new_pan_x = old_pan_x - floor(d.v[0] + 0.5);
        *new_pan_y = old_pan_y - floor(d.v[1] + 0.5);
    }
    else {
        *new_pan_x = screen_x - crtc_x;
        *new_pan_y = screen_y - crtc_y;
    }
}

static void
xf86RandR13Pan(xf86CrtcPtr crtc, int x, int y)
{
    int newX, newY;
    int width, height;
    Bool panned = FALSE;

    if (crtc->version < 2)
        return;

    if (!crtc->enabled ||
        (crtc->panningTotalArea.x2 <= crtc->panningTotalArea.x1 &&
         crtc->panningTotalArea.y2 <= crtc->panningTotalArea.y1))
        return;

    newX = crtc->x;
    newY = crtc->y;
    width = crtc->mode.HDisplay;
    height = crtc->mode.VDisplay;

    if ((crtc->panningTrackingArea.x2 <= crtc->panningTrackingArea.x1 ||
         (x >= crtc->panningTrackingArea.x1 &&
          x < crtc->panningTrackingArea.x2)) &&
        (crtc->panningTrackingArea.y2 <= crtc->panningTrackingArea.y1 ||
         (y >= crtc->panningTrackingArea.y1 &&
          y < crtc->panningTrackingArea.y2))) {
        struct pict_f_vector c;

        /*
         * Pre-clip the mouse position to the panning area so that we don't
         * push the crtc outside. This doesn't deal with changes to the
         * panning values, only mouse position changes.
         */
        if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1) {
            if (x < crtc->panningTotalArea.x1)
                x = crtc->panningTotalArea.x1;
            if (x >= crtc->panningTotalArea.x2)
                x = crtc->panningTotalArea.x2 - 1;
        }
        if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
            if (y < crtc->panningTotalArea.y1)
                y = crtc->panningTotalArea.y1;
            if (y >= crtc->panningTotalArea.y2)
                y = crtc->panningTotalArea.y2 - 1;
        }

        c.v[0] = x;
        c.v[1] = y;
        c.v[2] = 1.0;
        if (crtc->transform_in_use) {
            pixman_f_transform_point(&crtc->f_framebuffer_to_crtc, &c);
        }
        else {
            c.v[0] -= crtc->x;
            c.v[1] -= crtc->y;
        }

        if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1) {
            if (c.v[0] < crtc->panningBorder[0]) {
                c.v[0] = crtc->panningBorder[0];
                panned = TRUE;
            }
            if (c.v[0] >= width - crtc->panningBorder[2]) {
                c.v[0] = width - crtc->panningBorder[2] - 1;
                panned = TRUE;
            }
        }
        if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
            if (c.v[1] < crtc->panningBorder[1]) {
                c.v[1] = crtc->panningBorder[1];
                panned = TRUE;
            }
            if (c.v[1] >= height - crtc->panningBorder[3]) {
                c.v[1] = height - crtc->panningBorder[3] - 1;
                panned = TRUE;
            }
        }
        if (panned)
            xf86ComputeCrtcPan(crtc->transform_in_use,
                               &crtc->f_framebuffer_to_crtc,
                               x, y, c.v[0], c.v[1], newX, newY, &newX, &newY);
    }

    /*
     * Ensure that the crtc is within the panning region.
     *
     * XXX This computation only works when we do not have a transform
     * in use.
     */
    if (!crtc->transform_in_use) {
        /* Validate against [xy]1 after [xy]2, to be sure that results are > 0 for [xy]1 > 0 */
        if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1) {
            if (newX > crtc->panningTotalArea.x2 - width)
                newX = crtc->panningTotalArea.x2 - width;
            if (newX < crtc->panningTotalArea.x1)
                newX = crtc->panningTotalArea.x1;
        }
        if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
            if (newY > crtc->panningTotalArea.y2 - height)
                newY = crtc->panningTotalArea.y2 - height;
            if (newY < crtc->panningTotalArea.y1)
                newY = crtc->panningTotalArea.y1;
        }
    }
    if (newX != crtc->x || newY != crtc->y)
        xf86CrtcSetOrigin(crtc, newX, newY);
}

static Bool
xf86RandR12GetInfo(ScreenPtr pScreen, Rotation * rotations)
{
    RRScreenSizePtr pSize;
    ScrnInfoPtr scrp = XF86SCRNINFO(pScreen);
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    DisplayModePtr mode;
    int refresh0 = 60;
    int maxX = 0, maxY = 0;

    *rotations = randrp->supported_rotations;

    if (randrp->virtualX == -1 || randrp->virtualY == -1) {
        randrp->virtualX = scrp->virtualX;
        randrp->virtualY = scrp->virtualY;
    }

    /* Re-probe the outputs for new monitors or modes */
    if (scrp->vtSema) {
        xf86ProbeOutputModes(scrp, 0, 0);
        xf86SetScrnInfoModes(scrp);
    }

    for (mode = scrp->modes;; mode = mode->next) {
        int refresh = xf86RandR12ModeRefresh(mode);

        if (randrp->maxX == 0 || randrp->maxY == 0) {
            if (maxX < mode->HDisplay)
                maxX = mode->HDisplay;
            if (maxY < mode->VDisplay)
                maxY = mode->VDisplay;
        }
        if (mode == scrp->modes)
            refresh0 = refresh;
        pSize = RRRegisterSize(pScreen,
                               mode->HDisplay, mode->VDisplay,
                               randrp->mmWidth, randrp->mmHeight);
        if (!pSize)
            return FALSE;
        RRRegisterRate(pScreen, pSize, refresh);

        if (xf86ModesEqual(mode, scrp->currentMode)) {
            RRSetCurrentConfig(pScreen, randrp->rotation, refresh, pSize);
        }
        if (mode->next == scrp->modes)
            break;
    }

    if (randrp->maxX == 0 || randrp->maxY == 0) {
        randrp->maxX = maxX;
        randrp->maxY = maxY;
    }

    return TRUE;
}

static Bool
xf86RandR12SetMode(ScreenPtr pScreen,
                   DisplayModePtr mode,
                   Bool useVirtual, int mmWidth, int mmHeight)
{
    ScrnInfoPtr scrp = XF86SCRNINFO(pScreen);
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    int oldWidth = pScreen->width;
    int oldHeight = pScreen->height;
    int oldmmWidth = pScreen->mmWidth;
    int oldmmHeight = pScreen->mmHeight;
    WindowPtr pRoot = pScreen->root;
    DisplayModePtr currentMode = NULL;
    Bool ret = TRUE;

    if (pRoot)
        (*scrp->EnableDisableFBAccess) (pScreen->myNum, FALSE);
    if (useVirtual) {
        scrp->virtualX = randrp->virtualX;
        scrp->virtualY = randrp->virtualY;
    }
    else {
        scrp->virtualX = mode->HDisplay;
        scrp->virtualY = mode->VDisplay;
    }

    if (randrp->rotation & (RR_Rotate_90 | RR_Rotate_270)) {
        /* If the screen is rotated 90 or 270 degrees, swap the sizes. */
        pScreen->width = scrp->virtualY;
        pScreen->height = scrp->virtualX;
        pScreen->mmWidth = mmHeight;
        pScreen->mmHeight = mmWidth;
    }
    else {
        pScreen->width = scrp->virtualX;
        pScreen->height = scrp->virtualY;
        pScreen->mmWidth = mmWidth;
        pScreen->mmHeight = mmHeight;
    }
    if (scrp->currentMode == mode) {
        /* Save current mode */
        currentMode = scrp->currentMode;
        /* Reset, just so we ensure the drivers SwitchMode is called */
        scrp->currentMode = NULL;
    }
    /*
     * We know that if the driver failed to SwitchMode to the rotated
     * version, then it should revert back to it's prior mode.
     */
    if (!xf86SwitchMode(pScreen, mode)) {
        ret = FALSE;
        scrp->virtualX = pScreen->width = oldWidth;
        scrp->virtualY = pScreen->height = oldHeight;
        pScreen->mmWidth = oldmmWidth;
        pScreen->mmHeight = oldmmHeight;
        scrp->currentMode = currentMode;
    }

    /*
     * Make sure the layout is correct
     */
    xf86ReconfigureLayout();

    /*
     * Make sure the whole screen is visible
     */
    xf86SetViewport(pScreen, pScreen->width, pScreen->height);
    xf86SetViewport(pScreen, 0, 0);
    if (pRoot)
        (*scrp->EnableDisableFBAccess) (pScreen->myNum, TRUE);
    return ret;
}

Bool
xf86RandR12SetConfig(ScreenPtr pScreen,
                     Rotation rotation, int rate, RRScreenSizePtr pSize)
{
    ScrnInfoPtr scrp = XF86SCRNINFO(pScreen);
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    DisplayModePtr mode;
    int pos[MAXDEVICES][2];
    Bool useVirtual = FALSE;
    int maxX = 0, maxY = 0;
    Rotation oldRotation = randrp->rotation;
    DeviceIntPtr dev;
    Bool view_adjusted = FALSE;

    randrp->rotation = rotation;

    if (randrp->virtualX == -1 || randrp->virtualY == -1) {
        randrp->virtualX = scrp->virtualX;
        randrp->virtualY = scrp->virtualY;
    }

    for (dev = inputInfo.devices; dev; dev = dev->next) {
        if (!IsMaster(dev) && !IsFloating(dev))
            continue;

        miPointerGetPosition(dev, &pos[dev->id][0], &pos[dev->id][1]);
    }

    for (mode = scrp->modes;; mode = mode->next) {
        if (randrp->maxX == 0 || randrp->maxY == 0) {
            if (maxX < mode->HDisplay)
                maxX = mode->HDisplay;
            if (maxY < mode->VDisplay)
                maxY = mode->VDisplay;
        }
        if (mode->HDisplay == pSize->width &&
            mode->VDisplay == pSize->height &&
            (rate == 0 || xf86RandR12ModeRefresh(mode) == rate))
            break;
        if (mode->next == scrp->modes) {
            if (pSize->width == randrp->virtualX &&
                pSize->height == randrp->virtualY) {
                mode = scrp->modes;
                useVirtual = TRUE;
                break;
            }
            if (randrp->maxX == 0 || randrp->maxY == 0) {
                randrp->maxX = maxX;
                randrp->maxY = maxY;
            }
            return FALSE;
        }
    }

    if (randrp->maxX == 0 || randrp->maxY == 0) {
        randrp->maxX = maxX;
        randrp->maxY = maxY;
    }

    if (!xf86RandR12SetMode(pScreen, mode, useVirtual, pSize->mmWidth,
                            pSize->mmHeight)) {
        randrp->rotation = oldRotation;
        return FALSE;
    }

    /*
     * Move the cursor back where it belongs; SwitchMode repositions it
     * FIXME: duplicated code, see modes/xf86RandR12.c
     */
    for (dev = inputInfo.devices; dev; dev = dev->next) {
        if (!IsMaster(dev) && !IsFloating(dev))
            continue;

        if (pScreen == miPointerGetScreen(dev)) {
            int px = pos[dev->id][0];
            int py = pos[dev->id][1];

            px = (px >= pScreen->width ? (pScreen->width - 1) : px);
            py = (py >= pScreen->height ? (pScreen->height - 1) : py);

            /* Setting the viewpoint makes only sense on one device */
            if (!view_adjusted && IsMaster(dev)) {
                xf86SetViewport(pScreen, px, py);
                view_adjusted = TRUE;
            }

            (*pScreen->SetCursorPosition) (dev, pScreen, px, py, FALSE);
        }
    }

    return TRUE;
}

static Bool
xf86RandR12ScreenSetSize(ScreenPtr pScreen,
                         CARD16 width,
                         CARD16 height, CARD32 mmWidth, CARD32 mmHeight)
{
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    ScrnInfoPtr pScrn = XF86SCRNINFO(pScreen);
    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
    WindowPtr pRoot = pScreen->root;
    PixmapPtr pScrnPix;
    Bool ret = FALSE;
    int c;

    if (xf86RandR12Key) {
        if (randrp->virtualX == -1 || randrp->virtualY == -1) {
            randrp->virtualX = pScrn->virtualX;
            randrp->virtualY = pScrn->virtualY;
        }
    }
    if (pRoot && pScrn->vtSema)
        (*pScrn->EnableDisableFBAccess) (pScreen->myNum, FALSE);

    /* Let the driver update virtualX and virtualY */
    if (!(*config->funcs->resize) (pScrn, width, height))
        goto finish;

    ret = TRUE;
    /* Update panning information */
    for (c = 0; c < config->num_crtc; c++) {
        xf86CrtcPtr crtc = config->crtc[c];

        if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1 ||
            crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
            if (crtc->panningTotalArea.x2 > crtc->panningTrackingArea.x1)
                crtc->panningTotalArea.x2 += width - pScreen->width;
            if (crtc->panningTotalArea.y2 > crtc->panningTrackingArea.y1)
                crtc->panningTotalArea.y2 += height - pScreen->height;
            if (crtc->panningTrackingArea.x2 > crtc->panningTrackingArea.x1)
                crtc->panningTrackingArea.x2 += width - pScreen->width;
            if (crtc->panningTrackingArea.y2 > crtc->panningTrackingArea.y1)
                crtc->panningTrackingArea.y2 += height - pScreen->height;
            xf86RandR13VerifyPanningArea(crtc, width, height);
            xf86RandR13Pan(crtc, randrp->pointerX, randrp->pointerY);
        }
    }

    pScrnPix = (*pScreen->GetScreenPixmap) (pScreen);
    pScreen->width = pScrnPix->drawable.width = width;
    pScreen->height = pScrnPix->drawable.height = height;
    randrp->mmWidth = pScreen->mmWidth = mmWidth;
    randrp->mmHeight = pScreen->mmHeight = mmHeight;

    xf86SetViewport(pScreen, pScreen->width - 1, pScreen->height - 1);
    xf86SetViewport(pScreen, 0, 0);

 finish:
    update_desktop_dimensions();

    if (pRoot && pScrn->vtSema)
        (*pScrn->EnableDisableFBAccess) (pScreen->myNum, TRUE);
#if RANDR_12_INTERFACE
    if (xf86RandR12Key && pScreen->root && ret)
        RRScreenSizeNotify(pScreen);
#endif
    return ret;
}

Rotation
xf86RandR12GetRotation(ScreenPtr pScreen)
{
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);

    return randrp->rotation;
}

Bool
xf86RandR12CreateScreenResources(ScreenPtr pScreen)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    xf86CrtcConfigPtr config;
    XF86RandRInfoPtr randrp;
    int c;
    int width, height;
    int mmWidth, mmHeight;

#ifdef PANORAMIX
    /* XXX disable RandR when using Xinerama */
    if (!noPanoramiXExtension)
        return TRUE;
#endif

    config = XF86_CRTC_CONFIG_PTR(pScrn);
    randrp = XF86RANDRINFO(pScreen);
    /*
     * Compute size of screen
     */
    width = 0;
    height = 0;
    for (c = 0; c < config->num_crtc; c++) {
        xf86CrtcPtr crtc = config->crtc[c];
        int crtc_width = crtc->x + xf86ModeWidth(&crtc->mode, crtc->rotation);
        int crtc_height = crtc->y + xf86ModeHeight(&crtc->mode, crtc->rotation);

        if (crtc->enabled) {
            if (crtc_width > width)
                width = crtc_width;
            if (crtc_height > height)
                height = crtc_height;
            if (crtc->panningTotalArea.x2 > width)
                width = crtc->panningTotalArea.x2;
            if (crtc->panningTotalArea.y2 > height)
                height = crtc->panningTotalArea.y2;
        }
    }

    if (width && height) {
        /*
         * Compute physical size of screen
         */
        if (monitorResolution) {
            mmWidth = width * 25.4 / monitorResolution;
            mmHeight = height * 25.4 / monitorResolution;
        }
        else {
            xf86OutputPtr output = xf86CompatOutput(pScrn);

            if (output &&
                output->conf_monitor &&
                (output->conf_monitor->mon_width > 0 &&
                 output->conf_monitor->mon_height > 0)) {
                /*
                 * Prefer user configured DisplaySize
                 */
                mmWidth = output->conf_monitor->mon_width;
                mmHeight = output->conf_monitor->mon_height;
            }
            else {
                /*
                 * Otherwise, just set the screen to DEFAULT_DPI
                 */
                mmWidth = width * 25.4 / DEFAULT_DPI;
                mmHeight = height * 25.4 / DEFAULT_DPI;
            }
        }
        xf86DrvMsg(pScrn->scrnIndex, X_INFO,
                   "Setting screen physical size to %d x %d\n",
                   mmWidth, mmHeight);
        /*
         * This is the initial setting of the screen size.
         * We have to pre-set it here, otherwise panning would be adapted
         * to the new screen size.
         */
        pScreen->width = width;
        pScreen->height = height;
        xf86RandR12ScreenSetSize(pScreen, width, height, mmWidth, mmHeight);
        xf86ReconfigureLayout();
    }

    if (xf86RandR12Key == NULL)
        return TRUE;

    if (randrp->virtualX == -1 || randrp->virtualY == -1) {
        randrp->virtualX = pScrn->virtualX;
        randrp->virtualY = pScrn->virtualY;
    }
    xf86CrtcSetScreenSubpixelOrder(pScreen);
#if RANDR_12_INTERFACE
    if (xf86RandR12CreateScreenResources12(pScreen))
        return TRUE;
#endif
    return TRUE;
}

Bool
xf86RandR12Init(ScreenPtr pScreen)
{
    rrScrPrivPtr rp;
    XF86RandRInfoPtr randrp;

#ifdef PANORAMIX
    /* XXX disable RandR when using Xinerama */
    if (!noPanoramiXExtension) {
        if (xf86NumScreens == 1)
            noPanoramiXExtension = TRUE;
        else
            return TRUE;
    }
#endif

    if (xf86RandR12Generation != serverGeneration)
        xf86RandR12Generation = serverGeneration;

    xf86RandR12Key = &xf86RandR12KeyRec;
    if (!dixRegisterPrivateKey(&xf86RandR12KeyRec, PRIVATE_SCREEN, 0))
        return FALSE;

    randrp = malloc(sizeof(XF86RandRInfoRec));
    if (!randrp)
        return FALSE;

    if (!RRScreenInit(pScreen)) {
        free(randrp);
        return FALSE;
    }
    rp = rrGetScrPriv(pScreen);
    rp->rrGetInfo = xf86RandR12GetInfo;
    rp->rrSetConfig = xf86RandR12SetConfig;

    randrp->virtualX = -1;
    randrp->virtualY = -1;
    randrp->mmWidth = pScreen->mmWidth;
    randrp->mmHeight = pScreen->mmHeight;

    randrp->rotation = RR_Rotate_0;     /* initial rotated mode */

    randrp->supported_rotations = RR_Rotate_0;

    randrp->maxX = randrp->maxY = 0;

    dixSetPrivate(&pScreen->devPrivates, xf86RandR12Key, randrp);

#if RANDR_12_INTERFACE
    if (!xf86RandR12Init12(pScreen))
        return FALSE;
#endif
    return TRUE;
}

void
xf86RandR12CloseScreen(ScreenPtr pScreen)
{
    XF86RandRInfoPtr randrp;

    if (xf86RandR12Key == NULL)
        return;

    randrp = XF86RANDRINFO(pScreen);
#if RANDR_12_INTERFACE
    xf86Screens[pScreen->myNum]->EnterVT = randrp->orig_EnterVT;
#endif

    free(randrp);
}

void
xf86RandR12SetRotations(ScreenPtr pScreen, Rotation rotations)
{
    XF86RandRInfoPtr randrp;

#if RANDR_12_INTERFACE
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    int c;
    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
#endif

    if (xf86RandR12Key == NULL)
        return;

    randrp = XF86RANDRINFO(pScreen);
#if RANDR_12_INTERFACE
    for (c = 0; c < config->num_crtc; c++) {
        xf86CrtcPtr crtc = config->crtc[c];

        RRCrtcSetRotations(crtc->randr_crtc, rotations);
    }
#endif
    randrp->supported_rotations = rotations;
}

void
xf86RandR12SetTransformSupport(ScreenPtr pScreen, Bool transforms)
{
    XF86RandRInfoPtr randrp;

#if RANDR_13_INTERFACE
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    int c;
    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
#endif

    if (xf86RandR12Key == NULL)
        return;

    randrp = XF86RANDRINFO(pScreen);
#if RANDR_13_INTERFACE
    for (c = 0; c < config->num_crtc; c++) {
        xf86CrtcPtr crtc = config->crtc[c];

        RRCrtcSetTransformSupport(crtc->randr_crtc, transforms);
    }
#endif
}

void
xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr pScrn, int *x, int *y)
{
    ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex];

    if (xf86RandR12Generation != serverGeneration ||
        XF86RANDRINFO(pScreen)->virtualX == -1) {
        *x = pScrn->virtualX;
        *y = pScrn->virtualY;
    }
    else {
        XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);

        *x = randrp->virtualX;
        *y = randrp->virtualY;
    }
}

#if RANDR_12_INTERFACE

#define FLAG_BITS (RR_HSyncPositive | \
		   RR_HSyncNegative | \
		   RR_VSyncPositive | \
		   RR_VSyncNegative | \
		   RR_Interlace | \
		   RR_DoubleScan | \
		   RR_CSync | \
		   RR_CSyncPositive | \
		   RR_CSyncNegative | \
		   RR_HSkewPresent | \
		   RR_BCast | \
		   RR_PixelMultiplex | \
		   RR_DoubleClock | \
		   RR_ClockDivideBy2)

static Bool
xf86RandRModeMatches(RRModePtr randr_mode, DisplayModePtr mode)
{
#if 0
    if (match_name) {
        /* check for same name */
        int len = strlen(mode->name);

        if (randr_mode->mode.nameLength != len)
            return FALSE;
        if (memcmp(randr_mode->name, mode->name, len) != 0)
            return FALSE;
    }
#endif

    /* check for same timings */
    if (randr_mode->mode.dotClock / 1000 != mode->Clock)
        return FALSE;
    if (randr_mode->mode.width != mode->HDisplay)
        return FALSE;
    if (randr_mode->mode.hSyncStart != mode->HSyncStart)
        return FALSE;
    if (randr_mode->mode.hSyncEnd != mode->HSyncEnd)
        return FALSE;
    if (randr_mode->mode.hTotal != mode->HTotal)
        return FALSE;
    if (randr_mode->mode.hSkew != mode->HSkew)
        return FALSE;
    if (randr_mode->mode.height != mode->VDisplay)
        return FALSE;
    if (randr_mode->mode.vSyncStart != mode->VSyncStart)
        return FALSE;
    if (randr_mode->mode.vSyncEnd != mode->VSyncEnd)
        return FALSE;
    if (randr_mode->mode.vTotal != mode->VTotal)
        return FALSE;

    /* check for same flags (using only the XF86 valid flag bits) */
    if ((randr_mode->mode.modeFlags & FLAG_BITS) != (mode->Flags & FLAG_BITS))
        return FALSE;

    /* everything matches */
    return TRUE;
}

static Bool
xf86RandR12CrtcNotify(RRCrtcPtr randr_crtc)
{
    ScreenPtr pScreen = randr_crtc->pScreen;
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
    RRModePtr randr_mode = NULL;
    int x;
    int y;
    Rotation rotation;
    int numOutputs;
    RROutputPtr *randr_outputs;
    RROutputPtr randr_output;
    xf86CrtcPtr crtc = randr_crtc->devPrivate;
    xf86OutputPtr output;
    int i, j;
    DisplayModePtr mode = &crtc->mode;
    Bool ret;

    randr_outputs = malloc(config->num_output * sizeof(RROutputPtr));
    if (!randr_outputs)
        return FALSE;
    x = crtc->x;
    y = crtc->y;
    rotation = crtc->rotation;
    numOutputs = 0;
    randr_mode = NULL;
    for (i = 0; i < config->num_output; i++) {
        output = config->output[i];
        if (output->crtc == crtc) {
            randr_output = output->randr_output;
            randr_outputs[numOutputs++] = randr_output;
            /*
             * We make copies of modes, so pointer equality 
             * isn't sufficient
             */
            for (j = 0; j < randr_output->numModes + randr_output->numUserModes;
                 j++) {
                RRModePtr m =
                    (j <
                     randr_output->numModes ? randr_output->
                     modes[j] : randr_output->userModes[j -
                                                        randr_output->
                                                        numModes]);

                if (xf86RandRModeMatches(m, mode)) {
                    randr_mode = m;
                    break;
                }
            }
        }
    }
    ret = RRCrtcNotify(randr_crtc, randr_mode, x, y,
                       rotation,
                       crtc->transformPresent ? &crtc->transform : NULL,
                       numOutputs, randr_outputs);
    free(randr_outputs);
    return ret;
}

/*
 * Convert a RandR mode to a DisplayMode
 */
static void
xf86RandRModeConvert(ScrnInfoPtr scrn,
                     RRModePtr randr_mode, DisplayModePtr mode)
{
    memset(mode, 0, sizeof(DisplayModeRec));
    mode->status = MODE_OK;

    mode->Clock = randr_mode->mode.dotClock / 1000;

    mode->HDisplay = randr_mode->mode.width;
    mode->HSyncStart = randr_mode->mode.hSyncStart;
    mode->HSyncEnd = randr_mode->mode.hSyncEnd;
    mode->HTotal = randr_mode->mode.hTotal;
    mode->HSkew = randr_mode->mode.hSkew;

    mode->VDisplay = randr_mode->mode.height;
    mode->VSyncStart = randr_mode->mode.vSyncStart;
    mode->VSyncEnd = randr_mode->mode.vSyncEnd;
    mode->VTotal = randr_mode->mode.vTotal;
    mode->VScan = 0;

    mode->Flags = randr_mode->mode.modeFlags & FLAG_BITS;

    xf86SetModeCrtc(mode, scrn->adjustFlags);
}

static Bool
xf86RandR12CrtcSet(ScreenPtr pScreen,
                   RRCrtcPtr randr_crtc,
                   RRModePtr randr_mode,
                   int x,
                   int y,
                   Rotation rotation,
                   int num_randr_outputs, RROutputPtr * randr_outputs)
{
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
    xf86CrtcPtr crtc = randr_crtc->devPrivate;
    RRTransformPtr transform;
    Bool changed = FALSE;
    int o, ro;
    xf86CrtcPtr *save_crtcs;
    Bool save_enabled = crtc->enabled;

    if (!crtc->scrn->vtSema)
        return FALSE;

    save_crtcs = malloc(config->num_output * sizeof(xf86CrtcPtr));
    if ((randr_mode != NULL) != crtc->enabled)
        changed = TRUE;
    else if (randr_mode && !xf86RandRModeMatches(randr_mode, &crtc->mode))
        changed = TRUE;

    if (rotation != crtc->rotation)
        changed = TRUE;

    transform = RRCrtcGetTransform(randr_crtc);
    if ((transform != NULL) != crtc->transformPresent)
        changed = TRUE;
    else if (transform &&
             memcmp(&transform->transform, &crtc->transform.transform,
                    sizeof(transform->transform)) != 0)
        changed = TRUE;

    if (x != crtc->x || y != crtc->y)
        changed = TRUE;
    for (o = 0; o < config->num_output; o++) {
        xf86OutputPtr output = config->output[o];
        xf86CrtcPtr new_crtc;

        save_crtcs[o] = output->crtc;

        if (output->crtc == crtc)
            new_crtc = NULL;
        else
            new_crtc = output->crtc;
        for (ro = 0; ro < num_randr_outputs; ro++)
            if (output->randr_output == randr_outputs[ro]) {
                new_crtc = crtc;
                break;
            }
        if (new_crtc != output->crtc) {
            changed = TRUE;
            output->crtc = new_crtc;
        }
    }
    for (ro = 0; ro < num_randr_outputs; ro++)
        if (randr_outputs[ro]->pendingProperties)
            changed = TRUE;

    /* XXX need device-independent mode setting code through an API */
    if (changed) {
        crtc->enabled = randr_mode != NULL;

        if (randr_mode) {
            DisplayModeRec mode;
            RRTransformPtr transform = RRCrtcGetTransform(randr_crtc);

            xf86RandRModeConvert(pScrn, randr_mode, &mode);
            if (!xf86CrtcSetModeTransform
                (crtc, &mode, rotation, transform, x, y)) {
                crtc->enabled = save_enabled;
                for (o = 0; o < config->num_output; o++) {
                    xf86OutputPtr output = config->output[o];

                    output->crtc = save_crtcs[o];
                }
                free(save_crtcs);
                return FALSE;
            }
            xf86RandR13VerifyPanningArea(crtc, pScreen->width, pScreen->height);
            xf86RandR13Pan(crtc, randrp->pointerX, randrp->pointerY);
            /*
             * Save the last successful setting for EnterVT
             */
            crtc->desiredMode = mode;
            crtc->desiredRotation = rotation;
            if (transform) {
                crtc->desiredTransform = *transform;
                crtc->desiredTransformPresent = TRUE;
            }
            else
                crtc->desiredTransformPresent = FALSE;

            crtc->desiredX = x;
            crtc->desiredY = y;
        }
        xf86DisableUnusedFunctions(pScrn);
    }
    free(save_crtcs);
    return xf86RandR12CrtcNotify(randr_crtc);
}

static Bool
xf86RandR12CrtcSetGamma(ScreenPtr pScreen, RRCrtcPtr randr_crtc)
{
    xf86CrtcPtr crtc = randr_crtc->devPrivate;

    if (crtc->funcs->gamma_set == NULL)
        return FALSE;

    if (!crtc->scrn->vtSema)
        return TRUE;

    /* Realloc local gamma if needed. */
    if (randr_crtc->gammaSize != crtc->gamma_size) {
        CARD16 *tmp_ptr;

        tmp_ptr =
            realloc(crtc->gamma_red, 3 * crtc->gamma_size * sizeof(CARD16));
        if (!tmp_ptr)
            return FALSE;
        crtc->gamma_red = tmp_ptr;
        crtc->gamma_green = crtc->gamma_red + crtc->gamma_size;
        crtc->gamma_blue = crtc->gamma_green + crtc->gamma_size;
    }

    crtc->gamma_size = randr_crtc->gammaSize;
    memcpy(crtc->gamma_red, randr_crtc->gammaRed,
           crtc->gamma_size * sizeof(CARD16));
    memcpy(crtc->gamma_green, randr_crtc->gammaGreen,
           crtc->gamma_size * sizeof(CARD16));
    memcpy(crtc->gamma_blue, randr_crtc->gammaBlue,
           crtc->gamma_size * sizeof(CARD16));

    /* Only set it when the crtc is actually running.
     * Otherwise it will be set when it's activated.
     */
    if (crtc->active)
        crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,
                               crtc->gamma_blue, crtc->gamma_size);

    return TRUE;
}

static Bool
xf86RandR12CrtcGetGamma(ScreenPtr pScreen, RRCrtcPtr randr_crtc)
{
    xf86CrtcPtr crtc = randr_crtc->devPrivate;

    if (!crtc->gamma_size)
        return FALSE;

    if (!crtc->gamma_red || !crtc->gamma_green || !crtc->gamma_blue)
        return FALSE;

    /* Realloc randr gamma if needed. */
    if (randr_crtc->gammaSize != crtc->gamma_size) {
        CARD16 *tmp_ptr;

        tmp_ptr =
            realloc(randr_crtc->gammaRed,
                    3 * crtc->gamma_size * sizeof(CARD16));
        if (!tmp_ptr)
            return FALSE;
        randr_crtc->gammaRed = tmp_ptr;
        randr_crtc->gammaGreen = randr_crtc->gammaRed + crtc->gamma_size;
        randr_crtc->gammaBlue = randr_crtc->gammaGreen + crtc->gamma_size;
    }
    randr_crtc->gammaSize = crtc->gamma_size;
    memcpy(randr_crtc->gammaRed, crtc->gamma_red,
           crtc->gamma_size * sizeof(CARD16));
    memcpy(randr_crtc->gammaGreen, crtc->gamma_green,
           crtc->gamma_size * sizeof(CARD16));
    memcpy(randr_crtc->gammaBlue, crtc->gamma_blue,
           crtc->gamma_size * sizeof(CARD16));

    return TRUE;
}

static Bool
xf86RandR12OutputSetProperty(ScreenPtr pScreen,
                             RROutputPtr randr_output,
                             Atom property, RRPropertyValuePtr value)
{
    xf86OutputPtr output = randr_output->devPrivate;

    /* If we don't have any property handler, then we don't care what the
     * user is setting properties to.
     */
    if (output->funcs->set_property == NULL)
        return TRUE;

    /*
     * This function gets called even when vtSema is FALSE, as
     * drivers will need to remember the correct value to apply
     * when the VT switch occurs
     */
    return output->funcs->set_property(output, property, value);
}

static Bool
xf86RandR13OutputGetProperty(ScreenPtr pScreen,
                             RROutputPtr randr_output, Atom property)
{
    xf86OutputPtr output = randr_output->devPrivate;

    if (output->funcs->get_property == NULL)
        return TRUE;

    /* Should be safe even w/o vtSema */
    return output->funcs->get_property(output, property);
}

static Bool
xf86RandR12OutputValidateMode(ScreenPtr pScreen,
                              RROutputPtr randr_output, RRModePtr randr_mode)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    xf86OutputPtr output = randr_output->devPrivate;
    DisplayModeRec mode;

    xf86RandRModeConvert(pScrn, randr_mode, &mode);
    /*
     * This function may be called when vtSema is FALSE, so
     * the underlying function must either avoid touching the hardware
     * or return FALSE when vtSema is FALSE
     */
    if (output->funcs->mode_valid(output, &mode) != MODE_OK)
        return FALSE;
    return TRUE;
}

static void
xf86RandR12ModeDestroy(ScreenPtr pScreen, RRModePtr randr_mode)
{
}

/**
 * Given a list of xf86 modes and a RandR Output object, construct
 * RandR modes and assign them to the output
 */
static Bool
xf86RROutputSetModes(RROutputPtr randr_output, DisplayModePtr modes)
{
    DisplayModePtr mode;
    RRModePtr *rrmodes = NULL;
    int nmode = 0;
    int npreferred = 0;
    Bool ret = TRUE;
    int pref;

    for (mode = modes; mode; mode = mode->next)
        nmode++;

    if (nmode) {
        rrmodes = malloc(nmode * sizeof(RRModePtr));

        if (!rrmodes)
            return FALSE;
        nmode = 0;

        for (pref = 1; pref >= 0; pref--) {
            for (mode = modes; mode; mode = mode->next) {
                if ((pref != 0) == ((mode->type & M_T_PREFERRED) != 0)) {
                    xRRModeInfo modeInfo;
                    RRModePtr rrmode;

                    modeInfo.nameLength = strlen(mode->name);
                    modeInfo.width = mode->HDisplay;
                    modeInfo.dotClock = mode->Clock * 1000;
                    modeInfo.hSyncStart = mode->HSyncStart;
                    modeInfo.hSyncEnd = mode->HSyncEnd;
                    modeInfo.hTotal = mode->HTotal;
                    modeInfo.hSkew = mode->HSkew;

                    modeInfo.height = mode->VDisplay;
                    modeInfo.vSyncStart = mode->VSyncStart;
                    modeInfo.vSyncEnd = mode->VSyncEnd;
                    modeInfo.vTotal = mode->VTotal;
                    modeInfo.modeFlags = mode->Flags;

                    rrmode = RRModeGet(&modeInfo, mode->name);
                    if (rrmode) {
                        rrmodes[nmode++] = rrmode;
                        npreferred += pref;
                    }
                }
            }
        }
    }

    ret = RROutputSetModes(randr_output, rrmodes, nmode, npreferred);
    free(rrmodes);
    return ret;
}

/*
 * Mirror the current mode configuration to RandR
 */
static Bool
xf86RandR12SetInfo12(ScreenPtr pScreen)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
    RROutputPtr *clones;
    RRCrtcPtr *crtcs;
    int ncrtc;
    int o, c, l;
    RRCrtcPtr randr_crtc;
    int nclone;

    clones = malloc(config->num_output * sizeof(RROutputPtr));
    crtcs = malloc(config->num_crtc * sizeof(RRCrtcPtr));
    for (o = 0; o < config->num_output; o++) {
        xf86OutputPtr output = config->output[o];

        ncrtc = 0;
        for (c = 0; c < config->num_crtc; c++)
            if (output->possible_crtcs & (1 << c))
                crtcs[ncrtc++] = config->crtc[c]->randr_crtc;

        if (output->crtc)
            randr_crtc = output->crtc->randr_crtc;
        else
            randr_crtc = NULL;

        if (!RROutputSetCrtcs(output->randr_output, crtcs, ncrtc)) {
            free(crtcs);
            free(clones);
            return FALSE;
        }

        RROutputSetPhysicalSize(output->randr_output,
                                output->mm_width, output->mm_height);
        xf86RROutputSetModes(output->randr_output, output->probed_modes);

        switch (output->status) {
        case XF86OutputStatusConnected:
            RROutputSetConnection(output->randr_output, RR_Connected);
            break;
        case XF86OutputStatusDisconnected:
            RROutputSetConnection(output->randr_output, RR_Disconnected);
            break;
        case XF86OutputStatusUnknown:
            RROutputSetConnection(output->randr_output, RR_UnknownConnection);
            break;
        }

        RROutputSetSubpixelOrder(output->randr_output, output->subpixel_order);

        /*
         * Valid clones
         */
        nclone = 0;
        for (l = 0; l < config->num_output; l++) {
            xf86OutputPtr clone = config->output[l];

            if (l != o && (output->possible_clones & (1 << l)))
                clones[nclone++] = clone->randr_output;
        }
        if (!RROutputSetClones(output->randr_output, clones, nclone)) {
            free(crtcs);
            free(clones);
            return FALSE;
        }
    }
    free(crtcs);
    free(clones);
    return TRUE;
}

/*
 * Query the hardware for the current state, then mirror
 * that to RandR
 */
static Bool
xf86RandR12GetInfo12(ScreenPtr pScreen, Rotation * rotations)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];

    if (!pScrn->vtSema)
        return TRUE;
    xf86ProbeOutputModes(pScrn, 0, 0);
    xf86SetScrnInfoModes(pScrn);
    return xf86RandR12SetInfo12(pScreen);
}

static Bool
xf86RandR12CreateObjects12(ScreenPtr pScreen)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
    int c;
    int o;

    if (!RRInit())
        return FALSE;

    /*
     * Configure crtcs
     */
    for (c = 0; c < config->num_crtc; c++) {
        xf86CrtcPtr crtc = config->crtc[c];

        crtc->randr_crtc = RRCrtcCreate(pScreen, crtc);
        RRCrtcGammaSetSize(crtc->randr_crtc, 256);
    }
    /*
     * Configure outputs
     */
    for (o = 0; o < config->num_output; o++) {
        xf86OutputPtr output = config->output[o];

        output->randr_output = RROutputCreate(pScreen, output->name,
                                              strlen(output->name), output);

        if (output->funcs->create_resources != NULL)
            output->funcs->create_resources(output);
        RRPostPendingProperties(output->randr_output);
    }
    return TRUE;
}

static Bool
xf86RandR12CreateScreenResources12(ScreenPtr pScreen)
{
    int c;
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);

    if (xf86RandR12Key == NULL)
        return TRUE;

    for (c = 0; c < config->num_crtc; c++)
        xf86RandR12CrtcNotify(config->crtc[c]->randr_crtc);

    RRScreenSetSizeRange(pScreen, config->minWidth, config->minHeight,
                         config->maxWidth, config->maxHeight);
    return TRUE;
}

/*
 * Something happened within the screen configuration due
 * to DGA, VidMode or hot key. Tell RandR
 */

void
xf86RandR12TellChanged(ScreenPtr pScreen)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
    int c;

    if (xf86RandR12Key == NULL)
        return;

    xf86RandR12SetInfo12(pScreen);
    for (c = 0; c < config->num_crtc; c++)
        xf86RandR12CrtcNotify(config->crtc[c]->randr_crtc);

    RRTellChanged(pScreen);
}

static void
xf86RandR12PointerMoved(int scrnIndex, int x, int y)
{
    ScreenPtr pScreen = screenInfo.screens[scrnIndex];
    ScrnInfoPtr pScrn = XF86SCRNINFO(pScreen);
    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    int c;

    randrp->pointerX = x;
    randrp->pointerY = y;
    for (c = 0; c < config->num_crtc; c++)
        xf86RandR13Pan(config->crtc[c], x, y);
}

static Bool
xf86RandR13GetPanning(ScreenPtr pScreen,
                      RRCrtcPtr randr_crtc,
                      BoxPtr totalArea, BoxPtr trackingArea, INT16 *border)
{
    xf86CrtcPtr crtc = randr_crtc->devPrivate;

    if (crtc->version < 2)
        return FALSE;
    if (totalArea)
        memcpy(totalArea, &crtc->panningTotalArea, sizeof(BoxRec));
    if (trackingArea)
        memcpy(trackingArea, &crtc->panningTrackingArea, sizeof(BoxRec));
    if (border)
        memcpy(border, crtc->panningBorder, 4 * sizeof(INT16));

    return TRUE;
}

static Bool
xf86RandR13SetPanning(ScreenPtr pScreen,
                      RRCrtcPtr randr_crtc,
                      BoxPtr totalArea, BoxPtr trackingArea, INT16 *border)
{
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    xf86CrtcPtr crtc = randr_crtc->devPrivate;
    BoxRec oldTotalArea;
    BoxRec oldTrackingArea;
    INT16 oldBorder[4];

    if (crtc->version < 2)
        return FALSE;

    memcpy(&oldTotalArea, &crtc->panningTotalArea, sizeof(BoxRec));
    memcpy(&oldTrackingArea, &crtc->panningTrackingArea, sizeof(BoxRec));
    memcpy(oldBorder, crtc->panningBorder, 4 * sizeof(INT16));

    if (totalArea)
        memcpy(&crtc->panningTotalArea, totalArea, sizeof(BoxRec));
    if (trackingArea)
        memcpy(&crtc->panningTrackingArea, trackingArea, sizeof(BoxRec));
    if (border)
        memcpy(crtc->panningBorder, border, 4 * sizeof(INT16));

    if (xf86RandR13VerifyPanningArea(crtc, pScreen->width, pScreen->height)) {
        xf86RandR13Pan(crtc, randrp->pointerX, randrp->pointerY);
        return TRUE;
    }
    else {
        /* Restore old settings */
        memcpy(&crtc->panningTotalArea, &oldTotalArea, sizeof(BoxRec));
        memcpy(&crtc->panningTrackingArea, &oldTrackingArea, sizeof(BoxRec));
        memcpy(crtc->panningBorder, oldBorder, 4 * sizeof(INT16));
        return FALSE;
    }
}

/*
 * Compatibility with XF86VidMode's gamma changer.  This necessarily clobbers
 * any per-crtc setup.  You asked for it...
 */

static void
gamma_to_ramp(float gamma, CARD16 *ramp, int size)
{
    int i;

    for (i = 0; i < size; i++) {
        if (gamma == 1.0)
            ramp[i] = i << 8;
        else
            ramp[i] =
                (CARD16) (pow((double) i / (double) (size - 1), 1. / gamma)
                          * (double) (size - 1) * 256);
    }
}

static int
xf86RandR12ChangeGamma(int scrnIndex, Gamma gamma)
{
    CARD16 *points, *red, *green, *blue;
    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
    RRCrtcPtr crtc = xf86CompatRRCrtc(pScrn);
    int size;

    if (!crtc)
        return Success;

    size = max(0, crtc->gammaSize);
    if (!size)
        return Success;

    points = calloc(size, 3 * sizeof(CARD16));
    if (!points)
        return BadAlloc;

    red = points;
    green = points + size;
    blue = points + 2 * size;

    gamma_to_ramp(gamma.red, red, size);
    gamma_to_ramp(gamma.green, green, size);
    gamma_to_ramp(gamma.blue, blue, size);
    RRCrtcGammaSet(crtc, red, green, blue);

    free(points);

    pScrn->gamma = gamma;

    return Success;
}

static Bool
xf86RandR12EnterVT(int screen_index, int flags)
{
    ScreenPtr pScreen = screenInfo.screens[screen_index];
    ScrnInfoPtr pScrn = xf86Screens[screen_index];
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    rrScrPrivPtr rp = rrGetScrPriv(pScreen);
    Bool ret;
    int i;

    if (randrp->orig_EnterVT) {
        pScrn->EnterVT = randrp->orig_EnterVT;
        ret = pScrn->EnterVT(screen_index, flags);
        randrp->orig_EnterVT = pScrn->EnterVT;
        pScrn->EnterVT = xf86RandR12EnterVT;
        if (!ret)
            return FALSE;
    }

    /* reload gamma */
    for (i = 0; i < rp->numCrtcs; i++)
        xf86RandR12CrtcSetGamma(pScreen, rp->crtcs[i]);

    return RRGetInfo(pScreen, TRUE);    /* force a re-probe of outputs and notify clients about changes */
}

static Bool
xf86RandR12Init12(ScreenPtr pScreen)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    rrScrPrivPtr rp = rrGetScrPriv(pScreen);
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    int i;

    rp->rrGetInfo = xf86RandR12GetInfo12;
    rp->rrScreenSetSize = xf86RandR12ScreenSetSize;
    rp->rrCrtcSet = xf86RandR12CrtcSet;
    rp->rrCrtcSetGamma = xf86RandR12CrtcSetGamma;
    rp->rrCrtcGetGamma = xf86RandR12CrtcGetGamma;
    rp->rrOutputSetProperty = xf86RandR12OutputSetProperty;
    rp->rrOutputValidateMode = xf86RandR12OutputValidateMode;
#if RANDR_13_INTERFACE
    rp->rrOutputGetProperty = xf86RandR13OutputGetProperty;
    rp->rrGetPanning = xf86RandR13GetPanning;
    rp->rrSetPanning = xf86RandR13SetPanning;
#endif
    rp->rrModeDestroy = xf86RandR12ModeDestroy;
    rp->rrSetConfig = NULL;
    pScrn->PointerMoved = xf86RandR12PointerMoved;
    pScrn->ChangeGamma = xf86RandR12ChangeGamma;

    randrp->orig_EnterVT = pScrn->EnterVT;
    pScrn->EnterVT = xf86RandR12EnterVT;

    if (!xf86RandR12CreateObjects12(pScreen))
        return FALSE;

    /*
     * Configure output modes
     */
    if (!xf86RandR12SetInfo12(pScreen))
        return FALSE;
    for (i = 0; i < rp->numCrtcs; i++) {
        xf86RandR12CrtcGetGamma(pScreen, rp->crtcs[i]);
    }
    return TRUE;
}

#endif

Bool
xf86RandR12PreInit(ScrnInfoPtr pScrn)
{
    return TRUE;
}