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

   1 /* $XdotOrg: driver/xf86-video-nv/src/nv_driver.c,v 1.21 2006/01/24 16:45:29 aplattner Exp $ */
   2 /* $XConsortium: nv_driver.c /main/3 1996/10/28 05:13:37 kaleb $ */
   3 /*
   4  * Copyright 1996-1997  David J. McKay
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * DAVID J. MCKAY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  20  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  21  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24
  25 /* Hacked together from mga driver and 3.3.4 NVIDIA driver by Jarno Paananen
  26    <jpaana@s2.org> */
  27
  28 /* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/nv/nv_driver.c,v 1.144 2006/06/16 00:19:32 mvojkovi Exp $ */
  29
  30 #include <stdio.h>
  31
  32 #include "nv_include.h"
  33
  34 #include "xf86int10.h"
  35
  36 #include "xf86drm.h"
  37
  38 extern DisplayModePtr xf86ModesAdd(DisplayModePtr Modes, DisplayModePtr Additions);
  39
  40 /*
  41  * Forward definitions for the functions that make up the driver.
  42  */
  43 /* Mandatory functions */
  44 static const OptionInfoRec * NVAvailableOptions(int chipid, int busid);
  45 static void    NVIdentify(int flags);
  46 #ifndef XSERVER_LIBPCIACCESS
  47 static Bool    NVProbe(DriverPtr drv, int flags);
  48 #endif /* XSERVER_LIBPCIACCESS */
  49 static Bool    NVPreInit(ScrnInfoPtr pScrn, int flags);
  50 static Bool    NVScreenInit(int Index, ScreenPtr pScreen, int argc,
  51                             char **argv);
  52 static Bool    NVEnterVT(int scrnIndex, int flags);
  53 static void    NVLeaveVT(int scrnIndex, int flags);
  54 static Bool    NVCloseScreen(int scrnIndex, ScreenPtr pScreen);
  55 static Bool    NVSaveScreen(ScreenPtr pScreen, int mode);
  56
  57 /* Optional functions */
  58 static void    NVFreeScreen(int scrnIndex, int flags);
  59 static ModeStatus NVValidMode(int scrnIndex, DisplayModePtr mode,
  60                               Bool verbose, int flags);
  61 #ifdef RANDR
  62 static Bool    NVDriverFunc(ScrnInfoPtr pScrnInfo, xorgDriverFuncOp op,
  63                               pointer data);
  64 #endif
  65
  66 /* Internally used functions */
  67
  68 static Bool     NVMapMem(ScrnInfoPtr pScrn);
  69 static Bool     NVUnmapMem(ScrnInfoPtr pScrn);
  70 static void     NVSave(ScrnInfoPtr pScrn);
  71 static void     NVRestore(ScrnInfoPtr pScrn);
  72 static Bool     NVModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode);
  73
  74 #ifdef XSERVER_LIBPCIACCESS
  75
  76 #define NOUVEAU_PCI_DEVICE(_vendor_id, _device_id) \
  77         { (_vendor_id), (_device_id), PCI_MATCH_ANY, PCI_MATCH_ANY, 0x00030000, 0x00ffffff, 0 }
  78
  79 static const struct pci_id_match nouveau_device_match[] = {
  80         NOUVEAU_PCI_DEVICE(PCI_VENDOR_NVIDIA, PCI_MATCH_ANY),
  81         NOUVEAU_PCI_DEVICE(PCI_VENDOR_NVIDIA_SGS, PCI_MATCH_ANY),
  82         { 0, 0, 0 },
  83 };
  84
  85 static Bool NVPciProbe (        DriverPtr               drv,
  86                                 int                     entity_num,
  87                                 struct pci_device       *dev,
  88                                 intptr_t                match_data      );
  89
  90 #endif /* XSERVER_LIBPCIACCESS */
  91
  92 /*
  93  * This contains the functions needed by the server after loading the
  94  * driver module.  It must be supplied, and gets added the driver list by
  95  * the Module Setup funtion in the dynamic case.  In the static case a
  96  * reference to this is compiled in, and this requires that the name of
  97  * this DriverRec be an upper-case version of the driver name.
  98  */
  99
 100 _X_EXPORT DriverRec NV = {
 101         NV_VERSION,
 102         NV_DRIVER_NAME,
 103         NVIdentify,
 104 #ifdef XSERVER_LIBPCIACCESS
 105         NULL,
 106 #else
 107         NVProbe,
 108 #endif /* XSERVER_LIBPCIACCESS */
 109         NVAvailableOptions,
 110         NULL,
 111         0,
 112         NULL,
 113 #ifdef XSERVER_LIBPCIACCESS
 114         nouveau_device_match,
 115         NVPciProbe
 116 #endif /* XSERVER_LIBPCIACCESS */
 117 };
 118
 119 struct NvFamily
 120 {
 121   char *name;
 122   char *chipset;
 123 };
 124
 125 static struct NvFamily NVKnownFamilies[] =
 126 {
 127   { "RIVA TNT",    "NV04" },
 128   { "RIVA TNT2",   "NV05" },
 129   { "GeForce 256", "NV10" },
 130   { "GeForce 2",   "NV11, NV15" },
 131   { "GeForce 4MX", "NV17, NV18" },
 132   { "GeForce 3",   "NV20" },
 133   { "GeForce 4Ti", "NV25, NV28" },
 134   { "GeForce FX",  "NV3x" },
 135   { "GeForce 6",   "NV4x" },
 136   { "GeForce 7",   "G7x" },
 137   { "GeForce 8",   "G8x" },
 138   { NULL, NULL}
 139 };
 140
 141 /*
 142  * List of symbols from other modules that this module references.  This
 143  * list is used to tell the loader that it is OK for symbols here to be
 144  * unresolved providing that it hasn't been told that they haven't been
 145  * told that they are essential via a call to xf86LoaderReqSymbols() or
 146  * xf86LoaderReqSymLists().  The purpose is this is to avoid warnings about
 147  * unresolved symbols that are not required.
 148  */
 149
 150 static const char *vgahwSymbols[] = {
 151     "vgaHWUnmapMem",
 152     "vgaHWDPMSSet",
 153     "vgaHWFreeHWRec",
 154     "vgaHWGetHWRec",
 155     "vgaHWGetIndex",
 156     "vgaHWInit",
 157     "vgaHWMapMem",
 158     "vgaHWProtect",
 159     "vgaHWRestore",
 160     "vgaHWSave",
 161     "vgaHWSaveScreen",
 162     NULL
 163 };
 164
 165 static const char *fbSymbols[] = {
 166     "fbPictureInit",
 167     "fbScreenInit",
 168     NULL
 169 };
 170
 171 static const char *exaSymbols[] = {
 172     "exaDriverInit",
 173     "exaOffscreenInit",
 174     NULL
 175 };
 176
 177 static const char *ramdacSymbols[] = {
 178     "xf86CreateCursorInfoRec",
 179     "xf86DestroyCursorInfoRec",
 180     "xf86InitCursor",
 181     NULL
 182 };
 183
 184 static const char *ddcSymbols[] = {
 185     "xf86PrintEDID",
 186     "xf86DoEDID_DDC2",
 187     "xf86SetDDCproperties",
 188     NULL
 189 };
 190
 191 static const char *vbeSymbols[] = {
 192     "VBEInit",
 193     "vbeFree",
 194     "vbeDoEDID",
 195     NULL
 196 };
 197
 198 static const char *i2cSymbols[] = {
 199     "xf86CreateI2CBusRec",
 200     "xf86I2CBusInit",
 201     NULL
 202 };
 203
 204 static const char *shadowSymbols[] = {
 205     "ShadowFBInit",
 206     NULL
 207 };
 208
 209 static const char *int10Symbols[] = {
 210     "xf86FreeInt10",
 211     "xf86InitInt10",
 212     NULL
 213 };
 214
 215 const char *drmSymbols[] = {
 216     "drmOpen",
 217     "drmAddBufs",
 218     "drmAddMap",
 219     "drmAgpAcquire",
 220     "drmAgpVersionMajor",
 221     "drmAgpVersionMinor",
 222     "drmAgpAlloc",
 223     "drmAgpBind",
 224     "drmAgpEnable",
 225     "drmAgpFree",
 226     "drmAgpRelease",
 227     "drmAgpUnbind",
 228     "drmAuthMagic",
 229     "drmCommandNone",
 230     "drmCommandWrite",
 231     "drmCommandWriteRead",
 232     "drmCreateContext",
 233     "drmCtlInstHandler",
 234     "drmCtlUninstHandler",
 235     "drmDestroyContext",
 236     "drmFreeVersion",
 237     "drmGetInterruptFromBusID",
 238     "drmGetLibVersion",
 239     "drmGetVersion",
 240     NULL
 241 };
 242
 243 const char *driSymbols[] = {
 244     "DRICloseScreen",
 245     "DRICreateInfoRec",
 246     "DRIDestroyInfoRec",
 247     "DRIFinishScreenInit",
 248     "DRIGetSAREAPrivate",
 249     "DRILock",
 250     "DRIQueryVersion",
 251     "DRIScreenInit",
 252     "DRIUnlock",
 253     "GlxSetVisualConfigs",
 254     "DRICreatePCIBusID",
 255     NULL
 256 };
 257
 258
 259 static MODULESETUPPROTO(nouveauSetup);
 260
 261 static XF86ModuleVersionInfo nouveauVersRec =
 262 {
 263     "nouveau",
 264     MODULEVENDORSTRING,
 265     MODINFOSTRING1,
 266     MODINFOSTRING2,
 267     XORG_VERSION_CURRENT,
 268     NV_MAJOR_VERSION, NV_MINOR_VERSION, NV_PATCHLEVEL,
 269     ABI_CLASS_VIDEODRV,                     /* This is a video driver */
 270     ABI_VIDEODRV_VERSION,
 271     MOD_CLASS_VIDEODRV,
 272     {0,0,0,0}
 273 };
 274
 275 _X_EXPORT XF86ModuleData nouveauModuleData = { &nouveauVersRec, nouveauSetup, NULL };
 276
 277
 278 /*
 279  * This is intentionally screen-independent.  It indicates the binding
 280  * choice made in the first PreInit.
 281  */
 282 static int pix24bpp = 0;
 283
 284 static Bool
 285 NVGetRec(ScrnInfoPtr pScrn)
 286 {
 287     /*
 288      * Allocate an NVRec, and hook it into pScrn->driverPrivate.
 289      * pScrn->driverPrivate is initialised to NULL, so we can check if
 290      * the allocation has already been done.
 291      */
 292     if (pScrn->driverPrivate != NULL)
 293         return TRUE;
 294
 295     pScrn->driverPrivate = xnfcalloc(sizeof(NVRec), 1);
 296     /* Initialise it */
 297
 298     return TRUE;
 299 }
 300
 301 static void
 302 NVFreeRec(ScrnInfoPtr pScrn)
 303 {
 304     if (pScrn->driverPrivate == NULL)
 305         return;
 306     xfree(pScrn->driverPrivate);
 307     pScrn->driverPrivate = NULL;
 308 }
 309
 310
 311 static pointer
 312 nouveauSetup(pointer module, pointer opts, int *errmaj, int *errmin)
 313 {
 314         static Bool setupDone = FALSE;
 315
 316         /* This module should be loaded only once, but check to be sure. */
 317
 318         if (!setupDone) {
 319                 setupDone = TRUE;
 320                 /* The 1 here is needed to turn off a backwards compatibility mode */
 321                 /* Otherwise NVPciProbe() is not called */
 322                 xf86AddDriver(&NV, module, 1);
 323
 324                 /*
 325                  * Modules that this driver always requires may be loaded here
 326                  * by calling LoadSubModule().
 327                  */
 328                 /*
 329                  * Tell the loader about symbols from other modules that this module
 330                  * might refer to.
 331                  */
 332                 LoaderRefSymLists(vgahwSymbols, exaSymbols, fbSymbols,
 333 #ifdef XF86DRI
 334                                 drmSymbols,
 335 #endif
 336                                 ramdacSymbols, shadowSymbols,
 337                                 i2cSymbols, ddcSymbols, vbeSymbols,
 338                                 int10Symbols, NULL);
 339
 340                 /*
 341                  * The return value must be non-NULL on success even though there
 342                  * is no TearDownProc.
 343                  */
 344                 return (pointer)1;
 345         } else {
 346                 if (errmaj) *errmaj = LDR_ONCEONLY;
 347                 return NULL;
 348         }
 349 }
 350
 351 static const OptionInfoRec *
 352 NVAvailableOptions(int chipid, int busid)
 353 {
 354     return NVOptions;
 355 }
 356
 357 /* Mandatory */
 358 static void
 359 NVIdentify(int flags)
 360 {
 361     struct NvFamily *family;
 362     size_t maxLen=0;
 363
 364     xf86DrvMsg(0, X_INFO, NV_NAME " driver " NV_DRIVER_DATE "\n");
 365     xf86DrvMsg(0, X_INFO, NV_NAME " driver for NVIDIA chipset families :\n");
 366
 367     /* maximum length for alignment */
 368     family = NVKnownFamilies;
 369     while(family->name && family->chipset)
 370     {
 371         maxLen = max(maxLen, strlen(family->name));
 372         family++;
 373     }
 374
 375     /* display */
 376     family = NVKnownFamilies;
 377     while(family->name && family->chipset)
 378     {
 379         size_t len = strlen(family->name);
 380         xf86ErrorF("\t%s", family->name);
 381         while(len<maxLen+1)
 382         {
 383             xf86ErrorF(" ");
 384             len++;
 385         }
 386         xf86ErrorF("(%s)\n", family->chipset);
 387         family++;
 388     }
 389 }
 390
 391
 392 static Bool
 393 NVGetScrnInfoRec(PciChipsets *chips, int chip)
 394 {
 395     ScrnInfoPtr pScrn;
 396
 397     pScrn = xf86ConfigPciEntity(NULL, 0, chip,
 398                                 chips, NULL, NULL, NULL,
 399                                 NULL, NULL);
 400
 401     if(!pScrn) return FALSE;
 402
 403     pScrn->driverVersion    = NV_VERSION;
 404     pScrn->driverName       = NV_DRIVER_NAME;
 405     pScrn->name             = NV_NAME;
 406
 407 #ifndef XSERVER_LIBPCIACCESS
 408         pScrn->Probe = NVProbe;
 409 #else
 410         pScrn->Probe = NULL;
 411 #endif
 412     pScrn->PreInit          = NVPreInit;
 413     pScrn->ScreenInit       = NVScreenInit;
 414     pScrn->SwitchMode       = NVSwitchMode;
 415     pScrn->AdjustFrame      = NVAdjustFrame;
 416     pScrn->EnterVT          = NVEnterVT;
 417     pScrn->LeaveVT          = NVLeaveVT;
 418     pScrn->FreeScreen       = NVFreeScreen;
 419     pScrn->ValidMode        = NVValidMode;
 420
 421     return TRUE;
 422 }
 423
 424 /* This returns architecture in hexdecimal, so NV40 is 0x40 */
 425 static int NVGetArchitecture (volatile CARD32 *regs)
 426 {
 427         int architecture = 0;
 428
 429         /* We're dealing with >=NV10 */
 430         if ((regs[0] & 0x0f000000) > 0 ) {
 431                 /* Bit 27-20 contain the architecture in hex */
 432                 architecture = (regs[0] & 0xff00000) >> 20;
 433         /* NV04 or NV05 */
 434         } else if ((regs[0] & 0xff00fff0) == 0x20004000) {
 435                 architecture = 0x04;
 436         }
 437
 438         return architecture;
 439 }
 440
 441 /* Reading the pci_id from the card registers is the most reliable way */
 442 static CARD32 NVGetPCIID (volatile CARD32 *regs)
 443 {
 444         CARD32 pci_id;
 445
 446         int architecture = NVGetArchitecture(regs);
 447
 448         /* Dealing with an unknown or unsupported card */
 449         if (architecture == 0) {
 450                 return 0;
 451         }
 452
 453         if (architecture >= 0x40)
 454                 pci_id = regs[0x88000/4];
 455         else
 456                 pci_id = regs[0x1800/4];
 457
 458         /* A pci-id can be inverted, we must correct this */
 459         if ((pci_id & 0xffff) == PCI_VENDOR_NVIDIA) {
 460                 pci_id = (PCI_VENDOR_NVIDIA << 16) | (pci_id >> 16);
 461         } else if ((pci_id & 0xffff) == PCI_VENDOR_NVIDIA_SGS) {
 462                 pci_id = (PCI_VENDOR_NVIDIA_SGS << 16) | (pci_id >> 16);
 463         /* Checking endian issues */
 464         } else {
 465                 /* PCI_VENDOR_NVIDIA = 0x10DE */
 466                 if ((pci_id & (0xffff << 16)) == (0xDE10 << 16)) { /* wrong endian */
 467                         pci_id = (PCI_VENDOR_NVIDIA << 16) | ((pci_id << 8) & 0x0000ff00) |
 468                                 ((pci_id >> 8) & 0x000000ff);
 469                 /* PCI_VENDOR_NVIDIA_SGS = 0x12D2 */
 470                 } else if ((pci_id & (0xffff << 16)) == (0xD212 << 16)) { /* wrong endian */
 471                         pci_id = (PCI_VENDOR_NVIDIA_SGS << 16) | ((pci_id << 8) & 0x0000ff00) |
 472                                 ((pci_id >> 8) & 0x000000ff);
 473                 }
 474         }
 475
 476         return pci_id;
 477 }
 478
 479 #ifdef XSERVER_LIBPCIACCESS
 480
 481 static Bool NVPciProbe (        DriverPtr               drv,
 482                                 int                     entity_num,
 483                                 struct pci_device       *dev,
 484                                 intptr_t                match_data      )
 485 {
 486         ScrnInfoPtr pScrn = NULL;
 487
 488         volatile CARD32 *regs = NULL;
 489
 490         /* Temporary mapping to discover the architecture */
 491         pci_device_map_range(dev, PCI_DEV_MEM_BASE(dev, 0), 0x90000, 0, &regs);
 492
 493         char architecture = NVGetArchitecture(regs);
 494
 495         CARD32 pci_id = NVGetPCIID(regs);
 496
 497         pci_device_unmap_range(dev, regs, 0x90000);
 498
 499         /* Currently NV04 up to NV83 is supported */
 500         /* For safety the fictional NV8F is used */
 501         if (architecture >= 0x04 && architecture <= 0x8F) {
 502
 503                 /* At this stage the pci_id should be ok, so we generate this to avoid list duplication */
 504                 /* AGP bridge chips need their bridge chip id to be detected */
 505                 const PciChipsets NVChipsets[] = {
 506                         { pci_id, PCI_DEV_PCI_ID(dev), RES_SHARED_VGA },
 507                         { -1, -1, RES_UNDEFINED }
 508                 };
 509
 510                 pScrn = xf86ConfigPciEntity(pScrn, 0, entity_num, NVChipsets,
 511                                                 NULL, NULL, NULL, NULL, NULL);
 512
 513                 if (pScrn != NULL) {
 514                         pScrn->driverVersion    = NV_VERSION;
 515                         pScrn->driverName       = NV_DRIVER_NAME;
 516                         pScrn->name             = NV_NAME;
 517
 518                         pScrn->Probe            = NULL;
 519                         pScrn->PreInit          = NVPreInit;
 520                         pScrn->ScreenInit       = NVScreenInit;
 521                         pScrn->SwitchMode       = NVSwitchMode;
 522                         pScrn->AdjustFrame      = NVAdjustFrame;
 523                         pScrn->EnterVT          = NVEnterVT;
 524                         pScrn->LeaveVT          = NVLeaveVT;
 525                         pScrn->FreeScreen       = NVFreeScreen;
 526                         pScrn->ValidMode        = NVValidMode;
 527
 528                         return TRUE;
 529                 }
 530         }
 531
 532         return FALSE;
 533 }
 534
 535 #endif /* XSERVER_LIBPCIACCESS */
 536
 537 #define MAX_CHIPS MAXSCREENS
 538
 539 #ifndef XSERVER_LIBPCIACCESS
 540 /* Mandatory */
 541 static Bool
 542 NVProbe(DriverPtr drv, int flags)
 543 {
 544         int i;
 545         GDevPtr *devSections;
 546         int *usedChips;
 547         SymTabRec NVChipsets[MAX_CHIPS + 1];
 548         PciChipsets NVPciChipsets[MAX_CHIPS + 1];
 549         pciVideoPtr *ppPci;
 550         int numDevSections;
 551         int numUsed;
 552         Bool foundScreen = FALSE;
 553
 554         if ((numDevSections = xf86MatchDevice(NV_DRIVER_NAME, &devSections)) <= 0)
 555                 return FALSE;  /* no matching device section */
 556
 557         if (!(ppPci = xf86GetPciVideoInfo()))
 558                 return FALSE;  /* no PCI cards found */
 559
 560         numUsed = 0;
 561
 562         /* Create the NVChipsets and NVPciChipsets from found devices */
 563         while (*ppPci && (numUsed < MAX_CHIPS)) {
 564                 if (((*ppPci)->vendor == PCI_VENDOR_NVIDIA_SGS) ||
 565                         ((*ppPci)->vendor == PCI_VENDOR_NVIDIA))
 566                 {
 567                         volatile CARD32 *regs;
 568                         CARD32 pcicmd;
 569
 570                         PCI_DEV_READ_LONG(*ppPci, PCI_CMD_STAT_REG, &pcicmd);
 571                         /* Enable reading memory? */
 572                         PCI_DEV_WRITE_LONG(*ppPci, PCI_CMD_STAT_REG, pcicmd | PCI_CMD_MEM_ENABLE);
 573
 574                         regs = xf86MapPciMem(-1, VIDMEM_MMIO, PCI_DEV_TAG(*ppPci), PCI_DEV_MEM_BASE(*ppPci, 0), 0x90000);
 575                         int pciid = NVGetPCIID(regs);
 576
 577                         int architecture = NVGetArchitecture(regs);
 578                         char name[25];
 579                         sprintf(name, "NVIDIA NV%02X", architecture);
 580                         /* NV04 upto NV83 is supported, NV8F is fictive limit */
 581                         if (architecture >= 0x04 && architecture <= 0x8F) {
 582                                 NVChipsets[numUsed].token = pciid;
 583                                 NVChipsets[numUsed].name = name;
 584                                 NVPciChipsets[numUsed].numChipset = pciid;
 585                                 /* AGP bridge chips need their bridge chip id to be detected */
 586                                 NVPciChipsets[numUsed].PCIid = PCI_DEV_PCI_ID(*ppPci);
 587                                 NVPciChipsets[numUsed].resList = RES_SHARED_VGA;
 588                                 numUsed++;
 589                         }
 590                         xf86UnMapVidMem(-1, (pointer)regs, 0x90000);
 591
 592                         /* Reset previous state */
 593                         PCI_DEV_WRITE_LONG(*ppPci, PCI_CMD_STAT_REG, pcicmd);
 594                 }
 595                 ppPci++;
 596         }
 597
 598         /* terminate the list */
 599         NVChipsets[numUsed].token = -1;
 600         NVChipsets[numUsed].name = NULL;
 601         NVPciChipsets[numUsed].numChipset = -1;
 602         NVPciChipsets[numUsed].PCIid = -1;
 603         NVPciChipsets[numUsed].resList = RES_UNDEFINED;
 604
 605         numUsed = xf86MatchPciInstances(NV_NAME, 0, NVChipsets, NVPciChipsets,
 606                                         devSections, numDevSections, drv,
 607                                         &usedChips);
 608
 609         if (numUsed <= 0) {
 610                 return FALSE;
 611         }
 612
 613         if (flags & PROBE_DETECT) {
 614                 foundScreen = TRUE;
 615         } else {
 616                 for (i = 0; i < numUsed; i++) {
 617                         pciVideoPtr pPci;
 618
 619                         pPci = xf86GetPciInfoForEntity(usedChips[i]);
 620                         if (NVGetScrnInfoRec(NVPciChipsets, usedChips[i])) {
 621                                 foundScreen = TRUE;
 622                         }
 623                 }
 624         }
 625
 626         xfree(devSections);
 627         xfree(usedChips);
 628
 629         return foundScreen;
 630 }
 631 #endif /* XSERVER_LIBPCIACCESS */
 632
 633 Bool
 634 NVSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
 635 {
 636         ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 637         NVPtr pNv = NVPTR(pScrn);
 638
 639 #ifdef ENABLE_RANDR12
 640         if (pNv->randr12_enable) {
 641                 /* No rotation support for the moment */
 642                 return xf86SetSingleMode(pScrn, mode, RR_Rotate_0);
 643         }
 644 #endif
 645
 646         return NVModeInit(xf86Screens[scrnIndex], mode);
 647 }
 648
 649 /*
 650  * This function is used to initialize the Start Address - the first
 651  * displayed location in the video memory.
 652  */
 653 /* Usually mandatory */
 654 void
 655 NVAdjustFrame(int scrnIndex, int x, int y, int flags)
 656 {
 657     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 658     int startAddr;
 659     NVPtr pNv = NVPTR(pScrn);
 660     NVFBLayout *pLayout = &pNv->CurrentLayout;
 661
 662 #ifdef ENABLE_RANDR12
 663     if (pNv->randr12_enable) {
 664         xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
 665         int startAddr;
 666         xf86CrtcPtr crtc = config->output[config->compat_output]->crtc;
 667
 668         if (crtc && crtc->enabled) {
 669             NVCrtcSetBase(crtc, x, y);
 670         }
 671     } else
 672 #endif
 673     {
 674         startAddr = (((y*pLayout->displayWidth)+x)*(pLayout->bitsPerPixel/8));
 675         startAddr += pNv->FB->offset;
 676         NVSetStartAddress(pNv, startAddr);
 677     }
 678 }
 679
 680 #ifdef ENABLE_RANDR12
 681 void
 682 NVResetCrtcConfig(ScrnInfoPtr pScrn, int set)
 683 {
 684         xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
 685         NVPtr pNv = NVPTR(pScrn);
 686         int i;
 687         CARD32 val = 0;
 688
 689         for (i = 0; i < config->num_crtc; i++) {
 690                 xf86CrtcPtr crtc = config->crtc[i];
 691                 NVCrtcPrivatePtr nv_crtc = crtc->driver_private;
 692
 693                 if (set) {
 694                         NVCrtcRegPtr regp;
 695
 696                         regp = &pNv->ModeReg.crtc_reg[nv_crtc->head];
 697                         val = regp->head;
 698                 }
 699
 700                 nvWriteCRTC(pNv, nv_crtc->head, NV_CRTC_FSEL, val);
 701         }
 702 }
 703 #endif
 704
 705 static Bool
 706 NV50AcquireDisplay(ScrnInfoPtr pScrn)
 707 {
 708 #ifdef ENABLE_RANDR12
 709         if (!NV50DispInit(pScrn))
 710                 return FALSE;
 711         if (!NV50CursorAcquire(pScrn))
 712                 return FALSE;
 713         xf86SetDesiredModes(pScrn);
 714
 715         return TRUE;
 716 #else
 717         return FALSE;
 718 #endif
 719 }
 720
 721 static Bool
 722 NV50ReleaseDisplay(ScrnInfoPtr pScrn)
 723 {
 724 #ifdef ENABLE_RANDR12
 725         NV50CursorRelease(pScrn);
 726         NV50DispShutdown(pScrn);
 727 #endif
 728         return TRUE;
 729 }
 730
 731 /*
 732  * This is called when VT switching back to the X server.  Its job is
 733  * to reinitialise the video mode.
 734  *
 735  * We may wish to unmap video/MMIO memory too.
 736  */
 737
 738 /* Mandatory */
 739 static Bool
 740 NVEnterVT(int scrnIndex, int flags)
 741 {
 742     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 743     NVPtr pNv = NVPTR(pScrn);
 744
 745 #ifdef ENABLE_RANDR12
 746     if (pNv->randr12_enable) {
 747         xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
 748         int i;
 749         pScrn->vtSema = TRUE;
 750
 751         if (pNv->Architecture == NV_ARCH_50) {
 752                 if (!NV50AcquireDisplay(pScrn))
 753                         return FALSE;
 754                 return TRUE;
 755         }
 756
 757         /* Save the current state */
 758         if (pNv->SaveGeneration != serverGeneration) {
 759                 pNv->SaveGeneration = serverGeneration;
 760                 NVSave(pScrn);
 761         }
 762
 763         for (i = 0; i < xf86_config->num_crtc; i++) {
 764                 NVCrtcLockUnlock(xf86_config->crtc[i], 0);
 765         }
 766
 767         NVResetCrtcConfig(pScrn, 0);
 768         if (!xf86SetDesiredModes(pScrn))
 769                 return FALSE;
 770         NVResetCrtcConfig(pScrn, 1);
 771
 772     } else
 773 #endif
 774     {
 775         if (!NVModeInit(pScrn, pScrn->currentMode))
 776             return FALSE;
 777
 778     }
 779     NVAdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
 780     if(pNv->overlayAdaptor)
 781         NVResetVideo(pScrn);
 782     return TRUE;
 783
 784 }
 785
 786 /*
 787  * This is called when VT switching away from the X server.  Its job is
 788  * to restore the previous (text) mode.
 789  *
 790  * We may wish to remap video/MMIO memory too.
 791  */
 792
 793 /* Mandatory */
 794 static void
 795 NVLeaveVT(int scrnIndex, int flags)
 796 {
 797     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 798     NVPtr pNv = NVPTR(pScrn);
 799
 800     if (pNv->Architecture == NV_ARCH_50) {
 801         NV50ReleaseDisplay(pScrn);
 802         return;
 803     }
 804     NVSync(pScrn);
 805     NVRestore(pScrn);
 806     if (!pNv->randr12_enable)
 807         NVLockUnlock(pNv, 1);
 808 }
 809
 810
 811
 812 static void
 813 NVBlockHandler (
 814     int i,
 815     pointer blockData,
 816     pointer pTimeout,
 817     pointer pReadmask
 818 )
 819 {
 820     ScreenPtr     pScreen = screenInfo.screens[i];
 821     ScrnInfoPtr   pScrnInfo = xf86Screens[i];
 822     NVPtr         pNv = NVPTR(pScrnInfo);
 823
 824     if (pNv->DMAKickoffCallback)
 825         (*pNv->DMAKickoffCallback)(pNv);
 826
 827     pScreen->BlockHandler = pNv->BlockHandler;
 828     (*pScreen->BlockHandler) (i, blockData, pTimeout, pReadmask);
 829     pScreen->BlockHandler = NVBlockHandler;
 830
 831     if (pNv->VideoTimerCallback)
 832         (*pNv->VideoTimerCallback)(pScrnInfo, currentTime.milliseconds);
 833
 834 }
 835
 836
 837 /*
 838  * This is called at the end of each server generation.  It restores the
 839  * original (text) mode.  It should also unmap the video memory, and free
 840  * any per-generation data allocated by the driver.  It should finish
 841  * by unwrapping and calling the saved CloseScreen function.
 842  */
 843
 844 /* Mandatory */
 845 static Bool
 846 NVCloseScreen(int scrnIndex, ScreenPtr pScreen)
 847 {
 848     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 849     NVPtr pNv = NVPTR(pScrn);
 850
 851     if (pScrn->vtSema) {
 852         pScrn->vtSema = FALSE;
 853         if (pNv->Architecture == NV_ARCH_50) {
 854             NV50ReleaseDisplay(pScrn);
 855         } else {
 856             NVSync(pScrn);
 857             NVRestore(pScrn);
 858             if (!pNv->randr12_enable)
 859                 NVLockUnlock(pNv, 1);
 860         }
 861     }
 862
 863     NVUnmapMem(pScrn);
 864     vgaHWUnmapMem(pScrn);
 865     if (pNv->CursorInfoRec)
 866         xf86DestroyCursorInfoRec(pNv->CursorInfoRec);
 867     if (pNv->ShadowPtr)
 868         xfree(pNv->ShadowPtr);
 869     if (pNv->overlayAdaptor)
 870         xfree(pNv->overlayAdaptor);
 871     if (pNv->blitAdaptor)
 872         xfree(pNv->blitAdaptor);
 873
 874     pScrn->vtSema = FALSE;
 875     pScreen->CloseScreen = pNv->CloseScreen;
 876     pScreen->BlockHandler = pNv->BlockHandler;
 877     return (*pScreen->CloseScreen)(scrnIndex, pScreen);
 878 }
 879
 880 /* Free up any persistent data structures */
 881
 882 /* Optional */
 883 static void
 884 NVFreeScreen(int scrnIndex, int flags)
 885 {
 886     /*
 887      * This only gets called when a screen is being deleted.  It does not
 888      * get called routinely at the end of a server generation.
 889      */
 890     if (xf86LoaderCheckSymbol("vgaHWFreeHWRec"))
 891         vgaHWFreeHWRec(xf86Screens[scrnIndex]);
 892     NVFreeRec(xf86Screens[scrnIndex]);
 893 }
 894
 895
 896 /* Checks if a mode is suitable for the selected chipset. */
 897
 898 /* Optional */
 899 static ModeStatus
 900 NVValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
 901 {
 902     NVPtr pNv = NVPTR(xf86Screens[scrnIndex]);
 903
 904     if(pNv->fpWidth && pNv->fpHeight)
 905       if((pNv->fpWidth < mode->HDisplay) || (pNv->fpHeight < mode->VDisplay))
 906         return (MODE_PANEL);
 907
 908     return (MODE_OK);
 909 }
 910
 911 static void
 912 nvProbeDDC(ScrnInfoPtr pScrn, int index)
 913 {
 914     vbeInfoPtr pVbe;
 915
 916     if (xf86LoadSubModule(pScrn, "vbe")) {
 917         pVbe = VBEInit(NULL,index);
 918         ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
 919         vbeFree(pVbe);
 920     }
 921 }
 922
 923
 924 Bool NVI2CInit(ScrnInfoPtr pScrn)
 925 {
 926         NVPtr pNv = NVPTR(pScrn);
 927         char *mod = "i2c";
 928
 929         if (xf86LoadSubModule(pScrn, mod)) {
 930                 xf86LoaderReqSymLists(i2cSymbols,NULL);
 931
 932                 mod = "ddc";
 933                 if(xf86LoadSubModule(pScrn, mod)) {
 934                         xf86LoaderReqSymLists(ddcSymbols, NULL);
 935                         /* randr-1.2 clients have their DDC's initialized elsewhere */
 936                         if (pNv->randr12_enable) {
 937                                 return TRUE;
 938                         } else {
 939                                 return NVDACi2cInit(pScrn);
 940                         }
 941                 }
 942         }
 943
 944         xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
 945                 "Couldn't load %s module.  DDC probing can't be done\n", mod);
 946
 947         return FALSE;
 948 }
 949
 950 static Bool NVPreInitDRI(ScrnInfoPtr pScrn)
 951 {
 952         NVPtr pNv = NVPTR(pScrn);
 953
 954         if (!NVDRIGetVersion(pScrn))
 955                 return FALSE;
 956
 957         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 958                 "[dri] Found DRI library version %d.%d.%d and kernel"
 959                 " module version %d.%d.%d\n",
 960                 pNv->pLibDRMVersion->version_major,
 961                 pNv->pLibDRMVersion->version_minor,
 962                 pNv->pLibDRMVersion->version_patchlevel,
 963                 pNv->pKernelDRMVersion->version_major,
 964                 pNv->pKernelDRMVersion->version_minor,
 965                 pNv->pKernelDRMVersion->version_patchlevel);
 966
 967         return TRUE;
 968 }
 969
 970 #ifdef ENABLE_RANDR12
 971 static Bool
 972 nv_xf86crtc_resize(ScrnInfoPtr pScrn, int width, int height)
 973 {
 974         ErrorF("nv_xf86crtc_resize is called with %dx%d resolution\n", width, height);
 975         pScrn->virtualX = width;
 976         pScrn->virtualY = height;
 977         return TRUE;
 978 }
 979
 980 static const xf86CrtcConfigFuncsRec nv_xf86crtc_config_funcs = {
 981         nv_xf86crtc_resize
 982 };
 983
 984 /* This is taken from the haiku driver */
 985 /* We must accept crtc pitch constrains */
 986 /* A hardware bug on some hardware requires twice the pitch */
 987 static CARD8 NVGetCRTCMask(ScrnInfoPtr pScrn, CARD8 bpp)
 988 {
 989         NVPtr pNv = NVPTR(pScrn);
 990         CARD8 mask = 0;
 991         switch(bpp) {
 992                 case 8:
 993                         mask = 0xf; /* 0x7 */
 994                         break;
 995                 case 15:
 996                         mask = 0x7; /* 0x3 */
 997                         break;
 998                 case 16:
 999                         mask = 0x7; /* 0x3 */
1000                         break;
1001                 case 24:
1002                         mask = 0xf; /* 0x7 */
1003                         break;
1004                 case 32:
1005                         mask = 0x3; /* 0x1 */
1006                         break;
1007                 default:
1008                         ErrorF("Unkown color format\n");
1009                         break;
1010         }
1011
1012         return mask;
1013 }
1014
1015 /* This is taken from the haiku driver */
1016 static CARD8 NVGetAccelerationMask(ScrnInfoPtr pScrn, CARD8 bpp)
1017 {
1018         NVPtr pNv = NVPTR(pScrn);
1019         CARD8 mask = 0;
1020         /* Identical for NV04 */
1021         if (pNv->Architecture == NV_ARCH_04) {
1022                 return NVGetCRTCMask(pScrn, bpp);
1023         } else {
1024                 switch(bpp) {
1025                         case 8:
1026                                 mask = 0x3f;
1027                                 break;
1028                         case 15:
1029                                 mask = 0x1f;
1030                                 break;
1031                         case 16:
1032                                 mask = 0x1f;
1033                                 break;
1034                         case 24:
1035                                 mask = 0x3f;
1036                                 break;
1037                         case 32:
1038                                 mask = 0x0f;
1039                                 break;
1040                         default:
1041                                 ErrorF("Unkown color format\n");
1042                                 break;
1043                 }
1044         }
1045
1046         return mask;
1047 }
1048
1049 static CARD32 NVGetVideoPitch(ScrnInfoPtr pScrn, CARD8 bpp)
1050 {
1051         NVPtr pNv = NVPTR(pScrn);
1052         CARD8 crtc_mask, accel_mask = 0;
1053         crtc_mask = NVGetCRTCMask(pScrn, bpp);
1054         if (!pNv->NoAccel) {
1055                 accel_mask = NVGetAccelerationMask(pScrn, bpp);
1056         }
1057
1058         /* adhere to the largest granularity imposed */
1059         if (accel_mask > crtc_mask) {
1060                 return (pScrn->virtualX + accel_mask) & ~accel_mask;
1061         } else {
1062                 return (pScrn->virtualX + crtc_mask) & ~crtc_mask;
1063         }
1064 }
1065
1066 #endif /* ENABLE_RANDR12 */
1067
1068 #define NVPreInitFail(fmt, args...) do {                                    \
1069         xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%d: "fmt, __LINE__, ##args); \
1070         if (pNv->pInt10)                                                    \
1071                 xf86FreeInt10(pNv->pInt10);                                 \
1072         NVFreeRec(pScrn);                                                   \
1073         return FALSE;                                                       \
1074 } while(0)
1075
1076 /* Mandatory */
1077 Bool
1078 NVPreInit(ScrnInfoPtr pScrn, int flags)
1079 {
1080 #ifdef ENABLE_RANDR12
1081     xf86CrtcConfigPtr xf86_config;
1082 #endif
1083     NVPtr pNv;
1084     MessageType from;
1085     int i, max_width, max_height;
1086     ClockRangePtr clockRanges;
1087     const char *s;
1088     int config_mon_rates = FALSE;
1089     int num_crtc;
1090
1091     if (flags & PROBE_DETECT) {
1092         EntityInfoPtr pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
1093
1094         if (!pEnt)
1095             return FALSE;
1096
1097         i = pEnt->index;
1098         xfree(pEnt);
1099
1100         nvProbeDDC(pScrn, i);
1101         return TRUE;
1102     }
1103
1104     /*
1105      * Note: This function is only called once at server startup, and
1106      * not at the start of each server generation.  This means that
1107      * only things that are persistent across server generations can
1108      * be initialised here.  xf86Screens[] is (pScrn is a pointer to one
1109      * of these).  Privates allocated using xf86AllocateScrnInfoPrivateIndex()
1110      * are too, and should be used for data that must persist across
1111      * server generations.
1112      *
1113      * Per-generation data should be allocated with
1114      * AllocateScreenPrivateIndex() from the ScreenInit() function.
1115      */
1116
1117     /* Check the number of entities, and fail if it isn't one. */
1118     if (pScrn->numEntities != 1)
1119         return FALSE;
1120
1121     /* Allocate the NVRec driverPrivate */
1122     if (!NVGetRec(pScrn)) {
1123         return FALSE;
1124     }
1125     pNv = NVPTR(pScrn);
1126
1127     /* Get the entity, and make sure it is PCI. */
1128     pNv->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
1129     if (pNv->pEnt->location.type != BUS_PCI)
1130         return FALSE;
1131
1132     /* Find the PCI info for this screen */
1133     pNv->PciInfo = xf86GetPciInfoForEntity(pNv->pEnt->index);
1134 #ifndef XSERVER_LIBPCIACCESS
1135     pNv->PciTag = pciTag(pNv->PciInfo->bus, pNv->PciInfo->device,
1136                           pNv->PciInfo->func);
1137 #endif /* XSERVER_LIBPCIACCESS */
1138
1139     pNv->Primary = xf86IsPrimaryPci(pNv->PciInfo);
1140
1141     /* Initialize the card through int10 interface if needed */
1142     if (xf86LoadSubModule(pScrn, "int10")) {
1143         xf86LoaderReqSymLists(int10Symbols, NULL);
1144 #if !defined(__alpha__) && !defined(__powerpc__)
1145         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Initializing int10\n");
1146         pNv->pInt10 = xf86InitInt10(pNv->pEnt->index);
1147 #endif
1148     }
1149
1150     xf86SetOperatingState(resVgaIo, pNv->pEnt->index, ResUnusedOpr);
1151     xf86SetOperatingState(resVgaMem, pNv->pEnt->index, ResDisableOpr);
1152
1153     /* Set pScrn->monitor */
1154     pScrn->monitor = pScrn->confScreen->monitor;
1155
1156         volatile CARD32 *regs = NULL;
1157 #ifdef XSERVER_LIBPCIACCESS
1158         pci_device_map_range(pNv->PciInfo, PCI_DEV_MEM_BASE(pNv->PciInfo, 0), 0x90000, 0, &regs);
1159         pNv->Chipset = NVGetPCIID(regs) & 0xffff;
1160         pNv->NVArch = NVGetArchitecture(regs);
1161         pci_device_unmap_range(pNv->PciInfo, regs, 0x90000);
1162 #else
1163         CARD32 pcicmd;
1164         PCI_DEV_READ_LONG(pNv->PciInfo, PCI_CMD_STAT_REG, &pcicmd);
1165         /* Enable reading memory? */
1166         PCI_DEV_WRITE_LONG(pNv->PciInfo, PCI_CMD_STAT_REG, pcicmd | PCI_CMD_MEM_ENABLE);
1167         regs = xf86MapPciMem(-1, VIDMEM_MMIO, pNv->PciTag, PCI_DEV_MEM_BASE(pNv->PciInfo, 0), 0x90000);
1168         pNv->Chipset = NVGetPCIID(regs) & 0xffff;
1169         pNv->NVArch = NVGetArchitecture(regs);
1170         xf86UnMapVidMem(-1, (pointer)regs, 0x90000);
1171         /* Reset previous state */
1172         PCI_DEV_WRITE_LONG(pNv->PciInfo, PCI_CMD_STAT_REG, pcicmd);
1173 #endif /* XSERVER_LIBPCIACCESS */
1174
1175         pScrn->chipset = malloc(sizeof(char) * 25);
1176         sprintf(pScrn->chipset, "NVIDIA NV%02X", pNv->NVArch);
1177
1178         if(!pScrn->chipset) {
1179                 pScrn->chipset = "Unknown NVIDIA";
1180         }
1181
1182         /*
1183         * This shouldn't happen because such problems should be caught in
1184         * NVProbe(), but check it just in case.
1185         */
1186         if (pScrn->chipset == NULL)
1187                 NVPreInitFail("ChipID 0x%04X is not recognised\n", pNv->Chipset);
1188
1189         if (pNv->NVArch < 0x04)
1190                 NVPreInitFail("Chipset \"%s\" is not recognised\n", pScrn->chipset);
1191
1192         xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "Chipset: \"%s\"\n", pScrn->chipset);
1193
1194         /* The highest architecture currently supported is NV5x */
1195         if (pNv->NVArch >= 0x50) {
1196                 pNv->Architecture =  NV_ARCH_50;
1197         } else if (pNv->NVArch >= 0x40) {
1198                 pNv->Architecture =  NV_ARCH_40;
1199         } else if (pNv->NVArch >= 0x30) {
1200                 pNv->Architecture = NV_ARCH_30;
1201         } else if (pNv->NVArch >= 0x20) {
1202                 pNv->Architecture = NV_ARCH_20;
1203         } else if (pNv->NVArch >= 0x10) {
1204                 pNv->Architecture = NV_ARCH_10;
1205         } else if (pNv->NVArch >= 0x04) {
1206                 pNv->Architecture = NV_ARCH_04;
1207         /*  The lowest architecture currently supported is NV04 */
1208         } else {
1209                 return FALSE;
1210         }
1211
1212     /*
1213      * The first thing we should figure out is the depth, bpp, etc.
1214      */
1215
1216     if (!xf86SetDepthBpp(pScrn, 0, 0, 0, Support32bppFb)) {
1217         NVPreInitFail("\n");
1218     } else {
1219         /* Check that the returned depth is one we support */
1220         switch (pScrn->depth) {
1221             case 8:
1222             case 15:
1223             case 16:
1224             case 24:
1225                 /* OK */
1226                 break;
1227             default:
1228                 NVPreInitFail("Given depth (%d) is not supported by this driver\n",
1229                               pScrn->depth);
1230         }
1231     }
1232     xf86PrintDepthBpp(pScrn);
1233
1234     /* Get the depth24 pixmap format */
1235     if (pScrn->depth == 24 && pix24bpp == 0)
1236         pix24bpp = xf86GetBppFromDepth(pScrn, 24);
1237
1238     /*
1239      * This must happen after pScrn->display has been set because
1240      * xf86SetWeight references it.
1241      */
1242     if (pScrn->depth > 8) {
1243         /* The defaults are OK for us */
1244         rgb zeros = {0, 0, 0};
1245
1246         if (!xf86SetWeight(pScrn, zeros, zeros)) {
1247             NVPreInitFail("\n");
1248         }
1249     }
1250
1251     if (!xf86SetDefaultVisual(pScrn, -1)) {
1252         NVPreInitFail("\n");
1253     } else {
1254         /* We don't currently support DirectColor at > 8bpp */
1255         if (pScrn->depth > 8 && (pScrn->defaultVisual != TrueColor)) {
1256             NVPreInitFail("Given default visual"
1257                        " (%s) is not supported at depth %d\n",
1258                        xf86GetVisualName(pScrn->defaultVisual), pScrn->depth);
1259
1260         }
1261     }
1262
1263     /* The vgahw module should be loaded here when needed */
1264     if (!xf86LoadSubModule(pScrn, "vgahw")) {
1265         NVPreInitFail("\n");
1266     }
1267
1268     xf86LoaderReqSymLists(vgahwSymbols, NULL);
1269
1270     /*
1271      * Allocate a vgaHWRec
1272      */
1273     if (!vgaHWGetHWRec(pScrn)) {
1274         NVPreInitFail("\n");
1275     }
1276
1277     /* We use a programmable clock */
1278     pScrn->progClock = TRUE;
1279
1280     /* Collect all of the relevant option flags (fill in pScrn->options) */
1281     xf86CollectOptions(pScrn, NULL);
1282
1283     /* Process the options */
1284     if (!(pNv->Options = xalloc(sizeof(NVOptions))))
1285         return FALSE;
1286     memcpy(pNv->Options, NVOptions, sizeof(NVOptions));
1287     xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pNv->Options);
1288
1289     /* Set the bits per RGB for 8bpp mode */
1290     if (pScrn->depth == 8)
1291         pScrn->rgbBits = 8;
1292
1293     from = X_DEFAULT;
1294
1295     if (pNv->Architecture == NV_ARCH_50) {
1296             pNv->randr12_enable = TRUE;
1297     } else {
1298         pNv->randr12_enable = FALSE;
1299         if (xf86ReturnOptValBool(pNv->Options, OPTION_RANDR12, FALSE)) {
1300             pNv->randr12_enable = TRUE;
1301         }
1302     }
1303     xf86DrvMsg(pScrn->scrnIndex, from, "Randr1.2 support %sabled\n", pNv->randr12_enable ? "en" : "dis");
1304
1305     pNv->HWCursor = TRUE;
1306     /*
1307      * The preferred method is to use the "hw cursor" option as a tri-state
1308      * option, with the default set above.
1309      */
1310     if (xf86GetOptValBool(pNv->Options, OPTION_HW_CURSOR, &pNv->HWCursor)) {
1311         from = X_CONFIG;
1312     }
1313     /* For compatibility, accept this too (as an override) */
1314     if (xf86ReturnOptValBool(pNv->Options, OPTION_SW_CURSOR, FALSE)) {
1315         from = X_CONFIG;
1316         pNv->HWCursor = FALSE;
1317     }
1318     xf86DrvMsg(pScrn->scrnIndex, from, "Using %s cursor\n",
1319                 pNv->HWCursor ? "HW" : "SW");
1320
1321     pNv->FpScale = TRUE;
1322     if (xf86GetOptValBool(pNv->Options, OPTION_FP_SCALE, &pNv->FpScale)) {
1323         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Flat panel scaling %s\n",
1324                    pNv->FpScale ? "on" : "off");
1325     }
1326     if (xf86ReturnOptValBool(pNv->Options, OPTION_NOACCEL, FALSE)) {
1327         pNv->NoAccel = TRUE;
1328         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Acceleration disabled\n");
1329     }
1330     if (xf86ReturnOptValBool(pNv->Options, OPTION_SHADOW_FB, FALSE)) {
1331         pNv->ShadowFB = TRUE;
1332         pNv->NoAccel = TRUE;
1333         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
1334                 "Using \"Shadow Framebuffer\" - acceleration disabled\n");
1335     }
1336
1337     pNv->Rotate = 0;
1338     pNv->RandRRotation = FALSE;
1339     if ((s = xf86GetOptValString(pNv->Options, OPTION_ROTATE))) {
1340       if(!xf86NameCmp(s, "CW")) {
1341         pNv->ShadowFB = TRUE;
1342         pNv->NoAccel = TRUE;
1343         pNv->HWCursor = FALSE;
1344         pNv->Rotate = 1;
1345         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
1346                 "Rotating screen clockwise - acceleration disabled\n");
1347       } else
1348       if(!xf86NameCmp(s, "CCW")) {
1349         pNv->ShadowFB = TRUE;
1350         pNv->NoAccel = TRUE;
1351         pNv->HWCursor = FALSE;
1352         pNv->Rotate = -1;
1353         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
1354                 "Rotating screen counter clockwise - acceleration disabled\n");
1355       } else
1356       if(!xf86NameCmp(s, "RandR")) {
1357 #ifdef RANDR
1358         pNv->ShadowFB = TRUE;
1359         pNv->NoAccel = TRUE;
1360         pNv->HWCursor = FALSE;
1361         pNv->RandRRotation = TRUE;
1362         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
1363                 "Using RandR rotation - acceleration disabled\n");
1364 #else
1365         xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
1366                 "This driver was not compiled with support for the Resize and "
1367                 "Rotate extension.  Cannot honor 'Option \"Rotate\" "
1368                 "\"RandR\"'.\n");
1369 #endif
1370       } else {
1371         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
1372                 "\"%s\" is not a valid value for Option \"Rotate\"\n", s);
1373         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1374                 "Valid options are \"CW\", \"CCW\", and \"RandR\"\n");
1375       }
1376     }
1377
1378     if(xf86GetOptValInteger(pNv->Options, OPTION_VIDEO_KEY, &(pNv->videoKey))) {
1379         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "video key set to 0x%x\n",
1380                                 pNv->videoKey);
1381     } else {
1382         pNv->videoKey =  (1 << pScrn->offset.red) |
1383                           (1 << pScrn->offset.green) |
1384         (((pScrn->mask.blue >> pScrn->offset.blue) - 1) << pScrn->offset.blue);
1385     }
1386
1387     if (xf86GetOptValBool(pNv->Options, OPTION_FLAT_PANEL, &(pNv->FlatPanel))) {
1388         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "forcing %s usage\n",
1389                    pNv->FlatPanel ? "DFP" : "CRTC");
1390     } else {
1391         pNv->FlatPanel = -1;   /* autodetect later */
1392     }
1393
1394     pNv->FPDither = FALSE;
1395     if (xf86GetOptValBool(pNv->Options, OPTION_FP_DITHER, &(pNv->FPDither)))
1396         xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "enabling flat panel dither\n");
1397
1398     //if (xf86GetOptValInteger(pNv->Options, OPTION_CRTC_NUMBER,
1399    //                          &pNv->CRTCnumber))
1400     //{
1401         //pNv->crtc_active[0] = FALSE;
1402         //pNv->crtc_active[1] = FALSE;
1403     //}
1404
1405
1406     if (xf86GetOptValInteger(pNv->Options, OPTION_FP_TWEAK,
1407                              &pNv->PanelTweak))
1408     {
1409         pNv->usePanelTweak = TRUE;
1410     } else {
1411         pNv->usePanelTweak = FALSE;
1412     }
1413
1414     if (pNv->pEnt->device->MemBase != 0) {
1415         /* Require that the config file value matches one of the PCI values. */
1416         if (!xf86CheckPciMemBase(pNv->PciInfo, pNv->pEnt->device->MemBase)) {
1417             NVPreInitFail(
1418                 "MemBase 0x%08lX doesn't match any PCI base register.\n",
1419                 pNv->pEnt->device->MemBase);
1420         }
1421         pNv->VRAMPhysical = pNv->pEnt->device->MemBase;
1422         from = X_CONFIG;
1423     } else {
1424         if (PCI_DEV_MEM_BASE(pNv->PciInfo, 1) != 0) {
1425             pNv->VRAMPhysical = PCI_DEV_MEM_BASE(pNv->PciInfo, 1) & 0xff800000;
1426             from = X_PROBED;
1427         } else {
1428             NVPreInitFail("No valid FB address in PCI config space\n");
1429             return FALSE;
1430         }
1431     }
1432     xf86DrvMsg(pScrn->scrnIndex, from, "Linear framebuffer at 0x%lX\n",
1433                (unsigned long)pNv->VRAMPhysical);
1434
1435     if (pNv->pEnt->device->IOBase != 0) {
1436         /* Require that the config file value matches one of the PCI values. */
1437         if (!xf86CheckPciMemBase(pNv->PciInfo, pNv->pEnt->device->IOBase)) {
1438             NVPreInitFail("IOBase 0x%08lX doesn't match any PCI base register.\n",
1439                           pNv->pEnt->device->IOBase);
1440         }
1441         pNv->IOAddress = pNv->pEnt->device->IOBase;
1442         from = X_CONFIG;
1443     } else {
1444         if (PCI_DEV_MEM_BASE(pNv->PciInfo, 0) != 0) {
1445             pNv->IOAddress = PCI_DEV_MEM_BASE(pNv->PciInfo, 0) & 0xffffc000;
1446             from = X_PROBED;
1447         } else {
1448             NVPreInitFail("No valid MMIO address in PCI config space\n");
1449         }
1450     }
1451     xf86DrvMsg(pScrn->scrnIndex, from, "MMIO registers at 0x%lX\n",
1452                (unsigned long)pNv->IOAddress);
1453
1454         if (xf86RegisterResources(pNv->pEnt->index, NULL, ResExclusive)) {
1455                 NVPreInitFail("xf86RegisterResources() found resource conflicts\n");
1456     }
1457
1458         pNv->alphaCursor = (pNv->NVArch >= 0x11);
1459
1460         //pNv->alphaCursor = FALSE;
1461
1462 #ifdef ENABLE_RANDR12
1463     if (pNv->randr12_enable) {
1464         /* Allocate an xf86CrtcConfig */
1465         xf86CrtcConfigInit(pScrn, &nv_xf86crtc_config_funcs);
1466         xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
1467
1468         max_width = 16384;
1469         xf86CrtcSetSizeRange(pScrn, 320, 200, max_width, 2048);
1470     }
1471 #endif
1472
1473     if (NVPreInitDRI(pScrn) == FALSE) {
1474         NVPreInitFail("\n");
1475     }
1476
1477     if (!pNv->randr12_enable) {
1478         if ((pScrn->monitor->nHsync == 0) &&
1479             (pScrn->monitor->nVrefresh == 0))
1480             config_mon_rates = FALSE;
1481         else
1482             config_mon_rates = TRUE;
1483     }
1484
1485     NVCommonSetup(pScrn);
1486
1487 #ifdef ENABLE_RANDR12
1488     if (pNv->randr12_enable) {
1489         if (pNv->Architecture < NV_ARCH_50) {
1490             NVI2CInit(pScrn);
1491
1492             num_crtc = pNv->twoHeads ? 2 : 1;
1493             for (i = 0; i < num_crtc; i++) {
1494                 nv_crtc_init(pScrn, i);
1495             }
1496
1497             NvSetupOutputs(pScrn);
1498         } else {
1499             if (!NV50DispPreInit(pScrn))
1500                 NVPreInitFail("\n");
1501             if (!NV50CreateOutputs(pScrn))
1502                 NVPreInitFail("\n");
1503             NV50DispCreateCrtcs(pScrn);
1504         }
1505
1506         if (!xf86InitialConfiguration(pScrn, FALSE))
1507             NVPreInitFail("No valid modes.\n");
1508     }
1509 #endif
1510
1511     pScrn->videoRam = pNv->RamAmountKBytes;
1512     xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "VideoRAM: %d kBytes\n",
1513                pScrn->videoRam);
1514
1515     pNv->VRAMPhysicalSize = pScrn->videoRam * 1024;
1516
1517     /*
1518      * If the driver can do gamma correction, it should call xf86SetGamma()
1519      * here.
1520      */
1521
1522     {
1523         Gamma zeros = {0.0, 0.0, 0.0};
1524
1525         if (!xf86SetGamma(pScrn, zeros)) {
1526             NVPreInitFail("\n");
1527         }
1528     }
1529
1530     /*
1531      * Setup the ClockRanges, which describe what clock ranges are available,
1532      * and what sort of modes they can be used for.
1533      */
1534
1535     clockRanges = xnfcalloc(sizeof(ClockRange), 1);
1536     clockRanges->next = NULL;
1537     clockRanges->minClock = pNv->MinVClockFreqKHz;
1538     clockRanges->maxClock = pNv->MaxVClockFreqKHz;
1539     clockRanges->clockIndex = -1;               /* programmable */
1540     clockRanges->doubleScanAllowed = TRUE;
1541     if((pNv->Architecture == NV_ARCH_20) ||
1542          ((pNv->Architecture == NV_ARCH_10) &&
1543            ((pNv->Chipset & 0x0ff0) != CHIPSET_NV10) &&
1544            ((pNv->Chipset & 0x0ff0) != CHIPSET_NV15)))
1545     {
1546        /* HW is broken */
1547        clockRanges->interlaceAllowed = FALSE;
1548     } else {
1549        clockRanges->interlaceAllowed = TRUE;
1550     }
1551
1552     if(pNv->FlatPanel == 1) {
1553        clockRanges->interlaceAllowed = FALSE;
1554        clockRanges->doubleScanAllowed = FALSE;
1555     }
1556
1557     if(pNv->Architecture < NV_ARCH_10) {
1558        max_width = (pScrn->bitsPerPixel > 16) ? 2032 : 2048;
1559        max_height = 2048;
1560     } else {
1561        max_width = (pScrn->bitsPerPixel > 16) ? 4080 : 4096;
1562        max_height = 4096;
1563     }
1564
1565 #ifdef M_T_DRIVER
1566     /* If DFP, add a modeline corresponding to its panel size */
1567     if (pNv->FlatPanel && !pNv->Television && pNv->fpWidth && pNv->fpHeight) {
1568         DisplayModePtr Mode;
1569
1570         Mode = xnfcalloc(1, sizeof(DisplayModeRec));
1571         Mode = xf86CVTMode(pNv->fpWidth, pNv->fpHeight, 60.00, TRUE, FALSE);
1572         Mode->type = M_T_DRIVER;
1573         pScrn->monitor->Modes = xf86ModesAdd(pScrn->monitor->Modes, Mode);
1574
1575         if (!config_mon_rates) {
1576             if (!Mode->HSync)
1577                 Mode->HSync = ((float) Mode->Clock ) / ((float) Mode->HTotal);
1578             if (!Mode->VRefresh)
1579                 Mode->VRefresh = (1000.0 * ((float) Mode->Clock)) /
1580                     ((float) (Mode->HTotal * Mode->VTotal));
1581
1582             if (Mode->HSync < pScrn->monitor->hsync[0].lo)
1583                 pScrn->monitor->hsync[0].lo = Mode->HSync;
1584             if (Mode->HSync > pScrn->monitor->hsync[0].hi)
1585                 pScrn->monitor->hsync[0].hi = Mode->HSync;
1586             if (Mode->VRefresh < pScrn->monitor->vrefresh[0].lo)
1587                 pScrn->monitor->vrefresh[0].lo = Mode->VRefresh;
1588             if (Mode->VRefresh > pScrn->monitor->vrefresh[0].hi)
1589                 pScrn->monitor->vrefresh[0].hi = Mode->VRefresh;
1590
1591             pScrn->monitor->nHsync = 1;
1592             pScrn->monitor->nVrefresh = 1;
1593         }
1594     }
1595 #endif
1596
1597         if (pNv->randr12_enable) {
1598                 pScrn->displayWidth = NVGetVideoPitch(pScrn, pScrn->depth);
1599         } else {
1600             /*
1601              * xf86ValidateModes will check that the mode HTotal and VTotal values
1602              * don't exceed the chipset's limit if pScrn->maxHValue and
1603              * pScrn->maxVValue are set.  Since our NVValidMode() already takes
1604              * care of this, we don't worry about setting them here.
1605              */
1606             i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
1607                                   pScrn->display->modes, clockRanges,
1608                                   NULL, 256, max_width,
1609                                   512, 128, max_height,
1610                                   pScrn->display->virtualX,
1611                                   pScrn->display->virtualY,
1612                                   pNv->VRAMPhysicalSize / 2,
1613                                   LOOKUP_BEST_REFRESH);
1614
1615             if (i == -1) {
1616                 NVPreInitFail("\n");
1617             }
1618
1619             /* Prune the modes marked as invalid */
1620             xf86PruneDriverModes(pScrn);
1621
1622             /*
1623              * Set the CRTC parameters for all of the modes based on the type
1624              * of mode, and the chipset's interlace requirements.
1625              *
1626              * Calling this is required if the mode->Crtc* values are used by the
1627              * driver and if the driver doesn't provide code to set them.  They
1628              * are not pre-initialised at all.
1629              */
1630             xf86SetCrtcForModes(pScrn, 0);
1631     }
1632
1633     if (pScrn->modes == NULL) {
1634         NVPreInitFail("No valid modes found\n");
1635     }
1636
1637     /* Set the current mode to the first in the list */
1638     pScrn->currentMode = pScrn->modes;
1639
1640     /* Print the list of modes being used */
1641     xf86PrintModes(pScrn);
1642
1643     /* Set display resolution */
1644     xf86SetDpi(pScrn, 0, 0);
1645
1646
1647     /*
1648      * XXX This should be taken into account in some way in the mode valdation
1649      * section.
1650      */
1651
1652     if (xf86LoadSubModule(pScrn, "fb") == NULL) {
1653         NVPreInitFail("\n");
1654     }
1655
1656     xf86LoaderReqSymLists(fbSymbols, NULL);
1657
1658     /* Load EXA if needed */
1659     if (!pNv->NoAccel) {
1660         if (!xf86LoadSubModule(pScrn, "exa")) {
1661             NVPreInitFail("\n");
1662         }
1663         xf86LoaderReqSymLists(exaSymbols, NULL);
1664     }
1665
1666     /* Load ramdac if needed */
1667     if (pNv->HWCursor) {
1668         if (!xf86LoadSubModule(pScrn, "ramdac")) {
1669             NVPreInitFail("\n");
1670         }
1671         xf86LoaderReqSymLists(ramdacSymbols, NULL);
1672     }
1673
1674     /* Load shadowfb if needed */
1675     if (pNv->ShadowFB) {
1676         if (!xf86LoadSubModule(pScrn, "shadowfb")) {
1677             NVPreInitFail("\n");
1678         }
1679         xf86LoaderReqSymLists(shadowSymbols, NULL);
1680     }
1681
1682     pNv->CurrentLayout.bitsPerPixel = pScrn->bitsPerPixel;
1683     pNv->CurrentLayout.depth = pScrn->depth;
1684     pNv->CurrentLayout.displayWidth = pScrn->displayWidth;
1685     pNv->CurrentLayout.weight.red = pScrn->weight.red;
1686     pNv->CurrentLayout.weight.green = pScrn->weight.green;
1687     pNv->CurrentLayout.weight.blue = pScrn->weight.blue;
1688     pNv->CurrentLayout.mode = pScrn->currentMode;
1689
1690     xf86FreeInt10(pNv->pInt10);
1691
1692     pNv->pInt10 = NULL;
1693     return TRUE;
1694 }
1695
1696
1697 /*
1698  * Map the framebuffer and MMIO memory.
1699  */
1700
1701 static Bool
1702 NVMapMem(ScrnInfoPtr pScrn)
1703 {
1704         NVPtr pNv = NVPTR(pScrn);
1705
1706         pNv->FB = NVAllocateMemory(pNv, NOUVEAU_MEM_FB, pNv->VRAMPhysicalSize/2);
1707         if (!pNv->FB) {
1708                 ErrorF("Failed to allocate memory for framebuffer!\n");
1709                 return FALSE;
1710         }
1711         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1712                    "Allocated %dMiB VRAM for framebuffer + offscreen pixmaps\n",
1713                    (unsigned int)(pNv->FB->size >> 20));
1714
1715         /*XXX: have to get these after we've allocated something, otherwise
1716          *     they're uninitialised in the DRM!
1717          */
1718         pNv->VRAMSize     = NVDRMGetParam(pNv, NOUVEAU_GETPARAM_FB_SIZE);
1719         pNv->VRAMPhysical = NVDRMGetParam(pNv, NOUVEAU_GETPARAM_FB_PHYSICAL);
1720         pNv->AGPSize      = NVDRMGetParam(pNv, NOUVEAU_GETPARAM_AGP_SIZE);
1721         pNv->AGPPhysical  = NVDRMGetParam(pNv, NOUVEAU_GETPARAM_AGP_PHYSICAL);
1722         if ( ! pNv->AGPSize ) /*if no AGP*/
1723                 /*use PCI*/
1724                 pNv->SGPhysical  = NVDRMGetParam(pNv, NOUVEAU_GETPARAM_PCI_PHYSICAL);
1725
1726         int gart_scratch_size;
1727
1728         if (pNv->AGPSize) {
1729                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1730                            "AGPGART: %dMiB available\n",
1731                            (unsigned int)(pNv->AGPSize >> 20));
1732
1733                 if (pNv->AGPSize > (16*1024*1024))
1734                         gart_scratch_size = 16*1024*1024;
1735                 else
1736                         gart_scratch_size = pNv->AGPSize;
1737
1738                 }
1739         else {
1740
1741                 gart_scratch_size = (4 << 20) - (1 << 18) ;
1742                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1743                            "GART: PCI DMA - using %dKiB\n", gart_scratch_size >> 10);
1744
1745         }
1746
1747         /*The DRM allocates AGP memory, PCI as a fallback */
1748         pNv->GARTScratch = NVAllocateMemory(pNv, NOUVEAU_MEM_AGP | NOUVEAU_MEM_PCI_ACCEPTABLE,
1749                                                         gart_scratch_size);
1750         if (!pNv->GARTScratch) {
1751                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1752                            "Unable to allocate GART memory\n");
1753         } else {
1754                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1755                            "GART: mapped %dMiB at %p, offset is %d\n",
1756                            (unsigned int)(pNv->GARTScratch->size >> 20),
1757                            pNv->GARTScratch->map, pNv->GARTScratch->offset);
1758         }
1759
1760
1761         pNv->Cursor = NVAllocateMemory(pNv, NOUVEAU_MEM_FB, 64*1024);
1762         if (!pNv->Cursor) {
1763                 ErrorF("Failed to allocate memory for hardware cursor\n");
1764                 return FALSE;
1765         }
1766
1767         pNv->ScratchBuffer = NVAllocateMemory(pNv, NOUVEAU_MEM_FB,
1768                         pNv->Architecture <NV_ARCH_10 ? 8192 : 16384);
1769         if (!pNv->ScratchBuffer) {
1770                 ErrorF("Failed to allocate memory for scratch buffer\n");
1771                 return FALSE;
1772         }
1773
1774         if (pNv->Architecture >= NV_ARCH_50) {
1775                 pNv->CLUT = NVAllocateMemory(pNv, NOUVEAU_MEM_FB, 0x1000);
1776                 if (!pNv->CLUT) {
1777                         xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1778                                    "Failed to allocate memory for CLUT\n");
1779                         return FALSE;
1780                 }
1781         }
1782
1783         return TRUE;
1784 }
1785
1786 /*
1787  * Unmap the framebuffer and MMIO memory.
1788  */
1789
1790 static Bool
1791 NVUnmapMem(ScrnInfoPtr pScrn)
1792 {
1793         NVPtr pNv = NVPTR(pScrn);
1794
1795         NVFreeMemory(pNv, pNv->FB);
1796         NVFreeMemory(pNv, pNv->ScratchBuffer);
1797         NVFreeMemory(pNv, pNv->Cursor);
1798
1799     return TRUE;
1800 }
1801
1802
1803 /*
1804  * Initialise a new mode.
1805  */
1806
1807 static Bool
1808 NVModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
1809 {
1810     vgaHWPtr hwp = VGAHWPTR(pScrn);
1811     vgaRegPtr vgaReg;
1812     NVPtr pNv = NVPTR(pScrn);
1813     NVRegPtr nvReg;
1814
1815     /* Initialise the ModeReg values */
1816     if (!vgaHWInit(pScrn, mode))
1817         return FALSE;
1818     pScrn->vtSema = TRUE;
1819
1820     vgaReg = &hwp->ModeReg;
1821     nvReg = &pNv->ModeReg;
1822
1823     if(!NVDACInit(pScrn, mode))
1824         return FALSE;
1825
1826     NVLockUnlock(pNv, 0);
1827     if(pNv->twoHeads) {
1828         nvWriteVGA(pNv, NV_VGA_CRTCX_OWNER, nvReg->crtcOwner);
1829         NVLockUnlock(pNv, 0);
1830     }
1831
1832     /* Program the registers */
1833     vgaHWProtect(pScrn, TRUE);
1834
1835     NVDACRestore(pScrn, vgaReg, nvReg, FALSE);
1836
1837 #if X_BYTE_ORDER == X_BIG_ENDIAN
1838     /* turn on LFB swapping */
1839     {
1840         unsigned char tmp;
1841
1842         tmp = nvReadVGA(pNv, NV_VGA_CRTCX_SWAPPING);
1843         tmp |= (1 << 7);
1844         nvWriteVGA(pNv, NV_VGA_CRTCX_SWAPPING, tmp);
1845     }
1846 #endif
1847
1848     if (!pNv->NoAccel)
1849             NVResetGraphics(pScrn);
1850
1851     vgaHWProtect(pScrn, FALSE);
1852
1853     pNv->CurrentLayout.mode = mode;
1854
1855     return TRUE;
1856 }
1857
1858 /*
1859  * Restore the initial (text) mode.
1860  */
1861 static void
1862 NVRestore(ScrnInfoPtr pScrn)
1863 {
1864         vgaHWPtr hwp = VGAHWPTR(pScrn);
1865         vgaRegPtr vgaReg = &hwp->SavedReg;
1866         NVPtr pNv = NVPTR(pScrn);
1867         NVRegPtr nvReg = &pNv->SavedReg;
1868
1869 #ifdef ENABLE_RANDR12
1870         if (pNv->randr12_enable) {
1871                 xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
1872                 int i;
1873                 int vgaflags = VGA_SR_CMAP | VGA_SR_MODE;
1874
1875                 for (i = 0; i < xf86_config->num_crtc; i++) {
1876                         NVCrtcLockUnlock(xf86_config->crtc[i], 0);
1877                 }
1878
1879                 for (i = 0; i < xf86_config->num_crtc; i++) {
1880                         xf86_config->crtc[i]->funcs->restore(xf86_config->crtc[i]);
1881                 }
1882
1883                 for (i = 0; i < xf86_config->num_output; i++) {
1884                         xf86_config->output[i]->funcs->restore(xf86_config->
1885                                                                output[i]);
1886                 }
1887
1888 #ifndef __powerpc__
1889                 vgaflags |= VGA_SR_FONTS;
1890 #endif
1891                 vgaHWRestore(pScrn, vgaReg, vgaflags);
1892                 vgaHWLock(hwp);
1893
1894                 for (i = 0; i < xf86_config->num_crtc; i++) {
1895                         NVCrtcLockUnlock(xf86_config->crtc[i], 1);
1896                 }
1897         } else
1898 #endif
1899         {
1900                 NVLockUnlock(pNv, 0);
1901
1902                 if(pNv->twoHeads) {
1903                         nvWriteVGA(pNv, NV_VGA_CRTCX_OWNER, pNv->crtc_active[1] * 0x3);
1904                         NVLockUnlock(pNv, 0);
1905                 }
1906
1907                 /* Only restore text mode fonts/text for the primary card */
1908                 vgaHWProtect(pScrn, TRUE);
1909                 NVDACRestore(pScrn, vgaReg, nvReg, pNv->Primary);
1910                 if(pNv->twoHeads) {
1911                         nvWriteVGA(pNv, NV_VGA_CRTCX_OWNER, pNv->vtOWNER);
1912                 }
1913                 vgaHWProtect(pScrn, FALSE);
1914         }
1915 }
1916
1917
1918 #define DEPTH_SHIFT(val, w) ((val << (8 - w)) | (val >> ((w << 1) - 8)))
1919 #define MAKE_INDEX(in, w) (DEPTH_SHIFT(in, w) * 3)
1920
1921 static void
1922 NVLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
1923               LOCO * colors, VisualPtr pVisual)
1924 {
1925 #ifdef ENABLE_RANDR12
1926         xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
1927         int c;
1928         NVPtr pNv = NVPTR(pScrn);
1929         int i, index;
1930
1931         for (c = 0; c < xf86_config->num_crtc; c++) {
1932                 xf86CrtcPtr crtc = xf86_config->crtc[c];
1933                 NVCrtcPrivatePtr nv_crtc = crtc->driver_private;
1934                 NVCrtcRegPtr regp;
1935
1936                 regp = &pNv->ModeReg.crtc_reg[nv_crtc->head];
1937
1938                 if (crtc->enabled == 0)
1939                         continue;
1940
1941                 switch (pNv->CurrentLayout.depth) {
1942                 case 15:
1943                         for (i = 0; i < numColors; i++) {
1944                                 index = indices[i];
1945                                 regp->DAC[MAKE_INDEX(index, 5) + 0] =
1946                                     colors[index].red;
1947                                 regp->DAC[MAKE_INDEX(index, 5) + 1] =
1948                                     colors[index].green;
1949                                 regp->DAC[MAKE_INDEX(index, 5) + 2] =
1950                                     colors[index].blue;
1951                         }
1952                         break;
1953                 case 16:
1954                         for (i = 0; i < numColors; i++) {
1955                                 index = indices[i];
1956                                 regp->DAC[MAKE_INDEX(index, 6) + 1] =
1957                                     colors[index].green;
1958                                 if (index < 32) {
1959                                         regp->DAC[MAKE_INDEX(index, 5) +
1960                                                   0] = colors[index].red;
1961                                         regp->DAC[MAKE_INDEX(index, 5) +
1962                                                   2] = colors[index].blue;
1963                                 }
1964                         }
1965                         break;
1966                 default:
1967                         for (i = 0; i < numColors; i++) {
1968                                 index = indices[i];
1969                                 regp->DAC[index * 3] = colors[index].red;
1970                                 regp->DAC[(index * 3) + 1] =
1971                                     colors[index].green;
1972                                 regp->DAC[(index * 3) + 2] =
1973                                     colors[index].blue;
1974                         }
1975                         break;
1976                 }
1977
1978                 NVCrtcLoadPalette(crtc);
1979         }
1980 #endif
1981 }
1982
1983 //#define DEPTH_SHIFT(val, w) ((val << (8 - w)) | (val >> ((w << 1) - 8)))
1984 #define COLOR(c) (unsigned int)(0x3fff * ((c)/255.0))
1985 static void
1986 NV50LoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
1987                 LOCO * colors, VisualPtr pVisual)
1988 {
1989         NVPtr pNv = NVPTR(pScrn);
1990         int i, index;
1991         volatile struct {
1992                 unsigned short red, green, blue, unused;
1993         } *lut = (void *) pNv->CLUT->map;
1994
1995         switch (pScrn->depth) {
1996         case 15:
1997                 for (i = 0; i < numColors; i++) {
1998                         index = indices[i];
1999                         lut[DEPTH_SHIFT(index, 5)].red =
2000                             COLOR(colors[index].red);
2001                         lut[DEPTH_SHIFT(index, 5)].green =
2002                             COLOR(colors[index].green);
2003                         lut[DEPTH_SHIFT(index, 5)].blue =
2004                             COLOR(colors[index].blue);
2005                 }
2006                 break;
2007         case 16:
2008                 for (i = 0; i < numColors; i++) {
2009                         index = indices[i];
2010                         lut[DEPTH_SHIFT(index, 6)].green =
2011                             COLOR(colors[index].green);
2012                         if (index < 32) {
2013                                 lut[DEPTH_SHIFT(index, 5)].red =
2014                                     COLOR(colors[index].red);
2015                                 lut[DEPTH_SHIFT(index, 5)].blue =
2016                                     COLOR(colors[index].blue);
2017                         }
2018                 }
2019                 break;
2020         default:
2021                 for (i = 0; i < numColors; i++) {
2022                         index = indices[i];
2023                         lut[index].red = COLOR(colors[index].red);
2024                         lut[index].green = COLOR(colors[index].green);
2025                         lut[index].blue = COLOR(colors[index].blue);
2026                 }
2027                 break;
2028         }
2029 }
2030
2031
2032 static void NVBacklightEnable(NVPtr pNv,  Bool on)
2033 {
2034     /* This is done differently on each laptop.  Here we
2035        define the ones we know for sure. */
2036
2037 #if defined(__powerpc__)
2038     if((pNv->Chipset == 0x10DE0179) ||
2039        (pNv->Chipset == 0x10DE0189) ||
2040        (pNv->Chipset == 0x10DE0329))
2041     {
2042        /* NV17,18,34 Apple iMac, iBook, PowerBook */
2043       CARD32 tmp_pmc, tmp_pcrt;
2044       tmp_pmc = nvReadMC(pNv, 0x10F0) & 0x7FFFFFFF;
2045       tmp_pcrt = nvReadCRTC0(pNv, NV_CRTC_081C) & 0xFFFFFFFC;
2046       if(on) {
2047           tmp_pmc |= (1 << 31);
2048           tmp_pcrt |= 0x1;
2049       }
2050       nvWriteMC(pNv, 0x10F0, tmp_pmc);
2051       nvWriteCRTC0(pNv, NV_CRTC_081C, tmp_pcrt);
2052     }
2053 #endif
2054
2055     if(pNv->LVDS) {
2056        if(pNv->twoHeads && ((pNv->Chipset & 0x0ff0) != CHIPSET_NV11)) {
2057            nvWriteMC(pNv, 0x130C, on ? 3 : 7);
2058        }
2059     } else {
2060        CARD32 fpcontrol;
2061
2062        fpcontrol = nvReadCurRAMDAC(pNv, 0x848) & 0xCfffffCC;
2063
2064        /* cut the TMDS output */
2065        if(on) fpcontrol |= pNv->fpSyncs;
2066        else fpcontrol |= 0x20000022;
2067
2068        nvWriteCurRAMDAC(pNv, 0x0848, fpcontrol);
2069     }
2070 }
2071
2072 static void
2073 NVDPMSSetLCD(ScrnInfoPtr pScrn, int PowerManagementMode, int flags)
2074 {
2075   NVPtr pNv = NVPTR(pScrn);
2076
2077   if (!pScrn->vtSema) return;
2078
2079   vgaHWDPMSSet(pScrn, PowerManagementMode, flags);
2080
2081   switch (PowerManagementMode) {
2082   case DPMSModeStandby:  /* HSync: Off, VSync: On */
2083   case DPMSModeSuspend:  /* HSync: On, VSync: Off */
2084   case DPMSModeOff:      /* HSync: Off, VSync: Off */
2085     NVBacklightEnable(pNv, 0);
2086     break;
2087   case DPMSModeOn:       /* HSync: On, VSync: On */
2088     NVBacklightEnable(pNv, 1);
2089   default:
2090     break;
2091   }
2092 }
2093
2094
2095 static void
2096 NVDPMSSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags)
2097 {
2098   unsigned char crtc1A;
2099   vgaHWPtr hwp = VGAHWPTR(pScrn);
2100
2101   if (!pScrn->vtSema) return;
2102
2103   crtc1A = hwp->readCrtc(hwp, 0x1A) & ~0xC0;
2104
2105   switch (PowerManagementMode) {
2106   case DPMSModeStandby:  /* HSync: Off, VSync: On */
2107     crtc1A |= 0x80;
2108     break;
2109   case DPMSModeSuspend:  /* HSync: On, VSync: Off */
2110     crtc1A |= 0x40;
2111     break;
2112   case DPMSModeOff:      /* HSync: Off, VSync: Off */
2113     crtc1A |= 0xC0;
2114     break;
2115   case DPMSModeOn:       /* HSync: On, VSync: On */
2116   default:
2117     break;
2118   }
2119
2120   /* vgaHWDPMSSet will merely cut the dac output */
2121   vgaHWDPMSSet(pScrn, PowerManagementMode, flags);
2122
2123   hwp->writeCrtc(hwp, 0x1A, crtc1A);
2124 }
2125
2126
2127 /* Mandatory */
2128
2129 /* This gets called at the start of each server generation */
2130
2131 static Bool
2132 NVScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
2133 {
2134     ScrnInfoPtr pScrn;
2135     vgaHWPtr hwp;
2136     NVPtr pNv;
2137     int ret;
2138     VisualPtr visual;
2139     unsigned char *FBStart;
2140     int width, height, displayWidth, shadowHeight;
2141
2142     /*
2143      * First get the ScrnInfoRec
2144      */
2145     pScrn = xf86Screens[pScreen->myNum];
2146
2147     hwp = VGAHWPTR(pScrn);
2148     pNv = NVPTR(pScrn);
2149
2150     /* Map the VGA memory when the primary video */
2151     if (pNv->Primary) {
2152         hwp->MapSize = 0x10000;
2153         if (!vgaHWMapMem(pScrn))
2154             return FALSE;
2155     }
2156
2157     /* First init DRI/DRM */
2158     if (!NVDRIScreenInit(pScrn))
2159         return FALSE;
2160
2161     ret = drmCommandNone(pNv->drm_fd, DRM_NOUVEAU_CARD_INIT);
2162     if (ret) {
2163         xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
2164                    "Error initialising the nouveau kernel module: %d\n",
2165                    ret);
2166         return FALSE;
2167     }
2168
2169     /* Allocate and map memory areas we need */
2170     if (!NVMapMem(pScrn))
2171         return FALSE;
2172
2173     if (!pNv->NoAccel) {
2174         /* Init DRM - Alloc FIFO */
2175         if (!NVInitDma(pScrn))
2176             return FALSE;
2177
2178         /* setup graphics objects */
2179         if (!NVAccelCommonInit(pScrn))
2180             return FALSE;
2181     }
2182
2183     if (!pNv->randr12_enable) {
2184         /* Save the current state */
2185         NVSave(pScrn);
2186         /* Initialise the first mode */
2187         if (!NVModeInit(pScrn, pScrn->currentMode))
2188             return FALSE;
2189
2190         /* Darken the screen for aesthetic reasons and set the viewport */
2191
2192         NVSaveScreen(pScreen, SCREEN_SAVER_ON);
2193         pScrn->AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
2194
2195     } else {
2196         pScrn->memPhysBase = pNv->VRAMPhysical;
2197         pScrn->fbOffset = 0;
2198
2199         /* Gather some misc info before the randr stuff kicks in */
2200         pNv->misc_info.crtc_0_reg_52 = NVReadVGA0(pNv, NV_VGA_CRTCX_52);
2201
2202         if (!NVEnterVT(scrnIndex, 0))
2203             return FALSE;
2204     }
2205
2206
2207     /*
2208      * The next step is to setup the screen's visuals, and initialise the
2209      * framebuffer code.  In cases where the framebuffer's default
2210      * choices for things like visual layouts and bits per RGB are OK,
2211      * this may be as simple as calling the framebuffer's ScreenInit()
2212      * function.  If not, the visuals will need to be setup before calling
2213      * a fb ScreenInit() function and fixed up after.
2214      *
2215      * For most PC hardware at depths >= 8, the defaults that fb uses
2216      * are not appropriate.  In this driver, we fixup the visuals after.
2217      */
2218
2219     /*
2220      * Reset the visual list.
2221      */
2222     miClearVisualTypes();
2223
2224     /* Setup the visuals we support. */
2225
2226     if (!miSetVisualTypes(pScrn->depth,
2227                           miGetDefaultVisualMask(pScrn->depth), 8,
2228                           pScrn->defaultVisual))
2229           return FALSE;
2230     if (!miSetPixmapDepths ()) return FALSE;
2231
2232     /*
2233      * Call the framebuffer layer's ScreenInit function, and fill in other
2234      * pScreen fields.
2235      */
2236
2237     width = pScrn->virtualX;
2238     height = pScrn->virtualY;
2239     displayWidth = pScrn->displayWidth;
2240
2241
2242     if(pNv->Rotate) {
2243         height = pScrn->virtualX;
2244         width = pScrn->virtualY;
2245     }
2246
2247     /* If RandR rotation is enabled, leave enough space in the
2248      * framebuffer for us to rotate the screen dimensions without
2249      * changing the pitch.
2250      */
2251     if(pNv->RandRRotation)
2252         shadowHeight = max(width, height);
2253     else
2254         shadowHeight = height;
2255
2256     if(pNv->ShadowFB) {
2257         pNv->ShadowPitch = BitmapBytePad(pScrn->bitsPerPixel * width);
2258         pNv->ShadowPtr = xalloc(pNv->ShadowPitch * shadowHeight);
2259         displayWidth = pNv->ShadowPitch / (pScrn->bitsPerPixel >> 3);
2260         FBStart = pNv->ShadowPtr;
2261     } else {
2262         pNv->ShadowPtr = NULL;
2263         FBStart = pNv->FB->map;
2264     }
2265
2266     switch (pScrn->bitsPerPixel) {
2267         case 8:
2268         case 16:
2269         case 32:
2270             ret = fbScreenInit(pScreen, FBStart, width, height,
2271                                pScrn->xDpi, pScrn->yDpi,
2272                                displayWidth, pScrn->bitsPerPixel);
2273             break;
2274         default:
2275             xf86DrvMsg(scrnIndex, X_ERROR,
2276                        "Internal error: invalid bpp (%d) in NVScreenInit\n",
2277                        pScrn->bitsPerPixel);
2278             ret = FALSE;
2279             break;
2280     }
2281     if (!ret)
2282         return FALSE;
2283
2284     if (pScrn->bitsPerPixel > 8) {
2285         /* Fixup RGB ordering */
2286         visual = pScreen->visuals + pScreen->numVisuals;
2287         while (--visual >= pScreen->visuals) {
2288             if ((visual->class | DynamicClass) == DirectColor) {
2289                 visual->offsetRed = pScrn->offset.red;
2290                 visual->offsetGreen = pScrn->offset.green;
2291                 visual->offsetBlue = pScrn->offset.blue;
2292                 visual->redMask = pScrn->mask.red;
2293                 visual->greenMask = pScrn->mask.green;
2294                 visual->blueMask = pScrn->mask.blue;
2295             }
2296         }
2297     }
2298
2299     fbPictureInit (pScreen, 0, 0);
2300
2301     xf86SetBlackWhitePixels(pScreen);
2302
2303     if (!pNv->NoAccel) {
2304             NVExaInit(pScreen);
2305             NVResetGraphics(pScrn);
2306     }
2307
2308     miInitializeBackingStore(pScreen);
2309     xf86SetBackingStore(pScreen);
2310     xf86SetSilkenMouse(pScreen);
2311
2312     /* Finish DRI init */
2313     NVDRIFinishScreenInit(pScrn);
2314
2315     /* Initialize software cursor.
2316         Must precede creation of the default colormap */
2317     miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
2318
2319     /* Initialize HW cursor layer.
2320         Must follow software cursor initialization*/
2321     if (pNv->HWCursor) {
2322         if (pNv->Architecture < NV_ARCH_50 && !pNv->randr12_enable)
2323                 ret = NVCursorInit(pScreen);
2324 #ifdef ENABLE_RANDR12
2325         else if (pNv->Architecture < NV_ARCH_50 && pNv->randr12_enable)
2326                 ret = NVCursorInitRandr12(pScreen);
2327         else
2328                 ret = NV50CursorInit(pScreen);
2329 #endif
2330
2331         if (ret != TRUE) {
2332             xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
2333                 "Hardware cursor initialization failed\n");
2334             pNv->HWCursor = FALSE;
2335         }
2336     }
2337
2338     /* Initialise default colourmap */
2339     if (!miCreateDefColormap(pScreen))
2340         return FALSE;
2341
2342     /* Initialize colormap layer.
2343        Must follow initialization of the default colormap */
2344     if (!pNv->randr12_enable) {
2345         if(!xf86HandleColormaps(pScreen, 256, 8, NVDACLoadPalette,
2346                                 NULL, CMAP_RELOAD_ON_MODE_SWITCH | CMAP_PALETTED_TRUECOLOR))
2347             return FALSE;
2348     } else {
2349         if (pNv->Architecture < NV_ARCH_50) {
2350             if (!xf86HandleColormaps(pScreen, 256, 8, NVLoadPalette,
2351                                      NULL,
2352                                      CMAP_RELOAD_ON_MODE_SWITCH |
2353                                      CMAP_PALETTED_TRUECOLOR))
2354                 return FALSE;
2355         } else {
2356             if (!xf86HandleColormaps(pScreen, 256, 8, NV50LoadPalette,
2357                                      NULL, CMAP_PALETTED_TRUECOLOR))
2358                 return FALSE;
2359         }
2360     }
2361
2362 #ifdef ENABLE_RANDR12
2363     if (pNv->randr12_enable) {
2364         xf86DPMSInit(pScreen, xf86DPMSSet, 0);
2365
2366         if (!xf86CrtcScreenInit(pScreen))
2367             return FALSE;
2368
2369         pNv->PointerMoved = pScrn->PointerMoved;
2370         pScrn->PointerMoved = NVPointerMoved;
2371     }
2372 #endif
2373
2374     if(pNv->ShadowFB) {
2375         RefreshAreaFuncPtr refreshArea = NVRefreshArea;
2376
2377         if(pNv->Rotate || pNv->RandRRotation) {
2378            pNv->PointerMoved = pScrn->PointerMoved;
2379            if(pNv->Rotate)
2380                pScrn->PointerMoved = NVPointerMoved;
2381
2382            switch(pScrn->bitsPerPixel) {
2383                case 8:  refreshArea = NVRefreshArea8;   break;
2384                case 16: refreshArea = NVRefreshArea16;  break;
2385                case 32: refreshArea = NVRefreshArea32;  break;
2386            }
2387            if(!pNv->RandRRotation) {
2388                xf86DisableRandR();
2389                xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2390                           "Driver rotation enabled, RandR disabled\n");
2391            }
2392         }
2393
2394         ShadowFBInit(pScreen, refreshArea);
2395     }
2396
2397     if (!pNv->randr12_enable) {
2398         if(pNv->FlatPanel)
2399             xf86DPMSInit(pScreen, NVDPMSSetLCD, 0);
2400         else
2401             xf86DPMSInit(pScreen, NVDPMSSet, 0);
2402     }
2403
2404     pScrn->memPhysBase = pNv->VRAMPhysical;
2405     pScrn->fbOffset = 0;
2406
2407     if(pNv->Rotate == 0 && !pNv->RandRRotation)
2408        NVInitVideo(pScreen);
2409
2410     pScreen->SaveScreen = NVSaveScreen;
2411
2412     /* Wrap the current CloseScreen function */
2413     pNv->CloseScreen = pScreen->CloseScreen;
2414     pScreen->CloseScreen = NVCloseScreen;
2415
2416     pNv->BlockHandler = pScreen->BlockHandler;
2417     pScreen->BlockHandler = NVBlockHandler;
2418
2419 #ifdef RANDR
2420     /* Install our DriverFunc.  We have to do it this way instead of using the
2421      * HaveDriverFuncs argument to xf86AddDriver, because InitOutput clobbers
2422      * pScrn->DriverFunc */
2423     if (!pNv->randr12_enable)
2424         pScrn->DriverFunc = NVDriverFunc;
2425 #endif
2426
2427     /* Report any unused options (only for the first generation) */
2428     if (serverGeneration == 1) {
2429         xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
2430     }
2431     return TRUE;
2432 }
2433
2434 static Bool
2435 NVSaveScreen(ScreenPtr pScreen, int mode)
2436 {
2437 #ifdef ENABLE_RANDR12
2438     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
2439     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
2440     NVPtr pNv = NVPTR(pScrn);
2441     int i;
2442     Bool on = xf86IsUnblank(mode);
2443
2444     if (pNv->randr12_enable) {
2445         if (pScrn->vtSema) {
2446             for (i = 0; i < xf86_config->num_crtc; i++) {
2447
2448                 if (xf86_config->crtc[i]->enabled) {
2449                     NVCrtcBlankScreen(xf86_config->crtc[i],
2450                                       on);
2451                 }
2452             }
2453
2454         }
2455         return TRUE;
2456     } else
2457 #endif
2458         return vgaHWSaveScreen(pScreen, mode);
2459 }
2460
2461 static void
2462 NVSave(ScrnInfoPtr pScrn)
2463 {
2464     NVPtr pNv = NVPTR(pScrn);
2465     NVRegPtr nvReg = &pNv->SavedReg;
2466     vgaHWPtr pVga = VGAHWPTR(pScrn);
2467     vgaRegPtr vgaReg = &pVga->SavedReg;
2468
2469 #ifdef ENABLE_RANDR12
2470     if (pNv->randr12_enable) {
2471         xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
2472         int vgaflags = VGA_SR_CMAP | VGA_SR_MODE;
2473         int i;
2474
2475         for (i = 0; i < xf86_config->num_crtc; i++) {
2476                 xf86_config->crtc[i]->funcs->save(xf86_config->crtc[i]);
2477         }
2478
2479         for (i = 0; i < xf86_config->num_output; i++) {
2480                 xf86_config->output[i]->funcs->save(xf86_config->
2481                                                     output[i]);
2482         }
2483
2484         vgaHWUnlock(pVga);
2485 #ifndef __powerpc__
2486         vgaflags |= VGA_SR_FONTS;
2487 #endif
2488         vgaHWSave(pScrn, vgaReg, vgaflags);
2489     } else
2490 #endif
2491     {
2492         NVLockUnlock(pNv, 0);
2493         if(pNv->twoHeads) {
2494             nvWriteVGA(pNv, NV_VGA_CRTCX_OWNER, pNv->crtc_active[1] * 0x3);
2495             NVLockUnlock(pNv, 0);
2496         }
2497
2498         NVDACSave(pScrn, vgaReg, nvReg, pNv->Primary);
2499     }
2500 }
2501
2502 #ifdef RANDR
2503 static Bool
2504 NVRandRGetInfo(ScrnInfoPtr pScrn, Rotation *rotations)
2505 {
2506     NVPtr pNv = NVPTR(pScrn);
2507
2508     if(pNv->RandRRotation)
2509        *rotations = RR_Rotate_0 | RR_Rotate_90 | RR_Rotate_270;
2510     else
2511        *rotations = RR_Rotate_0;
2512
2513     return TRUE;
2514 }
2515
2516 static Bool
2517 NVRandRSetConfig(ScrnInfoPtr pScrn, xorgRRConfig *config)
2518 {
2519     NVPtr pNv = NVPTR(pScrn);
2520
2521     switch(config->rotation) {
2522         case RR_Rotate_0:
2523             pNv->Rotate = 0;
2524             pScrn->PointerMoved = pNv->PointerMoved;
2525             break;
2526
2527         case RR_Rotate_90:
2528             pNv->Rotate = -1;
2529             pScrn->PointerMoved = NVPointerMoved;
2530             break;
2531
2532         case RR_Rotate_270:
2533             pNv->Rotate = 1;
2534             pScrn->PointerMoved = NVPointerMoved;
2535             break;
2536
2537         default:
2538             xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
2539                     "Unexpected rotation in NVRandRSetConfig!\n");
2540             pNv->Rotate = 0;
2541             pScrn->PointerMoved = pNv->PointerMoved;
2542             return FALSE;
2543     }
2544
2545     return TRUE;
2546 }
2547
2548 static Bool
2549 NVDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op, pointer data)
2550 {
2551     switch(op) {
2552        case RR_GET_INFO:
2553           return NVRandRGetInfo(pScrn, (Rotation*)data);
2554        case RR_SET_CONFIG:
2555           return NVRandRSetConfig(pScrn, (xorgRRConfig*)data);
2556        default:
2557           return FALSE;
2558     }
2559
2560     return FALSE;
2561 }
2562 #endif