xorg-server-1.4/hw/kdrive/fake/fake.c

   1 /*
   2  * Copyright © 2004 Keith Packard
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of Keith Packard not be used in
   9  * advertising or publicity pertaining to distribution of the software without
  10  * specific, written prior permission.  Keith Packard makes no
  11  * representations about the suitability of this software for any purpose.  It
  12  * is provided "as is" without express or implied warranty.
  13  *
  14  * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  20  * PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <kdrive-config.h>
  25 #endif
  26 #include "fake.h"
  27
  28 extern int KdTsPhyScreen;
  29
  30 Bool
  31 fakeInitialize (KdCardInfo *card, FakePriv *priv)
  32 {
  33     priv->base = 0;
  34     priv->bytes_per_line = 0;
  35     return TRUE;
  36 }
  37
  38 Bool
  39 fakeCardInit (KdCardInfo *card)
  40 {
  41     FakePriv    *priv;
  42
  43     priv = (FakePriv *) xalloc (sizeof (FakePriv));
  44     if (!priv)
  45         return FALSE;
  46
  47     if (!fakeInitialize (card, priv))
  48     {
  49         xfree (priv);
  50         return FALSE;
  51     }
  52     card->driver = priv;
  53
  54     return TRUE;
  55 }
  56
  57 Bool
  58 fakeScreenInitialize (KdScreenInfo *screen, FakeScrPriv *scrpriv)
  59 {
  60     if (!screen->width || !screen->height)
  61     {
  62         screen->width = 1024;
  63         screen->height = 768;
  64         screen->rate = 72;
  65     }
  66
  67     if (screen->width <= 0)
  68         screen->width = 1;
  69     if (screen->height <= 0)
  70         screen->height = 1;
  71
  72     if (!screen->fb[0].depth)
  73         screen->fb[0].depth = 16;
  74
  75     if (screen->fb[0].depth <= 8)
  76     {
  77         screen->fb[0].visuals = ((1 << StaticGray) |
  78                                  (1 << GrayScale) |
  79                                  (1 << StaticColor) |
  80                                  (1 << PseudoColor) |
  81                                  (1 << TrueColor) |
  82                                  (1 << DirectColor));
  83     }
  84     else
  85     {
  86         screen->fb[0].visuals = (1 << TrueColor);
  87 #define Mask(o,l)   (((1 << l) - 1) << o)
  88         if (screen->fb[0].depth <= 15)
  89         {
  90             screen->fb[0].depth = 15;
  91             screen->fb[0].bitsPerPixel = 16;
  92             screen->fb[0].redMask = Mask (10, 5);
  93             screen->fb[0].greenMask = Mask (5, 5);
  94             screen->fb[0].blueMask = Mask (0, 5);
  95         }
  96         else if (screen->fb[0].depth <= 16)
  97         {
  98             screen->fb[0].depth = 16;
  99             screen->fb[0].bitsPerPixel = 16;
 100             screen->fb[0].redMask = Mask (11, 5);
 101             screen->fb[0].greenMask = Mask (5, 6);
 102             screen->fb[0].blueMask = Mask (0, 5);
 103         }
 104         else
 105         {
 106             screen->fb[0].depth = 24;
 107             screen->fb[0].bitsPerPixel = 32;
 108             screen->fb[0].redMask = Mask (16, 8);
 109             screen->fb[0].greenMask = Mask (8, 8);
 110             screen->fb[0].blueMask = Mask (0, 8);
 111         }
 112     }
 113
 114     scrpriv->randr = screen->randr;
 115
 116     return fakeMapFramebuffer (screen);
 117 }
 118
 119 Bool
 120 fakeScreenInit (KdScreenInfo *screen)
 121 {
 122     FakeScrPriv *scrpriv;
 123
 124     scrpriv = xalloc (sizeof (FakeScrPriv));
 125     if (!scrpriv)
 126         return FALSE;
 127     memset (scrpriv, '\0', sizeof (FakeScrPriv));
 128     screen->driver = scrpriv;
 129     if (!fakeScreenInitialize (screen, scrpriv))
 130     {
 131         screen->driver = 0;
 132         xfree (scrpriv);
 133         return FALSE;
 134     }
 135     return TRUE;
 136 }
 137
 138 void *
 139 fakeWindowLinear (ScreenPtr     pScreen,
 140                    CARD32       row,
 141                    CARD32       offset,
 142                    int          mode,
 143                    CARD32       *size,
 144                    void         *closure)
 145 {
 146     KdScreenPriv(pScreen);
 147     FakePriv        *priv = pScreenPriv->card->driver;
 148
 149     if (!pScreenPriv->enabled)
 150         return 0;
 151     *size = priv->bytes_per_line;
 152     return priv->base + row * priv->bytes_per_line;
 153 }
 154
 155 Bool
 156 fakeMapFramebuffer (KdScreenInfo *screen)
 157 {
 158     FakeScrPriv *scrpriv = screen->driver;
 159     KdPointerMatrix     m;
 160     FakePriv            *priv = screen->card->driver;
 161
 162     if (scrpriv->randr != RR_Rotate_0)
 163         scrpriv->shadow = TRUE;
 164     else
 165         scrpriv->shadow = FALSE;
 166
 167     KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
 168
 169     KdSetPointerMatrix (&m);
 170
 171     priv->bytes_per_line = ((screen->width * screen->fb[0].bitsPerPixel + 31) >> 5) << 2;
 172     if (priv->base)
 173         free (priv->base);
 174     priv->base = malloc (priv->bytes_per_line * screen->height);
 175     screen->memory_base = (CARD8 *) (priv->base);
 176     screen->memory_size = 0;
 177     screen->off_screen_base = 0;
 178
 179     if (scrpriv->shadow)
 180     {
 181         if (!KdShadowFbAlloc (screen, 0,
 182                               scrpriv->randr & (RR_Rotate_90|RR_Rotate_270)))
 183             return FALSE;
 184     }
 185     else
 186     {
 187         screen->fb[0].byteStride = priv->bytes_per_line;
 188         screen->fb[0].pixelStride = (priv->bytes_per_line * 8/
 189                                      screen->fb[0].bitsPerPixel);
 190         screen->fb[0].frameBuffer = (CARD8 *) (priv->base);
 191     }
 192
 193     return TRUE;
 194 }
 195
 196 void
 197 fakeSetScreenSizes (ScreenPtr pScreen)
 198 {
 199     KdScreenPriv(pScreen);
 200     KdScreenInfo        *screen = pScreenPriv->screen;
 201     FakeScrPriv *scrpriv = screen->driver;
 202
 203     if (scrpriv->randr & (RR_Rotate_0|RR_Rotate_180))
 204     {
 205         pScreen->width = screen->width;
 206         pScreen->height = screen->height;
 207         pScreen->mmWidth = screen->width_mm;
 208         pScreen->mmHeight = screen->height_mm;
 209     }
 210     else
 211     {
 212         pScreen->width = screen->width;
 213         pScreen->height = screen->height;
 214         pScreen->mmWidth = screen->height_mm;
 215         pScreen->mmHeight = screen->width_mm;
 216     }
 217 }
 218
 219 Bool
 220 fakeUnmapFramebuffer (KdScreenInfo *screen)
 221 {
 222     FakePriv            *priv = screen->card->driver;
 223     KdShadowFbFree (screen, 0);
 224     if (priv->base)
 225     {
 226         free (priv->base);
 227         priv->base = 0;
 228     }
 229     return TRUE;
 230 }
 231
 232 Bool
 233 fakeSetShadow (ScreenPtr pScreen)
 234 {
 235     KdScreenPriv(pScreen);
 236     KdScreenInfo        *screen = pScreenPriv->screen;
 237     FakeScrPriv *scrpriv = screen->driver;
 238     ShadowUpdateProc    update;
 239     ShadowWindowProc    window;
 240
 241     window = fakeWindowLinear;
 242     update = 0;
 243     if (scrpriv->randr)
 244         update = shadowUpdateRotatePacked;
 245     else
 246         update = shadowUpdatePacked;
 247     return KdShadowSet (pScreen, scrpriv->randr, update, window);
 248 }
 249
 250
 251 #ifdef RANDR
 252 Bool
 253 fakeRandRGetInfo (ScreenPtr pScreen, Rotation *rotations)
 254 {
 255     KdScreenPriv(pScreen);
 256     KdScreenInfo            *screen = pScreenPriv->screen;
 257     FakeScrPriv     *scrpriv = screen->driver;
 258     RRScreenSizePtr         pSize;
 259     Rotation                randr;
 260     int                     n;
 261
 262     *rotations = RR_Rotate_All|RR_Reflect_All;
 263
 264     for (n = 0; n < pScreen->numDepths; n++)
 265         if (pScreen->allowedDepths[n].numVids)
 266             break;
 267     if (n == pScreen->numDepths)
 268         return FALSE;
 269
 270     pSize = RRRegisterSize (pScreen,
 271                             screen->width,
 272                             screen->height,
 273                             screen->width_mm,
 274                             screen->height_mm);
 275
 276     randr = KdSubRotation (scrpriv->randr, screen->randr);
 277
 278     RRSetCurrentConfig (pScreen, randr, 0, pSize);
 279
 280     return TRUE;
 281 }
 282
 283 Bool
 284 fakeRandRSetConfig (ScreenPtr           pScreen,
 285                      Rotation           randr,
 286                      int                rate,
 287                      RRScreenSizePtr    pSize)
 288 {
 289     KdScreenPriv(pScreen);
 290     KdScreenInfo        *screen = pScreenPriv->screen;
 291     FakeScrPriv *scrpriv = screen->driver;
 292     Bool                wasEnabled = pScreenPriv->enabled;
 293     FakeScrPriv oldscr;
 294     int                 oldwidth;
 295     int                 oldheight;
 296     int                 oldmmwidth;
 297     int                 oldmmheight;
 298     int                 newwidth, newheight;
 299
 300     if (screen->randr & (RR_Rotate_0|RR_Rotate_180))
 301     {
 302         newwidth = pSize->width;
 303         newheight = pSize->height;
 304     }
 305     else
 306     {
 307         newwidth = pSize->height;
 308         newheight = pSize->width;
 309     }
 310
 311     if (wasEnabled)
 312         KdDisableScreen (pScreen);
 313
 314     oldscr = *scrpriv;
 315
 316     oldwidth = screen->width;
 317     oldheight = screen->height;
 318     oldmmwidth = pScreen->mmWidth;
 319     oldmmheight = pScreen->mmHeight;
 320
 321     /*
 322      * Set new configuration
 323      */
 324
 325     scrpriv->randr = KdAddRotation (screen->randr, randr);
 326
 327     KdOffscreenSwapOut (screen->pScreen);
 328
 329     fakeUnmapFramebuffer (screen);
 330
 331     if (!fakeMapFramebuffer (screen))
 332         goto bail4;
 333
 334     KdShadowUnset (screen->pScreen);
 335
 336     if (!fakeSetShadow (screen->pScreen))
 337         goto bail4;
 338
 339     fakeSetScreenSizes (screen->pScreen);
 340
 341     /*
 342      * Set frame buffer mapping
 343      */
 344     (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
 345                                     pScreen->width,
 346                                     pScreen->height,
 347                                     screen->fb[0].depth,
 348                                     screen->fb[0].bitsPerPixel,
 349                                     screen->fb[0].byteStride,
 350                                     screen->fb[0].frameBuffer);
 351
 352     /* set the subpixel order */
 353
 354     KdSetSubpixelOrder (pScreen, scrpriv->randr);
 355     if (wasEnabled)
 356         KdEnableScreen (pScreen);
 357
 358     return TRUE;
 359
 360 bail4:
 361     fakeUnmapFramebuffer (screen);
 362     *scrpriv = oldscr;
 363     (void) fakeMapFramebuffer (screen);
 364     pScreen->width = oldwidth;
 365     pScreen->height = oldheight;
 366     pScreen->mmWidth = oldmmwidth;
 367     pScreen->mmHeight = oldmmheight;
 368
 369     if (wasEnabled)
 370         KdEnableScreen (pScreen);
 371     return FALSE;
 372 }
 373
 374 Bool
 375 fakeRandRInit (ScreenPtr pScreen)
 376 {
 377     rrScrPrivPtr    pScrPriv;
 378
 379     if (!RRScreenInit (pScreen))
 380         return FALSE;
 381
 382     pScrPriv = rrGetScrPriv(pScreen);
 383     pScrPriv->rrGetInfo = fakeRandRGetInfo;
 384     pScrPriv->rrSetConfig = fakeRandRSetConfig;
 385     return TRUE;
 386 }
 387 #endif
 388
 389 Bool
 390 fakeCreateColormap (ColormapPtr pmap)
 391 {
 392     return fbInitializeColormap (pmap);
 393 }
 394
 395 Bool
 396 fakeInitScreen (ScreenPtr pScreen)
 397 {
 398 #ifdef TOUCHSCREEN
 399     KdTsPhyScreen = pScreen->myNum;
 400 #endif
 401
 402     pScreen->CreateColormap = fakeCreateColormap;
 403     return TRUE;
 404 }
 405
 406 Bool
 407 fakeFinishInitScreen (ScreenPtr pScreen)
 408 {
 409     if (!shadowSetup (pScreen))
 410         return FALSE;
 411
 412 #ifdef RANDR
 413     if (!fakeRandRInit (pScreen))
 414         return FALSE;
 415 #endif
 416
 417     return TRUE;
 418 }
 419
 420
 421 Bool
 422 fakeCreateResources (ScreenPtr pScreen)
 423 {
 424     return fakeSetShadow (pScreen);
 425 }
 426
 427 void
 428 fakePreserve (KdCardInfo *card)
 429 {
 430 }
 431
 432 Bool
 433 fakeEnable (ScreenPtr pScreen)
 434 {
 435     return TRUE;
 436 }
 437
 438 Bool
 439 fakeDPMS (ScreenPtr pScreen, int mode)
 440 {
 441     return TRUE;
 442 }
 443
 444 void
 445 fakeDisable (ScreenPtr pScreen)
 446 {
 447 }
 448
 449 void
 450 fakeRestore (KdCardInfo *card)
 451 {
 452 }
 453
 454 void
 455 fakeScreenFini (KdScreenInfo *screen)
 456 {
 457 }
 458
 459 void
 460 fakeCardFini (KdCardInfo *card)
 461 {
 462     FakePriv    *priv = card->driver;
 463
 464     if (priv->base)
 465         free (priv->base);
 466     xfree (priv);
 467 }
 468
 469 void
 470 fakeGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
 471 {
 472     while (n--)
 473     {
 474         pdefs->red = 0;
 475         pdefs->green = 0;
 476         pdefs->blue = 0;
 477         pdefs++;
 478     }
 479 }
 480
 481 void
 482 fakePutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
 483 {
 484 }