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

   1 /*
   2  * Copyright 1993-2003 NVIDIA, Corporation
   3  * Copyright 2008 Stuart Bennett
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  19  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  20  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23
  24 #include "nv_include.h"
  25
  26 uint32_t NVRead(NVPtr pNv, uint32_t reg)
  27 {
  28         DDXMMIOW("NVRead: reg %08x val %08x\n", reg, (uint32_t)NV_RD32(pNv->REGS, reg));
  29         return NV_RD32(pNv->REGS, reg);
  30 }
  31
  32 void NVWrite(NVPtr pNv, uint32_t reg, uint32_t val)
  33 {
  34         DDXMMIOW("NVWrite: reg %08x val %08x\n", reg, NV_WR32(pNv->REGS, reg, val));
  35 }
  36
  37 uint32_t NVReadCRTC(NVPtr pNv, int head, uint32_t reg)
  38 {
  39         if (head)
  40                 reg += NV_PCRTC0_SIZE;
  41         DDXMMIOH("NVReadCRTC: head %d reg %08x val %08x\n", head, reg, (uint32_t)NV_RD32(pNv->REGS, reg));
  42         return NV_RD32(pNv->REGS, reg);
  43 }
  44
  45 void NVWriteCRTC(NVPtr pNv, int head, uint32_t reg, uint32_t val)
  46 {
  47         if (head)
  48                 reg += NV_PCRTC0_SIZE;
  49         DDXMMIOH("NVWriteCRTC: head %d reg %08x val %08x\n", head, reg, val);
  50         NV_WR32(pNv->REGS, reg, val);
  51 }
  52
  53 uint32_t NVReadRAMDAC(NVPtr pNv, int head, uint32_t reg)
  54 {
  55         if (head)
  56                 reg += NV_PRAMDAC0_SIZE;
  57         DDXMMIOH("NVReadRamdac: head %d reg %08x val %08x\n", head, reg, (uint32_t)NV_RD32(pNv->REGS, reg));
  58         return NV_RD32(pNv->REGS, reg);
  59 }
  60
  61 void NVWriteRAMDAC(NVPtr pNv, int head, uint32_t reg, uint32_t val)
  62 {
  63         if (head)
  64                 reg += NV_PRAMDAC0_SIZE;
  65         DDXMMIOH("NVWriteRamdac: head %d reg %08x val %08x\n", head, reg, val);
  66         NV_WR32(pNv->REGS, reg, val);
  67 }
  68
  69 uint8_t nv_read_tmds(NVPtr pNv, int or, int dl, uint8_t address)
  70 {
  71         int ramdac = (or & OUTPUT_C) >> 2;
  72
  73         NVWriteRAMDAC(pNv, ramdac, NV_RAMDAC_FP_TMDS_CONTROL + dl * 8,
  74                       NV_RAMDAC_FP_TMDS_CONTROL_WRITE_DISABLE | address);
  75         return NVReadRAMDAC(pNv, ramdac, NV_RAMDAC_FP_TMDS_DATA + dl * 8);
  76 }
  77
  78 int nv_get_digital_bound_head(NVPtr pNv, int or)
  79 {
  80         /* special case of nv_read_tmds to find crtc associated with an output.
  81          * this does not give a correct answer for off-chip dvi, but there's no
  82          * use for such an answer anyway
  83          */
  84         int ramdac = (or & OUTPUT_C) >> 2;
  85
  86         NVWriteRAMDAC(pNv, ramdac, NV_RAMDAC_FP_TMDS_CONTROL,
  87                       NV_RAMDAC_FP_TMDS_CONTROL_WRITE_DISABLE | 0x4);
  88         return (((NVReadRAMDAC(pNv, ramdac, NV_RAMDAC_FP_TMDS_DATA) & 0x8) >> 3) ^ ramdac);
  89 }
  90
  91 void nv_write_tmds(NVPtr pNv, int or, int dl, uint8_t address, uint8_t data)
  92 {
  93         int ramdac = (or & OUTPUT_C) >> 2;
  94
  95         NVWriteRAMDAC(pNv, ramdac, NV_RAMDAC_FP_TMDS_DATA + dl * 8, data);
  96         NVWriteRAMDAC(pNv, ramdac, NV_RAMDAC_FP_TMDS_CONTROL + dl * 8, address);
  97 }
  98
  99 void NVWriteVgaCrtc(NVPtr pNv, int head, uint8_t index, uint8_t value)
 100 {
 101         DDXMMIOH("NVWriteVgaCrtc: head %d index 0x%02x data 0x%02x\n", head, index, value);
 102         NV_WR08(pNv->REGS, NV_PRMCIO_CRX__COLOR + head * NV_PRMCIO_SIZE, index);
 103         NV_WR08(pNv->REGS, NV_PRMCIO_CR__COLOR + head * NV_PRMCIO_SIZE, value);
 104 }
 105
 106 uint8_t NVReadVgaCrtc(NVPtr pNv, int head, uint8_t index)
 107 {
 108         NV_WR08(pNv->REGS, NV_PRMCIO_CRX__COLOR + head * NV_PRMCIO_SIZE, index);
 109         DDXMMIOH("NVReadVgaCrtc: head %d index 0x%02x data 0x%02x\n", head, index, NV_RD08(pNv->REGS, NV_PRMCIO_CR__COLOR + head * NV_PRMCIO_SIZE));
 110         return NV_RD08(pNv->REGS, NV_PRMCIO_CR__COLOR + head * NV_PRMCIO_SIZE);
 111 }
 112
 113 /* CR57 and CR58 are a fun pair of regs. CR57 provides an index (0-0xf) for CR58
 114  * I suspect they in fact do nothing, but are merely a way to carry useful
 115  * per-head variables around
 116  *
 117  * Known uses:
 118  * CR57         CR58
 119  * 0x00         index to the appropriate dcb entry (or 7f for inactive)
 120  * 0x02         dcb entry's "or" value (or 00 for inactive)
 121  * 0x03         bit0 set for dual link (LVDS, possibly elsewhere too)
 122  * 0x08 or 0x09 pxclk in MHz
 123  * 0x0f         laptop panel info -     low nibble for PEXTDEV_BOOT_0 strap
 124  *                                      high nibble for xlat strap value
 125  */
 126
 127 void NVWriteVgaCrtc5758(NVPtr pNv, int head, uint8_t index, uint8_t value)
 128 {
 129         NVWriteVgaCrtc(pNv, head, NV_CIO_CRE_57, index);
 130         NVWriteVgaCrtc(pNv, head, NV_CIO_CRE_58, value);
 131 }
 132
 133 uint8_t NVReadVgaCrtc5758(NVPtr pNv, int head, uint8_t index)
 134 {
 135         NVWriteVgaCrtc(pNv, head, NV_CIO_CRE_57, index);
 136         return NVReadVgaCrtc(pNv, head, NV_CIO_CRE_58);
 137 }
 138
 139 uint8_t NVReadPRMVIO(NVPtr pNv, int head, uint32_t reg)
 140 {
 141         /* Only NV4x have two pvio ranges */
 142         if (head && pNv->Architecture == NV_ARCH_40)
 143                 reg += NV_PRMVIO_SIZE;
 144
 145         DDXMMIOH("NVReadPRMVIO: head %d reg %08x val %02x\n", head, reg, NV_RD08(pNv->REGS, reg));
 146         return NV_RD08(pNv->REGS, reg);
 147 }
 148
 149 void NVWritePRMVIO(NVPtr pNv, int head, uint32_t reg, uint8_t value)
 150 {
 151         /* Only NV4x have two pvio ranges */
 152         if (head && pNv->Architecture == NV_ARCH_40)
 153                 reg += NV_PRMVIO_SIZE;
 154
 155         DDXMMIOH("NVWritePRMVIO: head %d reg %08x val %02x\n", head, reg, value);
 156         NV_WR08(pNv->REGS, reg, value);
 157 }
 158
 159 void NVWriteVgaSeq(NVPtr pNv, int head, uint8_t index, uint8_t value)
 160 {
 161         NVWritePRMVIO(pNv, head, NV_PRMVIO_SRX, index);
 162         NVWritePRMVIO(pNv, head, NV_PRMVIO_SR, value);
 163 }
 164
 165 uint8_t NVReadVgaSeq(NVPtr pNv, int head, uint8_t index)
 166 {
 167         NVWritePRMVIO(pNv, head, NV_PRMVIO_SRX, index);
 168         return NVReadPRMVIO(pNv, head, NV_PRMVIO_SR);
 169 }
 170
 171 void NVWriteVgaGr(NVPtr pNv, int head, uint8_t index, uint8_t value)
 172 {
 173         NVWritePRMVIO(pNv, head, NV_PRMVIO_GRX, index);
 174         NVWritePRMVIO(pNv, head, NV_PRMVIO_GX, value);
 175 }
 176
 177 uint8_t NVReadVgaGr(NVPtr pNv, int head, uint8_t index)
 178 {
 179         NVWritePRMVIO(pNv, head, NV_PRMVIO_GRX, index);
 180         return NVReadPRMVIO(pNv, head, NV_PRMVIO_GX);
 181 }
 182
 183 void NVSetEnablePalette(NVPtr pNv, int head, bool enable)
 184 {
 185         VGA_RD08(pNv->REGS, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
 186         VGA_WR08(pNv->REGS, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, enable ? 0 : 0x20);
 187 }
 188
 189 static bool NVGetEnablePalette(NVPtr pNv, int head)
 190 {
 191         VGA_RD08(pNv->REGS, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
 192         return !(VGA_RD08(pNv->REGS, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE) & 0x20);
 193 }
 194
 195 void NVWriteVgaAttr(NVPtr pNv, int head, uint8_t index, uint8_t value)
 196 {
 197         if (NVGetEnablePalette(pNv, head))
 198                 index &= ~0x20;
 199         else
 200                 index |= 0x20;
 201
 202         NV_RD08(pNv->REGS, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
 203         DDXMMIOH("NVWriteVgaAttr: head %d index 0x%02x data 0x%02x\n", head, index, value);
 204         NV_WR08(pNv->REGS, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, index);
 205         NV_WR08(pNv->REGS, NV_PRMCIO_AR__WRITE + head * NV_PRMCIO_SIZE, value);
 206 }
 207
 208 uint8_t NVReadVgaAttr(NVPtr pNv, int head, uint8_t index)
 209 {
 210         if (NVGetEnablePalette(pNv, head))
 211                 index &= ~0x20;
 212         else
 213                 index |= 0x20;
 214
 215         NV_RD08(pNv->REGS, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
 216         NV_WR08(pNv->REGS, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, index);
 217         DDXMMIOH("NVReadVgaAttr: head %d index 0x%02x data 0x%02x\n", head, index, NV_RD08(pNv->REGS, NV_PRMCIO_AR__READ + head * NV_PRMCIO_SIZE));
 218         return NV_RD08(pNv->REGS, NV_PRMCIO_AR__READ + head * NV_PRMCIO_SIZE);
 219 }
 220
 221 void NVVgaSeqReset(NVPtr pNv, int head, bool start)
 222 {
 223         NVWriteVgaSeq(pNv, head, NV_VIO_SR_RESET_INDEX, start ? 0x1 : 0x3);
 224 }
 225
 226 void NVVgaProtect(NVPtr pNv, int head, bool protect)
 227 {
 228         uint8_t seq1 = NVReadVgaSeq(pNv, head, NV_VIO_SR_CLOCK_INDEX);
 229
 230         if (protect) {
 231                 NVVgaSeqReset(pNv, head, true);
 232                 NVWriteVgaSeq(pNv, head, NV_VIO_SR_CLOCK_INDEX, seq1 | 0x20);
 233         } else {
 234                 /* Reenable sequencer, then turn on screen */
 235                 NVWriteVgaSeq(pNv, head, NV_VIO_SR_CLOCK_INDEX, seq1 & ~0x20);   /* reenable display */
 236                 NVVgaSeqReset(pNv, head, false);
 237         }
 238         NVSetEnablePalette(pNv, head, protect);
 239 }
 240
 241 void NVSetOwner(NVPtr pNv, int head)
 242 {
 243         /* CR44 is always changed on CRTC0 */
 244         NVWriteVgaCrtc(pNv, 0, NV_CIO_CRE_44, head * 0x3);
 245 }
 246
 247 void NVLockVgaCrtc(NVPtr pNv, int head, bool lock)
 248 {
 249         uint8_t cr11;
 250
 251         NVWriteVgaCrtc(pNv, head, NV_CIO_SR_LOCK_INDEX,
 252                        lock ? NV_CIO_SR_LOCK_VALUE : NV_CIO_SR_UNLOCK_RW_VALUE);
 253
 254         cr11 = NVReadVgaCrtc(pNv, head, NV_CIO_CR_VRE_INDEX);
 255         if (lock)
 256                 cr11 |= 0x80;
 257         else
 258                 cr11 &= ~0x80;
 259         NVWriteVgaCrtc(pNv, head, NV_CIO_CR_VRE_INDEX, cr11);
 260 }
 261
 262 void NVBlankScreen(NVPtr pNv, int head, bool blank)
 263 {
 264         unsigned char seq1;
 265
 266         if (pNv->twoHeads)
 267                 NVSetOwner(pNv, head);
 268
 269         seq1 = NVReadVgaSeq(pNv, head, NV_VIO_SR_CLOCK_INDEX);
 270
 271         NVVgaSeqReset(pNv, head, true);
 272         if (blank)
 273                 NVWriteVgaSeq(pNv, head, NV_VIO_SR_CLOCK_INDEX, seq1 | 0x20);
 274         else
 275                 NVWriteVgaSeq(pNv, head, NV_VIO_SR_CLOCK_INDEX, seq1 & ~0x20);
 276         NVVgaSeqReset(pNv, head, false);
 277 }
 278
 279 void nv_fix_nv40_hw_cursor(NVPtr pNv, int head)
 280 {
 281         /* on some nv40 (such as the "true" (in the NV_PFB_BOOT_0 sense) nv40,
 282          * the gf6800gt) a hardware bug requires a write to PRAMDAC_CURSOR_POS
 283          * for changes to the CRTC CURCTL regs to take effect, whether changing
 284          * the pixmap location, or just showing/hiding the cursor
 285          */
 286         volatile uint32_t curpos = NVReadRAMDAC(pNv, head, NV_RAMDAC_CURSOR_POS);
 287         NVWriteRAMDAC(pNv, head, NV_RAMDAC_CURSOR_POS, curpos);
 288 }
 289
 290 void nv_show_cursor(NVPtr pNv, int head, bool show)
 291 {
 292         int curctl1 = NVReadVgaCrtc(pNv, head, NV_CIO_CRE_HCUR_ADDR1_INDEX);
 293
 294         if (show)
 295                 NVWriteVgaCrtc(pNv, head, NV_CIO_CRE_HCUR_ADDR1_INDEX,
 296                                curctl1 | NV_CIO_CRE_HCUR_ADDR1_ENABLE);
 297         else
 298                 NVWriteVgaCrtc(pNv, head, NV_CIO_CRE_HCUR_ADDR1_INDEX,
 299                                curctl1 & ~NV_CIO_CRE_HCUR_ADDR1_ENABLE);
 300
 301         if (pNv->Architecture == NV_ARCH_40)
 302                 nv_fix_nv40_hw_cursor(pNv, head);
 303 }
 304
 305 int nv_decode_pll_highregs(NVPtr pNv, uint32_t pll1, uint32_t pll2, bool force_single, int refclk)
 306 {
 307         int M1, N1, M2 = 1, N2 = 1, log2P;
 308
 309         M1 = pll1 & 0xff;
 310         N1 = (pll1 >> 8) & 0xff;
 311         log2P = (pll1 >> 16) & 0x7; /* never more than 6, and nv30/35 only uses 3 bits */
 312         if (pNv->twoStagePLL && pll2 & NV31_RAMDAC_ENABLE_VCO2 && !force_single) {
 313                 M2 = pll2 & 0xff;
 314                 N2 = (pll2 >> 8) & 0xff;
 315         } else if (pNv->NVArch == 0x30 || pNv->NVArch == 0x35) {
 316                 M1 &= 0xf; /* only 4 bits */
 317                 if (pll1 & NV30_RAMDAC_ENABLE_VCO2) {
 318                         M2 = (pll1 >> 4) & 0x7;
 319                         N2 = ((pll2 >> 21) & 0x18) | ((pll2 >> 19) & 0x7);
 320                 }
 321         }
 322
 323         /* Avoid divide by zero if called at an inappropriate time */
 324         if (!M1 || !M2)
 325                 return 0;
 326
 327         return (N1 * N2 * refclk / (M1 * M2)) >> log2P;
 328 }
 329
 330 static int nv_decode_pll_lowregs(uint32_t Pval, uint32_t NMNM, int refclk)
 331 {
 332         int M1, N1, M2 = 1, N2 = 1, log2P;
 333
 334         log2P = (Pval >> 16) & 0x7;
 335
 336         M1 = NMNM & 0xff;
 337         N1 = (NMNM >> 8) & 0xff;
 338         /* NVPLL and VPLLs use 1 << 8 to indicate single stage mode, MPLL uses 1 << 12 */
 339         if (!(Pval & (1 << 8) || Pval & (1 << 12))) {
 340                 M2 = (NMNM >> 16) & 0xff;
 341                 N2 = (NMNM >> 24) & 0xff;
 342         }
 343
 344         /* Avoid divide by zero if called at an inappropriate time */
 345         if (!M1 || !M2)
 346                 return 0;
 347
 348         return (N1 * N2 * refclk / (M1 * M2)) >> log2P;
 349 }
 350
 351 static int nv_get_clock(ScrnInfoPtr pScrn, enum pll_types plltype)
 352 {
 353         NVPtr pNv = NVPTR(pScrn);
 354         const uint32_t nv04_regs[MAX_PLL_TYPES] = { NV_RAMDAC_NVPLL, NV_RAMDAC_MPLL, NV_RAMDAC_VPLL, NV_RAMDAC_VPLL2 };
 355         const uint32_t nv40_regs[MAX_PLL_TYPES] = { 0x4000, 0x4020, NV_RAMDAC_VPLL, NV_RAMDAC_VPLL2 };
 356         uint32_t reg1;
 357         struct pll_lims pll_lim;
 358
 359         if (plltype == MPLL && (pNv->Chipset & 0x0ff0) == CHIPSET_NFORCE) {
 360                 uint32_t mpllP = (PCI_SLOT_READ_LONG(3, 0x6c) >> 8) & 0xf;
 361
 362                 if (!mpllP)
 363                         mpllP = 4;
 364                 return 400000 / mpllP;
 365         } else if (plltype == MPLL && (pNv->Chipset & 0xff0) == CHIPSET_NFORCE2)
 366                 return PCI_SLOT_READ_LONG(5, 0x4c) / 1000;
 367
 368         if (pNv->Architecture < NV_ARCH_40)
 369                 reg1 = nv04_regs[plltype];
 370         else
 371                 reg1 = nv40_regs[plltype];
 372
 373         if (!get_pll_limits(pScrn, plltype, &pll_lim))
 374                 return 0;
 375
 376         if (reg1 <= 0x405c)
 377                 return nv_decode_pll_lowregs(nvReadMC(pNv, reg1), nvReadMC(pNv, reg1 + 4), pll_lim.refclk);
 378         if (pNv->twoStagePLL) {
 379                 bool nv40_single = pNv->Architecture == 0x40 && ((plltype == VPLL1 && NVReadRAMDAC(pNv, 0, NV_RAMDAC_580) & NV_RAMDAC_580_VPLL1_ACTIVE) || (plltype == VPLL2 && NVReadRAMDAC(pNv, 0, NV_RAMDAC_580) & NV_RAMDAC_580_VPLL2_ACTIVE));
 380
 381                 return nv_decode_pll_highregs(pNv, nvReadMC(pNv, reg1), nvReadMC(pNv, reg1 + ((reg1 == NV_RAMDAC_VPLL2) ? 0x5c : 0x70)), nv40_single, pll_lim.refclk);
 382         }
 383         return nv_decode_pll_highregs(pNv, nvReadMC(pNv, reg1), 0, false, pll_lim.refclk);
 384 }
 385
 386 /****************************************************************************\
 387 *                                                                            *
 388 * The video arbitration routines calculate some "magic" numbers.  Fixes      *
 389 * the snow seen when accessing the framebuffer without it.                   *
 390 * It just works (I hope).                                                    *
 391 *                                                                            *
 392 \****************************************************************************/
 393
 394 struct nv_fifo_info {
 395         int graphics_lwm;
 396         int video_lwm;
 397         int graphics_burst_size;
 398         int video_burst_size;
 399         bool valid;
 400 };
 401
 402 struct nv_sim_state {
 403         int pclk_khz;
 404         int mclk_khz;
 405         int nvclk_khz;
 406         int pix_bpp;
 407         bool enable_mp;
 408         bool enable_video;
 409         int mem_page_miss;
 410         int mem_latency;
 411         int memory_type;
 412         int memory_width;
 413 };
 414
 415 static void nv4CalcArbitration(struct nv_fifo_info *fifo, struct nv_sim_state *arb)
 416 {
 417         int pagemiss, cas, width, video_enable, bpp;
 418         int nvclks, mclks, pclks, vpagemiss, crtpagemiss, vbs;
 419         int found, mclk_extra, mclk_loop, cbs, m1, p1;
 420         int mclk_freq, pclk_freq, nvclk_freq, mp_enable;
 421         int us_m, us_n, us_p, video_drain_rate, crtc_drain_rate;
 422         int vpm_us, us_video, vlwm, video_fill_us, cpm_us, us_crt, clwm;
 423
 424         pclk_freq = arb->pclk_khz;
 425         mclk_freq = arb->mclk_khz;
 426         nvclk_freq = arb->nvclk_khz;
 427         pagemiss = arb->mem_page_miss;
 428         cas = arb->mem_latency;
 429         width = arb->memory_width >> 6;
 430         video_enable = arb->enable_video;
 431         bpp = arb->pix_bpp;
 432         mp_enable = arb->enable_mp;
 433         clwm = 0;
 434         vlwm = 0;
 435         cbs = 128;
 436         pclks = 2;
 437         nvclks = 2;
 438         nvclks += 2;
 439         nvclks += 1;
 440         mclks = 5;
 441         mclks += 3;
 442         mclks += 1;
 443         mclks += cas;
 444         mclks += 1;
 445         mclks += 1;
 446         mclks += 1;
 447         mclks += 1;
 448         mclk_extra = 3;
 449         nvclks += 2;
 450         nvclks += 1;
 451         nvclks += 1;
 452         nvclks += 1;
 453         if (mp_enable)
 454                 mclks += 4;
 455         nvclks += 0;
 456         pclks += 0;
 457         found = 0;
 458         vbs = 0;
 459         while (found != 1) {
 460                 fifo->valid = true;
 461                 found = 1;
 462                 mclk_loop = mclks + mclk_extra;
 463                 us_m = mclk_loop * 1000 * 1000 / mclk_freq;
 464                 us_n = nvclks * 1000 * 1000 / nvclk_freq;
 465                 us_p = nvclks * 1000 * 1000 / pclk_freq;
 466                 if (video_enable) {
 467                         video_drain_rate = pclk_freq * 2;
 468                         crtc_drain_rate = pclk_freq * bpp / 8;
 469                         vpagemiss = 2;
 470                         vpagemiss += 1;
 471                         crtpagemiss = 2;
 472                         vpm_us = vpagemiss * pagemiss * 1000 * 1000 / mclk_freq;
 473                         if (nvclk_freq * 2 > mclk_freq * width)
 474                                 video_fill_us = cbs * 1000 * 1000 / 16 / nvclk_freq;
 475                         else
 476                                 video_fill_us = cbs * 1000 * 1000 / (8 * width) / mclk_freq;
 477                         us_video = vpm_us + us_m + us_n + us_p + video_fill_us;
 478                         vlwm = us_video * video_drain_rate / (1000 * 1000);
 479                         vlwm++;
 480                         vbs = 128;
 481                         if (vlwm > 128)
 482                                 vbs = 64;
 483                         if (vlwm > (256 - 64))
 484                                 vbs = 32;
 485                         if (nvclk_freq * 2 > mclk_freq * width)
 486                                 video_fill_us = vbs * 1000 * 1000 / 16 / nvclk_freq;
 487                         else
 488                                 video_fill_us = vbs * 1000 * 1000 / (8 * width) / mclk_freq;
 489                         cpm_us = crtpagemiss * pagemiss * 1000 * 1000 / mclk_freq;
 490                         us_crt = us_video + video_fill_us + cpm_us + us_m + us_n + us_p;
 491                         clwm = us_crt * crtc_drain_rate / (1000 * 1000);
 492                         clwm++;
 493                 } else {
 494                         crtc_drain_rate = pclk_freq * bpp / 8;
 495                         crtpagemiss = 2;
 496                         crtpagemiss += 1;
 497                         cpm_us = crtpagemiss * pagemiss * 1000 * 1000 / mclk_freq;
 498                         us_crt = cpm_us + us_m + us_n + us_p;
 499                         clwm = us_crt * crtc_drain_rate / (1000 * 1000);
 500                         clwm++;
 501                 }
 502                 m1 = clwm + cbs - 512;
 503                 p1 = m1 * pclk_freq / mclk_freq;
 504                 p1 = p1 * bpp / 8;
 505                 if ((p1 < m1 && m1 > 0) ||
 506                     (video_enable && (clwm > 511 || vlwm > 255)) ||
 507                     (!video_enable && clwm > 519)) {
 508                         fifo->valid = false;
 509                         found = !mclk_extra;
 510                         mclk_extra--;
 511                 }
 512                 if (clwm < 384)
 513                         clwm = 384;
 514                 if (vlwm < 128)
 515                         vlwm = 128;
 516                 fifo->graphics_lwm = clwm;
 517                 fifo->graphics_burst_size = 128;
 518                 fifo->video_lwm = vlwm + 15;
 519                 fifo->video_burst_size = vbs;
 520         }
 521 }
 522
 523 static void nv10CalcArbitration(struct nv_fifo_info *fifo, struct nv_sim_state *arb)
 524 {
 525         int pagemiss, width, video_enable, bpp;
 526         int nvclks, mclks, pclks, vpagemiss, crtpagemiss;
 527         int nvclk_fill;
 528         int found, mclk_extra, mclk_loop, cbs, m1;
 529         int mclk_freq, pclk_freq, nvclk_freq, mp_enable;
 530         int us_m, us_m_min, us_n, us_p, crtc_drain_rate;
 531         int vus_m;
 532         int vpm_us, us_video, cpm_us, us_crt, clwm;
 533         int clwm_rnd_down;
 534         int m2us, us_pipe_min, p1clk, p2;
 535         int min_mclk_extra;
 536         int us_min_mclk_extra;
 537
 538         pclk_freq = arb->pclk_khz;      /* freq in KHz */
 539         mclk_freq = arb->mclk_khz;
 540         nvclk_freq = arb->nvclk_khz;
 541         pagemiss = arb->mem_page_miss;
 542         width = arb->memory_width / 64;
 543         video_enable = arb->enable_video;
 544         bpp = arb->pix_bpp;
 545         mp_enable = arb->enable_mp;
 546         clwm = 0;
 547         cbs = 512;
 548         pclks = 4;      /* lwm detect. */
 549         nvclks = 3;     /* lwm -> sync. */
 550         nvclks += 2;    /* fbi bus cycles (1 req + 1 busy) */
 551         mclks = 1;      /* 2 edge sync.  may be very close to edge so just put one. */
 552         mclks += 1;     /* arb_hp_req */
 553         mclks += 5;     /* ap_hp_req   tiling pipeline */
 554         mclks += 2;     /* tc_req     latency fifo */
 555         mclks += 2;     /* fb_cas_n_  memory request to fbio block */
 556         mclks += 7;     /* sm_d_rdv   data returned from fbio block */
 557
 558         /* fb.rd.d.Put_gc   need to accumulate 256 bits for read */
 559         if (arb->memory_type == 0) {
 560                 if (arb->memory_width == 64)    /* 64 bit bus */
 561                         mclks += 4;
 562                 else
 563                         mclks += 2;
 564         } else if (arb->memory_width == 64)     /* 64 bit bus */
 565                 mclks += 2;
 566         else
 567                 mclks += 1;
 568
 569         if (!video_enable && arb->memory_width == 128) {
 570                 mclk_extra = (bpp == 32) ? 31 : 42;     /* Margin of error */
 571                 min_mclk_extra = 17;
 572         } else {
 573                 mclk_extra = (bpp == 32) ? 8 : 4;       /* Margin of error */
 574                 /* mclk_extra = 4; *//* Margin of error */
 575                 min_mclk_extra = 18;
 576         }
 577
 578         nvclks += 1;    /* 2 edge sync.  may be very close to edge so just put one. */
 579         nvclks += 1;    /* fbi_d_rdv_n */
 580         nvclks += 1;    /* Fbi_d_rdata */
 581         nvclks += 1;    /* crtfifo load */
 582
 583         if (mp_enable)
 584                 mclks += 4;     /* Mp can get in with a burst of 8. */
 585         /* Extra clocks determined by heuristics */
 586
 587         nvclks += 0;
 588         pclks += 0;
 589         found = 0;
 590         while (found != 1) {
 591                 fifo->valid = true;
 592                 found = 1;
 593                 mclk_loop = mclks + mclk_extra;
 594                 us_m = mclk_loop * 1000 * 1000 / mclk_freq;     /* Mclk latency in us */
 595                 us_m_min = mclks * 1000 * 1000 / mclk_freq;     /* Minimum Mclk latency in us */
 596                 us_min_mclk_extra = min_mclk_extra * 1000 * 1000 / mclk_freq;
 597                 us_n = nvclks * 1000 * 1000 / nvclk_freq;       /* nvclk latency in us */
 598                 us_p = pclks * 1000 * 1000 / pclk_freq; /* nvclk latency in us */
 599                 us_pipe_min = us_m_min + us_n + us_p;
 600
 601                 vus_m = mclk_loop * 1000 * 1000 / mclk_freq;    /* Mclk latency in us */
 602
 603                 if (video_enable) {
 604                         crtc_drain_rate = pclk_freq * bpp / 8;  /* MB/s */
 605
 606                         vpagemiss = 1;  /* self generating page miss */
 607                         vpagemiss += 1; /* One higher priority before */
 608
 609                         crtpagemiss = 2;        /* self generating page miss */
 610                         if (mp_enable)
 611                                 crtpagemiss += 1;       /* if MA0 conflict */
 612
 613                         vpm_us = vpagemiss * pagemiss * 1000 * 1000 / mclk_freq;
 614
 615                         us_video = vpm_us + vus_m;      /* Video has separate read return path */
 616
 617                         cpm_us = crtpagemiss * pagemiss * 1000 * 1000 / mclk_freq;
 618                         us_crt = us_video       /* Wait for video */
 619                                  + cpm_us       /* CRT Page miss */
 620                                  + us_m + us_n + us_p;  /* other latency */
 621
 622                         clwm = us_crt * crtc_drain_rate / (1000 * 1000);
 623                         clwm++; /* fixed point <= float_point - 1.  Fixes that */
 624                 } else {
 625                         crtc_drain_rate = pclk_freq * bpp / 8;  /* bpp * pclk/8 */
 626
 627                         crtpagemiss = 1;        /* self generating page miss */
 628                         crtpagemiss += 1;       /* MA0 page miss */
 629                         if (mp_enable)
 630                                 crtpagemiss += 1;       /* if MA0 conflict */
 631                         cpm_us = crtpagemiss * pagemiss * 1000 * 1000 / mclk_freq;
 632                         us_crt = cpm_us + us_m + us_n + us_p;
 633                         clwm = us_crt * crtc_drain_rate / (1000 * 1000);
 634                         clwm++; /* fixed point <= float_point - 1.  Fixes that */
 635
 636                         /* Finally, a heuristic check when width == 64 bits */
 637                         if (width == 1) {
 638                                 nvclk_fill = nvclk_freq * 8;
 639                                 if (crtc_drain_rate * 100 >= nvclk_fill * 102)
 640                                         clwm = 0xfff;   /* Large number to fail */
 641                                 else if (crtc_drain_rate * 100 >= nvclk_fill * 98) {
 642                                         clwm = 1024;
 643                                         cbs = 512;
 644                                 }
 645                         }
 646                 }
 647
 648                 /*
 649                  * Overfill check:
 650                  */
 651
 652                 clwm_rnd_down = (clwm / 8) * 8;
 653                 if (clwm_rnd_down < clwm)
 654                         clwm += 8;
 655
 656                 m1 = clwm + cbs - 1024; /* Amount of overfill */
 657                 m2us = us_pipe_min + us_min_mclk_extra;
 658
 659                 /* pclk cycles to drain */
 660                 p1clk = m2us * pclk_freq / (1000 * 1000);
 661                 p2 = p1clk * bpp / 8;   /* bytes drained. */
 662
 663                 if (p2 < m1 && m1 > 0) {
 664                         fifo->valid = false;
 665                         found = 0;
 666                         if (min_mclk_extra == 0) {
 667                                 if (cbs <= 32)
 668                                         found = 1;      /* Can't adjust anymore! */
 669                                 else
 670                                         cbs = cbs / 2;  /* reduce the burst size */
 671                         } else
 672                                 min_mclk_extra--;
 673                 } else if (clwm > 1023) {       /* Have some margin */
 674                         fifo->valid = false;
 675                         found = 0;
 676                         if (min_mclk_extra == 0)
 677                                 found = 1;      /* Can't adjust anymore! */
 678                         else
 679                                 min_mclk_extra--;
 680                 }
 681
 682                 if (clwm < (1024 - cbs + 8))
 683                         clwm = 1024 - cbs + 8;
 684                 /*  printf("CRT LWM: prog: 0x%x, bs: 256\n", clwm); */
 685                 fifo->graphics_lwm = clwm;
 686                 fifo->graphics_burst_size = cbs;
 687
 688                 fifo->video_lwm = 1024;
 689                 fifo->video_burst_size = 512;
 690         }
 691 }
 692
 693 void nv4_10UpdateArbitrationSettings(ScrnInfoPtr pScrn, int VClk, int bpp, uint8_t *burst, uint16_t *lwm)
 694 {
 695         NVPtr pNv = NVPTR(pScrn);
 696         struct nv_fifo_info fifo_data;
 697         struct nv_sim_state sim_data;
 698         int MClk = nv_get_clock(pScrn, MPLL);
 699         int NVClk = nv_get_clock(pScrn, NVPLL);
 700         uint32_t cfg1 = nvReadFB(pNv, NV_PFB_CFG1);
 701
 702         sim_data.pclk_khz = VClk;
 703         sim_data.mclk_khz = MClk;
 704         sim_data.nvclk_khz = NVClk;
 705         sim_data.pix_bpp = bpp;
 706         sim_data.enable_mp = false;
 707         if ((pNv->Chipset & 0xffff) == CHIPSET_NFORCE ||
 708             (pNv->Chipset & 0xffff) == CHIPSET_NFORCE2) {
 709                 sim_data.enable_video = false;
 710                 sim_data.memory_type = (PCI_SLOT_READ_LONG(1, 0x7c) >> 12) & 1;
 711                 sim_data.memory_width = 64;
 712                 sim_data.mem_latency = 3;
 713                 sim_data.mem_page_miss = 10;
 714         } else {
 715                 sim_data.enable_video = (pNv->Architecture != NV_ARCH_04);
 716                 sim_data.memory_type = nvReadFB(pNv, NV_PFB_CFG0) & 0x1;
 717                 sim_data.memory_width = (nvReadEXTDEV(pNv, NV_PEXTDEV_BOOT_0) & 0x10) ? 128 : 64;
 718                 sim_data.mem_latency = cfg1 & 0xf;
 719                 sim_data.mem_page_miss = ((cfg1 >> 4) & 0xf) + ((cfg1 >> 31) & 0x1);
 720         }
 721
 722         if (pNv->Architecture == NV_ARCH_04)
 723                 nv4CalcArbitration(&fifo_data, &sim_data);
 724         else
 725                 nv10CalcArbitration(&fifo_data, &sim_data);
 726
 727         if (fifo_data.valid) {
 728                 int b = fifo_data.graphics_burst_size >> 4;
 729                 *burst = 0;
 730                 while (b >>= 1)
 731                         (*burst)++;
 732                 *lwm = fifo_data.graphics_lwm >> 3;
 733         }
 734 }
 735
 736 void nv30UpdateArbitrationSettings(uint8_t *burst, uint16_t *lwm)
 737 {
 738         unsigned int fifo_size, burst_size, graphics_lwm;
 739
 740         fifo_size = 2048;
 741         burst_size = 512;
 742         graphics_lwm = fifo_size - burst_size;
 743
 744         *burst = 0;
 745         burst_size >>= 5;
 746         while (burst_size >>= 1)
 747                 (*burst)++;
 748         *lwm = graphics_lwm >> 3;
 749 }
 750
 751 /****************************************************************************\
 752 *                                                                            *
 753 *                          RIVA Mode State Routines                          *
 754 *                                                                            *
 755 \****************************************************************************/
 756
 757 /*
 758  * Calculate the Video Clock parameters for the PLL.
 759  */
 760 static void CalcVClock (
 761     int           clockIn,
 762     int          *clockOut,
 763     CARD32         *pllOut,
 764     NVPtr        pNv
 765 )
 766 {
 767     unsigned lowM, highM;
 768     unsigned DeltaNew, DeltaOld;
 769     unsigned VClk, Freq;
 770     unsigned M, N, P;
 771
 772     DeltaOld = 0xFFFFFFFF;
 773
 774     VClk = (unsigned)clockIn;
 775
 776     if (pNv->CrystalFreqKHz == 13500) {
 777         lowM  = 7;
 778         highM = 13;
 779     } else {
 780         lowM  = 8;
 781         highM = 14;
 782     }
 783
 784     for (P = 0; P <= 4; P++) {
 785         Freq = VClk << P;
 786         if ((Freq >= 128000) && (Freq <= 350000)) {
 787             for (M = lowM; M <= highM; M++) {
 788                 N = ((VClk << P) * M) / pNv->CrystalFreqKHz;
 789                 if(N <= 255) {
 790                     Freq = ((pNv->CrystalFreqKHz * N) / M) >> P;
 791                     if (Freq > VClk)
 792                         DeltaNew = Freq - VClk;
 793                     else
 794                         DeltaNew = VClk - Freq;
 795                     if (DeltaNew < DeltaOld) {
 796                         *pllOut   = (P << 16) | (N << 8) | M;
 797                         *clockOut = Freq;
 798                         DeltaOld  = DeltaNew;
 799                     }
 800                 }
 801             }
 802         }
 803     }
 804 }
 805
 806 static void CalcVClock2Stage (
 807     int           clockIn,
 808     int          *clockOut,
 809     CARD32         *pllOut,
 810     CARD32         *pllBOut,
 811     NVPtr        pNv
 812 )
 813 {
 814     unsigned DeltaNew, DeltaOld;
 815     unsigned VClk, Freq;
 816     unsigned M, N, P;
 817
 818     DeltaOld = 0xFFFFFFFF;
 819
 820     *pllBOut = 0x80000401;  /* fixed at x4 for now */
 821
 822     VClk = (unsigned)clockIn;
 823
 824     for (P = 0; P <= 6; P++) {
 825         Freq = VClk << P;
 826         if ((Freq >= 400000) && (Freq <= 1000000)) {
 827             for (M = 1; M <= 13; M++) {
 828                 N = ((VClk << P) * M) / (pNv->CrystalFreqKHz << 2);
 829                 if((N >= 5) && (N <= 255)) {
 830                     Freq = (((pNv->CrystalFreqKHz << 2) * N) / M) >> P;
 831                     if (Freq > VClk)
 832                         DeltaNew = Freq - VClk;
 833                     else
 834                         DeltaNew = VClk - Freq;
 835                     if (DeltaNew < DeltaOld) {
 836                         *pllOut   = (P << 16) | (N << 8) | M;
 837                         *clockOut = Freq;
 838                         DeltaOld  = DeltaNew;
 839                     }
 840                 }
 841             }
 842         }
 843     }
 844 }
 845
 846 /*
 847  * Calculate extended mode parameters (SVGA) and save in a
 848  * mode state structure.
 849  */
 850 void NVCalcStateExt (
 851     ScrnInfoPtr pScrn,
 852     RIVA_HW_STATE *state,
 853     int            bpp,
 854     int            width,
 855     int            hDisplaySize,
 856     int            height,
 857     int            dotClock,
 858     int            flags
 859 )
 860 {
 861         NVPtr pNv = NVPTR(pScrn);
 862     int pixelDepth, VClk = 0;
 863         CARD32 CursorStart;
 864
 865     /*
 866      * Save mode parameters.
 867      */
 868     state->bpp    = bpp;    /* this is not bitsPerPixel, it's 8,15,16,32 */
 869     state->width  = width;
 870     state->height = height;
 871     /*
 872      * Extended RIVA registers.
 873      */
 874     pixelDepth = (bpp + 1)/8;
 875     if(pNv->twoStagePLL)
 876         CalcVClock2Stage(dotClock, &VClk, &state->pll, &state->pllB, pNv);
 877     else
 878         CalcVClock(dotClock, &VClk, &state->pll, pNv);
 879
 880     switch (pNv->Architecture)
 881     {
 882         case NV_ARCH_04:
 883             nv4_10UpdateArbitrationSettings(pScrn, VClk,
 884                                          pixelDepth * 8,
 885                                         &(state->arbitration0),
 886                                         &(state->arbitration1));
 887             state->cursor0  = 0x00;
 888             state->cursor1  = 0xbC;
 889             if (flags & V_DBLSCAN)
 890                 state->cursor1 |= 2;
 891             state->cursor2  = 0x00000000;
 892             state->pllsel   = 0x10000700;
 893             state->general  = bpp == 16 ? 0x00101100 : 0x00100100;
 894             state->repaint1 = hDisplaySize < 1280 ? 0x04 : 0x00;
 895             break;
 896         case NV_ARCH_10:
 897         case NV_ARCH_20:
 898         case NV_ARCH_30:
 899         default:
 900             if(((pNv->Chipset & 0xfff0) == CHIPSET_C51) ||
 901                ((pNv->Chipset & 0xfff0) == CHIPSET_C512))
 902             {
 903                 state->arbitration0 = 128;
 904                 state->arbitration1 = 0x0480;
 905             } else if(pNv->Architecture < NV_ARCH_30) {
 906                 nv4_10UpdateArbitrationSettings(pScrn, VClk,
 907                                           pixelDepth * 8,
 908                                          &(state->arbitration0),
 909                                          &(state->arbitration1));
 910             } else {
 911                 nv30UpdateArbitrationSettings(&(state->arbitration0),
 912                                          &(state->arbitration1));
 913             }
 914             CursorStart = pNv->Cursor->offset;
 915             state->cursor0  = 0x80 | (CursorStart >> 17);
 916             state->cursor1  = (CursorStart >> 11) << 2;
 917             state->cursor2  = CursorStart >> 24;
 918             if (flags & V_DBLSCAN)
 919                 state->cursor1 |= 2;
 920             state->pllsel   = 0x10000700;
 921             state->general  = bpp == 16 ? 0x00101100 : 0x00100100;
 922             state->repaint1 = hDisplaySize < 1280 ? 0x04 : 0x00;
 923             break;
 924     }
 925
 926     if(bpp != 8) /* DirectColor */
 927         state->general |= 0x00000030;
 928
 929     state->repaint0 = (((width / 8) * pixelDepth) & 0x700) >> 3;
 930     state->pixel    = (pixelDepth > 2) ? 3 : pixelDepth;
 931 }
 932
 933
 934 void NVLoadStateExt (
 935     ScrnInfoPtr pScrn,
 936     RIVA_HW_STATE *state
 937 )
 938 {
 939     NVPtr pNv = NVPTR(pScrn);
 940     CARD32 temp;
 941
 942     if(pNv->Architecture >= NV_ARCH_40) {
 943         switch(pNv->Chipset & 0xfff0) {
 944         case CHIPSET_NV44:
 945         case CHIPSET_NV44A:
 946         case CHIPSET_C51:
 947         case CHIPSET_G70:
 948         case CHIPSET_G71:
 949         case CHIPSET_G72:
 950         case CHIPSET_G73:
 951         case CHIPSET_C512:
 952              temp = nvReadCurRAMDAC(pNv, NV_RAMDAC_TEST_CONTROL);
 953              nvWriteCurRAMDAC(pNv, NV_RAMDAC_TEST_CONTROL, temp | 0x00100000);
 954              break;
 955         default:
 956              break;
 957         };
 958     }
 959
 960     if(pNv->Architecture >= NV_ARCH_10) {
 961         if(pNv->twoHeads) {
 962            NVWriteCRTC(pNv, 0, NV_CRTC_FSEL, state->head);
 963            NVWriteCRTC(pNv, 1, NV_CRTC_FSEL, state->head2);
 964         }
 965         temp = nvReadCurRAMDAC(pNv, NV_RAMDAC_NV10_CURSYNC);
 966         nvWriteCurRAMDAC(pNv, NV_RAMDAC_NV10_CURSYNC, temp | (1 << 25));
 967
 968         nvWriteVIDEO(pNv, NV_PVIDEO_STOP, 1);
 969         nvWriteVIDEO(pNv, NV_PVIDEO_INTR_EN, 0);
 970         nvWriteVIDEO(pNv, NV_PVIDEO_OFFSET_BUFF(0), 0);
 971         nvWriteVIDEO(pNv, NV_PVIDEO_OFFSET_BUFF(1), 0);
 972         nvWriteVIDEO(pNv, NV_PVIDEO_LIMIT(0), pNv->VRAMPhysicalSize - 1);
 973         nvWriteVIDEO(pNv, NV_PVIDEO_LIMIT(1), pNv->VRAMPhysicalSize - 1);
 974         nvWriteVIDEO(pNv, NV_PVIDEO_UVPLANE_LIMIT(0), pNv->VRAMPhysicalSize - 1);
 975         nvWriteVIDEO(pNv, NV_PVIDEO_UVPLANE_LIMIT(1), pNv->VRAMPhysicalSize - 1);
 976         nvWriteMC(pNv, NV_PBUS_POWERCTRL_2, 0);
 977
 978         nvWriteCurCRTC(pNv, NV_CRTC_CURSOR_CONFIG, state->cursorConfig);
 979         nvWriteCurCRTC(pNv, NV_CRTC_0830, state->displayV - 3);
 980         nvWriteCurCRTC(pNv, NV_CRTC_0834, state->displayV - 1);
 981
 982         if(pNv->FlatPanel) {
 983            if((pNv->Chipset & 0x0ff0) == CHIPSET_NV11) {
 984                nvWriteCurRAMDAC(pNv, NV_RAMDAC_DITHER_NV11, state->dither);
 985            } else
 986            if(pNv->twoHeads) {
 987                nvWriteCurRAMDAC(pNv, NV_RAMDAC_FP_DITHER, state->dither);
 988            }
 989
 990            nvWriteCurVGA(pNv, NV_CIO_CRE_53, state->timingH);
 991            nvWriteCurVGA(pNv, NV_CIO_CRE_54, state->timingV);
 992            nvWriteCurVGA(pNv, NV_CIO_CRE_21, 0xfa);
 993         }
 994
 995         nvWriteCurVGA(pNv, NV_CIO_CRE_EBR_INDEX, state->extra);
 996     }
 997
 998     nvWriteCurVGA(pNv, NV_CIO_CRE_RPC0_INDEX, state->repaint0);
 999     nvWriteCurVGA(pNv, NV_CIO_CRE_RPC1_INDEX, state->repaint1);
1000     nvWriteCurVGA(pNv, NV_CIO_CRE_LSR_INDEX, state->screen);
1001     nvWriteCurVGA(pNv, NV_CIO_CRE_PIXEL_INDEX, state->pixel);
1002     nvWriteCurVGA(pNv, NV_CIO_CRE_HEB__INDEX, state->horiz);
1003     nvWriteCurVGA(pNv, NV_CIO_CRE_ENH_INDEX, state->fifo);
1004     nvWriteCurVGA(pNv, NV_CIO_CRE_FF_INDEX, state->arbitration0);
1005     nvWriteCurVGA(pNv, NV_CIO_CRE_FFLWM__INDEX, state->arbitration1);
1006     if(pNv->Architecture >= NV_ARCH_30) {
1007       nvWriteCurVGA(pNv, NV_CIO_CRE_47, state->arbitration1 >> 8);
1008     }
1009
1010     nvWriteCurVGA(pNv, NV_CIO_CRE_HCUR_ADDR0_INDEX, state->cursor0);
1011     nvWriteCurVGA(pNv, NV_CIO_CRE_HCUR_ADDR1_INDEX, state->cursor1);
1012     if(pNv->Architecture == NV_ARCH_40) {  /* HW bug */
1013        volatile CARD32 curpos = nvReadCurRAMDAC(pNv, NV_RAMDAC_CURSOR_POS);
1014        nvWriteCurRAMDAC(pNv, NV_RAMDAC_CURSOR_POS, curpos);
1015     }
1016     nvWriteCurVGA(pNv, NV_CIO_CRE_HCUR_ADDR2_INDEX, state->cursor2);
1017     nvWriteCurVGA(pNv, NV_CIO_CRE_ILACE__INDEX, state->interlace);
1018
1019     if(!pNv->FlatPanel) {
1020        NVWriteRAMDAC(pNv, 0, NV_RAMDAC_PLL_SELECT, state->pllsel);
1021        NVWriteRAMDAC(pNv, 0, NV_RAMDAC_VPLL, state->vpll);
1022        if(pNv->twoHeads)
1023           NVWriteRAMDAC(pNv, 0, NV_RAMDAC_VPLL2, state->vpll2);
1024        if(pNv->twoStagePLL) {
1025           NVWriteRAMDAC(pNv, 0, NV_RAMDAC_VPLL_B, state->vpllB);
1026           NVWriteRAMDAC(pNv, 0, NV_RAMDAC_VPLL2_B, state->vpll2B);
1027        }
1028     } else {
1029        nvWriteCurRAMDAC(pNv, NV_RAMDAC_FP_CONTROL, state->scale);
1030        nvWriteCurRAMDAC(pNv, NV_RAMDAC_FP_HCRTC, state->crtcSync);
1031     }
1032     nvWriteCurRAMDAC(pNv, NV_RAMDAC_GENERAL_CONTROL, state->general);
1033
1034     nvWriteCurCRTC(pNv, NV_CRTC_INTR_EN_0, 0);
1035     nvWriteCurCRTC(pNv, NV_CRTC_INTR_0, NV_CRTC_INTR_VBLANK);
1036 }
1037
1038 void NVUnloadStateExt
1039 (
1040     NVPtr pNv,
1041     RIVA_HW_STATE *state
1042 )
1043 {
1044     state->repaint0     = nvReadCurVGA(pNv, NV_CIO_CRE_RPC0_INDEX);
1045     state->repaint1     = nvReadCurVGA(pNv, NV_CIO_CRE_RPC1_INDEX);
1046     state->screen       = nvReadCurVGA(pNv, NV_CIO_CRE_LSR_INDEX);
1047     state->pixel        = nvReadCurVGA(pNv, NV_CIO_CRE_PIXEL_INDEX);
1048     state->horiz        = nvReadCurVGA(pNv, NV_CIO_CRE_HEB__INDEX);
1049     state->fifo         = nvReadCurVGA(pNv, NV_CIO_CRE_ENH_INDEX);
1050     state->arbitration0 = nvReadCurVGA(pNv, NV_CIO_CRE_FF_INDEX);
1051     state->arbitration1 = nvReadCurVGA(pNv, NV_CIO_CRE_FFLWM__INDEX);
1052     if(pNv->Architecture >= NV_ARCH_30) {
1053        state->arbitration1 |= (nvReadCurVGA(pNv, NV_CIO_CRE_47) & 1) << 8;
1054     }
1055     state->cursor0      = nvReadCurVGA(pNv, NV_CIO_CRE_HCUR_ADDR0_INDEX);
1056     state->cursor1      = nvReadCurVGA(pNv, NV_CIO_CRE_HCUR_ADDR1_INDEX);
1057     state->cursor2      = nvReadCurVGA(pNv, NV_CIO_CRE_HCUR_ADDR2_INDEX);
1058     state->interlace    = nvReadCurVGA(pNv, NV_CIO_CRE_ILACE__INDEX);
1059
1060     state->vpll         = NVReadRAMDAC(pNv, 0, NV_RAMDAC_VPLL);
1061     if(pNv->twoHeads)
1062        state->vpll2     = NVReadRAMDAC(pNv, 0, NV_RAMDAC_VPLL2);
1063     if(pNv->twoStagePLL) {
1064         state->vpllB    = NVReadRAMDAC(pNv, 0, NV_RAMDAC_VPLL_B);
1065         state->vpll2B   = NVReadRAMDAC(pNv, 0, NV_RAMDAC_VPLL2_B);
1066     }
1067     state->pllsel       = NVReadRAMDAC(pNv, 0, NV_RAMDAC_PLL_SELECT);
1068     state->general      = nvReadCurRAMDAC(pNv, NV_RAMDAC_GENERAL_CONTROL);
1069     state->scale        = nvReadCurRAMDAC(pNv, NV_RAMDAC_FP_CONTROL);
1070
1071     if(pNv->Architecture >= NV_ARCH_10) {
1072         if(pNv->twoHeads) {
1073            state->head     = NVReadCRTC(pNv, 0, NV_CRTC_FSEL);
1074            state->head2    = NVReadCRTC(pNv, 1, NV_CRTC_FSEL);
1075            state->crtcOwner = nvReadCurVGA(pNv, NV_CIO_CRE_44);
1076         }
1077         state->extra = nvReadCurVGA(pNv, NV_CIO_CRE_EBR_INDEX);
1078
1079         state->cursorConfig = nvReadCurCRTC(pNv, NV_CRTC_CURSOR_CONFIG);
1080
1081         if((pNv->Chipset & 0x0ff0) == CHIPSET_NV11) {
1082            state->dither = nvReadCurRAMDAC(pNv, NV_RAMDAC_DITHER_NV11);
1083         } else
1084         if(pNv->twoHeads) {
1085             state->dither = nvReadCurRAMDAC(pNv, NV_RAMDAC_FP_DITHER);
1086         }
1087
1088         if(pNv->FlatPanel) {
1089            state->timingH = nvReadCurVGA(pNv, NV_CIO_CRE_53);
1090            state->timingV = nvReadCurVGA(pNv, NV_CIO_CRE_54);
1091         }
1092     }
1093
1094     if(pNv->FlatPanel) {
1095        state->crtcSync = nvReadCurRAMDAC(pNv, NV_RAMDAC_FP_HCRTC);
1096     }
1097 }
1098
1099 void NVSetStartAddress (
1100     NVPtr   pNv,
1101     CARD32 start
1102 )
1103 {
1104     nvWriteCurCRTC(pNv, NV_CRTC_START, start);
1105 }
1106
1107 uint32_t nv_pitch_align(NVPtr pNv, uint32_t width, int bpp)
1108 {
1109         int mask;
1110
1111         if (bpp == 15)
1112                 bpp = 16;
1113         if (bpp == 24)
1114                 bpp = 8;
1115
1116         /* Alignment requirements taken from the Haiku driver */
1117         if (pNv->Architecture == NV_ARCH_04)
1118                 mask = 128 / bpp - 1;
1119         else
1120                 mask = 512 / bpp - 1;
1121
1122         return (width + mask) & ~mask;
1123 }
1124
1125 void nv_save_restore_vga_fonts(ScrnInfoPtr pScrn, bool save)
1126 {
1127         NVPtr pNv = NVPTR(pScrn);
1128         bool graphicsmode;
1129         uint8_t misc, gr4, gr5, gr6, seq2, seq4;
1130         int i;
1131
1132         NVSetEnablePalette(pNv, 0, true);
1133         graphicsmode = NVReadVgaAttr(pNv, 0, NV_CIO_AR_MODE_INDEX) & 1;
1134         NVSetEnablePalette(pNv, 0, false);
1135
1136         if (graphicsmode)       /* graphics mode => framebuffer => no need to save */
1137                 return;
1138
1139         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "%sing VGA fonts\n", save ? "Sav" : "Restor");
1140         if (pNv->twoHeads)
1141                 NVBlankScreen(pNv, 1, true);
1142         NVBlankScreen(pNv, 0, true);
1143
1144         /* save control regs */
1145         misc = NVReadPRMVIO(pNv, 0, NV_PRMVIO_MISC__READ);
1146         seq2 = NVReadVgaSeq(pNv, 0, NV_VIO_SR_PLANE_MASK_INDEX);
1147         seq4 = NVReadVgaSeq(pNv, 0, NV_VIO_SR_MEM_MODE_INDEX);
1148         gr4 = NVReadVgaGr(pNv, 0, NV_VIO_GX_READ_MAP_INDEX);
1149         gr5 = NVReadVgaGr(pNv, 0, NV_VIO_GX_MODE_INDEX);
1150         gr6 = NVReadVgaGr(pNv, 0, NV_VIO_GX_MISC_INDEX);
1151
1152         NVWritePRMVIO(pNv, 0, NV_PRMVIO_MISC__WRITE, 0x67);
1153         NVWriteVgaSeq(pNv, 0, NV_VIO_SR_MEM_MODE_INDEX, 0x6);
1154         NVWriteVgaGr(pNv, 0, NV_VIO_GX_MODE_INDEX, 0x0);
1155         NVWriteVgaGr(pNv, 0, NV_VIO_GX_MISC_INDEX, 0x5);
1156
1157         /* store font in plane 0 */
1158         NVWriteVgaSeq(pNv, 0, NV_VIO_SR_PLANE_MASK_INDEX, 0x1);
1159         NVWriteVgaGr(pNv, 0, NV_VIO_GX_READ_MAP_INDEX, 0x0);
1160         for (i = 0; i < 16384; i++)
1161                 if (save)
1162                         pNv->saved_vga_font[0][i] = MMIO_IN32(pNv->FB_BAR, i * 4);
1163                 else
1164                         MMIO_OUT32(pNv->FB_BAR, i * 4, pNv->saved_vga_font[0][i]);
1165
1166         /* store font in plane 1 */
1167         NVWriteVgaSeq(pNv, 0, NV_VIO_SR_PLANE_MASK_INDEX, 0x2);
1168         NVWriteVgaGr(pNv, 0, NV_VIO_GX_READ_MAP_INDEX, 0x1);
1169         for (i = 0; i < 16384; i++)
1170                 if (save)
1171                         pNv->saved_vga_font[1][i] = MMIO_IN32(pNv->FB_BAR, i * 4);
1172                 else
1173                         MMIO_OUT32(pNv->FB_BAR, i * 4, pNv->saved_vga_font[1][i]);
1174
1175         /* store font in plane 2 */
1176         NVWriteVgaSeq(pNv, 0, NV_VIO_SR_PLANE_MASK_INDEX, 0x4);
1177         NVWriteVgaGr(pNv, 0, NV_VIO_GX_READ_MAP_INDEX, 0x2);
1178         for (i = 0; i < 16384; i++)
1179                 if (save)
1180                         pNv->saved_vga_font[2][i] = MMIO_IN32(pNv->FB_BAR, i * 4);
1181                 else
1182                         MMIO_OUT32(pNv->FB_BAR, i * 4, pNv->saved_vga_font[2][i]);
1183
1184         /* store font in plane 3 */
1185         NVWriteVgaSeq(pNv, 0, NV_VIO_SR_PLANE_MASK_INDEX, 0x8);
1186         NVWriteVgaGr(pNv, 0, NV_VIO_GX_READ_MAP_INDEX, 0x3);
1187         for (i = 0; i < 16384; i++)
1188                 if (save)
1189                         pNv->saved_vga_font[3][i] = MMIO_IN32(pNv->FB_BAR, i * 4);
1190                 else
1191                         MMIO_OUT32(pNv->FB_BAR, i * 4, pNv->saved_vga_font[3][i]);
1192
1193         /* restore control regs */
1194         NVWritePRMVIO(pNv, 0, NV_PRMVIO_MISC__WRITE, misc);
1195         NVWriteVgaGr(pNv, 0, NV_VIO_GX_READ_MAP_INDEX, gr4);
1196         NVWriteVgaGr(pNv, 0, NV_VIO_GX_MODE_INDEX, gr5);
1197         NVWriteVgaGr(pNv, 0, NV_VIO_GX_MISC_INDEX, gr6);
1198         NVWriteVgaSeq(pNv, 0, NV_VIO_SR_PLANE_MASK_INDEX, seq2);
1199         NVWriteVgaSeq(pNv, 0, NV_VIO_SR_MEM_MODE_INDEX, seq4);
1200
1201         if (pNv->twoHeads)
1202                 NVBlankScreen(pNv, 1, false);
1203         NVBlankScreen(pNv, 0, false);
1204 }