NV50: rename G80* to NV50*

8 files changed, 196 insertions, 191 deletions

diff --git a/src/nv50_cursor.c b/src/nv50_cursor.c
index 4c3a44a..9b51afa 100644
--- a/src/nv50_cursor.c
+++ b/src/nv50_cursor.c
@@ -36,10 +36,10 @@
 
 #define CURSOR_PTR ((CARD32*)pNv->Cursor->map)
 
-void G80SetCursorPosition(xf86CrtcPtr crtc, int x, int y)
+void NV50SetCursorPosition(xf86CrtcPtr crtc, int x, int y)
 {
     NVPtr pNv = NVPTR(crtc->scrn);
-    const int headOff = 0x1000*G80CrtcGetHead(crtc);
+    const int headOff = 0x1000*NV50CrtcGetHead(crtc);
 
     x &= 0xffff;
     y &= 0xffff;
@@ -47,7 +47,7 @@ void G80SetCursorPosition(xf86CrtcPtr crtc, int x, int y)
     pNv->REGS[(0x00647080 + headOff)/4] = 0;
 }
 
-void G80LoadCursorARGB(xf86CrtcPtr crtc, CARD32 *src)
+void NV50LoadCursorARGB(xf86CrtcPtr crtc, CARD32 *src)
 {
     NVPtr pNv = NVPTR(crtc->scrn);
     CARD32 *dst = CURSOR_PTR;
@@ -56,7 +56,7 @@ void G80LoadCursorARGB(xf86CrtcPtr crtc, CARD32 *src)
     memcpy(dst, src, 64 * 64 * 4);
 }
 
-Bool G80CursorAcquire(ScrnInfoPtr pScrn)
+Bool NV50CursorAcquire(ScrnInfoPtr pScrn)
 {
     NVPtr pNv = NVPTR(pScrn);
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
@@ -66,7 +66,7 @@ Bool G80CursorAcquire(ScrnInfoPtr pScrn)
 
     /* Initialize the cursor on each head */
     for(i = 0; i < xf86_config->num_crtc; i++) {
-        const int headOff = 0x10 * G80CrtcGetHead(xf86_config->crtc[i]);
+        const int headOff = 0x10 * NV50CrtcGetHead(xf86_config->crtc[i]);
 
         pNv->REGS[(0x00610270+headOff)/4] = 0x2000;
         while(pNv->REGS[(0x00610270+headOff)/4] & 0x30000);
@@ -78,7 +78,7 @@ Bool G80CursorAcquire(ScrnInfoPtr pScrn)
     return TRUE;
 }
 
-void G80CursorRelease(ScrnInfoPtr pScrn)
+void NV50CursorRelease(ScrnInfoPtr pScrn)
 {
     NVPtr pNv = NVPTR(pScrn);
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
@@ -88,14 +88,14 @@ void G80CursorRelease(ScrnInfoPtr pScrn)
 
     /* Release the cursor on each head */
     for(i = 0; i < xf86_config->num_crtc; i++) {
-        const int headOff = 0x10 * G80CrtcGetHead(xf86_config->crtc[i]);
+        const int headOff = 0x10 * NV50CrtcGetHead(xf86_config->crtc[i]);
 
         pNv->REGS[(0x00610270+headOff)/4] = 0;
         while(pNv->REGS[(0x00610270+headOff)/4] & 0x30000);
     }
 }
 
-Bool G80CursorInit(ScreenPtr pScreen)
+Bool NV50CursorInit(ScreenPtr pScreen)
 {
     return xf86_cursors_init(pScreen, 64, 64,
             HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
diff --git a/src/nv50_cursor.h b/src/nv50_cursor.h
index 4d81d80..c856780 100644
--- a/src/nv50_cursor.h
+++ b/src/nv50_cursor.h
@@ -1,7 +1,12 @@
-Bool G80CursorInit(ScreenPtr);
-Bool G80CursorAcquire(ScrnInfoPtr);
-void G80CursorRelease(ScrnInfoPtr);
+#ifndef __NV50_CURSOR_H__
+#define __NV50_CURSOR_H__
+
+Bool NV50CursorInit(ScreenPtr);
+Bool NV50CursorAcquire(ScrnInfoPtr);
+void NV50CursorRelease(ScrnInfoPtr);
 
 /* CRTC cursor functions */
-void G80SetCursorPosition(xf86CrtcPtr crtc, int x, int y);
-void G80LoadCursorARGB(xf86CrtcPtr crtc, CARD32 *src);
+void NV50SetCursorPosition(xf86CrtcPtr crtc, int x, int y);
+void NV50LoadCursorARGB(xf86CrtcPtr crtc, CARD32 *src);
+
+#endif
diff --git a/src/nv50_dac.c b/src/nv50_dac.c
index 2ce8346..fcb4e97 100644
--- a/src/nv50_dac.c
+++ b/src/nv50_dac.c
@@ -35,20 +35,20 @@
 #include "nv50_output.h"
 
 static void
-G80DacSetPClk(xf86OutputPtr output, int pclk)
+NV50DacSetPClk(xf86OutputPtr output, int pclk)
 {
     NVPtr pNv = NVPTR(output->scrn);
-    G80OutputPrivPtr pPriv = output->driver_private;
+    NV50OutputPrivPtr pPriv = output->driver_private;
     const int orOff = 0x800 * pPriv->or;
 
     pNv->REGS[(0x00614280+orOff)/4] = 0;
 }
 
 static void
-G80DacDPMSSet(xf86OutputPtr output, int mode)
+NV50DacDPMSSet(xf86OutputPtr output, int mode)
 {
     NVPtr pNv = NVPTR(output->scrn);
-    G80OutputPrivPtr pPriv = output->driver_private;
+    NV50OutputPrivPtr pPriv = output->driver_private;
     const int off = 0x800 * pPriv->or;
     CARD32 tmp;
 
@@ -77,11 +77,11 @@ G80DacDPMSSet(xf86OutputPtr output, int mode)
 }
 
 static void
-G80DacModeSet(xf86OutputPtr output, DisplayModePtr mode,
+NV50DacModeSet(xf86OutputPtr output, DisplayModePtr mode,
               DisplayModePtr adjusted_mode)
 {
     ScrnInfoPtr pScrn = output->scrn;
-    G80OutputPrivPtr pPriv = output->driver_private;
+    NV50OutputPrivPtr pPriv = output->driver_private;
     const int dacOff = 0x80 * pPriv->or;
 
     if(!adjusted_mode) {
@@ -90,12 +90,12 @@ G80DacModeSet(xf86OutputPtr output, DisplayModePtr mode,
     }
 
     // This wouldn't be necessary, but the server is stupid and calls
-    // G80DacDPMSSet after the output is disconnected, even though the hardware
+    // NV50DacDPMSSet after the output is disconnected, even though the hardware
     // turns it off automatically.
-    G80DacDPMSSet(output, DPMSModeOn);
+    NV50DacDPMSSet(output, DPMSModeOn);
 
     C(0x00000400 + dacOff,
-        (G80CrtcGetHead(output->crtc) == HEAD0 ? 1 : 2) | 0x40);
+        (NV50CrtcGetHead(output->crtc) == HEAD0 ? 1 : 2) | 0x40);
     C(0x00000404 + dacOff,
         (adjusted_mode->Flags & V_NHSYNC) ? 1 : 0 |
         (adjusted_mode->Flags & V_NVSYNC) ? 2 : 0);
@@ -105,24 +105,24 @@ G80DacModeSet(xf86OutputPtr output, DisplayModePtr mode,
  * Perform DAC load detection to determine if there is a connected display.
  */
 static xf86OutputStatus
-G80DacDetect(xf86OutputPtr output)
+NV50DacDetect(xf86OutputPtr output)
 {
-    G80OutputPrivPtr pPriv = output->driver_private;
+    NV50OutputPrivPtr pPriv = output->driver_private;
 
     /* Assume physical status isn't going to change before the BlockHandler */
     if(pPriv->cached_status != XF86OutputStatusUnknown)
         return pPriv->cached_status;
 
-    G80OutputPartnersDetect(output, pPriv->partner, pPriv->i2c);
+    NV50OutputPartnersDetect(output, pPriv->partner, pPriv->i2c);
     return pPriv->cached_status;
 }
 
 Bool
-G80DacLoadDetect(xf86OutputPtr output)
+NV50DacLoadDetect(xf86OutputPtr output)
 {
     ScrnInfoPtr pScrn = output->scrn;
     NVPtr pNv = NVPTR(pScrn);
-    G80OutputPrivPtr pPriv = output->driver_private;
+    NV50OutputPrivPtr pPriv = output->driver_private;
     const int scrnIndex = pScrn->scrnIndex;
     const int dacOff = 2048 * pPriv->or;
     CARD32 load, tmp, tmp2;
@@ -152,32 +152,32 @@ G80DacLoadDetect(xf86OutputPtr output)
 }
 
 static void
-G80DacDestroy(xf86OutputPtr output)
+NV50DacDestroy(xf86OutputPtr output)
 {
-    G80OutputDestroy(output);
+    NV50OutputDestroy(output);
 
     xfree(output->driver_private);
     output->driver_private = NULL;
 }
 
-static const xf86OutputFuncsRec G80DacOutputFuncs = {
-    .dpms = G80DacDPMSSet,
+static const xf86OutputFuncsRec NV50DacOutputFuncs = {
+    .dpms = NV50DacDPMSSet,
     .save = NULL,
     .restore = NULL,
-    .mode_valid = G80OutputModeValid,
-    .mode_fixup = G80OutputModeFixup,
-    .prepare = G80OutputPrepare,
-    .commit = G80OutputCommit,
-    .mode_set = G80DacModeSet,
-    .detect = G80DacDetect,
-    .get_modes = G80OutputGetDDCModes,
-    .destroy = G80DacDestroy,
+    .mode_valid = NV50OutputModeValid,
+    .mode_fixup = NV50OutputModeFixup,
+    .prepare = NV50OutputPrepare,
+    .commit = NV50OutputCommit,
+    .mode_set = NV50DacModeSet,
+    .detect = NV50DacDetect,
+    .get_modes = NV50OutputGetDDCModes,
+    .destroy = NV50DacDestroy,
 };
 
 xf86OutputPtr
-G80CreateDac(ScrnInfoPtr pScrn, ORNum or)
+NV50CreateDac(ScrnInfoPtr pScrn, ORNum or)
 {
-    G80OutputPrivPtr pPriv = xnfcalloc(sizeof(*pPriv), 1);
+    NV50OutputPrivPtr pPriv = xnfcalloc(sizeof(*pPriv), 1);
     xf86OutputPtr output;
     char orName[5];
 
@@ -185,12 +185,12 @@ G80CreateDac(ScrnInfoPtr pScrn, ORNum or)
         return FALSE;
 
     snprintf(orName, 5, "VGA%i", or);
-    output = xf86OutputCreate(pScrn, &G80DacOutputFuncs, orName);
+    output = xf86OutputCreate(pScrn, &NV50DacOutputFuncs, orName);
 
     pPriv->type = DAC;
     pPriv->or = or;
     pPriv->cached_status = XF86OutputStatusUnknown;
-    pPriv->set_pclk = G80DacSetPClk;
+    pPriv->set_pclk = NV50DacSetPClk;
     output->driver_private = pPriv;
     output->interlaceAllowed = TRUE;
     output->doubleScanAllowed = TRUE;
diff --git a/src/nv50_display.c b/src/nv50_display.c
index a1d531b..912179d 100644
--- a/src/nv50_display.c
+++ b/src/nv50_display.c
@@ -37,19 +37,19 @@
 #include "nv50_display.h"
 #include "nv50_output.h"
 
-typedef struct G80CrtcPrivRec {
+typedef struct NV50CrtcPrivRec {
     Head head;
     int pclk; /* Target pixel clock in kHz */
     Bool cursorVisible;
-} G80CrtcPrivRec, *G80CrtcPrivPtr;
+} NV50CrtcPrivRec, *NV50CrtcPrivPtr;
 
-static void G80CrtcShowHideCursor(xf86CrtcPtr crtc, Bool show, Bool update);
+static void NV50CrtcShowHideCursor(xf86CrtcPtr crtc, Bool show, Bool update);
 
 /*
  * PLL calculation.  pclk is in kHz.
  */
 static void
-G80CalcPLL(float pclk, int *pNA, int *pMA, int *pNB, int *pMB, int *pP)
+NV50CalcPLL(float pclk, int *pNA, int *pMA, int *pNB, int *pMB, int *pP)
 {
     const float refclk = 27000.0f;
     const float minVcoA = 100000;
@@ -145,10 +145,10 @@ G80CalcPLL(float pclk, int *pNA, int *pMA, int *pNB, int *pMB, int *pP)
 }
 
 static void
-G80CrtcSetPClk(xf86CrtcPtr crtc)
+NV50CrtcSetPClk(xf86CrtcPtr crtc)
 {
     NVPtr pNv = NVPTR(crtc->scrn);
-    G80CrtcPrivPtr pPriv = crtc->driver_private;
+    NV50CrtcPrivPtr pPriv = crtc->driver_private;
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
     const int headOff = 0x800 * pPriv->head;
     int lo_n, lo_m, hi_n, hi_m, p, i;
@@ -159,7 +159,7 @@ G80CrtcSetPClk(xf86CrtcPtr crtc)
     lo &= 0xff00ff00;
     hi &= 0x8000ff00;
 
-    G80CalcPLL(pPriv->pclk, &lo_n, &lo_m, &hi_n, &hi_m, &p);
+    NV50CalcPLL(pPriv->pclk, &lo_n, &lo_m, &hi_n, &hi_m, &p);
 
     lo |= (lo_m << 16) | lo_n;
     hi |= (p << 28) | (hi_m << 16) | hi_n;
@@ -172,12 +172,12 @@ G80CrtcSetPClk(xf86CrtcPtr crtc)
 
         if(output->crtc != crtc)
             continue;
-        G80OutputSetPClk(output, pPriv->pclk);
+        NV50OutputSetPClk(output, pPriv->pclk);
     }
 }
 
 void
-G80DispCommand(ScrnInfoPtr pScrn, CARD32 addr, CARD32 data)
+NV50DispCommand(ScrnInfoPtr pScrn, CARD32 addr, CARD32 data)
 {
     NVPtr pNv = NVPTR(pScrn);
 
@@ -196,10 +196,10 @@ G80DispCommand(ScrnInfoPtr pScrn, CARD32 addr, CARD32 data)
                 for(i = 0; i < xf86_config->num_crtc; i++)
                 {
                     xf86CrtcPtr crtc = xf86_config->crtc[i];
-                    G80CrtcPrivPtr pPriv = crtc->driver_private;
+                    NV50CrtcPrivPtr pPriv = crtc->driver_private;
 
                     if(r & (0x200 << pPriv->head))
-                        G80CrtcSetPClk(crtc);
+                        NV50CrtcSetPClk(crtc);
                 }
             }
 
@@ -210,14 +210,14 @@ G80DispCommand(ScrnInfoPtr pScrn, CARD32 addr, CARD32 data)
 }
 
 Head
-G80CrtcGetHead(xf86CrtcPtr crtc)
+NV50CrtcGetHead(xf86CrtcPtr crtc)
 {
-    G80CrtcPrivPtr pPriv = crtc->driver_private;
+    NV50CrtcPrivPtr pPriv = crtc->driver_private;
     return pPriv->head;
 }
 
 Bool
-G80DispPreInit(ScrnInfoPtr pScrn)
+NV50DispPreInit(ScrnInfoPtr pScrn)
 {
     NVPtr pNv = NVPTR(pScrn);
 
@@ -254,7 +254,7 @@ G80DispPreInit(ScrnInfoPtr pScrn)
 }
 
 Bool
-G80DispInit(ScrnInfoPtr pScrn)
+NV50DispInit(ScrnInfoPtr pScrn)
 {
     NVPtr pNv = NVPTR(pScrn);
 
@@ -281,7 +281,7 @@ G80DispInit(ScrnInfoPtr pScrn)
 }
 
 void
-G80DispShutdown(ScrnInfoPtr pScrn)
+NV50DispShutdown(ScrnInfoPtr pScrn)
 {
     NVPtr pNv = NVPTR(pScrn);
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
@@ -290,7 +290,7 @@ G80DispShutdown(ScrnInfoPtr pScrn)
     for(i = 0; i < xf86_config->num_crtc; i++) {
         xf86CrtcPtr crtc = xf86_config->crtc[i];
 
-        G80CrtcBlankScreen(crtc, TRUE);
+        NV50CrtcBlankScreen(crtc, TRUE);
     }
 
     C(0x00000080, 0);
@@ -299,7 +299,7 @@ G80DispShutdown(ScrnInfoPtr pScrn)
         xf86CrtcPtr crtc = xf86_config->crtc[i];
 
         if(crtc->enabled) {
-            const CARD32 mask = 4 << G80CrtcGetHead(crtc);
+            const CARD32 mask = 4 << NV50CrtcGetHead(crtc);
 
             pNv->REGS[0x00610024/4] = mask;
             while(!(pNv->REGS[0x00610024/4] & mask));
@@ -312,7 +312,7 @@ G80DispShutdown(ScrnInfoPtr pScrn)
 }
 
 static Bool
-G80CrtcModeFixup(xf86CrtcPtr crtc,
+NV50CrtcModeFixup(xf86CrtcPtr crtc,
                  DisplayModePtr mode, DisplayModePtr adjusted_mode)
 {
     // TODO: Fix up the mode here
@@ -320,16 +320,16 @@ G80CrtcModeFixup(xf86CrtcPtr crtc,
 }
 
 static void
-G80CrtcModeSet(xf86CrtcPtr crtc, DisplayModePtr mode,
+NV50CrtcModeSet(xf86CrtcPtr crtc, DisplayModePtr mode,
                DisplayModePtr adjusted_mode, int x, int y)
 {
     ScrnInfoPtr pScrn = crtc->scrn;
-    G80CrtcPrivPtr pPriv = crtc->driver_private;
+    NV50CrtcPrivPtr pPriv = crtc->driver_private;
     const int HDisplay = mode->HDisplay, VDisplay = mode->VDisplay;
-    const int headOff = 0x400 * G80CrtcGetHead(crtc);
+    const int headOff = 0x400 * NV50CrtcGetHead(crtc);
     int interlaceDiv, fudge;
 
-    // TODO: Use adjusted_mode and fix it up in G80CrtcModeFixup
+    // TODO: Use adjusted_mode and fix it up in NV50CrtcModeFixup
     pPriv->pclk = mode->Clock;
 
     /* Magic mode timing fudge factor */
@@ -377,19 +377,19 @@ G80CrtcModeSet(xf86CrtcPtr crtc, DisplayModePtr mode,
     C(0x000008D8 + headOff, mode->CrtcVDisplay << 16 | mode->CrtcHDisplay);
     C(0x000008DC + headOff, mode->CrtcVDisplay << 16 | mode->CrtcHDisplay);
 
-    G80CrtcBlankScreen(crtc, FALSE);
+    NV50CrtcBlankScreen(crtc, FALSE);
 }
 
 void
-G80CrtcBlankScreen(xf86CrtcPtr crtc, Bool blank)
+NV50CrtcBlankScreen(xf86CrtcPtr crtc, Bool blank)
 {
     ScrnInfoPtr pScrn = crtc->scrn;
     NVPtr pNv = NVPTR(pScrn);
-    G80CrtcPrivPtr pPriv = crtc->driver_private;
+    NV50CrtcPrivPtr pPriv = crtc->driver_private;
     const int headOff = 0x400 * pPriv->head;
 
     if(blank) {
-        G80CrtcShowHideCursor(crtc, FALSE, FALSE);
+        NV50CrtcShowHideCursor(crtc, FALSE, FALSE);
 
         C(0x00000840 + headOff, 0);
         C(0x00000844 + headOff, 0);
@@ -412,7 +412,7 @@ G80CrtcBlankScreen(xf86CrtcPtr crtc, Bool blank)
         if(pNv->_Chipset != 0x50)
             C(0x0000089C + headOff, 1);
         if(pPriv->cursorVisible)
-            G80CrtcShowHideCursor(crtc, TRUE, FALSE);
+            NV50CrtcShowHideCursor(crtc, TRUE, FALSE);
         C(0x00000840 + headOff, pScrn->depth == 8 ? 0x80000000 : 0xc0000000);
         C(0x00000844 + headOff, (pNv->RamAmountKBytes * 1024 - 0x5000) >> 8);
         if(pNv->_Chipset != 0x50)
@@ -422,16 +422,16 @@ G80CrtcBlankScreen(xf86CrtcPtr crtc, Bool blank)
 }
 
 void
-G80CrtcDPMSSet(xf86CrtcPtr crtc, int mode)
+NV50CrtcDPMSSet(xf86CrtcPtr crtc, int mode)
 {
 }
 
 /******************************** Cursor stuff ********************************/
-static void G80CrtcShowHideCursor(xf86CrtcPtr crtc, Bool show, Bool update)
+static void NV50CrtcShowHideCursor(xf86CrtcPtr crtc, Bool show, Bool update)
 {
     ScrnInfoPtr pScrn = crtc->scrn;
-    G80CrtcPrivPtr pPriv = crtc->driver_private;
-    const int headOff = 0x400 * G80CrtcGetHead(crtc);
+    NV50CrtcPrivPtr pPriv = crtc->driver_private;
+    const int headOff = 0x400 * NV50CrtcGetHead(crtc);
 
     C(0x00000880 + headOff, show ? 0x85000000 : 0x5000000);
     if(update) {
@@ -440,26 +440,26 @@ static void G80CrtcShowHideCursor(xf86CrtcPtr crtc, Bool show, Bool update)
     }
 }
 
-void G80CrtcShowCursor(xf86CrtcPtr crtc)
+void NV50CrtcShowCursor(xf86CrtcPtr crtc)
 {
-    G80CrtcShowHideCursor(crtc, TRUE, TRUE);
+    NV50CrtcShowHideCursor(crtc, TRUE, TRUE);
 }
 
-void G80CrtcHideCursor(xf86CrtcPtr crtc)
+void NV50CrtcHideCursor(xf86CrtcPtr crtc)
 {
-    G80CrtcShowHideCursor(crtc, FALSE, TRUE);
+    NV50CrtcShowHideCursor(crtc, FALSE, TRUE);
 }
 
 /******************************** CRTC stuff ********************************/
 
 static Bool
-G80CrtcLock(xf86CrtcPtr crtc)
+NV50CrtcLock(xf86CrtcPtr crtc)
 {
     return FALSE;
 }
 
 static void
-G80CrtcPrepare(xf86CrtcPtr crtc)
+NV50CrtcPrepare(xf86CrtcPtr crtc)
 {
     ScrnInfoPtr pScrn = crtc->scrn;
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
@@ -474,7 +474,7 @@ G80CrtcPrepare(xf86CrtcPtr crtc)
 }
 
 static void
-G80CrtcCommit(xf86CrtcPtr crtc)
+NV50CrtcCommit(xf86CrtcPtr crtc)
 {
     ScrnInfoPtr pScrn = crtc->scrn;
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
@@ -486,50 +486,50 @@ G80CrtcCommit(xf86CrtcPtr crtc)
 
         if(output->crtc)
             /* XXXagp: This assumes that xf86_config->crtc[i] is HEADi */
-            crtc_mask |= 1 << G80CrtcGetHead(output->crtc);
+            crtc_mask |= 1 << NV50CrtcGetHead(output->crtc);
     }
 
     for(i = 0; i < xf86_config->num_crtc; i++)
         if(!((1 << i) & crtc_mask))
-            G80CrtcBlankScreen(xf86_config->crtc[i], TRUE);
+            NV50CrtcBlankScreen(xf86_config->crtc[i], TRUE);
 
     C(0x00000080, 0);
 }
 
-static const xf86CrtcFuncsRec g80_crtc_funcs = {
-    .dpms = G80CrtcDPMSSet,
+static const xf86CrtcFuncsRec nv50_crtc_funcs = {
+    .dpms = NV50CrtcDPMSSet,
     .save = NULL,
     .restore = NULL,
-    .lock = G80CrtcLock,
+    .lock = NV50CrtcLock,
     .unlock = NULL,
-    .mode_fixup = G80CrtcModeFixup,
-    .prepare = G80CrtcPrepare,
-    .mode_set = G80CrtcModeSet,
-    // .gamma_set = G80DispGammaSet,
-    .commit = G80CrtcCommit,
+    .mode_fixup = NV50CrtcModeFixup,
+    .prepare = NV50CrtcPrepare,
+    .mode_set = NV50CrtcModeSet,
+    // .gamma_set = NV50DispGammaSet,
+    .commit = NV50CrtcCommit,
     .shadow_create = NULL,
     .shadow_destroy = NULL,
-    .set_cursor_position = G80SetCursorPosition,
-    .show_cursor = G80CrtcShowCursor,
-    .hide_cursor = G80CrtcHideCursor,
-    .load_cursor_argb = G80LoadCursorARGB,
+    .set_cursor_position = NV50SetCursorPosition,
+    .show_cursor = NV50CrtcShowCursor,
+    .hide_cursor = NV50CrtcHideCursor,
+    .load_cursor_argb = NV50LoadCursorARGB,
     .destroy = NULL,
 };
 
 void
-G80DispCreateCrtcs(ScrnInfoPtr pScrn)
+NV50DispCreateCrtcs(ScrnInfoPtr pScrn)
 {
     Head head;
     xf86CrtcPtr crtc;
-    G80CrtcPrivPtr g80_crtc;
+    NV50CrtcPrivPtr nv50_crtc;
 
     /* Create a "crtc" object for each head */
     for(head = HEAD0; head <= HEAD1; head++) {
-        crtc = xf86CrtcCreate(pScrn, &g80_crtc_funcs);
+        crtc = xf86CrtcCreate(pScrn, &nv50_crtc_funcs);
         if(!crtc) return;
 
-        g80_crtc = xnfcalloc(sizeof(*g80_crtc), 1);
-        g80_crtc->head = head;
-        crtc->driver_private = g80_crtc;
+        nv50_crtc = xnfcalloc(sizeof(*nv50_crtc), 1);
+        nv50_crtc->head = head;
+        crtc->driver_private = nv50_crtc;
     }
 }
diff --git a/src/nv50_display.h b/src/nv50_display.h
index c0b2e19..4f43e32 100644
--- a/src/nv50_display.h
+++ b/src/nv50_display.h
@@ -3,20 +3,20 @@
 
 #include "nv50_type.h"
 
-Bool G80DispPreInit(ScrnInfoPtr);
-Bool G80DispInit(ScrnInfoPtr);
-void G80DispShutdown(ScrnInfoPtr);
+Bool NV50DispPreInit(ScrnInfoPtr);
+Bool NV50DispInit(ScrnInfoPtr);
+void NV50DispShutdown(ScrnInfoPtr);
 
-void G80DispCommand(ScrnInfoPtr, CARD32 addr, CARD32 data);
-#define C(mthd, data) G80DispCommand(pScrn, (mthd), (data))
+void NV50DispCommand(ScrnInfoPtr, CARD32 addr, CARD32 data);
+#define C(mthd, data) NV50DispCommand(pScrn, (mthd), (data))
 
-Head G80CrtcGetHead(xf86CrtcPtr);
+Head NV50CrtcGetHead(xf86CrtcPtr);
 
-void G80CrtcBlankScreen(xf86CrtcPtr, Bool blank);
-void G80CrtcEnableCursor(xf86CrtcPtr, Bool update);
-void G80CrtcDisableCursor(xf86CrtcPtr, Bool update);
-void G80CrtcSetCursorPosition(xf86CrtcPtr, int x, int y);
+void NV50CrtcBlankScreen(xf86CrtcPtr, Bool blank);
+void NV50CrtcEnableCursor(xf86CrtcPtr, Bool update);
+void NV50CrtcDisableCursor(xf86CrtcPtr, Bool update);
+void NV50CrtcSetCursorPosition(xf86CrtcPtr, int x, int y);
 
-void G80DispCreateCrtcs(ScrnInfoPtr pScrn);
+void NV50DispCreateCrtcs(ScrnInfoPtr pScrn);
 
 #endif
diff --git a/src/nv50_output.c b/src/nv50_output.c
index fc14f19..7c5e3f4 100644
--- a/src/nv50_output.c
+++ b/src/nv50_output.c
@@ -52,7 +52,7 @@ NV50GetVBIOSImage(NVPtr pNv)
 	return (unsigned const char *)VBIOS;
 }
 
-static Bool G80ReadPortMapping(int scrnIndex, NVPtr pNv)
+static Bool NV50ReadPortMapping(int scrnIndex, NVPtr pNv)
 {
     unsigned const char *VBIOS;
     unsigned char *table2;
@@ -132,7 +132,7 @@ fail:
     return FALSE;
 }
 
-static void G80_I2CPutBits(I2CBusPtr b, int clock, int data)
+static void NV50_I2CPutBits(I2CBusPtr b, int clock, int data)
 {
     NVPtr pNv = NVPTR(xf86Screens[b->scrnIndex]);
     const int off = b->DriverPrivate.val * 0x18;
@@ -140,7 +140,7 @@ static void G80_I2CPutBits(I2CBusPtr b, int clock, int data)
     pNv->REGS[(0x0000E138+off)/4] = 4 | clock | data << 1;
 }
 
-static void G80_I2CGetBits(I2CBusPtr b, int *clock, int *data)
+static void NV50_I2CGetBits(I2CBusPtr b, int *clock, int *data)
 {
     NVPtr pNv = NVPTR(xf86Screens[b->scrnIndex]);
     const int off = b->DriverPrivate.val * 0x18;
@@ -152,7 +152,7 @@ static void G80_I2CGetBits(I2CBusPtr b, int *clock, int *data)
 }
 
 static I2CBusPtr
-G80I2CInit(ScrnInfoPtr pScrn, const char *name, const int port)
+NV50I2CInit(ScrnInfoPtr pScrn, const char *name, const int port)
 {
     I2CBusPtr i2c;
 
@@ -162,8 +162,8 @@ G80I2CInit(ScrnInfoPtr pScrn, const char *name, const int port)
 
     i2c->BusName = strdup(name);
     i2c->scrnIndex = pScrn->scrnIndex;
-    i2c->I2CPutBits = G80_I2CPutBits;
-    i2c->I2CGetBits = G80_I2CGetBits;
+    i2c->I2CPutBits = NV50_I2CPutBits;
+    i2c->I2CGetBits = NV50_I2CGetBits;
     i2c->ByteTimeout = 2200; /* VESA DDC spec 3 p. 43 (+10 %) */
     i2c->StartTimeout = 550;
     i2c->BitTimeout = 40;
@@ -180,14 +180,14 @@ G80I2CInit(ScrnInfoPtr pScrn, const char *name, const int port)
 }
 
 void
-G80OutputSetPClk(xf86OutputPtr output, int pclk)
+NV50OutputSetPClk(xf86OutputPtr output, int pclk)
 {
-    G80OutputPrivPtr pPriv = output->driver_private;
+    NV50OutputPrivPtr pPriv = output->driver_private;
     pPriv->set_pclk(output, pclk);
 }
 
 int
-G80OutputModeValid(xf86OutputPtr output, DisplayModePtr mode)
+NV50OutputModeValid(xf86OutputPtr output, DisplayModePtr mode)
 {
     if(mode->Clock > 400000 || mode->Clock < 25000)
         return MODE_CLOCK_RANGE;
@@ -196,19 +196,19 @@ G80OutputModeValid(xf86OutputPtr output, DisplayModePtr mode)
 }
 
 Bool
-G80OutputModeFixup(xf86OutputPtr output, DisplayModePtr mode,
+NV50OutputModeFixup(xf86OutputPtr output, DisplayModePtr mode,
                    DisplayModePtr adjusted_mode)
 {
     return TRUE;
 }
 
 void
-G80OutputPrepare(xf86OutputPtr output)
+NV50OutputPrepare(xf86OutputPtr output)
 {
 }
 
 void
-G80OutputCommit(xf86OutputPtr output)
+NV50OutputCommit(xf86OutputPtr output)
 {
 }
 
@@ -244,14 +244,14 @@ ProbeDDC(I2CBusPtr i2c)
  * present) to see if the display is connected via VGA.  Sets the cached status
  * of both outputs.  The status is marked dirty again in the BlockHandler.
  */
-void G80OutputPartnersDetect(xf86OutputPtr dac, xf86OutputPtr sor, I2CBusPtr i2c)
+void NV50OutputPartnersDetect(xf86OutputPtr dac, xf86OutputPtr sor, I2CBusPtr i2c)
 {
     xf86MonPtr monInfo = ProbeDDC(i2c);
     xf86OutputPtr connected = NULL;
-    Bool load = dac && G80DacLoadDetect(dac);
+    Bool load = dac && NV50DacLoadDetect(dac);
 
     if(dac) {
-        G80OutputPrivPtr pPriv = dac->driver_private;
+        NV50OutputPrivPtr pPriv = dac->driver_private;
 
         if(load) {
             pPriv->cached_status = XF86OutputStatusConnected;
@@ -262,7 +262,7 @@ void G80OutputPartnersDetect(xf86OutputPtr dac, xf86OutputPtr sor, I2CBusPtr i2c
     }
 
     if(sor) {
-        G80OutputPrivPtr pPriv = sor->driver_private;
+        NV50OutputPrivPtr pPriv = sor->driver_private;
 
         if(monInfo && !load) {
             pPriv->cached_status = XF86OutputStatusConnected;
@@ -277,22 +277,22 @@ void G80OutputPartnersDetect(xf86OutputPtr dac, xf86OutputPtr sor, I2CBusPtr i2c
 }
 
 /*
- * Reset the cached output status for all outputs.  Called from G80BlockHandler.
+ * Reset the cached output status for all outputs.  Called from NV50BlockHandler.
  */
 void
-G80OutputResetCachedStatus(ScrnInfoPtr pScrn)
+NV50OutputResetCachedStatus(ScrnInfoPtr pScrn)
 {
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
     int i;
 
     for(i = 0; i < xf86_config->num_output; i++) {
-        G80OutputPrivPtr pPriv = xf86_config->output[i]->driver_private;
+        NV50OutputPrivPtr pPriv = xf86_config->output[i]->driver_private;
         pPriv->cached_status = XF86OutputStatusUnknown;
     }
 }
 
 DisplayModePtr
-G80OutputGetDDCModes(xf86OutputPtr output)
+NV50OutputGetDDCModes(xf86OutputPtr output)
 {
     /* The EDID is read as part of the detect step */
     output->funcs->detect(output);
@@ -300,25 +300,25 @@ G80OutputGetDDCModes(xf86OutputPtr output)
 }
 
 void
-G80OutputDestroy(xf86OutputPtr output)
+NV50OutputDestroy(xf86OutputPtr output)
 {
-    G80OutputPrivPtr pPriv = output->driver_private;
+    NV50OutputPrivPtr pPriv = output->driver_private;
 
     if(pPriv->partner)
-        ((G80OutputPrivPtr)pPriv->partner->driver_private)->partner = NULL;
+        ((NV50OutputPrivPtr)pPriv->partner->driver_private)->partner = NULL;
     else
         xf86DestroyI2CBusRec(pPriv->i2c, TRUE, TRUE);
     pPriv->i2c = NULL;
 }
 
 Bool
-G80CreateOutputs(ScrnInfoPtr pScrn)
+NV50CreateOutputs(ScrnInfoPtr pScrn)
 {
     NVPtr pNv = NVPTR(pScrn);
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
     int i;
 
-    if(!G80ReadPortMapping(pScrn->scrnIndex, pNv))
+    if(!NV50ReadPortMapping(pScrn->scrnIndex, pNv))
         return FALSE;
 
     /* For each DDC port, create an output for the attached ORs */
@@ -332,7 +332,7 @@ G80CreateOutputs(ScrnInfoPtr pScrn)
             continue;
 
         snprintf(i2cName, sizeof(i2cName), "I2C%i", i);
-        i2c = G80I2CInit(pScrn, i2cName, i);
+        i2c = NV50I2CInit(pScrn, i2cName, i);
         if(!i2c) {
             xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
                        "Failed to initialize I2C for port %i.\n",
@@ -341,18 +341,18 @@ G80CreateOutputs(ScrnInfoPtr pScrn)
         }
 
         if(pNv->i2cMap[i].dac != -1)
-            dac = G80CreateDac(pScrn, pNv->i2cMap[i].dac);
+            dac = NV50CreateDac(pScrn, pNv->i2cMap[i].dac);
         if(pNv->i2cMap[i].sor != -1)
-            sor = G80CreateSor(pScrn, pNv->i2cMap[i].sor);
+            sor = NV50CreateSor(pScrn, pNv->i2cMap[i].sor);
 
         if(dac) {
-            G80OutputPrivPtr pPriv = dac->driver_private;
+            NV50OutputPrivPtr pPriv = dac->driver_private;
 
             pPriv->partner = sor;
             pPriv->i2c = i2c;
         }
         if(sor) {
-            G80OutputPrivPtr pPriv = sor->driver_private;
+            NV50OutputPrivPtr pPriv = sor->driver_private;
 
             pPriv->partner = dac;
             pPriv->i2c = i2c;
diff --git a/src/nv50_output.h b/src/nv50_output.h
index ce100ea..4fac55a 100644
--- a/src/nv50_output.h
+++ b/src/nv50_output.h
@@ -1,7 +1,7 @@
 #ifndef __NV50_OUTPUT_H__
 #define __NV50_OUTPUT_H__
 
-typedef struct G80OutputPrivRec {
+typedef struct NV50OutputPrivRec {
     ORType type;
     ORNum or;
 
@@ -11,24 +11,24 @@ typedef struct G80OutputPrivRec {
     xf86OutputStatus cached_status;
 
     void (*set_pclk)(xf86OutputPtr, int pclk);
-} G80OutputPrivRec, *G80OutputPrivPtr;
-
-void G80OutputSetPClk(xf86OutputPtr, int pclk);
-int G80OutputModeValid(xf86OutputPtr, DisplayModePtr);
-Bool G80OutputModeFixup(xf86OutputPtr, DisplayModePtr mode, DisplayModePtr adjusted_mode);
-void G80OutputPrepare(xf86OutputPtr);
-void G80OutputCommit(xf86OutputPtr);
-void G80OutputPartnersDetect(xf86OutputPtr dac, xf86OutputPtr sor, I2CBusPtr i2c);
-void G80OutputResetCachedStatus(ScrnInfoPtr);
-DisplayModePtr G80OutputGetDDCModes(xf86OutputPtr);
-void G80OutputDestroy(xf86OutputPtr);
-Bool G80CreateOutputs(ScrnInfoPtr);
-
-/* g80_dac.c */
-xf86OutputPtr G80CreateDac(ScrnInfoPtr, ORNum);
-Bool G80DacLoadDetect(xf86OutputPtr);
-
-/* g80_sor.c */
-xf86OutputPtr G80CreateSor(ScrnInfoPtr, ORNum);
+} NV50OutputPrivRec, *NV50OutputPrivPtr;
+
+void NV50OutputSetPClk(xf86OutputPtr, int pclk);
+int NV50OutputModeValid(xf86OutputPtr, DisplayModePtr);
+Bool NV50OutputModeFixup(xf86OutputPtr, DisplayModePtr mode, DisplayModePtr adjusted_mode);
+void NV50OutputPrepare(xf86OutputPtr);
+void NV50OutputCommit(xf86OutputPtr);
+void NV50OutputPartnersDetect(xf86OutputPtr dac, xf86OutputPtr sor, I2CBusPtr i2c);
+void NV50OutputResetCachedStatus(ScrnInfoPtr);
+DisplayModePtr NV50OutputGetDDCModes(xf86OutputPtr);
+void NV50OutputDestroy(xf86OutputPtr);
+Bool NV50CreateOutputs(ScrnInfoPtr);
+
+/* nv50_dac.c */
+xf86OutputPtr NV50CreateDac(ScrnInfoPtr, ORNum);
+Bool NV50DacLoadDetect(xf86OutputPtr);
+
+/* nv50_sor.c */
+xf86OutputPtr NV50CreateSor(ScrnInfoPtr, ORNum);
 
 #endif
diff --git a/src/nv50_sor.c b/src/nv50_sor.c
index 3181991..d33bf4c 100644
--- a/src/nv50_sor.c
+++ b/src/nv50_sor.c
@@ -34,20 +34,20 @@
 #include "nv50_output.h"
 
 static void
-G80SorSetPClk(xf86OutputPtr output, int pclk)
+NV50SorSetPClk(xf86OutputPtr output, int pclk)
 {
     NVPtr pNv = NVPTR(output->scrn);
-    G80OutputPrivPtr pPriv = output->driver_private;
+    NV50OutputPrivPtr pPriv = output->driver_private;
     const int orOff = 0x800 * pPriv->or;
 
     pNv->REGS[(0x00614300+orOff)/4] = (pclk > 165000) ? 0x101 : 0;
 }
 
 static void
-G80SorDPMSSet(xf86OutputPtr output, int mode)
+NV50SorDPMSSet(xf86OutputPtr output, int mode)
 {
     NVPtr pNv = NVPTR(output->scrn);
-    G80OutputPrivPtr pPriv = output->driver_private;
+    NV50OutputPrivPtr pPriv = output->driver_private;
     const int off = 0x800 * pPriv->or;
     CARD32 tmp;
 
@@ -65,11 +65,11 @@ G80SorDPMSSet(xf86OutputPtr output, int mode)
 }
 
 static void
-G80SorModeSet(xf86OutputPtr output, DisplayModePtr mode,
+NV50SorModeSet(xf86OutputPtr output, DisplayModePtr mode,
               DisplayModePtr adjusted_mode)
 {
     ScrnInfoPtr pScrn = output->scrn;
-    G80OutputPrivPtr pPriv = output->driver_private;
+    NV50OutputPrivPtr pPriv = output->driver_private;
     const int sorOff = 0x40 * pPriv->or;
 
     if(!adjusted_mode) {
@@ -79,58 +79,58 @@ G80SorModeSet(xf86OutputPtr output, DisplayModePtr mode,
     }
 
     // This wouldn't be necessary, but the server is stupid and calls
-    // G80SorDPMSSet after the output is disconnected, even though the hardware
+    // NV50SorDPMSSet after the output is disconnected, even though the hardware
     // turns it off automatically.
-    G80SorDPMSSet(output, DPMSModeOn);
+    NV50SorDPMSSet(output, DPMSModeOn);
 
     C(0x00000600 + sorOff,
-        (G80CrtcGetHead(output->crtc) == HEAD0 ? 1 : 2) |
+        (NV50CrtcGetHead(output->crtc) == HEAD0 ? 1 : 2) |
         (adjusted_mode->Clock > 165000 ? 0x500 : 0x100) |
         ((adjusted_mode->Flags & V_NHSYNC) ? 0x1000 : 0) |
         ((adjusted_mode->Flags & V_NVSYNC) ? 0x2000 : 0));
 }
 
 static xf86OutputStatus
-G80SorDetect(xf86OutputPtr output)
+NV50SorDetect(xf86OutputPtr output)
 {
 
-    G80OutputPrivPtr pPriv = output->driver_private;
+    NV50OutputPrivPtr pPriv = output->driver_private;
 
     /* Assume physical status isn't going to change before the BlockHandler */
     if(pPriv->cached_status != XF86OutputStatusUnknown)
         return pPriv->cached_status;
 
-    G80OutputPartnersDetect(pPriv->partner, output, pPriv->i2c);
+    NV50OutputPartnersDetect(pPriv->partner, output, pPriv->i2c);
     return pPriv->cached_status;
 }
 
 static void
-G80SorDestroy(xf86OutputPtr output)
+NV50SorDestroy(xf86OutputPtr output)
 {
-    G80OutputDestroy(output);
+    NV50OutputDestroy(output);
 
     xfree(output->driver_private);
     output->driver_private = NULL;
 }
 
-static const xf86OutputFuncsRec G80SorOutputFuncs = {
-    .dpms = G80SorDPMSSet,
+static const xf86OutputFuncsRec NV50SorOutputFuncs = {
+    .dpms = NV50SorDPMSSet,
     .save = NULL,
     .restore = NULL,
-    .mode_valid = G80OutputModeValid,
-    .mode_fixup = G80OutputModeFixup,
-    .prepare = G80OutputPrepare,
-    .commit = G80OutputCommit,
-    .mode_set = G80SorModeSet,
-    .detect = G80SorDetect,
-    .get_modes = G80OutputGetDDCModes,
-    .destroy = G80SorDestroy,
+    .mode_valid = NV50OutputModeValid,
+    .mode_fixup = NV50OutputModeFixup,
+    .prepare = NV50OutputPrepare,
+    .commit = NV50OutputCommit,
+    .mode_set = NV50SorModeSet,
+    .detect = NV50SorDetect,
+    .get_modes = NV50OutputGetDDCModes,
+    .destroy = NV50SorDestroy,
 };
 
 xf86OutputPtr
-G80CreateSor(ScrnInfoPtr pScrn, ORNum or)
+NV50CreateSor(ScrnInfoPtr pScrn, ORNum or)
 {
-    G80OutputPrivPtr pPriv = xnfcalloc(sizeof(*pPriv), 1);
+    NV50OutputPrivPtr pPriv = xnfcalloc(sizeof(*pPriv), 1);
     xf86OutputPtr output;
     char orName[5];
 
@@ -138,12 +138,12 @@ G80CreateSor(ScrnInfoPtr pScrn, ORNum or)
         return FALSE;
 
     snprintf(orName, 5, "DVI%i", or);
-    output = xf86OutputCreate(pScrn, &G80SorOutputFuncs, orName);
+    output = xf86OutputCreate(pScrn, &NV50SorOutputFuncs, orName);
 
     pPriv->type = SOR;
     pPriv->or = or;
     pPriv->cached_status = XF86OutputStatusUnknown;
-    pPriv->set_pclk = G80SorSetPClk;
+    pPriv->set_pclk = NV50SorSetPClk;
     output->driver_private = pPriv;
     output->interlaceAllowed = TRUE;
     output->doubleScanAllowed = TRUE;