git.oblomov.eu Git - nouveau/blob - src/riva_driver.c

   1 /*
   2  * Copyright 1996-1997  David J. McKay
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * DAVID J. MCKAY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  18  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  19  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22
  23 /* Hacked together from mga driver and 3.3.4 NVIDIA driver by Jarno Paananen
  24    <jpaana@s2.org> */
  25
  26 /* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/nv/riva_driver.c,v 1.5 2003/11/03 05:11:26 tsi Exp $ */
  27
  28 #include "riva_include.h"
  29
  30 #include "xf86int10.h"
  31
  32 /*
  33  * Forward definitions for the functions that make up the driver.
  34  */
  35 /* Mandatory functions */
  36 static Bool    RivaPreInit(ScrnInfoPtr pScrn, int flags);
  37 static Bool    RivaScreenInit(int Index, ScreenPtr pScreen, int argc,
  38                             char **argv);
  39 static Bool    RivaEnterVT(int scrnIndex, int flags);
  40 static Bool    RivaEnterVTFBDev(int scrnIndex, int flags);
  41 static void    RivaLeaveVT(int scrnIndex, int flags);
  42 static Bool    RivaCloseScreen(int scrnIndex, ScreenPtr pScreen);
  43 static Bool    RivaSaveScreen(ScreenPtr pScreen, int mode);
  44
  45 /* Optional functions */
  46 static void    RivaFreeScreen(int scrnIndex, int flags);
  47 static ModeStatus RivaValidMode(int scrnIndex, DisplayModePtr mode,
  48                                 Bool verbose, int flags);
  49
  50 /* Internally used functions */
  51
  52 static Bool     RivaMapMem(ScrnInfoPtr pScrn);
  53 static Bool     RivaMapMemFBDev(ScrnInfoPtr pScrn);
  54 static Bool     RivaUnmapMem(ScrnInfoPtr pScrn);
  55 static void     RivaSave(ScrnInfoPtr pScrn);
  56 static void     RivaRestore(ScrnInfoPtr pScrn);
  57 static Bool     RivaModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode);
  58
  59
  60 /*
  61  * List of symbols from other modules that this module references.  This
  62  * list is used to tell the loader that it is OK for symbols here to be
  63  * unresolved providing that it hasn't been told that they haven't been
  64  * told that they are essential via a call to xf86LoaderReqSymbols() or
  65  * xf86LoaderReqSymLists().  The purpose is this is to avoid warnings about
  66  * unresolved symbols that are not required.
  67  */
  68
  69 static const char *vgahwSymbols[] = {
  70     "vgaHWUnmapMem",
  71     "vgaHWDPMSSet",
  72     "vgaHWFreeHWRec",
  73     "vgaHWGetHWRec",
  74     "vgaHWGetIndex",
  75     "vgaHWInit",
  76     "vgaHWMapMem",
  77     "vgaHWProtect",
  78     "vgaHWRestore",
  79     "vgaHWSave",
  80     "vgaHWSaveScreen",
  81     NULL
  82 };
  83
  84 static const char *fbSymbols[] = {
  85     "fbPictureInit",
  86     "fbScreenInit",
  87     NULL
  88 };
  89
  90 static const char *xaaSymbols[] = {
  91     "XAAGetCopyROP",
  92     "XAACreateInfoRec",
  93     "XAADestroyInfoRec",
  94     "XAAGetFallbackOps",
  95     "XAAInit",
  96     "XAAGetPatternROP",
  97     NULL
  98 };
  99
 100 static const char *ramdacSymbols[] = {
 101     "xf86CreateCursorInfoRec",
 102     "xf86DestroyCursorInfoRec",
 103     "xf86InitCursor",
 104     NULL
 105 };
 106
 107 static const char *ddcSymbols[] = {
 108     "xf86PrintEDID",
 109     "xf86DoEDID_DDC2",
 110     "xf86SetDDCproperties",
 111     NULL
 112 };
 113
 114 static const char *vbeSymbols[] = {
 115     "VBEInit",
 116     "vbeFree",
 117     "vbeDoEDID",
 118     NULL
 119 };
 120
 121 static const char *i2cSymbols[] = {
 122     "xf86CreateI2CBusRec",
 123     "xf86I2CBusInit",
 124     NULL
 125 };
 126
 127 static const char *shadowSymbols[] = {
 128     "ShadowFBInit",
 129     NULL
 130 };
 131
 132 static const char *fbdevHWSymbols[] = {
 133     "fbdevHWInit",
 134     "fbdevHWUseBuildinMode",
 135
 136     "fbdevHWGetVidmem",
 137
 138     /* colormap */
 139     "fbdevHWLoadPaletteWeak",
 140
 141     /* ScrnInfo hooks */
 142     "fbdevHWAdjustFrameWeak",
 143     "fbdevHWEnterVT",
 144     "fbdevHWLeaveVTWeak",
 145     "fbdevHWModeInit",
 146     "fbdevHWSave",
 147     "fbdevHWSwitchModeWeak",
 148     "fbdevHWValidModeWeak",
 149
 150     "fbdevHWMapMMIO",
 151     "fbdevHWMapVidmem",
 152
 153     NULL
 154 };
 155
 156 static const char *int10Symbols[] = {
 157     "xf86FreeInt10",
 158     "xf86InitInt10",
 159     NULL
 160 };
 161
 162
 163 static MODULESETUPPROTO(rivaSetup);
 164
 165 static XF86ModuleVersionInfo rivaVersRec =
 166 {
 167     "riva",
 168     MODULEVENDORSTRING,
 169     MODINFOSTRING1,
 170     MODINFOSTRING2,
 171     XORG_VERSION_CURRENT,
 172     NV_MAJOR_VERSION, NV_MINOR_VERSION, NV_PATCHLEVEL,
 173     ABI_CLASS_VIDEODRV,                     /* This is a video driver */
 174     ABI_VIDEODRV_VERSION,
 175     MOD_CLASS_VIDEODRV,
 176     {0,0,0,0}
 177 };
 178
 179 _X_EXPORT XF86ModuleData riva128ModuleData = { &rivaVersRec, rivaSetup, NULL };
 180
 181 typedef enum {
 182     OPTION_SW_CURSOR,
 183     OPTION_HW_CURSOR,
 184     OPTION_NOACCEL,
 185     OPTION_SHOWCACHE,
 186     OPTION_SHADOW_FB,
 187     OPTION_FBDEV,
 188     OPTION_ROTATE
 189 } RivaOpts;
 190
 191
 192 static const OptionInfoRec RivaOptions[] = {
 193     { OPTION_SW_CURSOR,         "SWcursor",     OPTV_BOOLEAN,   {0}, FALSE },
 194     { OPTION_HW_CURSOR,         "HWcursor",     OPTV_BOOLEAN,   {0}, FALSE },
 195     { OPTION_NOACCEL,           "NoAccel",      OPTV_BOOLEAN,   {0}, FALSE },
 196     { OPTION_SHOWCACHE,         "ShowCache",    OPTV_BOOLEAN,   {0}, FALSE },
 197     { OPTION_SHADOW_FB,         "ShadowFB",     OPTV_BOOLEAN,   {0}, FALSE },
 198     { OPTION_FBDEV,             "UseFBDev",     OPTV_BOOLEAN,   {0}, FALSE },
 199     { OPTION_ROTATE,            "Rotate",       OPTV_ANYSTR,    {0}, FALSE },
 200     { -1,                       NULL,           OPTV_NONE,      {0}, FALSE }
 201 };
 202
 203 /*
 204  * This is intentionally screen-independent.  It indicates the binding
 205  * choice made in the first PreInit.
 206  */
 207 static int pix24bpp = 0;
 208
 209 /*
 210  * ramdac info structure initialization
 211  */
 212 static RivaRamdacRec DacInit = {
 213         FALSE, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL,
 214         0, NULL, NULL, NULL, NULL
 215 };
 216
 217
 218
 219 static Bool
 220 RivaGetRec(ScrnInfoPtr pScrn)
 221 {
 222     /*
 223      * Allocate an RivaRec, and hook it into pScrn->driverPrivate.
 224      * pScrn->driverPrivate is initialised to NULL, so we can check if
 225      * the allocation has already been done.
 226      */
 227     if (pScrn->driverPrivate != NULL)
 228         return TRUE;
 229
 230     pScrn->driverPrivate = xnfcalloc(sizeof(RivaRec), 1);
 231     /* Initialise it */
 232
 233     RivaPTR(pScrn)->Dac = DacInit;
 234     return TRUE;
 235 }
 236
 237 static void
 238 RivaFreeRec(ScrnInfoPtr pScrn)
 239 {
 240     if (pScrn->driverPrivate == NULL)
 241         return;
 242     xfree(pScrn->driverPrivate);
 243     pScrn->driverPrivate = NULL;
 244 }
 245
 246 static pointer
 247 rivaSetup(pointer module, pointer opts, int *errmaj, int *errmin)
 248 {
 249     static Bool setupDone = FALSE;
 250
 251     /* This module should be loaded only once, but check to be sure. */
 252
 253     if (!setupDone) {
 254         setupDone = TRUE;
 255
 256         LoaderRefSymLists(vgahwSymbols, xaaSymbols, fbSymbols,
 257                           ramdacSymbols, shadowSymbols,
 258                           i2cSymbols, ddcSymbols, vbeSymbols,
 259                           fbdevHWSymbols, int10Symbols, NULL);
 260     }
 261     return (pointer)1;
 262 }
 263
 264 _X_EXPORT const OptionInfoRec *
 265 RivaAvailableOptions(int chipid, int busid)
 266 {
 267     return RivaOptions;
 268 }
 269
 270
 271 _X_EXPORT Bool
 272 RivaGetScrnInfoRec(PciChipsets *chips, int chip)
 273 {
 274     ScrnInfoPtr pScrn;
 275
 276     pScrn = xf86ConfigPciEntity(NULL, 0, chip,
 277                                 chips, NULL, NULL, NULL,
 278                                 NULL, NULL);
 279
 280     if(!pScrn) return FALSE;
 281
 282     pScrn->driverVersion    = RIVA_VERSION;
 283     pScrn->driverName       = RIVA_DRIVER_NAME;
 284     pScrn->name             = RIVA_NAME;
 285
 286     pScrn->Probe            = NULL;
 287     pScrn->PreInit          = RivaPreInit;
 288     pScrn->ScreenInit       = RivaScreenInit;
 289     pScrn->SwitchMode       = RivaSwitchMode;
 290     pScrn->AdjustFrame      = RivaAdjustFrame;
 291     pScrn->EnterVT          = RivaEnterVT;
 292     pScrn->LeaveVT          = RivaLeaveVT;
 293     pScrn->FreeScreen       = RivaFreeScreen;
 294     pScrn->ValidMode        = RivaValidMode;
 295
 296     return TRUE;
 297 }
 298
 299 /* Usually mandatory */
 300 Bool
 301 RivaSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
 302 {
 303     return RivaModeInit(xf86Screens[scrnIndex], mode);
 304 }
 305
 306 /*
 307  * This function is used to initialize the Start Address - the first
 308  * displayed location in the video memory.
 309  */
 310 /* Usually mandatory */
 311 void
 312 RivaAdjustFrame(int scrnIndex, int x, int y, int flags)
 313 {
 314     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 315     int startAddr;
 316     RivaPtr pRiva = RivaPTR(pScrn);
 317     RivaFBLayout *pLayout = &pRiva->CurrentLayout;
 318
 319     if(pRiva->ShowCache && y && pScrn->vtSema)
 320         y += pScrn->virtualY - 1;
 321
 322     startAddr = (((y*pLayout->displayWidth)+x)*(pLayout->bitsPerPixel/8));
 323     pRiva->riva.SetStartAddress(&pRiva->riva, startAddr);
 324 }
 325
 326
 327 /*
 328  * This is called when VT switching back to the X server.  Its job is
 329  * to reinitialise the video mode.
 330  *
 331  * We may wish to unmap video/MMIO memory too.
 332  */
 333
 334 /* Mandatory */
 335 static Bool
 336 RivaEnterVT(int scrnIndex, int flags)
 337 {
 338     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 339
 340     if (!RivaModeInit(pScrn, pScrn->currentMode))
 341         return FALSE;
 342     RivaAdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
 343
 344     return TRUE;
 345 }
 346
 347 static Bool
 348 RivaEnterVTFBDev(int scrnIndex, int flags)
 349 {
 350     fbdevHWEnterVT(scrnIndex,flags);
 351     return TRUE;
 352 }
 353
 354 /*
 355  * This is called when VT switching away from the X server.  Its job is
 356  * to restore the previous (text) mode.
 357  *
 358  * We may wish to remap video/MMIO memory too.
 359  */
 360
 361 /* Mandatory */
 362 static void
 363 RivaLeaveVT(int scrnIndex, int flags)
 364 {
 365     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 366     RivaPtr pRiva = RivaPTR(pScrn);
 367
 368     RivaRestore(pScrn);
 369     pRiva->riva.LockUnlock(&pRiva->riva, 1);
 370 }
 371
 372
 373
 374 /*
 375  * This is called at the end of each server generation.  It restores the
 376  * original (text) mode.  It should also unmap the video memory, and free
 377  * any per-generation data allocated by the driver.  It should finish
 378  * by unwrapping and calling the saved CloseScreen function.
 379  */
 380
 381 /* Mandatory */
 382 static Bool
 383 RivaCloseScreen(int scrnIndex, ScreenPtr pScreen)
 384 {
 385     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 386     RivaPtr pRiva = RivaPTR(pScrn);
 387
 388     if (pScrn->vtSema) {
 389         RivaRestore(pScrn);
 390         pRiva->riva.LockUnlock(&pRiva->riva, 1);
 391     }
 392
 393     RivaUnmapMem(pScrn);
 394     vgaHWUnmapMem(pScrn);
 395     if (pRiva->AccelInfoRec)
 396         XAADestroyInfoRec(pRiva->AccelInfoRec);
 397     if (pRiva->CursorInfoRec)
 398         xf86DestroyCursorInfoRec(pRiva->CursorInfoRec);
 399     if (pRiva->ShadowPtr)
 400         xfree(pRiva->ShadowPtr);
 401     if (pRiva->DGAModes)
 402         xfree(pRiva->DGAModes);
 403     if ( pRiva->expandBuffer )
 404         xfree(pRiva->expandBuffer);
 405
 406     pScrn->vtSema = FALSE;
 407     pScreen->CloseScreen = pRiva->CloseScreen;
 408     return (*pScreen->CloseScreen)(scrnIndex, pScreen);
 409 }
 410
 411 /* Free up any persistent data structures */
 412
 413 /* Optional */
 414 static void
 415 RivaFreeScreen(int scrnIndex, int flags)
 416 {
 417     /*
 418      * This only gets called when a screen is being deleted.  It does not
 419      * get called routinely at the end of a server generation.
 420      */
 421     if (xf86LoaderCheckSymbol("vgaHWFreeHWRec"))
 422         vgaHWFreeHWRec(xf86Screens[scrnIndex]);
 423     RivaFreeRec(xf86Screens[scrnIndex]);
 424 }
 425
 426
 427 /* Checks if a mode is suitable for the selected chipset. */
 428
 429 /* Optional */
 430 static ModeStatus
 431 RivaValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
 432 {
 433     return (MODE_OK);
 434 }
 435
 436 static void
 437 rivaProbeDDC(ScrnInfoPtr pScrn, int index)
 438 {
 439     vbeInfoPtr pVbe;
 440
 441     if (xf86LoadSubModule(pScrn, "vbe")) {
 442         pVbe = VBEInit(NULL,index);
 443         ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
 444         vbeFree(pVbe);
 445     }
 446 }
 447
 448
 449 Bool RivaI2CInit(ScrnInfoPtr pScrn)
 450 {
 451     char *mod = "i2c";
 452
 453     if (xf86LoadSubModule(pScrn, mod)) {
 454         xf86LoaderReqSymLists(i2cSymbols,NULL);
 455
 456         mod = "ddc";
 457         if(xf86LoadSubModule(pScrn, mod)) {
 458             xf86LoaderReqSymLists(ddcSymbols, NULL);
 459             return RivaDACi2cInit(pScrn);
 460         }
 461     }
 462
 463     xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
 464               "Couldn't load %s module.  DDC probing can't be done\n", mod);
 465
 466     return FALSE;
 467 }
 468
 469 /* Mandatory */
 470 Bool
 471 RivaPreInit(ScrnInfoPtr pScrn, int flags)
 472 {
 473     RivaPtr pRiva;
 474     MessageType from;
 475     int i;
 476     ClockRangePtr clockRanges;
 477     const char *s;
 478
 479     if (flags & PROBE_DETECT) {
 480         EntityInfoPtr pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
 481
 482         if (!pEnt)
 483             return FALSE;
 484
 485         i = pEnt->index;
 486         xfree(pEnt);
 487
 488         rivaProbeDDC(pScrn, i);
 489         return TRUE;
 490     }
 491
 492     /*
 493      * Note: This function is only called once at server startup, and
 494      * not at the start of each server generation.  This means that
 495      * only things that are persistent across server generations can
 496      * be initialised here.  xf86Screens[] is (pScrn is a pointer to one
 497      * of these).  Privates allocated using xf86AllocateScrnInfoPrivateIndex()
 498      * are too, and should be used for data that must persist across
 499      * server generations.
 500      *
 501      * Per-generation data should be allocated with
 502      * AllocateScreenPrivateIndex() from the ScreenInit() function.
 503      */
 504
 505     /* Check the number of entities, and fail if it isn't one. */
 506     if (pScrn->numEntities != 1)
 507         return FALSE;
 508
 509     /* Allocate the RivaRec driverPrivate */
 510     if (!RivaGetRec(pScrn)) {
 511         return FALSE;
 512     }
 513     pRiva = RivaPTR(pScrn);
 514
 515     /* Get the entity, and make sure it is PCI. */
 516     pRiva->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
 517     if (pRiva->pEnt->location.type != BUS_PCI)
 518         return FALSE;
 519
 520     /* Find the PCI info for this screen */
 521     pRiva->PciInfo = xf86GetPciInfoForEntity(pRiva->pEnt->index);
 522     pRiva->PciTag = pciTag(pRiva->PciInfo->bus, pRiva->PciInfo->device,
 523                           pRiva->PciInfo->func);
 524
 525     pRiva->Primary = xf86IsPrimaryPci(pRiva->PciInfo);
 526
 527     /* Initialize the card through int10 interface if needed */
 528     if (xf86LoadSubModule(pScrn, "int10")) {
 529         xf86LoaderReqSymLists(int10Symbols, NULL);
 530 #if !defined(__alpha__)
 531         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Initializing int10\n");
 532         pRiva->pInt = xf86InitInt10(pRiva->pEnt->index);
 533 #endif
 534     }
 535
 536     xf86SetOperatingState(resVgaIo, pRiva->pEnt->index, ResUnusedOpr);
 537     xf86SetOperatingState(resVgaMem, pRiva->pEnt->index, ResDisableOpr);
 538
 539     /* Set pScrn->monitor */
 540     pScrn->monitor = pScrn->confScreen->monitor;
 541
 542     pRiva->ChipRev = pRiva->PciInfo->chipRev;
 543     if((pRiva->PciInfo->vendor != 0x12D2) || (pRiva->PciInfo->chipType != 0x0018))
 544     {
 545         xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "This is not a RIVA 128\n");
 546         xf86FreeInt10(pRiva->pInt);
 547         return FALSE;
 548     }
 549
 550     pScrn->chipset = "RIVA 128";
 551
 552     /*
 553      * The first thing we should figure out is the depth, bpp, etc.
 554      */
 555
 556     if (!xf86SetDepthBpp(pScrn, 15, 0, 0, Support32bppFb)) {
 557         xf86FreeInt10(pRiva->pInt);
 558         return FALSE;
 559     } else {
 560         /* Check that the returned depth is one we support */
 561         switch (pScrn->depth) {
 562             case 8:
 563             case 15:
 564             case 24:
 565                 break;
 566             default:
 567                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 568                     "Given depth (%d) is not supported by this driver\n",
 569                     pScrn->depth);
 570                 xf86FreeInt10(pRiva->pInt);
 571                 return FALSE;
 572         }
 573     }
 574     xf86PrintDepthBpp(pScrn);
 575
 576     /* Get the depth24 pixmap format */
 577     if (pScrn->depth == 24 && pix24bpp == 0)
 578         pix24bpp = xf86GetBppFromDepth(pScrn, 24);
 579
 580     /*
 581      * This must happen after pScrn->display has been set because
 582      * xf86SetWeight references it.
 583      */
 584     if (pScrn->depth > 8) {
 585         /* The defaults are OK for us */
 586         rgb zeros = {0, 0, 0};
 587
 588         if (!xf86SetWeight(pScrn, zeros, zeros)) {
 589             xf86FreeInt10(pRiva->pInt);
 590             return FALSE;
 591         }
 592     }
 593
 594     if (!xf86SetDefaultVisual(pScrn, -1)) {
 595         xf86FreeInt10(pRiva->pInt);
 596         return FALSE;
 597     } else {
 598         /* We don't currently support DirectColor at > 8bpp */
 599         if (pScrn->depth > 8 && (pScrn->defaultVisual != TrueColor)) {
 600             xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Given default visual"
 601                        " (%s) is not supported at depth %d\n",
 602                        xf86GetVisualName(pScrn->defaultVisual), pScrn->depth);
 603             xf86FreeInt10(pRiva->pInt);
 604             return FALSE;
 605         }
 606     }
 607
 608     /* The vgahw module should be loaded here when needed */
 609     if (!xf86LoadSubModule(pScrn, "vgahw")) {
 610         xf86FreeInt10(pRiva->pInt);
 611         return FALSE;
 612     }
 613
 614     xf86LoaderReqSymLists(vgahwSymbols, NULL);
 615
 616     /*
 617      * Allocate a vgaHWRec
 618      */
 619     if (!vgaHWGetHWRec(pScrn)) {
 620         xf86FreeInt10(pRiva->pInt);
 621         return FALSE;
 622     }
 623
 624     /* We use a programmable clock */
 625     pScrn->progClock = TRUE;
 626
 627     /* Collect all of the relevant option flags (fill in pScrn->options) */
 628     xf86CollectOptions(pScrn, NULL);
 629
 630     /* Process the options */
 631     if (!(pRiva->Options = xalloc(sizeof(RivaOptions))))
 632         return FALSE;
 633     memcpy(pRiva->Options, RivaOptions, sizeof(RivaOptions));
 634     xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pRiva->Options);
 635
 636     /* Set the bits per RGB for 8bpp mode */
 637     if (pScrn->depth == 8)
 638         pScrn->rgbBits = 8;
 639
 640     from = X_DEFAULT;
 641     pRiva->HWCursor = TRUE;
 642     /*
 643      * The preferred method is to use the "hw cursor" option as a tri-state
 644      * option, with the default set above.
 645      */
 646     if (xf86GetOptValBool(pRiva->Options, OPTION_HW_CURSOR, &pRiva->HWCursor)) {
 647         from = X_CONFIG;
 648     }
 649     /* For compatibility, accept this too (as an override) */
 650     if (xf86ReturnOptValBool(pRiva->Options, OPTION_SW_CURSOR, FALSE)) {
 651         from = X_CONFIG;
 652         pRiva->HWCursor = FALSE;
 653     }
 654     xf86DrvMsg(pScrn->scrnIndex, from, "Using %s cursor\n",
 655                 pRiva->HWCursor ? "HW" : "SW");
 656     if (xf86ReturnOptValBool(pRiva->Options, OPTION_NOACCEL, FALSE)) {
 657         pRiva->NoAccel = TRUE;
 658         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Acceleration disabled\n");
 659     }
 660     if (xf86ReturnOptValBool(pRiva->Options, OPTION_SHOWCACHE, FALSE)) {
 661         pRiva->ShowCache = TRUE;
 662         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ShowCache enabled\n");
 663     }
 664     if (xf86ReturnOptValBool(pRiva->Options, OPTION_SHADOW_FB, FALSE)) {
 665         pRiva->ShadowFB = TRUE;
 666         pRiva->NoAccel = TRUE;
 667         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 668                 "Using \"Shadow Framebuffer\" - acceleration disabled\n");
 669     }
 670     if (xf86ReturnOptValBool(pRiva->Options, OPTION_FBDEV, FALSE)) {
 671         pRiva->FBDev = TRUE;
 672         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 673                 "Using framebuffer device\n");
 674     }
 675     if (pRiva->FBDev) {
 676         /* check for linux framebuffer device */
 677         if (!xf86LoadSubModule(pScrn, "fbdevhw")) {
 678             xf86FreeInt10(pRiva->pInt);
 679             return FALSE;
 680         }
 681
 682         xf86LoaderReqSymLists(fbdevHWSymbols, NULL);
 683         if (!fbdevHWInit(pScrn, pRiva->PciInfo, NULL)) {
 684             xf86FreeInt10(pRiva->pInt);
 685             return FALSE;
 686         }
 687         pScrn->SwitchMode    = fbdevHWSwitchModeWeak();
 688         pScrn->AdjustFrame   = fbdevHWAdjustFrameWeak();
 689         pScrn->EnterVT       = RivaEnterVTFBDev;
 690         pScrn->LeaveVT       = fbdevHWLeaveVTWeak();
 691         pScrn->ValidMode     = fbdevHWValidModeWeak();
 692     }
 693     pRiva->Rotate = 0;
 694     if ((s = xf86GetOptValString(pRiva->Options, OPTION_ROTATE))) {
 695       if(!xf86NameCmp(s, "CW")) {
 696         pRiva->ShadowFB = TRUE;
 697         pRiva->NoAccel = TRUE;
 698         pRiva->HWCursor = FALSE;
 699         pRiva->Rotate = 1;
 700         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 701                 "Rotating screen clockwise - acceleration disabled\n");
 702       } else
 703       if(!xf86NameCmp(s, "CCW")) {
 704         pRiva->ShadowFB = TRUE;
 705         pRiva->NoAccel = TRUE;
 706         pRiva->HWCursor = FALSE;
 707         pRiva->Rotate = -1;
 708         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 709                 "Rotating screen counter clockwise - acceleration disabled\n");
 710       } else {
 711         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 712                 "\"%s\" is not a valid value for Option \"Rotate\"\n", s);
 713         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 714                 "Valid options are \"CW\" or \"CCW\"\n");
 715       }
 716     }
 717
 718     if (pRiva->pEnt->device->MemBase != 0) {
 719         /* Require that the config file value matches one of the PCI values. */
 720         if (!xf86CheckPciMemBase(pRiva->PciInfo, pRiva->pEnt->device->MemBase)) {
 721             xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 722                 "MemBase 0x%08lX doesn't match any PCI base register.\n",
 723                 pRiva->pEnt->device->MemBase);
 724             xf86FreeInt10(pRiva->pInt);
 725             RivaFreeRec(pScrn);
 726             return FALSE;
 727         }
 728         pRiva->FbAddress = pRiva->pEnt->device->MemBase;
 729         from = X_CONFIG;
 730     } else {
 731         int i = 1;
 732         pRiva->FbBaseReg = i;
 733         if (pRiva->PciInfo->memBase[i] != 0) {
 734             pRiva->FbAddress = pRiva->PciInfo->memBase[i] & 0xff800000;
 735             from = X_PROBED;
 736         } else {
 737             xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 738                            "No valid FB address in PCI config space\n");
 739             xf86FreeInt10(pRiva->pInt);
 740             RivaFreeRec(pScrn);
 741             return FALSE;
 742         }
 743     }
 744     xf86DrvMsg(pScrn->scrnIndex, from, "Linear framebuffer at 0x%lX\n",
 745                (unsigned long)pRiva->FbAddress);
 746
 747     if (pRiva->pEnt->device->IOBase != 0) {
 748         /* Require that the config file value matches one of the PCI values. */
 749         if (!xf86CheckPciMemBase(pRiva->PciInfo, pRiva->pEnt->device->IOBase)) {
 750             xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 751                 "IOBase 0x%08lX doesn't match any PCI base register.\n",
 752                 pRiva->pEnt->device->IOBase);
 753             xf86FreeInt10(pRiva->pInt);
 754             RivaFreeRec(pScrn);
 755             return FALSE;
 756         }
 757         pRiva->IOAddress = pRiva->pEnt->device->IOBase;
 758         from = X_CONFIG;
 759     } else {
 760         int i = 0;
 761         if (pRiva->PciInfo->memBase[i] != 0) {
 762             pRiva->IOAddress = pRiva->PciInfo->memBase[i] & 0xffffc000;
 763             from = X_PROBED;
 764         } else {
 765             xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 766                         "No valid MMIO address in PCI config space\n");
 767             xf86FreeInt10(pRiva->pInt);
 768             RivaFreeRec(pScrn);
 769             return FALSE;
 770         }
 771     }
 772     xf86DrvMsg(pScrn->scrnIndex, from, "MMIO registers at 0x%lX\n",
 773                (unsigned long)pRiva->IOAddress);
 774
 775     if (xf86RegisterResources(pRiva->pEnt->index, NULL, ResExclusive)) {
 776         xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 777                 "xf86RegisterResources() found resource conflicts\n");
 778         xf86FreeInt10(pRiva->pInt);
 779         RivaFreeRec(pScrn);
 780         return FALSE;
 781     }
 782
 783     Riva3Setup(pScrn);
 784
 785     /*
 786      * If the user has specified the amount of memory in the XF86Config
 787      * file, we respect that setting.
 788      */
 789     if (pRiva->pEnt->device->videoRam != 0) {
 790         pScrn->videoRam = pRiva->pEnt->device->videoRam;
 791         from = X_CONFIG;
 792     } else {
 793         if (pRiva->FBDev) {
 794             pScrn->videoRam = fbdevHWGetVidmem(pScrn)/1024;
 795         } else {
 796             pScrn->videoRam = pRiva->riva.RamAmountKBytes;
 797         }
 798         from = X_PROBED;
 799     }
 800     xf86DrvMsg(pScrn->scrnIndex, from, "VideoRAM: %d kBytes\n",
 801                pScrn->videoRam);
 802
 803     pRiva->FbMapSize = pScrn->videoRam * 1024;
 804
 805     /*
 806      * If the driver can do gamma correction, it should call xf86SetGamma()
 807      * here.
 808      */
 809
 810     {
 811         Gamma zeros = {0.0, 0.0, 0.0};
 812
 813         if (!xf86SetGamma(pScrn, zeros)) {
 814             xf86FreeInt10(pRiva->pInt);
 815             return FALSE;
 816         }
 817     }
 818
 819     pRiva->FbUsableSize = pRiva->FbMapSize - (32 * 1024);
 820
 821     /*
 822      * Setup the ClockRanges, which describe what clock ranges are available,
 823      * and what sort of modes they can be used for.
 824      */
 825
 826     pRiva->MinClock = 12000;
 827     pRiva->MaxClock = pRiva->riva.MaxVClockFreqKHz;
 828
 829     clockRanges = xnfcalloc(sizeof(ClockRange), 1);
 830     clockRanges->next = NULL;
 831     clockRanges->minClock = pRiva->MinClock;
 832     clockRanges->maxClock = pRiva->MaxClock;
 833     clockRanges->clockIndex = -1;               /* programmable */
 834     clockRanges->interlaceAllowed = TRUE;
 835     clockRanges->doubleScanAllowed = TRUE;
 836
 837
 838     /*
 839      * xf86ValidateModes will check that the mode HTotal and VTotal values
 840      * don't exceed the chipset's limit if pScrn->maxHValue and
 841      * pScrn->maxVValue are set.  Since our RivaValidMode() already takes
 842      * care of this, we don't worry about setting them here.
 843      */
 844     i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
 845                           pScrn->display->modes, clockRanges,
 846                           NULL, 256, 2048,
 847                           32 * pScrn->bitsPerPixel, 128, 2048,
 848                           pScrn->display->virtualX,
 849                           pScrn->display->virtualY,
 850                           pRiva->FbUsableSize,
 851                           LOOKUP_BEST_REFRESH);
 852
 853     if (i < 1 && pRiva->FBDev) {
 854         fbdevHWUseBuildinMode(pScrn);
 855         pScrn->displayWidth = pScrn->virtualX; /* FIXME: might be wrong */
 856         i = 1;
 857     }
 858     if (i == -1) {
 859         xf86FreeInt10(pRiva->pInt);
 860         RivaFreeRec(pScrn);
 861         return FALSE;
 862     }
 863
 864     /* Prune the modes marked as invalid */
 865     xf86PruneDriverModes(pScrn);
 866
 867     if (i == 0 || pScrn->modes == NULL) {
 868         xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
 869         xf86FreeInt10(pRiva->pInt);
 870         RivaFreeRec(pScrn);
 871         return FALSE;
 872     }
 873
 874     /*
 875      * Set the CRTC parameters for all of the modes based on the type
 876      * of mode, and the chipset's interlace requirements.
 877      *
 878      * Calling this is required if the mode->Crtc* values are used by the
 879      * driver and if the driver doesn't provide code to set them.  They
 880      * are not pre-initialised at all.
 881      */
 882     xf86SetCrtcForModes(pScrn, 0);
 883
 884     /* Set the current mode to the first in the list */
 885     pScrn->currentMode = pScrn->modes;
 886
 887     /* Print the list of modes being used */
 888     xf86PrintModes(pScrn);
 889
 890     /* Set display resolution */
 891     xf86SetDpi(pScrn, 0, 0);
 892
 893
 894     /*
 895      * XXX This should be taken into account in some way in the mode valdation
 896      * section.
 897      */
 898
 899     if (xf86LoadSubModule(pScrn, "fb") == NULL) {
 900         xf86FreeInt10(pRiva->pInt);
 901         RivaFreeRec(pScrn);
 902         return FALSE;
 903     }
 904
 905     xf86LoaderReqSymLists(fbSymbols, NULL);
 906
 907     /* Load XAA if needed */
 908     if (!pRiva->NoAccel) {
 909         if (!xf86LoadSubModule(pScrn, "xaa")) {
 910             xf86FreeInt10(pRiva->pInt);
 911             RivaFreeRec(pScrn);
 912             return FALSE;
 913         }
 914         xf86LoaderReqSymLists(xaaSymbols, NULL);
 915     }
 916
 917     /* Load ramdac if needed */
 918     if (pRiva->HWCursor) {
 919         if (!xf86LoadSubModule(pScrn, "ramdac")) {
 920             xf86FreeInt10(pRiva->pInt);
 921             RivaFreeRec(pScrn);
 922             return FALSE;
 923         }
 924         xf86LoaderReqSymLists(ramdacSymbols, NULL);
 925     }
 926
 927     /* Load shadowfb if needed */
 928     if (pRiva->ShadowFB) {
 929         if (!xf86LoadSubModule(pScrn, "shadowfb")) {
 930             xf86FreeInt10(pRiva->pInt);
 931             RivaFreeRec(pScrn);
 932             return FALSE;
 933         }
 934         xf86LoaderReqSymLists(shadowSymbols, NULL);
 935     }
 936
 937     pRiva->CurrentLayout.bitsPerPixel = pScrn->bitsPerPixel;
 938     pRiva->CurrentLayout.depth = pScrn->depth;
 939     pRiva->CurrentLayout.displayWidth = pScrn->displayWidth;
 940     pRiva->CurrentLayout.weight.red = pScrn->weight.red;
 941     pRiva->CurrentLayout.weight.green = pScrn->weight.green;
 942     pRiva->CurrentLayout.weight.blue = pScrn->weight.blue;
 943     pRiva->CurrentLayout.mode = pScrn->currentMode;
 944
 945     xf86FreeInt10(pRiva->pInt);
 946
 947     pRiva->pInt = NULL;
 948     return TRUE;
 949 }
 950
 951
 952 /*
 953  * Map the framebuffer and MMIO memory.
 954  */
 955
 956 static Bool
 957 RivaMapMem(ScrnInfoPtr pScrn)
 958 {
 959     RivaPtr pRiva;
 960
 961     pRiva = RivaPTR(pScrn);
 962
 963     /*
 964      * Map IO registers to virtual address space
 965      */
 966     pRiva->IOBase = xf86MapPciMem(pScrn->scrnIndex,
 967                                 VIDMEM_MMIO | VIDMEM_READSIDEEFFECT,
 968                                 pRiva->PciTag, pRiva->IOAddress, 0x1000000);
 969     if (pRiva->IOBase == NULL)
 970         return FALSE;
 971
 972     pRiva->FbBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_FRAMEBUFFER,
 973                                  pRiva->PciTag, pRiva->FbAddress,
 974                                  pRiva->FbMapSize);
 975     if (pRiva->FbBase == NULL)
 976         return FALSE;
 977
 978     pRiva->FbStart = pRiva->FbBase;
 979
 980     return TRUE;
 981 }
 982
 983 Bool
 984 RivaMapMemFBDev(ScrnInfoPtr pScrn)
 985 {
 986     RivaPtr pRiva;
 987
 988     pRiva = RivaPTR(pScrn);
 989
 990     pRiva->FbBase = fbdevHWMapVidmem(pScrn);
 991     if (pRiva->FbBase == NULL)
 992         return FALSE;
 993
 994     pRiva->IOBase = fbdevHWMapMMIO(pScrn);
 995     if (pRiva->IOBase == NULL)
 996         return FALSE;
 997
 998     pRiva->FbStart = pRiva->FbBase;
 999
1000     return TRUE;
1001 }
1002
1003 /*
1004  * Unmap the framebuffer and MMIO memory.
1005  */
1006
1007 static Bool
1008 RivaUnmapMem(ScrnInfoPtr pScrn)
1009 {
1010     RivaPtr pRiva;
1011
1012     pRiva = RivaPTR(pScrn);
1013
1014     /*
1015      * Unmap IO registers to virtual address space
1016      */
1017     xf86UnMapVidMem(pScrn->scrnIndex, (pointer)pRiva->IOBase, 0x1000000);
1018     pRiva->IOBase = NULL;
1019
1020     xf86UnMapVidMem(pScrn->scrnIndex, (pointer)pRiva->FbBase, pRiva->FbMapSize);
1021     pRiva->FbBase = NULL;
1022     pRiva->FbStart = NULL;
1023
1024     return TRUE;
1025 }
1026
1027
1028 /*
1029  * Initialise a new mode.
1030  */
1031
1032 static Bool
1033 RivaModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
1034 {
1035     vgaHWPtr hwp = VGAHWPTR(pScrn);
1036     vgaRegPtr vgaReg;
1037     RivaPtr pRiva = RivaPTR(pScrn);
1038     RivaRegPtr rivaReg;
1039
1040
1041     /* Initialise the ModeReg values */
1042     if (!vgaHWInit(pScrn, mode))
1043         return FALSE;
1044     pScrn->vtSema = TRUE;
1045
1046     vgaReg = &hwp->ModeReg;
1047     rivaReg = &pRiva->ModeReg;
1048
1049     if(!(*pRiva->ModeInit)(pScrn, mode))
1050         return FALSE;
1051
1052     pRiva->riva.LockUnlock(&pRiva->riva, 0);
1053
1054     /* Program the registers */
1055     vgaHWProtect(pScrn, TRUE);
1056
1057     (*pRiva->Restore)(pScrn, vgaReg, rivaReg, FALSE);
1058
1059     RivaResetGraphics(pScrn);
1060
1061     vgaHWProtect(pScrn, FALSE);
1062
1063     pRiva->CurrentLayout.mode = mode;
1064
1065     return TRUE;
1066 }
1067
1068 /*
1069  * Restore the initial (text) mode.
1070  */
1071 static void
1072 RivaRestore(ScrnInfoPtr pScrn)
1073 {
1074     vgaHWPtr hwp = VGAHWPTR(pScrn);
1075     vgaRegPtr vgaReg = &hwp->SavedReg;
1076     RivaPtr pRiva = RivaPTR(pScrn);
1077     RivaRegPtr rivaReg = &pRiva->SavedReg;
1078
1079
1080     pRiva->riva.LockUnlock(&pRiva->riva, 0);
1081
1082     /* Only restore text mode fonts/text for the primary card */
1083     vgaHWProtect(pScrn, TRUE);
1084     (*pRiva->Restore)(pScrn, vgaReg, rivaReg, pRiva->Primary);
1085     vgaHWProtect(pScrn, FALSE);
1086 }
1087
1088 static void
1089 RivaDPMSSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags)
1090 {
1091   unsigned char crtc1A;
1092   vgaHWPtr hwp = VGAHWPTR(pScrn);
1093
1094   if (!pScrn->vtSema) return;
1095
1096   crtc1A = hwp->readCrtc(hwp, 0x1A) & ~0xC0;
1097
1098   switch (PowerManagementMode) {
1099   case DPMSModeStandby:  /* HSync: Off, VSync: On */
1100     crtc1A |= 0x80;
1101     break;
1102   case DPMSModeSuspend:  /* HSync: On, VSync: Off */
1103     crtc1A |= 0x40;
1104     break;
1105   case DPMSModeOff:      /* HSync: Off, VSync: Off */
1106     crtc1A |= 0xC0;
1107     break;
1108   case DPMSModeOn:       /* HSync: On, VSync: On */
1109   default:
1110     break;
1111   }
1112
1113   /* vgaHWDPMSSet will merely cut the dac output */
1114   vgaHWDPMSSet(pScrn, PowerManagementMode, flags);
1115
1116   hwp->writeCrtc(hwp, 0x1A, crtc1A);
1117 }
1118
1119
1120 /* Mandatory */
1121
1122 /* This gets called at the start of each server generation */
1123
1124 static Bool
1125 RivaScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
1126 {
1127     ScrnInfoPtr pScrn;
1128     vgaHWPtr hwp;
1129     RivaPtr pRiva;
1130     RivaRamdacPtr Rivadac;
1131     int ret;
1132     VisualPtr visual;
1133     unsigned char *FBStart;
1134     int width, height, displayWidth;
1135     BoxRec AvailFBArea;
1136
1137     /*
1138      * First get the ScrnInfoRec
1139      */
1140     pScrn = xf86Screens[pScreen->myNum];
1141
1142
1143     hwp = VGAHWPTR(pScrn);
1144     pRiva = RivaPTR(pScrn);
1145     Rivadac = &pRiva->Dac;
1146
1147     /* Map the Riva memory and MMIO areas */
1148     if (pRiva->FBDev) {
1149         if (!RivaMapMemFBDev(pScrn))
1150             return FALSE;
1151     } else {
1152         if (!RivaMapMem(pScrn))
1153             return FALSE;
1154     }
1155
1156     /* Map the VGA memory when the primary video */
1157     if (pRiva->Primary && !pRiva->FBDev) {
1158         hwp->MapSize = 0x10000;
1159         if (!vgaHWMapMem(pScrn))
1160             return FALSE;
1161     }
1162
1163     if (pRiva->FBDev) {
1164         fbdevHWSave(pScrn);
1165         if (!fbdevHWModeInit(pScrn, pScrn->currentMode))
1166             return FALSE;
1167     } else {
1168         /* Save the current state */
1169         RivaSave(pScrn);
1170         /* Initialise the first mode */
1171         if (!RivaModeInit(pScrn, pScrn->currentMode))
1172             return FALSE;
1173     }
1174
1175
1176     /* Darken the screen for aesthetic reasons and set the viewport */
1177     RivaSaveScreen(pScreen, SCREEN_SAVER_ON);
1178     pScrn->AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
1179
1180
1181     /*
1182      * The next step is to setup the screen's visuals, and initialise the
1183      * framebuffer code.  In cases where the framebuffer's default
1184      * choices for things like visual layouts and bits per RGB are OK,
1185      * this may be as simple as calling the framebuffer's ScreenInit()
1186      * function.  If not, the visuals will need to be setup before calling
1187      * a fb ScreenInit() function and fixed up after.
1188      *
1189      * For most PC hardware at depths >= 8, the defaults that fb uses
1190      * are not appropriate.  In this driver, we fixup the visuals after.
1191      */
1192
1193     /*
1194      * Reset the visual list.
1195      */
1196     miClearVisualTypes();
1197
1198     /* Setup the visuals we support. */
1199
1200     if (pScrn->bitsPerPixel > 8) {
1201           if (!miSetVisualTypes(pScrn->depth, TrueColorMask, 8,
1202                                 pScrn->defaultVisual))
1203               return FALSE;
1204     } else {
1205           if (!miSetVisualTypes(pScrn->depth,
1206                                 miGetDefaultVisualMask(pScrn->depth), 8,
1207                                 pScrn->defaultVisual))
1208           return FALSE;
1209      }
1210     if (!miSetPixmapDepths ()) return FALSE;
1211
1212
1213     /*
1214      * Call the framebuffer layer's ScreenInit function, and fill in other
1215      * pScreen fields.
1216      */
1217
1218     width = pScrn->virtualX;
1219     height = pScrn->virtualY;
1220     displayWidth = pScrn->displayWidth;
1221
1222
1223     if(pRiva->Rotate) {
1224         height = pScrn->virtualX;
1225         width = pScrn->virtualY;
1226     }
1227
1228     if(pRiva->ShadowFB) {
1229         pRiva->ShadowPitch = BitmapBytePad(pScrn->bitsPerPixel * width);
1230         pRiva->ShadowPtr = xalloc(pRiva->ShadowPitch * height);
1231         displayWidth = pRiva->ShadowPitch / (pScrn->bitsPerPixel >> 3);
1232         FBStart = pRiva->ShadowPtr;
1233     } else {
1234         pRiva->ShadowPtr = NULL;
1235         FBStart = pRiva->FbStart;
1236     }
1237
1238     switch (pScrn->bitsPerPixel) {
1239         case 8:
1240         case 16:
1241         case 32:
1242             ret = fbScreenInit(pScreen, FBStart, width, height,
1243                                pScrn->xDpi, pScrn->yDpi,
1244                                displayWidth, pScrn->bitsPerPixel);
1245             break;
1246         default:
1247             xf86DrvMsg(scrnIndex, X_ERROR,
1248                        "Internal error: invalid bpp (%d) in RivaScreenInit\n",
1249                        pScrn->bitsPerPixel);
1250             ret = FALSE;
1251             break;
1252     }
1253     if (!ret)
1254         return FALSE;
1255
1256
1257     if (pScrn->bitsPerPixel > 8) {
1258         /* Fixup RGB ordering */
1259         visual = pScreen->visuals + pScreen->numVisuals;
1260         while (--visual >= pScreen->visuals) {
1261             if ((visual->class | DynamicClass) == DirectColor) {
1262                 visual->offsetRed = pScrn->offset.red;
1263                 visual->offsetGreen = pScrn->offset.green;
1264                 visual->offsetBlue = pScrn->offset.blue;
1265                 visual->redMask = pScrn->mask.red;
1266                 visual->greenMask = pScrn->mask.green;
1267                 visual->blueMask = pScrn->mask.blue;
1268             }
1269         }
1270     }
1271
1272     fbPictureInit (pScreen, 0, 0);
1273
1274     xf86SetBlackWhitePixels(pScreen);
1275
1276
1277     if(!pRiva->ShadowFB) /* hardware cursor needs to wrap this layer */
1278         RivaDGAInit(pScreen);
1279
1280     AvailFBArea.x1 = 0;
1281     AvailFBArea.y1 = 0;
1282     AvailFBArea.x2 = pScrn->displayWidth;
1283     AvailFBArea.y2 = (min(pRiva->FbUsableSize, 32*1024*1024)) /
1284                      (pScrn->displayWidth * pScrn->bitsPerPixel / 8);
1285     xf86InitFBManager(pScreen, &AvailFBArea);
1286
1287     if (!pRiva->NoAccel)
1288         RivaAccelInit(pScreen);
1289
1290     miInitializeBackingStore(pScreen);
1291     xf86SetBackingStore(pScreen);
1292     xf86SetSilkenMouse(pScreen);
1293
1294
1295     /* Initialize software cursor.
1296         Must precede creation of the default colormap */
1297     miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
1298
1299
1300     /* Initialize HW cursor layer.
1301         Must follow software cursor initialization*/
1302     if (pRiva->HWCursor) {
1303         if(!RivaCursorInit(pScreen))
1304             xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1305                 "Hardware cursor initialization failed\n");
1306     }
1307
1308     /* Initialise default colourmap */
1309     if (!miCreateDefColormap(pScreen))
1310         return FALSE;
1311
1312
1313     /* Initialize colormap layer.
1314         Must follow initialization of the default colormap */
1315     if(!xf86HandleColormaps(pScreen, 256, 8,
1316         (pRiva->FBDev ? fbdevHWLoadPaletteWeak() : Rivadac->LoadPalette),
1317         NULL, CMAP_RELOAD_ON_MODE_SWITCH | CMAP_PALETTED_TRUECOLOR))
1318         return FALSE;
1319
1320
1321     if(pRiva->ShadowFB) {
1322         RefreshAreaFuncPtr refreshArea = RivaRefreshArea;
1323
1324         if(pRiva->Rotate) {
1325            pRiva->PointerMoved = pScrn->PointerMoved;
1326            pScrn->PointerMoved = RivaPointerMoved;
1327
1328            switch(pScrn->bitsPerPixel) {
1329                case 8:  refreshArea = RivaRefreshArea8; break;
1330                case 16: refreshArea = RivaRefreshArea16;        break;
1331                case 32: refreshArea = RivaRefreshArea32;        break;
1332            }
1333            xf86DisableRandR();
1334            xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1335                       "Driver rotation enabled, RandR disabled\n");
1336         }
1337
1338         ShadowFBInit(pScreen, refreshArea);
1339     }
1340
1341     xf86DPMSInit(pScreen, RivaDPMSSet, 0);
1342
1343
1344     pScrn->memPhysBase = pRiva->FbAddress;
1345     pScrn->fbOffset = 0;
1346
1347     pScreen->SaveScreen = RivaSaveScreen;
1348
1349     /* Wrap the current CloseScreen function */
1350     pRiva->CloseScreen = pScreen->CloseScreen;
1351     pScreen->CloseScreen = RivaCloseScreen;
1352
1353     /* Report any unused options (only for the first generation) */
1354     if (serverGeneration == 1) {
1355         xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
1356     }
1357     /* Done */
1358     return TRUE;
1359 }
1360
1361 /* Free up any persistent data structures */
1362
1363
1364 /* Do screen blanking */
1365
1366 /* Mandatory */
1367 static Bool
1368 RivaSaveScreen(ScreenPtr pScreen, int mode)
1369 {
1370     return vgaHWSaveScreen(pScreen, mode);
1371 }
1372
1373 static void
1374 RivaSave(ScrnInfoPtr pScrn)
1375 {
1376     RivaPtr pRiva = RivaPTR(pScrn);
1377     RivaRegPtr rivaReg = &pRiva->SavedReg;
1378     vgaHWPtr pVga = VGAHWPTR(pScrn);
1379     vgaRegPtr vgaReg = &pVga->SavedReg;
1380
1381     (*pRiva->Save)(pScrn, vgaReg, rivaReg, pRiva->Primary);
1382 }
1383