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

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