xorg-server-1.4/hw/xfree86/common/xf86RandR.c

   1 /*
   2  *
   3  * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and its
   6  * documentation for any purpose is hereby granted without fee, provided that
   7  * the above copyright notice appear in all copies and that both that
   8  * copyright notice and this permission notice appear in supporting
   9  * documentation, and that the name of Keith Packard not be used in
  10  * advertising or publicity pertaining to distribution of the software without
  11  * specific, written prior permission.  Keith Packard makes no
  12  * representations about the suitability of this software for any purpose.  It
  13  * is provided "as is" without express or implied warranty.
  14  *
  15  * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  17  * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  18  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  19  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  20  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  21  * PERFORMANCE OF THIS SOFTWARE.
  22  */
  23
  24 #ifdef HAVE_XORG_CONFIG_H
  25 #include <xorg-config.h>
  26 #endif
  27
  28 #include <X11/X.h>
  29 #include "os.h"
  30 #include "mibank.h"
  31 #include "globals.h"
  32 #include "xf86.h"
  33 #include "xf86Priv.h"
  34 #include "xf86DDC.h"
  35 #include "mipointer.h"
  36 #include <randrstr.h>
  37
  38 typedef struct _xf86RandRInfo {
  39     CreateScreenResourcesProcPtr    CreateScreenResources;
  40     CloseScreenProcPtr              CloseScreen;
  41     int                             virtualX;
  42     int                             virtualY;
  43     int                             mmWidth;
  44     int                             mmHeight;
  45     Rotation                        rotation;
  46 } XF86RandRInfoRec, *XF86RandRInfoPtr;
  47
  48 static int          xf86RandRIndex = -1;
  49 static int          xf86RandRGeneration;
  50
  51 #define XF86RANDRINFO(p)    ((XF86RandRInfoPtr) (p)->devPrivates[xf86RandRIndex].ptr)
  52
  53 static int
  54 xf86RandRModeRefresh (DisplayModePtr mode)
  55 {
  56     if (mode->VRefresh)
  57         return (int) (mode->VRefresh + 0.5);
  58     else
  59         return (int) (mode->Clock * 1000.0 / mode->HTotal / mode->VTotal + 0.5);
  60 }
  61
  62 static Bool
  63 xf86RandRGetInfo (ScreenPtr pScreen, Rotation *rotations)
  64 {
  65     RRScreenSizePtr         pSize;
  66     ScrnInfoPtr             scrp = XF86SCRNINFO(pScreen);
  67     XF86RandRInfoPtr        randrp = XF86RANDRINFO(pScreen);
  68     DisplayModePtr          mode;
  69     int                     refresh0 = 60;
  70     xorgRRModeMM            RRModeMM;
  71
  72     *rotations = RR_Rotate_0;
  73
  74     for (mode = scrp->modes; ; mode = mode->next)
  75     {
  76         int refresh = xf86RandRModeRefresh (mode);
  77
  78         if (mode == scrp->modes)
  79             refresh0 = refresh;
  80
  81         RRModeMM.mode = mode;
  82         RRModeMM.virtX = randrp->virtualX;
  83         RRModeMM.virtY = randrp->virtualY;
  84         RRModeMM.mmWidth = randrp->mmWidth;
  85         RRModeMM.mmHeight = randrp->mmHeight;
  86
  87         if(scrp->DriverFunc) {
  88            (*scrp->DriverFunc)(scrp, RR_GET_MODE_MM, &RRModeMM);
  89         }
  90
  91         pSize = RRRegisterSize (pScreen,
  92                                 mode->HDisplay, mode->VDisplay,
  93                                 RRModeMM.mmWidth, RRModeMM.mmHeight);
  94         if (!pSize)
  95             return FALSE;
  96         RRRegisterRate (pScreen, pSize, refresh);
  97         if (mode == scrp->currentMode &&
  98             mode->HDisplay == scrp->virtualX && mode->VDisplay == scrp->virtualY)
  99             RRSetCurrentConfig (pScreen, randrp->rotation, refresh, pSize);
 100         if (mode->next == scrp->modes)
 101             break;
 102     }
 103     if (scrp->currentMode->HDisplay != randrp->virtualX ||
 104         scrp->currentMode->VDisplay != randrp->virtualY)
 105     {
 106         mode = scrp->modes;
 107
 108         RRModeMM.mode = NULL;
 109         RRModeMM.virtX = randrp->virtualX;
 110         RRModeMM.virtY = randrp->virtualY;
 111         RRModeMM.mmWidth = randrp->mmWidth;
 112         RRModeMM.mmHeight = randrp->mmHeight;
 113
 114         if(scrp->DriverFunc) {
 115            (*scrp->DriverFunc)(scrp, RR_GET_MODE_MM, &RRModeMM);
 116         }
 117
 118         pSize = RRRegisterSize (pScreen,
 119                                 randrp->virtualX, randrp->virtualY,
 120                                 RRModeMM.mmWidth, RRModeMM.mmHeight);
 121         if (!pSize)
 122             return FALSE;
 123         RRRegisterRate (pScreen, pSize, refresh0);
 124         if (scrp->virtualX == randrp->virtualX &&
 125             scrp->virtualY == randrp->virtualY)
 126         {
 127             RRSetCurrentConfig (pScreen, randrp->rotation, refresh0, pSize);
 128         }
 129     }
 130
 131     /* If there is driver support for randr, let it set our supported rotations */
 132     if(scrp->DriverFunc) {
 133         xorgRRRotation RRRotation;
 134
 135         RRRotation.RRRotations = *rotations;
 136         if (!(*scrp->DriverFunc)(scrp, RR_GET_INFO, &RRRotation))
 137             return TRUE;
 138         *rotations = RRRotation.RRRotations;
 139     }
 140
 141     return TRUE;
 142 }
 143
 144 static Bool
 145 xf86RandRSetMode (ScreenPtr         pScreen,
 146                   DisplayModePtr    mode,
 147                   Bool              useVirtual,
 148                   int               mmWidth,
 149                   int               mmHeight)
 150 {
 151     ScrnInfoPtr         scrp = XF86SCRNINFO(pScreen);
 152     XF86RandRInfoPtr    randrp = XF86RANDRINFO(pScreen);
 153     int                 oldWidth = pScreen->width;
 154     int                 oldHeight = pScreen->height;
 155     int                 oldmmWidth = pScreen->mmWidth;
 156     int                 oldmmHeight = pScreen->mmHeight;
 157     int                 oldVirtualX = scrp->virtualX;
 158     int                 oldVirtualY = scrp->virtualY;
 159     WindowPtr           pRoot = WindowTable[pScreen->myNum];
 160     Bool                ret = TRUE;
 161
 162     if (pRoot)
 163         (*scrp->EnableDisableFBAccess) (pScreen->myNum, FALSE);
 164     if (useVirtual)
 165     {
 166         scrp->virtualX = randrp->virtualX;
 167         scrp->virtualY = randrp->virtualY;
 168     }
 169     else
 170     {
 171         scrp->virtualX = mode->HDisplay;
 172         scrp->virtualY = mode->VDisplay;
 173     }
 174     if(randrp->rotation & (RR_Rotate_90 | RR_Rotate_270))
 175     {
 176         /* If the screen is rotated 90 or 270 degrees, swap the sizes. */
 177         pScreen->width = scrp->virtualY;
 178         pScreen->height = scrp->virtualX;
 179         pScreen->mmWidth = mmHeight;
 180         pScreen->mmHeight = mmWidth;
 181     }
 182     else
 183     {
 184         pScreen->width = scrp->virtualX;
 185         pScreen->height = scrp->virtualY;
 186         pScreen->mmWidth = mmWidth;
 187         pScreen->mmHeight = mmHeight;
 188     }
 189     if (!xf86SwitchMode (pScreen, mode))
 190     {
 191         pScreen->width = oldWidth;
 192         pScreen->height = oldHeight;
 193         pScreen->mmWidth = oldmmWidth;
 194         pScreen->mmHeight = oldmmHeight;
 195         scrp->virtualX = oldVirtualX;
 196         scrp->virtualY = oldVirtualY;
 197         ret = FALSE;
 198     }
 199     /*
 200      * Make sure the layout is correct
 201      */
 202     xf86ReconfigureLayout();
 203
 204     /*
 205      * Make sure the whole screen is visible
 206      */
 207     xf86SetViewport (pScreen, pScreen->width, pScreen->height);
 208     xf86SetViewport (pScreen, 0, 0);
 209     if (pRoot)
 210         (*scrp->EnableDisableFBAccess) (pScreen->myNum, TRUE);
 211     return ret;
 212 }
 213
 214 static Bool
 215 xf86RandRSetConfig (ScreenPtr           pScreen,
 216                     Rotation            rotation,
 217                     int                 rate,
 218                     RRScreenSizePtr     pSize)
 219 {
 220     ScrnInfoPtr             scrp = XF86SCRNINFO(pScreen);
 221     XF86RandRInfoPtr        randrp = XF86RANDRINFO(pScreen);
 222     DisplayModePtr          mode;
 223     int                     px, py;
 224     Bool                    useVirtual = FALSE;
 225     Rotation                oldRotation = randrp->rotation;
 226
 227     miPointerPosition (&px, &py);
 228     for (mode = scrp->modes; ; mode = mode->next)
 229     {
 230         if (mode->HDisplay == pSize->width &&
 231             mode->VDisplay == pSize->height &&
 232             (rate == 0 || xf86RandRModeRefresh (mode) == rate))
 233             break;
 234         if (mode->next == scrp->modes)
 235         {
 236             if (pSize->width == randrp->virtualX &&
 237                 pSize->height == randrp->virtualY)
 238             {
 239                 mode = scrp->modes;
 240                 useVirtual = TRUE;
 241                 break;
 242             }
 243             return FALSE;
 244         }
 245     }
 246
 247     if (randrp->rotation != rotation) {
 248
 249         /* Have the driver do its thing. */
 250         if (scrp->DriverFunc) {
 251             xorgRRRotation RRRotation;
 252             RRRotation.RRConfig.rotation = rotation;
 253             RRRotation.RRConfig.rate = rate;
 254             RRRotation.RRConfig.width = pSize->width;
 255             RRRotation.RRConfig.height = pSize->height;
 256
 257             /*
 258              * Currently we need to rely on HW support for rotation.
 259              */
 260             if (!(*scrp->DriverFunc)(scrp, RR_SET_CONFIG, &RRRotation))
 261                 return FALSE;
 262         } else
 263             return FALSE;
 264
 265         randrp->rotation = rotation;
 266     }
 267
 268     if (!xf86RandRSetMode (pScreen, mode, useVirtual, pSize->mmWidth, pSize->mmHeight)) {
 269         if(randrp->rotation != oldRotation) {
 270            /* Have the driver undo its thing. */
 271            if (scrp->DriverFunc) {
 272                xorgRRRotation RRRotation;
 273                RRRotation.RRConfig.rotation = oldRotation;
 274                RRRotation.RRConfig.rate = xf86RandRModeRefresh (scrp->currentMode);
 275                RRRotation.RRConfig.width = scrp->virtualX;
 276                RRRotation.RRConfig.height = scrp->virtualY;
 277                (*scrp->DriverFunc)(scrp, RR_SET_CONFIG, &RRRotation);
 278            }
 279
 280            randrp->rotation = oldRotation;
 281         }
 282         return FALSE;
 283     }
 284     /*
 285      * Move the cursor back where it belongs; SwitchMode repositions it
 286      */
 287     if (pScreen == miPointerCurrentScreen ())
 288     {
 289         px = (px >= pScreen->width ? (pScreen->width - 1) : px);
 290         py = (py >= pScreen->height ? (pScreen->height - 1) : py);
 291
 292         xf86SetViewport(pScreen, px, py);
 293
 294         (*pScreen->SetCursorPosition) (pScreen, px, py, FALSE);
 295     }
 296
 297     return TRUE;
 298 }
 299
 300 /*
 301  * Wait until the screen is initialized before whacking the
 302  * sizes around; otherwise the screen pixmap will be allocated
 303  * at the current mode size rather than the maximum size
 304  */
 305 static Bool
 306 xf86RandRCreateScreenResources (ScreenPtr pScreen)
 307 {
 308     XF86RandRInfoPtr        randrp = XF86RANDRINFO(pScreen);
 309 #if 0
 310     ScrnInfoPtr             scrp = XF86SCRNINFO(pScreen);
 311     DisplayModePtr          mode;
 312 #endif
 313
 314     pScreen->CreateScreenResources = randrp->CreateScreenResources;
 315     if (!(*pScreen->CreateScreenResources) (pScreen))
 316         return FALSE;
 317
 318 #if 0
 319     mode = scrp->currentMode;
 320     if (mode)
 321         xf86RandRSetMode (pScreen, mode, TRUE);
 322 #endif
 323
 324     return TRUE;
 325 }
 326
 327 /*
 328  * Reset size back to original
 329  */
 330 static Bool
 331 xf86RandRCloseScreen (int index, ScreenPtr pScreen)
 332 {
 333     ScrnInfoPtr             scrp = XF86SCRNINFO(pScreen);
 334     XF86RandRInfoPtr        randrp = XF86RANDRINFO(pScreen);
 335
 336     scrp->virtualX = pScreen->width = randrp->virtualX;
 337     scrp->virtualY = pScreen->height = randrp->virtualY;
 338     scrp->currentMode = scrp->modes;
 339     pScreen->CloseScreen = randrp->CloseScreen;
 340     xfree (randrp);
 341     pScreen->devPrivates[xf86RandRIndex].ptr = 0;
 342     return (*pScreen->CloseScreen) (index, pScreen);
 343 }
 344
 345 _X_EXPORT Rotation
 346 xf86GetRotation(ScreenPtr pScreen)
 347 {
 348     if (xf86RandRIndex == -1)
 349        return RR_Rotate_0;
 350
 351     return XF86RANDRINFO(pScreen)->rotation;
 352 }
 353
 354 /* Function to change RandR's idea of the virtual screen size */
 355 _X_EXPORT Bool
 356 xf86RandRSetNewVirtualAndDimensions(ScreenPtr pScreen,
 357         int newvirtX, int newvirtY, int newmmWidth, int newmmHeight,
 358         Bool resetMode)
 359 {
 360     XF86RandRInfoPtr randrp;
 361
 362     if (xf86RandRIndex == -1)
 363         return FALSE;
 364
 365     randrp = XF86RANDRINFO(pScreen);
 366     if (randrp == NULL)
 367         return FALSE;
 368
 369     if (newvirtX > 0)
 370         randrp->virtualX = newvirtX;
 371
 372     if (newvirtY > 0)
 373         randrp->virtualY = newvirtY;
 374
 375     if (newmmWidth > 0)
 376         randrp->mmWidth = newmmWidth;
 377
 378     if (newmmHeight > 0)
 379         randrp->mmHeight = newmmHeight;
 380
 381     /* This is only for during server start */
 382     if (resetMode) {
 383         return (xf86RandRSetMode(pScreen,
 384                   XF86SCRNINFO(pScreen)->currentMode,
 385                   TRUE,
 386                   pScreen->mmWidth, pScreen->mmHeight));
 387     }
 388
 389     return TRUE;
 390 }
 391
 392 Bool
 393 xf86RandRInit (ScreenPtr    pScreen)
 394 {
 395     rrScrPrivPtr        rp;
 396     XF86RandRInfoPtr    randrp;
 397     ScrnInfoPtr         scrp = XF86SCRNINFO(pScreen);
 398
 399 #ifdef PANORAMIX
 400     /* XXX disable RandR when using Xinerama */
 401     if (!noPanoramiXExtension)
 402         return TRUE;
 403 #endif
 404     if (xf86RandRGeneration != serverGeneration)
 405     {
 406         xf86RandRIndex = AllocateScreenPrivateIndex();
 407         xf86RandRGeneration = serverGeneration;
 408     }
 409
 410     randrp = xalloc (sizeof (XF86RandRInfoRec));
 411     if (!randrp)
 412         return FALSE;
 413
 414     if (!RRScreenInit (pScreen))
 415     {
 416         xfree (randrp);
 417         return FALSE;
 418     }
 419     rp = rrGetScrPriv(pScreen);
 420     rp->rrGetInfo = xf86RandRGetInfo;
 421     rp->rrSetConfig = xf86RandRSetConfig;
 422
 423     randrp->virtualX = scrp->virtualX;
 424     randrp->virtualY = scrp->virtualY;
 425     randrp->mmWidth = pScreen->mmWidth;
 426     randrp->mmHeight = pScreen->mmHeight;
 427
 428     randrp->CreateScreenResources = pScreen->CreateScreenResources;
 429     pScreen->CreateScreenResources = xf86RandRCreateScreenResources;
 430
 431     randrp->CloseScreen = pScreen->CloseScreen;
 432     pScreen->CloseScreen = xf86RandRCloseScreen;
 433
 434     randrp->rotation = RR_Rotate_0;
 435
 436     pScreen->devPrivates[xf86RandRIndex].ptr = randrp;
 437     return TRUE;
 438 }
 439
 440