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