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 #if 0
 960         do not change virtual* for now, as it breaks multihead server regeneration
 961         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "nv_xf86crtc_resize is called with %dx%d resolution.\n", width, height);
 962         pScrn->virtualX = width;
 963         pScrn->virtualY = height;
 964 #endif
 965         return TRUE;
 966 }
 967
 968 static const xf86CrtcConfigFuncsRec nv_xf86crtc_config_funcs = {
 969         nv_xf86crtc_resize
 970 };
 971
 972 #define NVPreInitFail(fmt, args...) do {                                    \
 973         xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%d: "fmt, __LINE__, ##args); \
 974         NVFreeScreen(pScrn->scrnIndex, 0);                                  \
 975         return FALSE;                                                       \
 976 } while(0)
 977
 978 /* Mandatory */
 979 Bool
 980 NVPreInit(ScrnInfoPtr pScrn, int flags)
 981 {
 982         NVPtr pNv;
 983         MessageType from;
 984         int i, max_width, max_height;
 985         ClockRangePtr clockRanges;
 986         int config_mon_rates = FALSE;
 987
 988         if (flags & PROBE_DETECT) {
 989                 EntityInfoPtr pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
 990
 991                 if (!pEnt)
 992                         return FALSE;
 993
 994                 i = pEnt->index;
 995                 xfree(pEnt);
 996
 997                 if (xf86LoadSubModule(pScrn, "vbe")) {
 998                         vbeInfoPtr pVbe = VBEInit(NULL, i);
 999                         ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
1000                         vbeFree(pVbe);
1001                 }
1002
1003                 return TRUE;
1004         }
1005
1006         /*
1007          * Note: This function is only called once at server startup, and
1008          * not at the start of each server generation.  This means that
1009          * only things that are persistent across server generations can
1010          * be initialised here.  xf86Screens[] is (pScrn is a pointer to one
1011          * of these).  Privates allocated using xf86AllocateScrnInfoPrivateIndex()
1012          * are too, and should be used for data that must persist across
1013          * server generations.
1014          *
1015          * Per-generation data should be allocated with
1016          * AllocateScreenPrivateIndex() from the ScreenInit() function.
1017          */
1018
1019         /* Check the number of entities, and fail if it isn't one. */
1020         if (pScrn->numEntities != 1)
1021                 return FALSE;
1022
1023         /* Allocate the NVRec driverPrivate */
1024         if (!(pScrn->driverPrivate = xnfcalloc(1, sizeof(NVRec))))
1025                 return FALSE;
1026         pNv = NVPTR(pScrn);
1027
1028         /* Get the entity, and make sure it is PCI. */
1029         pNv->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
1030         if (pNv->pEnt->location.type != BUS_PCI)
1031                 return FALSE;
1032
1033         /* Find the PCI info for this screen */
1034         pNv->PciInfo = xf86GetPciInfoForEntity(pNv->pEnt->index);
1035 #ifndef XSERVER_LIBPCIACCESS
1036         pNv->PciTag = pciTag(pNv->PciInfo->bus, pNv->PciInfo->device,
1037                                 pNv->PciInfo->func);
1038 #endif /* XSERVER_LIBPCIACCESS */
1039
1040         pNv->Primary = xf86IsPrimaryPci(pNv->PciInfo);
1041
1042         volatile uint32_t *regs = NULL;
1043 #ifdef XSERVER_LIBPCIACCESS
1044         pci_device_map_range(pNv->PciInfo, PCI_DEV_MEM_BASE(pNv->PciInfo, 0),
1045                              0x90000, 0, (void *)&regs);
1046         pNv->Chipset = NVGetPCIID(regs) & 0xffff;
1047         pNv->NVArch = NVGetArchitecture(regs);
1048         pci_device_unmap_range(pNv->PciInfo, (void *) regs, 0x90000);
1049 #else
1050         CARD32 pcicmd;
1051         PCI_DEV_READ_LONG(pNv->PciInfo, PCI_CMD_STAT_REG, &pcicmd);
1052         /* Enable reading memory? */
1053         PCI_DEV_WRITE_LONG(pNv->PciInfo, PCI_CMD_STAT_REG, pcicmd | PCI_CMD_MEM_ENABLE);
1054         regs = xf86MapPciMem(-1, VIDMEM_MMIO, pNv->PciTag, PCI_DEV_MEM_BASE(pNv->PciInfo, 0), 0x90000);
1055         pNv->Chipset = NVGetPCIID(regs) & 0xffff;
1056         pNv->NVArch = NVGetArchitecture(regs);
1057         xf86UnMapVidMem(-1, (pointer)regs, 0x90000);
1058         /* Reset previous state */
1059         PCI_DEV_WRITE_LONG(pNv->PciInfo, PCI_CMD_STAT_REG, pcicmd);
1060 #endif /* XSERVER_LIBPCIACCESS */
1061
1062         pScrn->chipset = malloc(sizeof(char) * 25);
1063         sprintf(pScrn->chipset, "NVIDIA NV%02X", pNv->NVArch);
1064
1065         if(!pScrn->chipset) {
1066                 pScrn->chipset = "Unknown NVIDIA";
1067         }
1068
1069         /*
1070         * This shouldn't happen because such problems should be caught in
1071         * NVProbe(), but check it just in case.
1072         */
1073         if (pScrn->chipset == NULL)
1074                 NVPreInitFail("ChipID 0x%04X is not recognised\n", pNv->Chipset);
1075
1076         if (pNv->NVArch < 0x04)
1077                 NVPreInitFail("Chipset \"%s\" is not recognised\n", pScrn->chipset);
1078
1079         xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "Chipset: \"%s\"\n", pScrn->chipset);
1080
1081         /* The highest architecture currently supported is NV5x */
1082         if (pNv->NVArch >= 0x80) {
1083                 pNv->Architecture =  NV_ARCH_50;
1084         } else if (pNv->NVArch >= 0x60) {
1085                 pNv->Architecture =  NV_ARCH_40;
1086         } else if (pNv->NVArch >= 0x50) {
1087                 pNv->Architecture =  NV_ARCH_50;
1088         } else if (pNv->NVArch >= 0x40) {
1089                 pNv->Architecture =  NV_ARCH_40;
1090         } else if (pNv->NVArch >= 0x30) {
1091                 pNv->Architecture = NV_ARCH_30;
1092         } else if (pNv->NVArch >= 0x20) {
1093                 pNv->Architecture = NV_ARCH_20;
1094         } else if (pNv->NVArch >= 0x10) {
1095                 pNv->Architecture = NV_ARCH_10;
1096         } else if (pNv->NVArch >= 0x04) {
1097                 pNv->Architecture = NV_ARCH_04;
1098         /*  The lowest architecture currently supported is NV04 */
1099         } else {
1100                 return FALSE;
1101         }
1102
1103         /* Initialize the card through int10 interface if needed */
1104         if (xf86LoadSubModule(pScrn, "int10")) {
1105                 xf86LoaderReqSymLists(int10Symbols, NULL);
1106 #if !defined(__alpha__) && !defined(__powerpc__)
1107                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Initializing int10\n");
1108                 pNv->pInt10 = xf86InitInt10(pNv->pEnt->index);
1109 #endif
1110         }
1111
1112         /* Save current console video mode */
1113         if (pNv->Architecture >= NV_ARCH_50 && pNv->pInt10 && !pNv->kms_enable) {
1114                 const xf86Int10InfoPtr pInt10 = pNv->pInt10;
1115
1116                 pInt10->num = 0x10;
1117                 pInt10->ax  = 0x4f03;
1118                 pInt10->bx  =
1119                 pInt10->cx  =
1120                 pInt10->dx  = 0;
1121                 xf86ExecX86int10(pInt10);
1122                 pNv->Int10Mode = pInt10->bx & 0x3fff;
1123
1124                 xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
1125                            "VESA-HACK: Console VGA mode is 0x%x\n",
1126                            pNv->Int10Mode);
1127         }
1128
1129         xf86SetOperatingState(resVgaIo, pNv->pEnt->index, ResUnusedOpr);
1130         xf86SetOperatingState(resVgaMem, pNv->pEnt->index, ResDisableOpr);
1131
1132         /* Set pScrn->monitor */
1133         pScrn->monitor = pScrn->confScreen->monitor;
1134
1135         /*
1136          * The first thing we should figure out is the depth, bpp, etc.
1137          */
1138
1139         if (!xf86SetDepthBpp(pScrn, 0, 0, 0, Support32bppFb)) {
1140                 NVPreInitFail("\n");
1141         } else {
1142                 /* Check that the returned depth is one we support */
1143                 switch (pScrn->depth) {
1144                         case 16:
1145                         case 24:
1146                                 /* OK */
1147                                 break;
1148                         case 15: /* 15 may get done one day, so leave any code for it in place */
1149                         default:
1150                                 NVPreInitFail("Given depth (%d) is not supported by this driver\n",
1151                                         pScrn->depth);
1152                 }
1153         }
1154         xf86PrintDepthBpp(pScrn);
1155
1156         /*
1157          * This must happen after pScrn->display has been set because
1158          * xf86SetWeight references it.
1159          */
1160         /* The defaults are OK for us */
1161         rgb rgbzeros = {0, 0, 0};
1162
1163         if (!xf86SetWeight(pScrn, rgbzeros, rgbzeros))
1164                 NVPreInitFail("\n");
1165
1166         if (!xf86SetDefaultVisual(pScrn, -1))
1167                 NVPreInitFail("\n");
1168         /* We don't support DirectColor */
1169         else if (pScrn->defaultVisual != TrueColor)
1170                 NVPreInitFail("Given default visual (%s) is not supported at depth %d\n",
1171                               xf86GetVisualName(pScrn->defaultVisual), pScrn->depth);
1172
1173         /* The vgahw module should be loaded here when needed */
1174         if (!xf86LoadSubModule(pScrn, "vgahw")) {
1175                 NVPreInitFail("\n");
1176         }
1177
1178         xf86LoaderReqSymLists(vgahwSymbols, NULL);
1179
1180         /*
1181          * Allocate a vgaHWRec
1182          */
1183         if (!vgaHWGetHWRec(pScrn)) {
1184                 NVPreInitFail("\n");
1185         }
1186
1187         /* We use a programmable clock */
1188         pScrn->progClock = TRUE;
1189
1190         /* Collect all of the relevant option flags (fill in pScrn->options) */
1191         xf86CollectOptions(pScrn, NULL);
1192
1193         /* Process the options */
1194         if (!(pNv->Options = xalloc(sizeof(NVOptions))))
1195                 return FALSE;
1196         memcpy(pNv->Options, NVOptions, sizeof(NVOptions));
1197         xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pNv->Options);
1198
1199         from = X_DEFAULT;
1200
1201         pNv->kms_enable = false;
1202 #ifdef XF86DRM_MODE
1203         if (pNv->Architecture == NV_ARCH_50)
1204                 pNv->kms_enable = nouveau_kernel_modesetting_enabled(pScrn);
1205 #endif /* XF86DRM_MODE */
1206
1207         if (pNv->kms_enable)
1208                 xf86DrvMsg(pScrn->scrnIndex, from, "NV50 Kernel modesetting enabled\n");
1209
1210         pNv->randr12_enable = true;
1211         if (pNv->Architecture != NV_ARCH_50 && !xf86ReturnOptValBool(pNv->Options, OPTION_RANDR12, TRUE))
1212                 pNv->randr12_enable = false;
1213         xf86DrvMsg(pScrn->scrnIndex, from, "Randr1.2 support %sabled\n", pNv->randr12_enable ? "en" : "dis");
1214
1215         pNv->HWCursor = TRUE;
1216         /*
1217          * The preferred method is to use the "hw cursor" option as a tri-state
1218          * option, with the default set above.
1219          */
1220         if (xf86GetOptValBool(pNv->Options, OPTION_HW_CURSOR, &pNv->HWCursor)) {
1221                 from = X_CONFIG;
1222         }
1223         /* For compatibility, accept this too (as an override) */
1224         if (xf86ReturnOptValBool(pNv->Options, OPTION_SW_CURSOR, FALSE)) {
1225                 from = X_CONFIG;
1226                 pNv->HWCursor = FALSE;
1227         }
1228         xf86DrvMsg(pScrn->scrnIndex, from, "Using %s cursor\n",
1229                 pNv->HWCursor ? "HW" : "SW");
1230
1231         pNv->FpScale = TRUE;
1232
1233         if (xf86GetOptValBool(pNv->Options, OPTION_FP_SCALE, &pNv->FpScale)) {
1234                 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Flat panel scaling %s\n",
1235                         pNv->FpScale ? "on" : "off");
1236         }
1237         if (xf86ReturnOptValBool(pNv->Options, OPTION_NOACCEL, FALSE)) {
1238                 pNv->NoAccel = TRUE;
1239                 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Acceleration disabled\n");
1240         }
1241         if (xf86ReturnOptValBool(pNv->Options, OPTION_SHADOW_FB, FALSE)) {
1242                 pNv->ShadowFB = TRUE;
1243                 pNv->NoAccel = TRUE;
1244                 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
1245                         "Using \"Shadow Framebuffer\" - acceleration disabled\n");
1246         }
1247
1248         if(xf86GetOptValInteger(pNv->Options, OPTION_VIDEO_KEY, &(pNv->videoKey))) {
1249                 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "video key set to 0x%x\n",
1250                                         pNv->videoKey);
1251         } else {
1252                 pNv->videoKey =  (1 << pScrn->offset.red) |
1253                                         (1 << pScrn->offset.green) |
1254                 (((pScrn->mask.blue >> pScrn->offset.blue) - 1) << pScrn->offset.blue);
1255         }
1256
1257         /* Things happen on a per output basis for a randr-1.2 driver. */
1258         if (xf86GetOptValBool(pNv->Options, OPTION_FLAT_PANEL, &(pNv->FlatPanel)) && !pNv->randr12_enable) {
1259                 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "forcing %s usage\n",
1260                         pNv->FlatPanel ? "DFP" : "CRTC");
1261         } else {
1262                 pNv->FlatPanel = -1; /* autodetect later */
1263         }
1264
1265         pNv->FPDither = FALSE;
1266         if (xf86GetOptValBool(pNv->Options, OPTION_FP_DITHER, &(pNv->FPDither)))
1267                 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "enabling flat panel dither\n");
1268
1269         if (xf86GetOptValInteger(pNv->Options, OPTION_FP_TWEAK,
1270                                                 &pNv->PanelTweak)) {
1271                 pNv->usePanelTweak = TRUE;
1272         } else {
1273                 pNv->usePanelTweak = FALSE;
1274         }
1275
1276         if (pNv->pEnt->device->MemBase != 0) {
1277                 /* Require that the config file value matches one of the PCI values. */
1278                 if (!xf86CheckPciMemBase(pNv->PciInfo, pNv->pEnt->device->MemBase)) {
1279                         NVPreInitFail(
1280                                 "MemBase 0x%08lX doesn't match any PCI base register.\n",
1281                                 pNv->pEnt->device->MemBase);
1282                 }
1283                 pNv->VRAMPhysical = pNv->pEnt->device->MemBase;
1284                 from = X_CONFIG;
1285         } else {
1286                 if (PCI_DEV_MEM_BASE(pNv->PciInfo, 1) != 0) {
1287                         pNv->VRAMPhysical = PCI_DEV_MEM_BASE(pNv->PciInfo, 1) & 0xff800000;
1288                         from = X_PROBED;
1289                 } else {
1290                         NVPreInitFail("No valid FB address in PCI config space\n");
1291                         return FALSE;
1292                 }
1293         }
1294         xf86DrvMsg(pScrn->scrnIndex, from, "Linear framebuffer at 0x%lX\n",
1295                 (unsigned long)pNv->VRAMPhysical);
1296
1297         if (pNv->pEnt->device->IOBase != 0) {
1298                 /* Require that the config file value matches one of the PCI values. */
1299                 if (!xf86CheckPciMemBase(pNv->PciInfo, pNv->pEnt->device->IOBase)) {
1300                         NVPreInitFail("IOBase 0x%08lX doesn't match any PCI base register.\n",
1301                                 pNv->pEnt->device->IOBase);
1302                 }
1303                 pNv->IOAddress = pNv->pEnt->device->IOBase;
1304                 from = X_CONFIG;
1305         } else {
1306                 if (PCI_DEV_MEM_BASE(pNv->PciInfo, 0) != 0) {
1307                         pNv->IOAddress = PCI_DEV_MEM_BASE(pNv->PciInfo, 0) & 0xffffc000;
1308                         from = X_PROBED;
1309                 } else {
1310                         NVPreInitFail("No valid MMIO address in PCI config space\n");
1311                 }
1312         }
1313         xf86DrvMsg(pScrn->scrnIndex, from, "MMIO registers at 0x%lX\n",
1314                 (unsigned long)pNv->IOAddress);
1315
1316         if (xf86RegisterResources(pNv->pEnt->index, NULL, ResExclusive))
1317                 NVPreInitFail("xf86RegisterResources() found resource conflicts\n");
1318
1319         if (pNv->Architecture < NV_ARCH_10) {
1320                 max_width = (pScrn->bitsPerPixel > 16) ? 2032 : 2048;
1321                 max_height = 2048;
1322         } else if (pNv->Architecture < NV_ARCH_50) {
1323                 max_width = (pScrn->bitsPerPixel > 16) ? 4080 : 4096;
1324                 max_height = 4096;
1325         } else {
1326                 max_width = (pScrn->bitsPerPixel > 16) ? 8176 : 8192;
1327                 max_height = 8192;
1328         }
1329
1330 #ifdef XF86DRM_MODE
1331         if (pNv->kms_enable){
1332                 int res = 0;
1333                 char *bus_id;
1334                 bus_id = DRICreatePCIBusID(pNv->PciInfo);
1335
1336                 pNv->drmmode = calloc(1, sizeof(drmmode_rec));
1337                 res = drmmode_pre_init(pScrn, bus_id, pNv->drmmode, pScrn->bitsPerPixel >> 3);
1338                 if (!res) {
1339                         xfree(bus_id);
1340                         NVPreInitFail("Kernel modesetting failed to initialize\n");
1341                 }
1342         } else
1343 #endif
1344         if (pNv->randr12_enable) {
1345                 /* Allocate an xf86CrtcConfig */
1346                 xf86CrtcConfigInit(pScrn, &nv_xf86crtc_config_funcs);
1347                 xf86CrtcSetSizeRange(pScrn, 320, 200, max_width, max_height);
1348         }
1349
1350         if (NVPreInitDRI(pScrn) == FALSE)
1351                 NVPreInitFail("\n");
1352
1353         if (!pNv->randr12_enable) {
1354                 if ((pScrn->monitor->nHsync == 0) &&
1355                         (pScrn->monitor->nVrefresh == 0)) {
1356
1357                         config_mon_rates = FALSE;
1358                 } else {
1359                         config_mon_rates = TRUE;
1360                 }
1361         }
1362
1363         NVCommonSetup(pScrn);
1364
1365         if (pNv->randr12_enable && !pNv->kms_enable) {
1366                 if (pNv->Architecture == NV_ARCH_50)
1367                         if (!NV50DispPreInit(pScrn))
1368                                 NVPreInitFail("\n");
1369
1370                 NVI2CInit(pScrn);
1371
1372                 /* This is the internal system, not the randr-1.2 ones. */
1373                 if (pNv->Architecture == NV_ARCH_50) {
1374                         NV50CrtcInit(pScrn);
1375                         NV50ConnectorInit(pScrn);
1376                         NV50OutputSetup(pScrn);
1377                 }
1378
1379                 for (i = 0; i <= pNv->twoHeads; i++) {
1380                         if (pNv->Architecture == NV_ARCH_50)
1381                                 nv50_crtc_init(pScrn, i);
1382                         else
1383                                 nv_crtc_init(pScrn, i);
1384                 }
1385
1386                 if (pNv->Architecture < NV_ARCH_50)
1387                         NvSetupOutputs(pScrn);
1388                 else
1389                         nv50_output_create(pScrn); /* create randr-1.2 "outputs". */
1390
1391                 if (!xf86InitialConfiguration(pScrn, FALSE))
1392                         NVPreInitFail("No valid modes.\n");
1393         }
1394
1395         pScrn->videoRam = pNv->RamAmountKBytes;
1396         xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "VideoRAM: %d kBytes\n",
1397                 pScrn->videoRam);
1398
1399         pNv->VRAMPhysicalSize = pScrn->videoRam * 1024;
1400
1401         /*
1402          * If the driver can do gamma correction, it should call xf86SetGamma()
1403          * here.
1404          */
1405         Gamma gammazeros = {0.0, 0.0, 0.0};
1406
1407         if (!xf86SetGamma(pScrn, gammazeros))
1408                 NVPreInitFail("\n");
1409
1410         /*
1411          * Setup the ClockRanges, which describe what clock ranges are available,
1412          * and what sort of modes they can be used for.
1413          */
1414
1415         clockRanges = xnfcalloc(sizeof(ClockRange), 1);
1416         clockRanges->next = NULL;
1417         clockRanges->minClock = pNv->MinVClockFreqKHz;
1418         clockRanges->maxClock = pNv->MaxVClockFreqKHz;
1419         clockRanges->clockIndex = -1;           /* programmable */
1420         clockRanges->doubleScanAllowed = TRUE;
1421         if ((pNv->Architecture == NV_ARCH_20) ||
1422                 ((pNv->Architecture == NV_ARCH_10) &&
1423                 ((pNv->Chipset & 0x0ff0) != CHIPSET_NV10) &&
1424                 ((pNv->Chipset & 0x0ff0) != CHIPSET_NV15))) {
1425                 /* HW is broken */
1426                 clockRanges->interlaceAllowed = FALSE;
1427         } else {
1428                 clockRanges->interlaceAllowed = TRUE;
1429         }
1430
1431         if(pNv->FlatPanel == 1) {
1432                 clockRanges->interlaceAllowed = FALSE;
1433                 clockRanges->doubleScanAllowed = FALSE;
1434         }
1435
1436 #ifdef M_T_DRIVER
1437         /* If DFP, add a modeline corresponding to its panel size */
1438         if (pNv->FlatPanel && !pNv->Television && pNv->fpWidth && pNv->fpHeight) {
1439                 DisplayModePtr Mode;
1440
1441                 Mode = xnfcalloc(1, sizeof(DisplayModeRec));
1442                 Mode = xf86CVTMode(pNv->fpWidth, pNv->fpHeight, 60.00, TRUE, FALSE);
1443                 Mode->type = M_T_DRIVER;
1444                 pScrn->monitor->Modes = xf86ModesAdd(pScrn->monitor->Modes, Mode);
1445
1446                 if (!config_mon_rates) {
1447                         if (!Mode->HSync)
1448                                 Mode->HSync = ((float) Mode->Clock ) / ((float) Mode->HTotal);
1449                         if (!Mode->VRefresh)
1450                                 Mode->VRefresh = (1000.0 * ((float) Mode->Clock)) /
1451                                                         ((float) (Mode->HTotal * Mode->VTotal));
1452
1453                         if (Mode->HSync < pScrn->monitor->hsync[0].lo)
1454                                 pScrn->monitor->hsync[0].lo = Mode->HSync;
1455                         if (Mode->HSync > pScrn->monitor->hsync[0].hi)
1456                                 pScrn->monitor->hsync[0].hi = Mode->HSync;
1457                         if (Mode->VRefresh < pScrn->monitor->vrefresh[0].lo)
1458                                 pScrn->monitor->vrefresh[0].lo = Mode->VRefresh;
1459                         if (Mode->VRefresh > pScrn->monitor->vrefresh[0].hi)
1460                                 pScrn->monitor->vrefresh[0].hi = Mode->VRefresh;
1461
1462                         pScrn->monitor->nHsync = 1;
1463                         pScrn->monitor->nVrefresh = 1;
1464                 }
1465         }
1466 #endif
1467
1468         if (pNv->randr12_enable) {
1469                 pScrn->displayWidth = nv_pitch_align(pNv, pScrn->virtualX, pScrn->depth);
1470         } else {
1471                 /*
1472                  * xf86ValidateModes will check that the mode HTotal and VTotal values
1473                  * don't exceed the chipset's limit if pScrn->maxHValue and
1474                  * pScrn->maxVValue are set.  Since our NVValidMode() already takes
1475                  * care of this, we don't worry about setting them here.
1476                  */
1477                 i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
1478                                         pScrn->display->modes, clockRanges,
1479                                         NULL, 256, max_width,
1480                                         512, 128, max_height,
1481                                         pScrn->display->virtualX,
1482                                         pScrn->display->virtualY,
1483                                         pNv->VRAMPhysicalSize / 2,
1484                                         LOOKUP_BEST_REFRESH);
1485
1486                 if (i == -1) {
1487                         NVPreInitFail("\n");
1488                 }
1489
1490                 /* Prune the modes marked as invalid */
1491                 xf86PruneDriverModes(pScrn);
1492
1493                 /*
1494                  * Set the CRTC parameters for all of the modes based on the type
1495                  * of mode, and the chipset's interlace requirements.
1496                  *
1497                  * Calling this is required if the mode->Crtc* values are used by the
1498                  * driver and if the driver doesn't provide code to set them.  They
1499                  * are not pre-initialised at all.
1500                  */
1501                 xf86SetCrtcForModes(pScrn, 0);
1502
1503                 if (pScrn->modes == NULL)
1504                         NVPreInitFail("No valid modes found\n");
1505         }
1506
1507         /* Set the current mode to the first in the list */
1508         pScrn->currentMode = pScrn->modes;
1509
1510         /* Print the list of modes being used */
1511         xf86PrintModes(pScrn);
1512
1513         /* Set display resolution */
1514         xf86SetDpi(pScrn, 0, 0);
1515
1516         /*
1517          * XXX This should be taken into account in some way in the mode valdation
1518          * section.
1519          */
1520
1521         if (xf86LoadSubModule(pScrn, "fb") == NULL)
1522                 NVPreInitFail("\n");
1523
1524         xf86LoaderReqSymLists(fbSymbols, NULL);
1525
1526         /* Load EXA if needed */
1527         if (!pNv->NoAccel) {
1528                 if (!xf86LoadSubModule(pScrn, "exa")) {
1529                         NVPreInitFail("\n");
1530                 }
1531                 xf86LoaderReqSymLists(exaSymbols, NULL);
1532         }
1533
1534         /* Load ramdac if needed */
1535         if (pNv->HWCursor) {
1536                 if (!xf86LoadSubModule(pScrn, "ramdac")) {
1537                         NVPreInitFail("\n");
1538                 }
1539                 xf86LoaderReqSymLists(ramdacSymbols, NULL);
1540         }
1541
1542         /* Load shadowfb if needed */
1543         if (pNv->ShadowFB) {
1544                 if (!xf86LoadSubModule(pScrn, "shadowfb")) {
1545                         NVPreInitFail("\n");
1546                 }
1547                 xf86LoaderReqSymLists(shadowSymbols, NULL);
1548         }
1549
1550         return TRUE;
1551 }
1552
1553
1554 /*
1555  * Map the framebuffer and MMIO memory.
1556  */
1557
1558 static Bool
1559 NVMapMem(ScrnInfoPtr pScrn)
1560 {
1561         NVPtr pNv = NVPTR(pScrn);
1562         int gart_scratch_size;
1563         uint64_t res;
1564
1565         nouveau_device_get_param(pNv->dev, NOUVEAU_GETPARAM_FB_SIZE, &res);
1566         pNv->VRAMSize=res;
1567         nouveau_device_get_param(pNv->dev, NOUVEAU_GETPARAM_FB_PHYSICAL, &res);
1568         pNv->VRAMPhysical=res;
1569         nouveau_device_get_param(pNv->dev, NOUVEAU_GETPARAM_AGP_SIZE, &res);
1570         pNv->AGPSize=res;
1571
1572         if (pNv->AGPSize) {
1573                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1574                            "AGPGART: %dMiB available\n",
1575                            (unsigned int)(pNv->AGPSize >> 20));
1576                 if (pNv->AGPSize > (16*1024*1024))
1577                         gart_scratch_size = 16*1024*1024;
1578                 else
1579                         /* always leave 512kb for other things like the fifos */
1580                         gart_scratch_size = pNv->AGPSize - 512*1024;
1581         } else {
1582                 gart_scratch_size = (4 << 20) - (1 << 18) ;
1583                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1584                            "GART: PCI DMA - using %dKiB\n",
1585                            gart_scratch_size >> 10);
1586         }
1587
1588         if (nouveau_bo_new(pNv->dev, NOUVEAU_BO_GART | NOUVEAU_BO_PIN, 0,
1589                            gart_scratch_size, &pNv->GART)) {
1590                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1591                            "Unable to allocate GART memory\n");
1592         }
1593         if (pNv->GART) {
1594                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1595                            "GART: Allocated %dMiB as a scratch buffer\n",
1596                            (unsigned int)(pNv->GART->size >> 20));
1597         }
1598
1599         if (nouveau_bo_new(pNv->dev, NOUVEAU_BO_VRAM | NOUVEAU_BO_PIN, 0,
1600                            64 * 1024, &pNv->Cursor)) {
1601                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1602                            "Failed to allocate memory for hardware cursor\n");
1603                 return FALSE;
1604         }
1605
1606         if (pNv->randr12_enable) {
1607                 if (nouveau_bo_new(pNv->dev, NOUVEAU_BO_VRAM | NOUVEAU_BO_PIN, 0,
1608                         64 * 1024, &pNv->Cursor2)) {
1609                         xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1610                                 "Failed to allocate memory for hardware cursor\n");
1611                         return FALSE;
1612                 }
1613         }
1614
1615         if (pNv->Architecture >= NV_ARCH_50) {
1616                 /* Both CRTC's have a CLUT. */
1617                 if (nouveau_bo_new(pNv->dev, NOUVEAU_BO_VRAM | NOUVEAU_BO_PIN,
1618                                    0, 0x1000, &pNv->CLUT0)) {
1619                         xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1620                                    "Failed to allocate memory for CLUT0\n");
1621                         return FALSE;
1622                 }
1623
1624                 if (nouveau_bo_new(pNv->dev, NOUVEAU_BO_VRAM | NOUVEAU_BO_PIN,
1625                                    0, 0x1000, &pNv->CLUT1)) {
1626                         xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1627                                    "Failed to allocate memory for CLUT1\n");
1628                         return FALSE;
1629                 }
1630         }
1631
1632         if ((pNv->CLUT0 && nouveau_bo_map(pNv->CLUT0, NOUVEAU_BO_RDWR)) ||
1633             (pNv->CLUT1 && nouveau_bo_map(pNv->CLUT1, NOUVEAU_BO_RDWR)) ||
1634             nouveau_bo_map(pNv->Cursor, NOUVEAU_BO_RDWR) ||
1635             (pNv->randr12_enable && nouveau_bo_map(pNv->Cursor2, NOUVEAU_BO_RDWR))) {
1636                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1637                            "Failed to map pinned buffers\n");
1638                 return FALSE;
1639         }
1640
1641         return TRUE;
1642 }
1643
1644 /*
1645  * Unmap the framebuffer and MMIO memory.
1646  */
1647
1648 static Bool
1649 NVUnmapMem(ScrnInfoPtr pScrn)
1650 {
1651         NVPtr pNv = NVPTR(pScrn);
1652
1653         nouveau_bo_ref(NULL, &pNv->xv_filtertable_mem);
1654         if (pNv->blitAdaptor)
1655                 NVFreePortMemory(pScrn, GET_BLIT_PRIVATE(pNv));
1656         if (pNv->textureAdaptor[0])
1657                 NVFreePortMemory(pScrn, pNv->textureAdaptor[0]->pPortPrivates[0].ptr);
1658         if (pNv->textureAdaptor[1])
1659                 NVFreePortMemory(pScrn, pNv->textureAdaptor[1]->pPortPrivates[0].ptr);
1660
1661         nouveau_bo_ref(NULL, &pNv->FB);
1662         nouveau_bo_ref(NULL, &pNv->GART);
1663         nouveau_bo_ref(NULL, &pNv->Cursor);
1664         if (pNv->randr12_enable)
1665                 nouveau_bo_ref(NULL, &pNv->Cursor2);
1666         nouveau_bo_ref(NULL, &pNv->CLUT0);
1667         nouveau_bo_ref(NULL, &pNv->CLUT1);
1668
1669         return TRUE;
1670 }
1671
1672
1673 /*
1674  * Initialise a new mode.
1675  */
1676
1677 static Bool
1678 NVModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
1679 {
1680     vgaHWPtr hwp = VGAHWPTR(pScrn);
1681     vgaRegPtr vgaReg;
1682     NVPtr pNv = NVPTR(pScrn);
1683     NVRegPtr nvReg;
1684
1685     /* Initialise the ModeReg values */
1686     if (!vgaHWInit(pScrn, mode))
1687         return FALSE;
1688     pScrn->vtSema = TRUE;
1689
1690     vgaReg = &hwp->ModeReg;
1691     nvReg = &pNv->ModeReg;
1692
1693     if(!NVDACInit(pScrn, mode))
1694         return FALSE;
1695
1696     NVLockUnlock(pScrn, 0);
1697     if(pNv->twoHeads) {
1698         nvWriteCurVGA(pNv, NV_CIO_CRE_44, nvReg->crtcOwner);
1699         NVLockUnlock(pScrn, 0);
1700     }
1701
1702     /* Program the registers */
1703     vgaHWProtect(pScrn, TRUE);
1704
1705     NVDACRestore(pScrn, vgaReg, nvReg, FALSE);
1706
1707 #if X_BYTE_ORDER == X_BIG_ENDIAN
1708     /* turn on LFB swapping */
1709     {
1710         unsigned char tmp;
1711
1712         tmp = nvReadCurVGA(pNv, NV_CIO_CRE_RCR);
1713         tmp |= (1 << 7);
1714         nvWriteCurVGA(pNv, NV_CIO_CRE_RCR, tmp);
1715     }
1716 #endif
1717
1718     if (!pNv->NoAccel)
1719                 NVAccelCommonInit(pScrn);
1720
1721     vgaHWProtect(pScrn, FALSE);
1722
1723     pScrn->currentMode = mode;
1724
1725     return TRUE;
1726 }
1727
1728 /*
1729  * Restore the initial (text) mode.
1730  */
1731 static void
1732 NVRestore(ScrnInfoPtr pScrn)
1733 {
1734         NVPtr pNv = NVPTR(pScrn);
1735
1736         if (pNv->randr12_enable) {
1737                 xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
1738                 int i;
1739
1740                 for (i = 0; i < xf86_config->num_crtc; i++)
1741                         NVCrtcLockUnlock(xf86_config->crtc[i], 0);
1742
1743                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Restoring encoders\n");
1744                 for (i = 0; i < pNv->dcb_table.entries; i++)
1745                         nv_encoder_restore(pScrn, &pNv->encoders[i]);
1746
1747                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Restoring crtcs\n");
1748                 for (i = 0; i < xf86_config->num_crtc; i++)
1749                         xf86_config->crtc[i]->funcs->restore(xf86_config->crtc[i]);
1750
1751                 nv_save_restore_vga_fonts(pScrn, 0);
1752
1753                 for (i = 0; i < xf86_config->num_crtc; i++)
1754                         NVCrtcLockUnlock(xf86_config->crtc[i], 1);
1755         } else {
1756                 vgaHWPtr hwp = VGAHWPTR(pScrn);
1757                 vgaRegPtr vgaReg = &hwp->SavedReg;
1758                 NVRegPtr nvReg = &pNv->SavedReg;
1759
1760                 NVLockUnlock(pScrn, 0);
1761
1762                 if(pNv->twoHeads) {
1763                         nvWriteCurVGA(pNv, NV_CIO_CRE_44, pNv->crtc_active[1] * 0x3);
1764                         NVLockUnlock(pScrn, 0);
1765                 }
1766
1767                 /* Only restore text mode fonts/text for the primary card */
1768                 vgaHWProtect(pScrn, TRUE);
1769                 NVDACRestore(pScrn, vgaReg, nvReg, pNv->Primary);
1770                 vgaHWProtect(pScrn, FALSE);
1771         }
1772
1773         if (pNv->twoHeads) {
1774                 NVLockVgaCrtc(pNv, 0, false);
1775                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Restoring CRTC_OWNER to %d.\n", pNv->vtOWNER);
1776                 NVSetOwner(pNv, pNv->vtOWNER);
1777                 NVLockVgaCrtc(pNv, 0, true);
1778         }
1779 }
1780
1781 static void
1782 NVLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
1783               LOCO * colors, VisualPtr pVisual)
1784 {
1785         xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
1786         int c;
1787         int i, j, index;
1788         CARD16 lut_r[256], lut_g[256], lut_b[256];
1789
1790         for (c = 0; c < xf86_config->num_crtc; c++) {
1791                 xf86CrtcPtr crtc = xf86_config->crtc[c];
1792
1793                 /* code borrowed from intel driver */
1794                 switch (pScrn->depth) {
1795                 case 15:
1796                         for (i = 0; i < numColors; i++) {
1797                                 index = indices[i];
1798                                 for (j = 0; j < 8; j++) {
1799                                         lut_r[index * 8 + j] = colors[index].red << 8;
1800                                         lut_g[index * 8 + j] = colors[index].green << 8;
1801                                         lut_b[index * 8 + j] = colors[index].blue << 8;
1802                                 }
1803                         }
1804                 case 16:
1805                         for (i = 0; i < numColors; i++) {
1806                                 index = indices[i];
1807
1808                                 if (i <= 31) {
1809                                         for (j = 0; j < 8; j++) {
1810                                                 lut_r[index * 8 + j] = colors[index].red << 8;
1811                                                 lut_b[index * 8 + j] = colors[index].blue << 8;
1812                                         }
1813                                 }
1814
1815                                 for (j = 0; j < 4; j++) {
1816                                         lut_g[index * 4 + j] = colors[index].green << 8;
1817                                 }
1818                         }
1819                 default:
1820                         for (i = 0; i < numColors; i++) {
1821                                 index = indices[i];
1822                                 lut_r[index] = colors[index].red << 8;
1823                                 lut_g[index] = colors[index].green << 8;
1824                                 lut_b[index] = colors[index].blue << 8;
1825                         }
1826                         break;
1827                 }
1828
1829                 /* Make the change through RandR */
1830                 RRCrtcGammaSet(crtc->randr_crtc, lut_r, lut_g, lut_b);
1831         }
1832 }
1833
1834 static void NVBacklightEnable(NVPtr pNv,  Bool on)
1835 {
1836     /* This is done differently on each laptop.  Here we
1837        define the ones we know for sure. */
1838
1839 #if defined(__powerpc__)
1840     if((pNv->Chipset & 0xffff == 0x0179) ||
1841        (pNv->Chipset & 0xffff == 0x0189) ||
1842        (pNv->Chipset & 0xffff == 0x0329))
1843     {
1844        /* NV17,18,34 Apple iMac, iBook, PowerBook */
1845       CARD32 tmp_pmc, tmp_pcrt;
1846       tmp_pmc = nvReadMC(pNv, NV_PBUS_DEBUG_DUALHEAD_CTL) & 0x7FFFFFFF;
1847       tmp_pcrt = NVReadCRTC(pNv, 0, NV_CRTC_GPIO_EXT) & 0xFFFFFFFC;
1848       if(on) {
1849           tmp_pmc |= (1 << 31);
1850           tmp_pcrt |= 0x1;
1851       }
1852       nvWriteMC(pNv, NV_PBUS_DEBUG_DUALHEAD_CTL, tmp_pmc);
1853       NVWriteCRTC(pNv, 0, NV_CRTC_GPIO_EXT, tmp_pcrt);
1854     }
1855 #endif
1856
1857     if(pNv->LVDS) {
1858        if(pNv->twoHeads && ((pNv->Chipset & 0x0ff0) != CHIPSET_NV11)) {
1859            nvWriteMC(pNv, 0x130C, on ? 3 : 7);
1860        }
1861     } else {
1862        CARD32 fpcontrol;
1863
1864        fpcontrol = nvReadCurRAMDAC(pNv, NV_RAMDAC_FP_CONTROL) & 0xCfffffCC;
1865
1866        /* cut the TMDS output */
1867        if(on) fpcontrol |= pNv->fpSyncs;
1868        else fpcontrol |= 0x20000022;
1869
1870        nvWriteCurRAMDAC(pNv, NV_RAMDAC_FP_CONTROL, fpcontrol);
1871     }
1872 }
1873
1874 static void
1875 NVDPMSSetLCD(ScrnInfoPtr pScrn, int PowerManagementMode, int flags)
1876 {
1877   NVPtr pNv = NVPTR(pScrn);
1878
1879   if (!pScrn->vtSema) return;
1880
1881   vgaHWDPMSSet(pScrn, PowerManagementMode, flags);
1882
1883   switch (PowerManagementMode) {
1884   case DPMSModeStandby:  /* HSync: Off, VSync: On */
1885   case DPMSModeSuspend:  /* HSync: On, VSync: Off */
1886   case DPMSModeOff:      /* HSync: Off, VSync: Off */
1887     NVBacklightEnable(pNv, 0);
1888     break;
1889   case DPMSModeOn:       /* HSync: On, VSync: On */
1890     NVBacklightEnable(pNv, 1);
1891   default:
1892     break;
1893   }
1894 }
1895
1896
1897 static void
1898 NVDPMSSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags)
1899 {
1900   unsigned char crtc1A;
1901   vgaHWPtr hwp = VGAHWPTR(pScrn);
1902
1903   if (!pScrn->vtSema) return;
1904
1905   crtc1A = hwp->readCrtc(hwp, 0x1A) & ~0xC0;
1906
1907   switch (PowerManagementMode) {
1908   case DPMSModeStandby:  /* HSync: Off, VSync: On */
1909     crtc1A |= 0x80;
1910     break;
1911   case DPMSModeSuspend:  /* HSync: On, VSync: Off */
1912     crtc1A |= 0x40;
1913     break;
1914   case DPMSModeOff:      /* HSync: Off, VSync: Off */
1915     crtc1A |= 0xC0;
1916     break;
1917   case DPMSModeOn:       /* HSync: On, VSync: On */
1918   default:
1919     break;
1920   }
1921
1922   /* vgaHWDPMSSet will merely cut the dac output */
1923   vgaHWDPMSSet(pScrn, PowerManagementMode, flags);
1924
1925   hwp->writeCrtc(hwp, 0x1A, crtc1A);
1926 }
1927
1928
1929 /* Mandatory */
1930
1931 /* This gets called at the start of each server generation */
1932
1933 static Bool
1934 NVScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
1935 {
1936         ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
1937         vgaHWPtr hwp = VGAHWPTR(pScrn);
1938         NVPtr pNv = NVPTR(pScrn);
1939         int ret;
1940         VisualPtr visual;
1941         unsigned char *FBStart;
1942         int displayWidth;
1943
1944         /* Map the VGA memory when the primary video */
1945         if (pNv->Primary) {
1946                 hwp->MapSize = 0x10000;
1947                 if (!vgaHWMapMem(pScrn))
1948                         return FALSE;
1949         }
1950
1951         /* First init DRI/DRM */
1952         if (!NVDRIScreenInit(pScrn))
1953                 return FALSE;
1954         nouveau_dri2_init(pScreen);
1955
1956         /* Allocate and map memory areas we need */
1957         if (!NVMapMem(pScrn))
1958                 return FALSE;
1959
1960         if (!pNv->NoAccel) {
1961                 /* Init DRM - Alloc FIFO */
1962                 if (!NVInitDma(pScrn))
1963                         return FALSE;
1964
1965                 /* setup graphics objects */
1966                 if (!NVAccelCommonInit(pScrn))
1967                         return FALSE;
1968         }
1969
1970         if (nouveau_bo_new(pNv->dev, NOUVEAU_BO_VRAM | NOUVEAU_BO_PIN, 0,
1971                            NOUVEAU_ALIGN(pScrn->virtualX, 64) *
1972                            NOUVEAU_ALIGN(pScrn->virtualY, 64) *
1973                            (pScrn->bitsPerPixel >> 3), &pNv->FB)) {
1974                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1975                            "Failed to allocate memory for screen pixmap.\n");
1976                 return FALSE;
1977         }
1978
1979         nouveau_bo_map(pNv->FB, NOUVEAU_BO_RDWR);
1980         pNv->FBMap = pNv->FB->map;
1981         nouveau_bo_unmap(pNv->FB);
1982
1983 #ifdef XF86DRM_MODE
1984         if (pNv->kms_enable)
1985                 drmmode_set_fb(pScrn, pNv->drmmode, pScrn->virtualX, pScrn->virtualY, pScrn->displayWidth*(pScrn->bitsPerPixel >> 3), pNv->FB);
1986 #endif
1987
1988         if (!pNv->randr12_enable) {
1989                 /* Save the current state */
1990                 NVSave(pScrn);
1991                 /* Initialise the first mode */
1992                 if (!NVModeInit(pScrn, pScrn->currentMode))
1993                         return FALSE;
1994
1995                 /* Darken the screen for aesthetic reasons and set the viewport */
1996                 NVSaveScreen(pScreen, SCREEN_SAVER_ON);
1997                 pScrn->AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
1998         } else {
1999                 xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
2000                 int i;
2001
2002                 /* need to point to new screen on server regeneration */
2003                 for (i = 0; i < xf86_config->num_crtc; i++)
2004                         xf86_config->crtc[i]->scrn = pScrn;
2005                 for (i = 0; i < xf86_config->num_output; i++)
2006                         xf86_config->output[i]->scrn = pScrn;
2007
2008                 pScrn->memPhysBase = pNv->VRAMPhysical;
2009                 pScrn->fbOffset = 0;
2010
2011                 if (!NVEnterVT(scrnIndex, 0))
2012                         return FALSE;
2013                 NVSaveScreen(pScreen, SCREEN_SAVER_ON);
2014         }
2015
2016
2017         /*
2018          * The next step is to setup the screen's visuals, and initialise the
2019          * framebuffer code.  In cases where the framebuffer's default
2020          * choices for things like visual layouts and bits per RGB are OK,
2021          * this may be as simple as calling the framebuffer's ScreenInit()
2022          * function.  If not, the visuals will need to be setup before calling
2023          * a fb ScreenInit() function and fixed up after.
2024          *
2025          * For most PC hardware at depths >= 8, the defaults that fb uses
2026          * are not appropriate.  In this driver, we fixup the visuals after.
2027          */
2028
2029         /*
2030          * Reset the visual list.
2031          */
2032         miClearVisualTypes();
2033
2034         /* Setup the visuals we support. */
2035
2036         if (!miSetVisualTypes(pScrn->depth,
2037                                 miGetDefaultVisualMask(pScrn->depth), 8,
2038                                 pScrn->defaultVisual))
2039                 return FALSE;
2040         if (!miSetPixmapDepths ())
2041                 return FALSE;
2042
2043         /*
2044          * Call the framebuffer layer's ScreenInit function, and fill in other
2045          * pScreen fields.
2046          */
2047
2048         if (pNv->ShadowFB) {
2049                 pNv->ShadowPitch = BitmapBytePad(pScrn->bitsPerPixel * pScrn->virtualX);
2050                 pNv->ShadowPtr = xalloc(pNv->ShadowPitch * pScrn->virtualY);
2051                 displayWidth = pNv->ShadowPitch / (pScrn->bitsPerPixel >> 3);
2052                 FBStart = pNv->ShadowPtr;
2053         } else {
2054                 pNv->ShadowPtr = NULL;
2055                 displayWidth = pScrn->displayWidth;
2056                 nouveau_bo_map(pNv->FB, NOUVEAU_BO_RDWR);
2057                 FBStart = pNv->FB->map;
2058                 nouveau_bo_unmap(pNv->FB);
2059         }
2060
2061         switch (pScrn->bitsPerPixel) {
2062                 case 16:
2063                 case 32:
2064                         ret = fbScreenInit(pScreen, FBStart, pScrn->virtualX, pScrn->virtualY,
2065                                 pScrn->xDpi, pScrn->yDpi,
2066                                 displayWidth, pScrn->bitsPerPixel);
2067                         break;
2068                 default:
2069                         xf86DrvMsg(scrnIndex, X_ERROR,
2070                                 "Internal error: invalid bpp (%d) in NVScreenInit\n",
2071                                 pScrn->bitsPerPixel);
2072                         ret = FALSE;
2073                         break;
2074         }
2075         if (!ret)
2076                 return FALSE;
2077
2078         /* Fixup RGB ordering */
2079         visual = pScreen->visuals + pScreen->numVisuals;
2080         while (--visual >= pScreen->visuals) {
2081                 if ((visual->class | DynamicClass) == DirectColor) {
2082                         visual->offsetRed = pScrn->offset.red;
2083                         visual->offsetGreen = pScrn->offset.green;
2084                         visual->offsetBlue = pScrn->offset.blue;
2085                         visual->redMask = pScrn->mask.red;
2086                         visual->greenMask = pScrn->mask.green;
2087                         visual->blueMask = pScrn->mask.blue;
2088                 }
2089         }
2090
2091         fbPictureInit (pScreen, 0, 0);
2092
2093         xf86SetBlackWhitePixels(pScreen);
2094
2095         if (!pNv->NoAccel) {
2096                 if (!NVExaInit(pScreen))
2097                         return FALSE;
2098         } else if (pNv->VRAMPhysicalSize / 2 < NOUVEAU_ALIGN(pScrn->virtualX, 64) * NOUVEAU_ALIGN(pScrn->virtualY, 64) * (pScrn->bitsPerPixel >> 3)) {
2099                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "The virtual screen size's resolution is too big for the video RAM framebuffer at this colour depth.\n");
2100                 return FALSE;
2101         }
2102
2103
2104         miInitializeBackingStore(pScreen);
2105         xf86SetBackingStore(pScreen);
2106         xf86SetSilkenMouse(pScreen);
2107
2108         /* Finish DRI init */
2109         NVDRIFinishScreenInit(pScrn);
2110
2111         /*
2112          * Initialize software cursor.
2113          * Must precede creation of the default colormap.
2114          */
2115         miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
2116
2117         /*
2118          * Initialize HW cursor layer.
2119          * Must follow software cursor initialization.
2120          */
2121         if (pNv->HWCursor) {
2122                 if (pNv->Architecture < NV_ARCH_50 && !pNv->randr12_enable)
2123                         ret = NVCursorInit(pScreen);
2124                 else if (pNv->Architecture < NV_ARCH_50 && pNv->randr12_enable)
2125                         ret = NVCursorInitRandr12(pScreen);
2126                 else
2127                         ret = NV50CursorInit(pScreen);
2128
2129                 if (ret != TRUE) {
2130                         xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
2131                                 "Hardware cursor initialization failed\n");
2132                         pNv->HWCursor = FALSE;
2133                 }
2134         }
2135
2136         if (pNv->randr12_enable) {
2137                 xf86DPMSInit(pScreen, xf86DPMSSet, 0);
2138
2139                 if (!xf86CrtcScreenInit(pScreen))
2140                         return FALSE;
2141         }
2142
2143         /* Initialise default colourmap */
2144         if (!miCreateDefColormap(pScreen))
2145                 return FALSE;
2146
2147         /*
2148          * Initialize colormap layer.
2149          * Must follow initialization of the default colormap
2150          */
2151         if (!pNv->randr12_enable && !pNv->kms_enable) {
2152                 if(!xf86HandleColormaps(pScreen, 256, 8, NVDACLoadPalette,
2153                                 NULL, CMAP_RELOAD_ON_MODE_SWITCH | CMAP_PALETTED_TRUECOLOR))
2154                         return FALSE;
2155         } else {
2156                 if (!xf86HandleColormaps(pScreen, 256, 8, NVLoadPalette,
2157                                 NULL, CMAP_PALETTED_TRUECOLOR))
2158                         return FALSE;
2159         }
2160
2161         if (pNv->ShadowFB)
2162                 ShadowFBInit(pScreen, NVRefreshArea);
2163
2164         if (!pNv->randr12_enable) {
2165                 if(pNv->FlatPanel) {
2166                         xf86DPMSInit(pScreen, NVDPMSSetLCD, 0);
2167                 } else {
2168                         xf86DPMSInit(pScreen, NVDPMSSet, 0);
2169                 }
2170         }
2171
2172         pScrn->memPhysBase = pNv->VRAMPhysical;
2173         pScrn->fbOffset = 0;
2174
2175         NVInitVideo(pScreen);
2176
2177         pScreen->SaveScreen = NVSaveScreen;
2178
2179         /* Wrap the current CloseScreen function */
2180         pNv->CloseScreen = pScreen->CloseScreen;
2181         pScreen->CloseScreen = NVCloseScreen;
2182
2183         pNv->BlockHandler = pScreen->BlockHandler;
2184         pScreen->BlockHandler = NVBlockHandler;
2185
2186         /* Report any unused options (only for the first generation) */
2187         if (serverGeneration == 1)
2188                 xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
2189
2190         return TRUE;
2191 }
2192
2193 static Bool
2194 NVSaveScreen(ScreenPtr pScreen, int mode)
2195 {
2196         ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
2197         NVPtr pNv = NVPTR(pScrn);
2198         bool on = xf86IsUnblank(mode);
2199         int i;
2200
2201         if (!pNv->randr12_enable)
2202                 return vgaHWSaveScreen(pScreen, mode);
2203
2204         if (pScrn->vtSema && pNv->Architecture < NV_ARCH_50) {
2205                 xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
2206
2207                 for (i = 0; i < xf86_config->num_crtc; i++) {
2208                         struct nouveau_crtc *nv_crtc = to_nouveau_crtc(xf86_config->crtc[i]);
2209
2210                         if (xf86_config->crtc[i]->enabled)
2211                                 NVBlankScreen(pNv, nv_crtc->head, !on);
2212                 }
2213         }
2214
2215         return TRUE;
2216 }
2217
2218 static void
2219 NVSave(ScrnInfoPtr pScrn)
2220 {
2221         NVPtr pNv = NVPTR(pScrn);
2222         NVRegPtr nvReg = &pNv->SavedReg;
2223
2224         if (pNv->randr12_enable) {
2225                 xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
2226                 int i;
2227
2228                 nv_save_restore_vga_fonts(pScrn, 1);
2229
2230                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Saving crtcs\n");
2231                 for (i = 0; i < xf86_config->num_crtc; i++)
2232                         xf86_config->crtc[i]->funcs->save(xf86_config->crtc[i]);
2233
2234                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Saving encoders\n");
2235                 for (i = 0; i < pNv->dcb_table.entries; i++)
2236                         nv_encoder_save(pScrn, &pNv->encoders[i]);
2237         } else {
2238                 vgaHWPtr pVga = VGAHWPTR(pScrn);
2239                 vgaRegPtr vgaReg = &pVga->SavedReg;
2240                 NVLockUnlock(pScrn, 0);
2241                 if (pNv->twoHeads) {
2242                         nvWriteCurVGA(pNv, NV_CIO_CRE_44, pNv->crtc_active[1] * 0x3);
2243                         NVLockUnlock(pScrn, 0);
2244                 }
2245
2246                 NVDACSave(pScrn, vgaReg, nvReg, pNv->Primary);
2247         }
2248 }