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