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 #define NV_MODE_PRIVATE_ID 0x4F37ED65
1836 #define NV_MODE_PRIVATE_SIZE 2
1837
1838 /*
1839  * Match a private mode flag in a special function.
1840  * I don't want ugly casting all over the code.
1841  */
1842 Bool
1843 NVMatchModePrivate(DisplayModePtr mode, uint32_t flags)
1844 {
1845         if (!mode)
1846                 return FALSE;
1847         if (!mode->Private)
1848                 return FALSE;
1849         if (mode->PrivSize != NV_MODE_PRIVATE_SIZE)
1850                 return FALSE;
1851         if (mode->Private[0] != NV_MODE_PRIVATE_ID)
1852                 return FALSE;
1853
1854         if (mode->Private[1] & flags)
1855                 return TRUE;
1856
1857         return FALSE;
1858 }
1859
1860 static void
1861 NVRestoreConsole(xf86OutputPtr output, DisplayModePtr mode)
1862 {
1863         if (!output->crtc)
1864                 return;
1865
1866         xf86CrtcPtr crtc = output->crtc;
1867         NVCrtcPrivatePtr nv_crtc = crtc->driver_private;
1868         Bool need_unlock;
1869         ScrnInfoPtr pScrn = crtc->scrn;
1870         NVPtr pNv = NVPTR(pScrn);
1871         RIVA_HW_STATE *state = &pNv->ModeReg;
1872         NVCrtcRegPtr regp = &state->crtc_reg[nv_crtc->head];
1873         int i;
1874
1875         if (!crtc->enabled)
1876                 return;
1877
1878         xf86SetModeCrtc(mode, INTERLACE_HALVE_V);
1879         DisplayModePtr adjusted_mode = xf86DuplicateMode(mode);
1880
1881         /* Sequence mimics a normal modeset. */
1882         output->funcs->dpms(output, DPMSModeOff);
1883         crtc->funcs->dpms(crtc, DPMSModeOff);
1884         need_unlock = crtc->funcs->lock(crtc);
1885         output->funcs->mode_fixup(output, mode, adjusted_mode);
1886         crtc->funcs->mode_fixup(crtc, mode, adjusted_mode);
1887         output->funcs->prepare(output);
1888         crtc->funcs->prepare(crtc);
1889         /* Always use offset (0,0). */
1890         crtc->funcs->mode_set(crtc, mode, adjusted_mode, 0, 0);
1891         output->funcs->mode_set(output, mode, adjusted_mode);
1892         crtc->funcs->commit(crtc);
1893         output->funcs->commit(output);
1894         if (need_unlock)
1895                 crtc->funcs->unlock(crtc);
1896         /* Always turn on outputs afterwards. */
1897         output->funcs->dpms(output, DPMSModeOn);
1898         crtc->funcs->dpms(crtc, DPMSModeOn);
1899
1900         if (pNv->NVArch >= 0x17 && pNv->twoHeads)
1901                 for (i = 0; i < 0x10; i++)
1902                         NVWriteVGACR5758(pNv, nv_crtc->head, i, regp->CR58[i]);
1903
1904         /* Free mode. */
1905         xfree(adjusted_mode);
1906 }
1907
1908 #define MODEPREFIX(name) NULL, NULL, name, 0,M_T_DRIVER
1909 #define MODESUFFIX   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,FALSE,FALSE,0,NULL,0,0.0,0.0
1910
1911 /* hblankstart: 648, hblankend: 792, vblankstart: 407, vblankend: 442 for 640x400 */
1912 static DisplayModeRec VGAModes[2] = {
1913         { MODEPREFIX("640x400"),    28320, /*25175,*/ 640,  680,  776,  800, 0,  400,  412,  414,  449, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 640x400 */
1914         { MODEPREFIX("720x400"),    28320,  720,  738,  846,  900, 0,  400,  412,  414,  449, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 720x400@70Hz */
1915 };
1916
1917 /*
1918  * Restore the initial (text) mode.
1919  */
1920 static void
1921 NVRestore(ScrnInfoPtr pScrn)
1922 {
1923         vgaHWPtr hwp = VGAHWPTR(pScrn);
1924         vgaRegPtr vgaReg = &hwp->SavedReg;
1925         NVPtr pNv = NVPTR(pScrn);
1926         NVRegPtr nvReg = &pNv->SavedReg;
1927
1928         if (pNv->randr12_enable) {
1929                 xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
1930                 RIVA_HW_STATE *state = &pNv->ModeReg;
1931                 int i;
1932
1933                 /* Let's wipe some state regs */
1934                 state->vpll1_a = 0;
1935                 state->vpll1_b = 0;
1936                 state->vpll2_a = 0;
1937                 state->vpll2_b = 0;
1938                 state->reg594 = 0;
1939                 state->reg580 = 0;
1940                 state->pllsel = 0;
1941
1942                 if (pNv->new_restore) { /* new style restore. */
1943                         for (i = 0; i < xf86_config->num_crtc; i++) {
1944                                 NVCrtcLockUnlock(xf86_config->crtc[i], 0);
1945                         }
1946
1947                         /* Reset some values according to stored console value, to avoid confusion later on. */
1948                         /* Otherwise we end up with corrupted terminals. */
1949                         for (i = 0; i < xf86_config->num_crtc; i++) {
1950                                 NVCrtcPrivatePtr nv_crtc = xf86_config->crtc[i]->driver_private;
1951                                 uint8_t pixelDepth = pNv->console_mode[nv_crtc->head].depth/8;
1952                                 /* restore PIXEL value */
1953                                 uint32_t pixel = NVReadVgaCrtc(xf86_config->crtc[i], NV_VGA_CRTCX_PIXEL) & ~(0xF);
1954                                 pixel |= (pixelDepth > 2) ? 3 : pixelDepth;
1955                                 NVWriteVgaCrtc(xf86_config->crtc[i], NV_VGA_CRTCX_PIXEL, pixel);
1956                                 /* restore HDisplay and VDisplay */
1957                                 NVWriteVGA(pNv, nv_crtc->head, NV_VGA_CRTCX_HDISPE, (pNv->console_mode[nv_crtc->head].x_res)/8 - 1);
1958                                 NVWriteVGA(pNv, nv_crtc->head, NV_VGA_CRTCX_VDISPE, (pNv->console_mode[nv_crtc->head].y_res) - 1);
1959                                 /* restore CR52 */
1960                                 NVWriteVGA(pNv, nv_crtc->head, NV_VGA_CRTCX_52, pNv->misc_info.crtc_reg_52[nv_crtc->head]);
1961                                 /* restore crtc base */
1962                                 nvWriteCRTC(pNv, nv_crtc->head, NV_CRTC_START, pNv->console_mode[nv_crtc->head].fb_start);
1963                                 /* Restore general control */
1964                                 nvWriteRAMDAC(pNv, nv_crtc->head, NV_RAMDAC_GENERAL_CONTROL, pNv->misc_info.ramdac_general_control[nv_crtc->head]);
1965                         }
1966
1967                         /* Restore outputs when enabled. */
1968                         for (i = 0; i < xf86_config->num_output; i++) {
1969                                 xf86OutputPtr output = xf86_config->output[i];
1970                                 if (!xf86_config->output[i]->crtc) /* not enabled? */
1971                                         continue;
1972
1973                                 NVOutputPrivatePtr nv_output = output->driver_private;
1974                                 Bool is_fp = FALSE;
1975                                 DisplayModePtr mode = NULL;
1976                                 DisplayModePtr good_mode = NULL;
1977                                 NVConsoleMode *console = &pNv->console_mode[i];
1978                                 DisplayModePtr modes = output->probed_modes;
1979                                 if (!modes) /* no modes means no restore */
1980                                         continue;
1981
1982                                 if (nv_output->type == OUTPUT_TMDS || nv_output->type == OUTPUT_LVDS)
1983                                         is_fp = TRUE;
1984
1985                                 if (console->vga_mode) {
1986                                         /* We support 640x400 and 720x400 vga modes. */
1987                                         if (console->x_res == 720)
1988                                                 good_mode = &VGAModes[1];
1989                                         else
1990                                                 good_mode = &VGAModes[0];
1991                                         if (!good_mode) /* No suitable mode found. */
1992                                                 continue;
1993                                 } else {
1994                                         NVCrtcPrivatePtr nv_crtc = output->crtc->driver_private;
1995                                         uint32_t old_clock = nv_get_clock_from_crtc(pScrn, nv_crtc->head);
1996                                         uint32_t clock_diff = 0xFFFFFFFF;
1997                                         for (mode = modes; mode != NULL; mode = mode->next) {
1998                                                 /* We only have the first 8 bits of y_res - 1. */
1999                                                 /* And it's sometimes bogus. */
2000                                                 if (is_fp || !console->enabled) { /* digital outputs are run at their native clock */
2001                                                         if (mode->HDisplay == console->x_res) {
2002                                                                 if (!good_mode) /* Pick any match, in case we don't find a 60.0 Hz mode. */
2003                                                                         good_mode = mode;
2004                                                                 /* Pick a 60.0 Hz mode if there is one. */
2005                                                                 if (mode->VRefresh > 59.95 && mode->VRefresh < 60.05) {
2006                                                                         good_mode = mode;
2007                                                                         break;
2008                                                                 }
2009                                                         }
2010                                                 } else {
2011                                                         if (mode->HDisplay == console->x_res) {
2012                                                                 int temp_diff = mode->Clock - old_clock;
2013                                                                 if (temp_diff < 0)
2014                                                                         temp_diff *= -1;
2015                                                                 if (temp_diff < clock_diff) { /* converge on the closest mode */
2016                                                                         clock_diff = temp_diff;
2017                                                                         good_mode = mode;
2018                                                                 }
2019                                                         }
2020                                                 }
2021                                         }
2022                                         if (!good_mode) /* No suitable mode found. */
2023                                                 continue;
2024                                 }
2025
2026                                 mode = xf86DuplicateMode(good_mode);
2027
2028                                 INT32 *nv_mode = xnfcalloc(sizeof(INT32)*NV_MODE_PRIVATE_SIZE, 1);
2029
2030                                 /* A semi-unique identifier to avoid using other privates. */
2031                                 nv_mode[0] = NV_MODE_PRIVATE_ID;
2032
2033                                 if (console->vga_mode)
2034                                         nv_mode[1] |= NV_MODE_VGA;
2035
2036                                 nv_mode[1] |= NV_MODE_CONSOLE;
2037
2038                                 mode->Private = nv_mode;
2039                                 mode->PrivSize = NV_MODE_PRIVATE_SIZE;
2040
2041                                 uint8_t scale_backup = nv_output->scaling_mode;
2042                                 if (nv_output->type == OUTPUT_LVDS || nv_output->type == OUTPUT_TMDS)
2043                                         nv_output->scaling_mode = SCALE_FULLSCREEN;
2044
2045                                 NVRestoreConsole(output, mode);
2046
2047                                 /* Restore value, so we reenter X properly. */
2048                                 nv_output->scaling_mode = scale_backup;
2049
2050                                 xfree(mode->Private);
2051                                 xfree(mode);
2052                         }
2053
2054                         NVWriteVGA(pNv, 0, NV_VGA_CRTCX_OWNER, pNv->vtOWNER);
2055
2056                         /* Lock the crtc's. */
2057                         for (i = 0; i < xf86_config->num_crtc; i++) {
2058                                 NVCrtcLockUnlock(xf86_config->crtc[i], 1);
2059                         }
2060
2061                         /* Let's clean our slate once again, so we always rewrite vpll's upon returning to X. */
2062                         state->vpll1_a = 0;
2063                         state->vpll1_b = 0;
2064                         state->vpll2_a = 0;
2065                         state->vpll2_b = 0;
2066                         state->reg594 = 0;
2067                         state->reg580 = 0;
2068                         state->pllsel = 0;
2069                 } else {
2070                         for (i = 0; i < xf86_config->num_crtc; i++) {
2071                                 NVCrtcLockUnlock(xf86_config->crtc[i], 0);
2072                         }
2073
2074                         /* Some aspects of an output needs to be restore before the crtc. */
2075                         /* In my case this has to do with the mode that i get at very low resolutions. */
2076                         /* If i do this at the end, it will not be restored properly */
2077                         for (i = 0; i < xf86_config->num_output; i++) {
2078                                 NVOutputPrivatePtr nv_output2 = xf86_config->output[i]->driver_private;
2079                                 NVOutputRegPtr regp = &nvReg->dac_reg[nv_output2->preferred_output];
2080                                 Bool crosswired = regp->TMDS[0x4] & (1 << 3);
2081                                 /* Let's guess the bios state ;-) */
2082                                 if (nv_output2->type == OUTPUT_TMDS)
2083                                         ErrorF("Restoring TMDS timings, before restoring anything else\n");
2084                                 if (nv_output2->type == OUTPUT_LVDS)
2085                                         ErrorF("Restoring LVDS timings, before restoring anything else\n");
2086                                 if (nv_output2->type == OUTPUT_TMDS || nv_output2->type == OUTPUT_LVDS) {
2087                                         uint32_t clock = nv_calc_tmds_clock_from_pll(xf86_config->output[i]);
2088                                         nv_set_tmds_registers(xf86_config->output[i], clock, TRUE, crosswired);
2089                                 }
2090                         }
2091
2092                         /* This needs to happen before the crtc restore happens. */
2093                         for (i = 0; i < xf86_config->num_output; i++) {
2094                                 NVOutputPrivatePtr nv_output = xf86_config->output[i]->driver_private;
2095                                 /* Select the default output resource for consistent restore. */
2096                                 if (ffs(pNv->dcb_table.entry[nv_output->dcb_entry].or) & OUTPUT_1) {
2097                                         nv_output->output_resource = 1;
2098                                 } else {
2099                                         nv_output->output_resource = 0;
2100                                 }
2101                         }
2102
2103                         for (i = 0; i < xf86_config->num_crtc; i++) {
2104                                 NVCrtcPrivatePtr nv_crtc = xf86_config->crtc[i]->driver_private;
2105                                 /* Restore this, so it doesn't mess with restore. */
2106                                 pNv->fp_regs_owner[nv_crtc->head] = nv_crtc->head;
2107                         }
2108
2109                         for (i = 0; i < xf86_config->num_crtc; i++) {
2110                                 xf86_config->crtc[i]->funcs->restore(xf86_config->crtc[i]);
2111                         }
2112
2113                         for (i = 0; i < xf86_config->num_output; i++) {
2114                                 xf86_config->output[i]->funcs->restore(xf86_config->
2115                                                                        output[i]);
2116                         }
2117
2118                         for (i = 0; i < xf86_config->num_crtc; i++) {
2119                                 NVCrtcLockUnlock(xf86_config->crtc[i], 1);
2120                         }
2121                 }
2122         } else {
2123                 NVLockUnlock(pNv, 0);
2124
2125                 if(pNv->twoHeads) {
2126                         nvWriteVGA(pNv, NV_VGA_CRTCX_OWNER, pNv->crtc_active[1] * 0x3);
2127                         NVLockUnlock(pNv, 0);
2128                 }
2129
2130                 /* Only restore text mode fonts/text for the primary card */
2131                 vgaHWProtect(pScrn, TRUE);
2132                 NVDACRestore(pScrn, vgaReg, nvReg, pNv->Primary);
2133                 if(pNv->twoHeads) {
2134                         nvWriteVGA(pNv, NV_VGA_CRTCX_OWNER, pNv->vtOWNER);
2135                 }
2136                 vgaHWProtect(pScrn, FALSE);
2137         }
2138 }
2139
2140 static void
2141 NVLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
2142               LOCO * colors, VisualPtr pVisual)
2143 {
2144         xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
2145         int c;
2146         int i, j, index;
2147         CARD16 lut_r[256], lut_g[256], lut_b[256];
2148
2149         for (c = 0; c < xf86_config->num_crtc; c++) {
2150                 xf86CrtcPtr crtc = xf86_config->crtc[c];
2151
2152                 if (crtc->enabled == 0)
2153                         continue;
2154
2155                 /* code borrowed from intel driver */
2156                 switch (pScrn->depth) {
2157                 case 15:
2158                         for (i = 0; i < numColors; i++) {
2159                                 index = indices[i];
2160                                 for (j = 0; j < 8; j++) {
2161                                         lut_r[index * 8 + j] = colors[index].red << 8;
2162                                         lut_g[index * 8 + j] = colors[index].green << 8;
2163                                         lut_b[index * 8 + j] = colors[index].blue << 8;
2164                                 }
2165                         }
2166                 case 16:
2167                         for (i = 0; i < numColors; i++) {
2168                                 index = indices[i];
2169
2170                                 if (i <= 31) {
2171                                         for (j = 0; j < 8; j++) {
2172                                                 lut_r[index * 8 + j] = colors[index].red << 8;
2173                                                 lut_b[index * 8 + j] = colors[index].blue << 8;
2174                                         }
2175                                 }
2176
2177                                 for (j = 0; j < 4; j++) {
2178                                         lut_g[index * 4 + j] = colors[index].green << 8;
2179                                 }
2180                         }
2181                 default:
2182                         for (i = 0; i < numColors; i++) {
2183                                 index = indices[i];
2184                                 lut_r[index] = colors[index].red << 8;
2185                                 lut_g[index] = colors[index].green << 8;
2186                                 lut_b[index] = colors[index].blue << 8;
2187                         }
2188                         break;
2189                 }
2190
2191                 /* Make the change through RandR */
2192                 RRCrtcGammaSet(crtc->randr_crtc, lut_r, lut_g, lut_b);
2193         }
2194 }
2195
2196 #define DEPTH_SHIFT(val, w) ((val << (8 - w)) | (val >> ((w << 1) - 8)))
2197 #define COLOR(c) (unsigned int)(0x3fff * ((c)/255.0))
2198 static void
2199 NV50LoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
2200                 LOCO * colors, VisualPtr pVisual)
2201 {
2202         NVPtr pNv = NVPTR(pScrn);
2203         int i, index;
2204         volatile struct {
2205                 unsigned short red, green, blue, unused;
2206         } *lut = (void *) pNv->CLUT->map;
2207
2208         switch (pScrn->depth) {
2209         case 15:
2210                 for (i = 0; i < numColors; i++) {
2211                         index = indices[i];
2212                         lut[DEPTH_SHIFT(index, 5)].red =
2213                             COLOR(colors[index].red);
2214                         lut[DEPTH_SHIFT(index, 5)].green =
2215                             COLOR(colors[index].green);
2216                         lut[DEPTH_SHIFT(index, 5)].blue =
2217                             COLOR(colors[index].blue);
2218                 }
2219                 break;
2220         case 16:
2221                 for (i = 0; i < numColors; i++) {
2222                         index = indices[i];
2223                         lut[DEPTH_SHIFT(index, 6)].green =
2224                             COLOR(colors[index].green);
2225                         if (index < 32) {
2226                                 lut[DEPTH_SHIFT(index, 5)].red =
2227                                     COLOR(colors[index].red);
2228                                 lut[DEPTH_SHIFT(index, 5)].blue =
2229                                     COLOR(colors[index].blue);
2230                         }
2231                 }
2232                 break;
2233         default:
2234                 for (i = 0; i < numColors; i++) {
2235                         index = indices[i];
2236                         lut[index].red = COLOR(colors[index].red);
2237                         lut[index].green = COLOR(colors[index].green);
2238                         lut[index].blue = COLOR(colors[index].blue);
2239                 }
2240                 break;
2241         }
2242 }
2243
2244
2245 static void NVBacklightEnable(NVPtr pNv,  Bool on)
2246 {
2247     /* This is done differently on each laptop.  Here we
2248        define the ones we know for sure. */
2249
2250 #if defined(__powerpc__)
2251     if((pNv->Chipset == 0x10DE0179) ||
2252        (pNv->Chipset == 0x10DE0189) ||
2253        (pNv->Chipset == 0x10DE0329))
2254     {
2255        /* NV17,18,34 Apple iMac, iBook, PowerBook */
2256       CARD32 tmp_pmc, tmp_pcrt;
2257       tmp_pmc = nvReadMC(pNv, 0x10F0) & 0x7FFFFFFF;
2258       tmp_pcrt = nvReadCRTC0(pNv, NV_CRTC_081C) & 0xFFFFFFFC;
2259       if(on) {
2260           tmp_pmc |= (1 << 31);
2261           tmp_pcrt |= 0x1;
2262       }
2263       nvWriteMC(pNv, 0x10F0, tmp_pmc);
2264       nvWriteCRTC0(pNv, NV_CRTC_081C, tmp_pcrt);
2265     }
2266 #endif
2267
2268     if(pNv->LVDS) {
2269        if(pNv->twoHeads && ((pNv->Chipset & 0x0ff0) != CHIPSET_NV11)) {
2270            nvWriteMC(pNv, 0x130C, on ? 3 : 7);
2271        }
2272     } else {
2273        CARD32 fpcontrol;
2274
2275        fpcontrol = nvReadCurRAMDAC(pNv, 0x848) & 0xCfffffCC;
2276
2277        /* cut the TMDS output */
2278        if(on) fpcontrol |= pNv->fpSyncs;
2279        else fpcontrol |= 0x20000022;
2280
2281        nvWriteCurRAMDAC(pNv, 0x0848, fpcontrol);
2282     }
2283 }
2284
2285 static void
2286 NVDPMSSetLCD(ScrnInfoPtr pScrn, int PowerManagementMode, int flags)
2287 {
2288   NVPtr pNv = NVPTR(pScrn);
2289
2290   if (!pScrn->vtSema) return;
2291
2292   vgaHWDPMSSet(pScrn, PowerManagementMode, flags);
2293
2294   switch (PowerManagementMode) {
2295   case DPMSModeStandby:  /* HSync: Off, VSync: On */
2296   case DPMSModeSuspend:  /* HSync: On, VSync: Off */
2297   case DPMSModeOff:      /* HSync: Off, VSync: Off */
2298     NVBacklightEnable(pNv, 0);
2299     break;
2300   case DPMSModeOn:       /* HSync: On, VSync: On */
2301     NVBacklightEnable(pNv, 1);
2302   default:
2303     break;
2304   }
2305 }
2306
2307
2308 static void
2309 NVDPMSSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags)
2310 {
2311   unsigned char crtc1A;
2312   vgaHWPtr hwp = VGAHWPTR(pScrn);
2313
2314   if (!pScrn->vtSema) return;
2315
2316   crtc1A = hwp->readCrtc(hwp, 0x1A) & ~0xC0;
2317
2318   switch (PowerManagementMode) {
2319   case DPMSModeStandby:  /* HSync: Off, VSync: On */
2320     crtc1A |= 0x80;
2321     break;
2322   case DPMSModeSuspend:  /* HSync: On, VSync: Off */
2323     crtc1A |= 0x40;
2324     break;
2325   case DPMSModeOff:      /* HSync: Off, VSync: Off */
2326     crtc1A |= 0xC0;
2327     break;
2328   case DPMSModeOn:       /* HSync: On, VSync: On */
2329   default:
2330     break;
2331   }
2332
2333   /* vgaHWDPMSSet will merely cut the dac output */
2334   vgaHWDPMSSet(pScrn, PowerManagementMode, flags);
2335
2336   hwp->writeCrtc(hwp, 0x1A, crtc1A);
2337 }
2338
2339
2340 /* Mandatory */
2341
2342 /* This gets called at the start of each server generation */
2343
2344 static Bool
2345 NVScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
2346 {
2347         ScrnInfoPtr pScrn;
2348         vgaHWPtr hwp;
2349         NVPtr pNv;
2350         int ret;
2351         VisualPtr visual;
2352         unsigned char *FBStart;
2353         int width, height, displayWidth, shadowHeight, i;
2354
2355         /*
2356          * First get the ScrnInfoRec
2357          */
2358         pScrn = xf86Screens[pScreen->myNum];
2359
2360         hwp = VGAHWPTR(pScrn);
2361         pNv = NVPTR(pScrn);
2362
2363         /* Map the VGA memory when the primary video */
2364         if (pNv->Primary) {
2365                 hwp->MapSize = 0x10000;
2366                 if (!vgaHWMapMem(pScrn))
2367                         return FALSE;
2368         }
2369
2370         /* First init DRI/DRM */
2371         if (!NVDRIScreenInit(pScrn))
2372                 return FALSE;
2373
2374         /* Allocate and map memory areas we need */
2375         if (!NVMapMem(pScrn))
2376                 return FALSE;
2377
2378         if (!pNv->NoAccel) {
2379                 /* Init DRM - Alloc FIFO */
2380                 if (!NVInitDma(pScrn))
2381                         return FALSE;
2382
2383                 /* setup graphics objects */
2384                 if (!NVAccelCommonInit(pScrn))
2385                         return FALSE;
2386         }
2387
2388 #if NOUVEAU_EXA_PIXMAPS
2389         if (nouveau_bo_new(pNv->dev, NOUVEAU_BO_VRAM | NOUVEAU_BO_PIN,
2390                         0, NOUVEAU_ALIGN(pScrn->virtualX, 64) * NOUVEAU_ALIGN(pScrn->virtualY, 64) *
2391                         (pScrn->bitsPerPixel >> 3), &pNv->FB)) {
2392                 ErrorF("Failed to allocate memory for screen pixmap.\n");
2393                 return FALSE;
2394         }
2395 #endif
2396
2397         if (!pNv->randr12_enable) {
2398                 /* Save the current state */
2399                 NVSave(pScrn);
2400                 /* Initialise the first mode */
2401                 if (!NVModeInit(pScrn, pScrn->currentMode))
2402                         return FALSE;
2403
2404                 /* Darken the screen for aesthetic reasons and set the viewport */
2405                 NVSaveScreen(pScreen, SCREEN_SAVER_ON);
2406                 pScrn->AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
2407         } else {
2408                 pScrn->memPhysBase = pNv->VRAMPhysical;
2409                 pScrn->fbOffset = 0;
2410
2411                 /* Gather some misc info before the randr stuff kicks in */
2412                 if (pNv->Architecture >= NV_ARCH_10) {
2413                         pNv->misc_info.crtc_reg_52[0] = NVReadVGA0(pNv, NV_VGA_CRTCX_52);
2414                         pNv->misc_info.crtc_reg_52[1] = NVReadVGA1(pNv, NV_VGA_CRTCX_52);
2415                 }
2416                 if (pNv->Architecture == NV_ARCH_40) {
2417                         pNv->misc_info.ramdac_0_reg_580 = nvReadRAMDAC(pNv, 0, NV_RAMDAC_580);
2418                         pNv->misc_info.reg_c040 = nvReadMC(pNv, 0xc040);
2419                 }
2420                 pNv->misc_info.ramdac_general_control[0] = nvReadRAMDAC(pNv, 0, NV_RAMDAC_GENERAL_CONTROL);
2421                 pNv->misc_info.ramdac_general_control[1] = nvReadRAMDAC(pNv, 1, NV_RAMDAC_GENERAL_CONTROL);
2422                 pNv->misc_info.ramdac_0_pllsel = nvReadRAMDAC(pNv, 0, NV_RAMDAC_PLL_SELECT);
2423                 pNv->misc_info.sel_clk = nvReadRAMDAC(pNv, 0, NV_RAMDAC_SEL_CLK);
2424                 if (pNv->twoHeads) {
2425                         pNv->misc_info.output[0] = nvReadRAMDAC(pNv, 0, NV_RAMDAC_OUTPUT);
2426                         pNv->misc_info.output[1] = nvReadRAMDAC(pNv, 1, NV_RAMDAC_OUTPUT);
2427                 }
2428
2429                 for (i = 0; i <= pNv->twoHeads; i++) {
2430                         if (NVReadVGA(pNv, i, NV_VGA_CRTCX_PIXEL) & 0xf) { /* framebuffer mode */
2431                                 pNv->console_mode[i].vga_mode = FALSE;
2432                                 uint8_t var = NVReadVGA(pNv, i, NV_VGA_CRTCX_PIXEL) & 0xf;
2433                                 Bool filled = (nvReadRAMDAC(pNv, i, NV_RAMDAC_GENERAL_CONTROL) & 0x1000);
2434                                 switch (var){
2435                                         case 3:
2436                                                 if (filled)
2437                                                         pNv->console_mode[i].depth = 32;
2438                                                 else
2439                                                         pNv->console_mode[i].depth = 24;
2440                                                 /* This is pitch related. */
2441                                                 pNv->console_mode[i].bpp = 32;
2442                                                 break;
2443                                         case 2:
2444                                                 if (filled)
2445                                                         pNv->console_mode[i].depth = 16;
2446                                                 else
2447                                                         pNv->console_mode[i].depth = 15;
2448                                                 /* This is pitch related. */
2449                                                 pNv->console_mode[i].bpp = 16;
2450                                                 break;
2451                                         case 1:
2452                                                 /* 8bit mode is always filled? */
2453                                                 pNv->console_mode[i].depth = 8;
2454                                                 /* This is pitch related. */
2455                                                 pNv->console_mode[i].bpp = 8;
2456                                         default:
2457                                                 break;
2458                                 }
2459                         } else { /* vga mode */
2460                                 pNv->console_mode[i].vga_mode = TRUE;
2461                                 pNv->console_mode[i].bpp = 4;
2462                                 pNv->console_mode[i].depth = 4;
2463                         }
2464
2465                         pNv->console_mode[i].x_res = (NVReadVGA(pNv, i, NV_VGA_CRTCX_HDISPE) + 1) * 8;
2466                         pNv->console_mode[i].y_res = (NVReadVGA(pNv, i, NV_VGA_CRTCX_VDISPE) + 1); /* NV_VGA_CRTCX_VDISPE only contains the lower 8 bits. */
2467
2468                         pNv->console_mode[i].fb_start = nvReadCRTC(pNv, i, NV_CRTC_START);
2469
2470                         pNv->console_mode[i].enabled = FALSE;
2471
2472                         ErrorF("CRTC %d: Console mode: %dx%d depth: %d bpp: %d\n", i, pNv->console_mode[i].x_res, pNv->console_mode[i].y_res, pNv->console_mode[i].depth, pNv->console_mode[i].bpp);
2473                 }
2474
2475                 /* Check if crtc's were enabled. */
2476                 if (pNv->misc_info.ramdac_0_pllsel & NV_RAMDAC_PLL_SELECT_PLL_SOURCE_VPLL) {
2477                         pNv->console_mode[0].enabled = TRUE;
2478                         ErrorF("CRTC 0 was enabled.\n");
2479                 }
2480
2481                 if (pNv->misc_info.ramdac_0_pllsel & NV_RAMDAC_PLL_SELECT_PLL_SOURCE_VPLL2) {
2482                         pNv->console_mode[1].enabled = TRUE;
2483                         ErrorF("CRTC 1 was enabled.\n");
2484                 }
2485
2486                 if (!NVEnterVT(scrnIndex, 0))
2487                         return FALSE;
2488                 NVSaveScreen(pScreen, SCREEN_SAVER_ON);
2489         }
2490
2491
2492         /*
2493          * The next step is to setup the screen's visuals, and initialise the
2494          * framebuffer code.  In cases where the framebuffer's default
2495          * choices for things like visual layouts and bits per RGB are OK,
2496          * this may be as simple as calling the framebuffer's ScreenInit()
2497          * function.  If not, the visuals will need to be setup before calling
2498          * a fb ScreenInit() function and fixed up after.
2499          *
2500          * For most PC hardware at depths >= 8, the defaults that fb uses
2501          * are not appropriate.  In this driver, we fixup the visuals after.
2502          */
2503
2504         /*
2505          * Reset the visual list.
2506          */
2507         miClearVisualTypes();
2508
2509         /* Setup the visuals we support. */
2510
2511         if (!miSetVisualTypes(pScrn->depth,
2512                                 miGetDefaultVisualMask(pScrn->depth), 8,
2513                                 pScrn->defaultVisual))
2514                 return FALSE;
2515         if (!miSetPixmapDepths ())
2516                 return FALSE;
2517
2518         /*
2519          * Call the framebuffer layer's ScreenInit function, and fill in other
2520          * pScreen fields.
2521          */
2522
2523         width = pScrn->virtualX;
2524         height = pScrn->virtualY;
2525         displayWidth = pScrn->displayWidth;
2526
2527         if(pNv->Rotate) {
2528                 height = pScrn->virtualX;
2529                 width = pScrn->virtualY;
2530         }
2531
2532         /* If RandR rotation is enabled, leave enough space in the
2533          * framebuffer for us to rotate the screen dimensions without
2534          * changing the pitch.
2535          */
2536         if(pNv->RandRRotation) {
2537                 shadowHeight = max(width, height);
2538         } else {
2539                 shadowHeight = height;
2540         }
2541
2542         if (pNv->ShadowFB) {
2543                 pNv->ShadowPitch = BitmapBytePad(pScrn->bitsPerPixel * width);
2544                 pNv->ShadowPtr = xalloc(pNv->ShadowPitch * shadowHeight);
2545                 displayWidth = pNv->ShadowPitch / (pScrn->bitsPerPixel >> 3);
2546                 FBStart = pNv->ShadowPtr;
2547         } else {
2548                 pNv->ShadowPtr = NULL;
2549                 FBStart = pNv->FB->map;
2550         }
2551
2552         switch (pScrn->bitsPerPixel) {
2553                 case 8:
2554                 case 16:
2555                 case 32:
2556                         ret = fbScreenInit(pScreen, FBStart, width, height,
2557                                 pScrn->xDpi, pScrn->yDpi,
2558                                 displayWidth, pScrn->bitsPerPixel);
2559                         break;
2560                 default:
2561                         xf86DrvMsg(scrnIndex, X_ERROR,
2562                                 "Internal error: invalid bpp (%d) in NVScreenInit\n",
2563                                 pScrn->bitsPerPixel);
2564                         ret = FALSE;
2565                         break;
2566         }
2567         if (!ret)
2568                 return FALSE;
2569
2570         if (pScrn->bitsPerPixel > 8) {
2571                 /* Fixup RGB ordering */
2572                 visual = pScreen->visuals + pScreen->numVisuals;
2573                 while (--visual >= pScreen->visuals) {
2574                         if ((visual->class | DynamicClass) == DirectColor) {
2575                                 visual->offsetRed = pScrn->offset.red;
2576                                 visual->offsetGreen = pScrn->offset.green;
2577                                 visual->offsetBlue = pScrn->offset.blue;
2578                                 visual->redMask = pScrn->mask.red;
2579                                 visual->greenMask = pScrn->mask.green;
2580                                 visual->blueMask = pScrn->mask.blue;
2581                         }
2582                 }
2583         }
2584
2585         fbPictureInit (pScreen, 0, 0);
2586
2587         xf86SetBlackWhitePixels(pScreen);
2588
2589         if (!pNv->NoAccel) {
2590                 NVExaInit(pScreen);
2591                 NVResetGraphics(pScrn);
2592         }
2593
2594         miInitializeBackingStore(pScreen);
2595         xf86SetBackingStore(pScreen);
2596         xf86SetSilkenMouse(pScreen);
2597
2598         /* Finish DRI init */
2599         NVDRIFinishScreenInit(pScrn);
2600
2601         /*
2602          * Initialize software cursor.
2603          * Must precede creation of the default colormap.
2604          */
2605         miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
2606
2607         /*
2608          * Initialize HW cursor layer.
2609          * Must follow software cursor initialization.
2610          */
2611         if (pNv->HWCursor) {
2612                 if (pNv->Architecture < NV_ARCH_50 && !pNv->randr12_enable)
2613                         ret = NVCursorInit(pScreen);
2614                 else if (pNv->Architecture < NV_ARCH_50 && pNv->randr12_enable)
2615                         ret = NVCursorInitRandr12(pScreen);
2616                 else
2617                         ret = NV50CursorInit(pScreen);
2618
2619                 if (ret != TRUE) {
2620                         xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
2621                                 "Hardware cursor initialization failed\n");
2622                         pNv->HWCursor = FALSE;
2623                 }
2624         }
2625
2626         if (pNv->randr12_enable) {
2627                 xf86DPMSInit(pScreen, xf86DPMSSet, 0);
2628
2629                 if (!xf86CrtcScreenInit(pScreen))
2630                         return FALSE;
2631
2632                 pNv->PointerMoved = pScrn->PointerMoved;
2633                 pScrn->PointerMoved = NVPointerMoved;
2634         }
2635
2636         /* Initialise default colourmap */
2637         if (!miCreateDefColormap(pScreen))
2638                 return FALSE;
2639
2640         /*
2641          * Initialize colormap layer.
2642          * Must follow initialization of the default colormap
2643          */
2644         if (!pNv->randr12_enable) {
2645                 if(!xf86HandleColormaps(pScreen, 256, 8, NVDACLoadPalette,
2646                                 NULL, CMAP_RELOAD_ON_MODE_SWITCH | CMAP_PALETTED_TRUECOLOR))
2647                 return FALSE;
2648         } else {
2649                 if (pNv->Architecture < NV_ARCH_50) {
2650                         if (!xf86HandleColormaps(pScreen, 256, 8, NVLoadPalette,
2651                                                 NULL,
2652                                                 CMAP_RELOAD_ON_MODE_SWITCH |
2653                                                 CMAP_PALETTED_TRUECOLOR))
2654                         return FALSE;
2655                 } else {
2656                         if (!xf86HandleColormaps(pScreen, 256, 8, NV50LoadPalette,
2657                                                 NULL, CMAP_PALETTED_TRUECOLOR))
2658                         return FALSE;
2659                 }
2660         }
2661
2662         if(pNv->ShadowFB) {
2663                 RefreshAreaFuncPtr refreshArea = NVRefreshArea;
2664
2665                 if (pNv->Rotate || pNv->RandRRotation) {
2666                         pNv->PointerMoved = pScrn->PointerMoved;
2667                         if (pNv->Rotate)
2668                                 pScrn->PointerMoved = NVPointerMoved;
2669
2670                         switch(pScrn->bitsPerPixel) {
2671                                 case 8: refreshArea = NVRefreshArea8;   break;
2672                                 case 16:        refreshArea = NVRefreshArea16;  break;
2673                                 case 32:        refreshArea = NVRefreshArea32;  break;
2674                         }
2675                         if(!pNv->RandRRotation) {
2676                                 xf86DisableRandR();
2677                                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2678                                         "Driver rotation enabled, RandR disabled\n");
2679                         }
2680                 }
2681
2682                 ShadowFBInit(pScreen, refreshArea);
2683         }
2684
2685         if (!pNv->randr12_enable) {
2686                 if(pNv->FlatPanel) {
2687                         xf86DPMSInit(pScreen, NVDPMSSetLCD, 0);
2688                 } else {
2689                         xf86DPMSInit(pScreen, NVDPMSSet, 0);
2690                 }
2691         }
2692
2693         pScrn->memPhysBase = pNv->VRAMPhysical;
2694         pScrn->fbOffset = 0;
2695
2696         if (pNv->Rotate == 0 && !pNv->RandRRotation)
2697                 NVInitVideo(pScreen);
2698
2699         pScreen->SaveScreen = NVSaveScreen;
2700
2701         /* Wrap the current CloseScreen function */
2702         pNv->CloseScreen = pScreen->CloseScreen;
2703         pScreen->CloseScreen = NVCloseScreen;
2704
2705         pNv->BlockHandler = pScreen->BlockHandler;
2706         pScreen->BlockHandler = NVBlockHandler;
2707
2708         /* Install our DriverFunc.  We have to do it this way instead of using the
2709          * HaveDriverFuncs argument to xf86AddDriver, because InitOutput clobbers
2710          * pScrn->DriverFunc
2711          */
2712         if (!pNv->randr12_enable)
2713                 pScrn->DriverFunc = NVDriverFunc;
2714
2715         /* Report any unused options (only for the first generation) */
2716         if (serverGeneration == 1) {
2717                 xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
2718         }
2719
2720         return TRUE;
2721 }
2722
2723 static Bool
2724 NVSaveScreen(ScreenPtr pScreen, int mode)
2725 {
2726     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
2727     NVPtr pNv = NVPTR(pScrn);
2728     int i;
2729     Bool on = xf86IsUnblank(mode);
2730
2731     if (pNv->randr12_enable) {
2732         xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
2733         if (pScrn->vtSema && pNv->Architecture < NV_ARCH_50) {
2734             for (i = 0; i < xf86_config->num_crtc; i++) {
2735
2736                 if (xf86_config->crtc[i]->enabled) {
2737                     NVCrtcBlankScreen(xf86_config->crtc[i],
2738                                       on);
2739                 }
2740             }
2741
2742         }
2743         return TRUE;
2744     }
2745
2746         return vgaHWSaveScreen(pScreen, mode);
2747 }
2748
2749 static void
2750 NVSave(ScrnInfoPtr pScrn)
2751 {
2752         NVPtr pNv = NVPTR(pScrn);
2753         NVRegPtr nvReg = &pNv->SavedReg;
2754         vgaHWPtr pVga = VGAHWPTR(pScrn);
2755         vgaRegPtr vgaReg = &pVga->SavedReg;
2756
2757         if (pNv->randr12_enable) {
2758                 xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
2759                 int vgaflags = VGA_SR_CMAP | VGA_SR_MODE;
2760                 int i;
2761
2762                 for (i = 0; i < xf86_config->num_crtc; i++) {
2763                         xf86_config->crtc[i]->funcs->save(xf86_config->crtc[i]);
2764                 }
2765
2766                 for (i = 0; i < xf86_config->num_output; i++) {
2767                         xf86_config->output[i]->funcs->save(xf86_config->
2768                                                             output[i]);
2769                 }
2770
2771                 vgaHWUnlock(pVga);
2772         #ifndef __powerpc__
2773                 vgaflags |= VGA_SR_FONTS;
2774         #endif
2775                 vgaHWSave(pScrn, vgaReg, vgaflags);
2776         } else {
2777                 NVLockUnlock(pNv, 0);
2778                 if(pNv->twoHeads) {
2779                         nvWriteVGA(pNv, NV_VGA_CRTCX_OWNER, pNv->crtc_active[1] * 0x3);
2780                         NVLockUnlock(pNv, 0);
2781                 }
2782
2783                 NVDACSave(pScrn, vgaReg, nvReg, pNv->Primary);
2784         }
2785 }
2786
2787 static Bool
2788 NVRandRGetInfo(ScrnInfoPtr pScrn, Rotation *rotations)
2789 {
2790     NVPtr pNv = NVPTR(pScrn);
2791
2792     if(pNv->RandRRotation)
2793        *rotations = RR_Rotate_0 | RR_Rotate_90 | RR_Rotate_270;
2794     else
2795        *rotations = RR_Rotate_0;
2796
2797     return TRUE;
2798 }
2799
2800 static Bool
2801 NVRandRSetConfig(ScrnInfoPtr pScrn, xorgRRConfig *config)
2802 {
2803     NVPtr pNv = NVPTR(pScrn);
2804
2805     switch(config->rotation) {
2806         case RR_Rotate_0:
2807             pNv->Rotate = 0;
2808             pScrn->PointerMoved = pNv->PointerMoved;
2809             break;
2810
2811         case RR_Rotate_90:
2812             pNv->Rotate = -1;
2813             pScrn->PointerMoved = NVPointerMoved;
2814             break;
2815
2816         case RR_Rotate_270:
2817             pNv->Rotate = 1;
2818             pScrn->PointerMoved = NVPointerMoved;
2819             break;
2820
2821         default:
2822             xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
2823                     "Unexpected rotation in NVRandRSetConfig!\n");
2824             pNv->Rotate = 0;
2825             pScrn->PointerMoved = pNv->PointerMoved;
2826             return FALSE;
2827     }
2828
2829     return TRUE;
2830 }
2831
2832 static Bool
2833 NVDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op, pointer data)
2834 {
2835     switch(op) {
2836        case RR_GET_INFO:
2837           return NVRandRGetInfo(pScrn, (Rotation*)data);
2838        case RR_SET_CONFIG:
2839           return NVRandRSetConfig(pScrn, (xorgRRConfig*)data);
2840        default:
2841           return FALSE;
2842     }
2843
2844     return FALSE;
2845 }