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

   1 /*
   2  * Copyright 2005-2006 Erik Waling
   3  * Copyright 2006 Stephane Marchesin
   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 #include "nvreg.h"
  26 #include <byteswap.h>
  27
  28 /* FIXME: put these somewhere */
  29 #define CRTC_INDEX_COLOR (VGA_IOBASE_COLOR + VGA_CRTC_INDEX_OFFSET)
  30 #define NV_VGA_CRTCX_OWNER_HEADA 0x0
  31 #define NV_VGA_CRTCX_OWNER_HEADB 0x3
  32 #define NV_PBUS_PCI_NV_19 0x0000184C
  33 #define NV_PBUS_PCI_NV_20 0x00001850
  34 #define NV_PBUS_PCI_NV_20_ROM_SHADOW_DISABLED 0x00000000
  35 #define NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED 0x00000001
  36 #define NV_PEXTDEV_BOOT_0 0x00101000
  37 /* undef, as we want the +0x00100000 version */
  38 #undef NV_PFB_CFG0
  39 #define NV_PFB_CFG0 0x00100200
  40 #define NV_PFB_REFCTRL 0x00100210
  41 #define NV_PFB_REFCTRL_VALID_1 0x80000000
  42 #define NV_PRAMIN_ROM_OFFSET 0x00700000
  43
  44 #define DEBUGLEVEL 6
  45
  46 /* TODO:
  47  *       * PLL algorithms.
  48  */
  49
  50 static int crtchead = 0;
  51
  52 /* this will need remembering across a suspend */
  53 static uint32_t saved_nv_pfb_cfg0;
  54
  55 typedef struct {
  56         Bool execute;
  57         Bool repeat;
  58 } init_exec_t;
  59
  60 static uint16_t le16_to_cpu(const uint16_t x)
  61 {
  62 #if X_BYTE_ORDER == X_BIG_ENDIAN
  63         return bswap_16(x);
  64 #else
  65         return x;
  66 #endif
  67 }
  68
  69 static uint32_t le32_to_cpu(const uint32_t x)
  70 {
  71 #if X_BYTE_ORDER == X_BIG_ENDIAN
  72         return bswap_32(x);
  73 #else
  74         return x;
  75 #endif
  76 }
  77
  78 static Bool nv_cksum(const uint8_t *data, unsigned int length)
  79 {
  80         /* there's a few checksums in the BIOS, so here's a generic checking function */
  81         int i;
  82         uint8_t sum = 0;
  83
  84         for (i = 0; i < length; i++)
  85                 sum += data[i];
  86
  87         if (sum)
  88                 return TRUE;
  89
  90         return FALSE;
  91 }
  92
  93 static int NVValidVBIOS(ScrnInfoPtr pScrn, const uint8_t *data)
  94 {
  95         /* check for BIOS signature */
  96         if (!(data[0] == 0x55 && data[1] == 0xAA)) {
  97                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
  98                            "... BIOS signature not found\n");
  99                 return 0;
 100         }
 101
 102         if (nv_cksum(data, data[2] * 512)) {
 103                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 104                            "... BIOS checksum invalid\n");
 105                 /* probably ought to set a do_not_execute flag for table parsing here,
 106                  * assuming most BIOSen are valid */
 107                 return 1;
 108         } else
 109                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "... appears to be valid\n");
 110
 111         return 2;
 112 }
 113
 114 static void NVShadowVBIOS_PROM(ScrnInfoPtr pScrn, uint8_t *data)
 115 {
 116         NVPtr pNv = NVPTR(pScrn);
 117         int i;
 118
 119         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 120                    "Attempting to locate BIOS image in PROM\n");
 121
 122         /* enable ROM access */
 123         nvWriteMC(pNv, NV_PBUS_PCI_NV_20, NV_PBUS_PCI_NV_20_ROM_SHADOW_DISABLED);
 124         for (i = 0; i < NV_PROM_SIZE; i++) {
 125                 /* according to nvclock, we need that to work around a 6600GT/6800LE bug */
 126                 data[i] = pNv->PROM[i];
 127                 data[i] = pNv->PROM[i];
 128                 data[i] = pNv->PROM[i];
 129                 data[i] = pNv->PROM[i];
 130                 data[i] = pNv->PROM[i];
 131         }
 132         /* disable ROM access */
 133         nvWriteMC(pNv, NV_PBUS_PCI_NV_20, NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED);
 134 }
 135
 136 static void NVShadowVBIOS_PRAMIN(ScrnInfoPtr pScrn, uint32_t *data)
 137 {
 138         NVPtr pNv = NVPTR(pScrn);
 139         const uint32_t *pramin = (uint32_t *)&pNv->REGS[NV_PRAMIN_ROM_OFFSET/4];
 140         uint32_t old_bar0_pramin = 0;
 141
 142         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 143                    "Attempting to locate BIOS image in PRAMIN\n");
 144
 145         if (pNv->Architecture >= NV_ARCH_50) {
 146                 uint32_t vbios_vram;
 147
 148                 vbios_vram = (pNv->REGS[0x619f04/4] & ~0xff) << 8;
 149                 if (!vbios_vram) {
 150                         vbios_vram = pNv->REGS[0x1700/4] << 16;
 151                         vbios_vram += 0xf0000;
 152                 }
 153
 154                 old_bar0_pramin = pNv->REGS[0x1700/4];
 155                 pNv->REGS[0x1700/4] = vbios_vram >> 16;
 156         }
 157
 158         memcpy(data, pramin, NV_PROM_SIZE);
 159
 160         if (pNv->Architecture >= NV_ARCH_50) {
 161                 pNv->REGS[0x1700/4] = old_bar0_pramin;
 162         }
 163 }
 164
 165 static void NVVBIOS_PCIROM(ScrnInfoPtr pScrn, uint8_t *data)
 166 {
 167         NVPtr pNv = NVPTR(pScrn);
 168
 169         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 170                    "Attempting to use PCI ROM BIOS image\n");
 171
 172 #if XSERVER_LIBPCIACCESS
 173         pci_device_read_rom(pNv->PciInfo, data);
 174 #else
 175         xf86ReadPciBIOS(0, pNv->PciTag, 0, data, NV_PROM_SIZE);
 176 #endif
 177 }
 178
 179 static Bool NVShadowVBIOS(ScrnInfoPtr pScrn, uint8_t *data)
 180 {
 181         NVShadowVBIOS_PROM(pScrn, data);
 182         if (NVValidVBIOS(pScrn, data) == 2)
 183                 return TRUE;
 184
 185         NVShadowVBIOS_PRAMIN(pScrn, (uint32_t *)data);
 186         if (NVValidVBIOS(pScrn, data))
 187                 return TRUE;
 188
 189 #ifndef __powerpc__
 190         NVVBIOS_PCIROM(pScrn, data);
 191         if (NVValidVBIOS(pScrn, data))
 192                 return TRUE;
 193 #endif
 194
 195         return FALSE;
 196 }
 197
 198 typedef struct {
 199         char* name;
 200         uint8_t id;
 201         int length;
 202         int length_offset;
 203         int length_multiplier;
 204         Bool (*handler)(ScrnInfoPtr pScrn, bios_t *, uint16_t, init_exec_t *);
 205 } init_tbl_entry_t;
 206
 207 typedef struct {
 208         uint8_t id[2];
 209         uint16_t length;
 210         uint16_t offset;
 211 } bit_entry_t;
 212
 213 static void parse_init_table(ScrnInfoPtr pScrn, bios_t *bios, unsigned int offset, init_exec_t *iexec);
 214
 215 #define MACRO_INDEX_SIZE        2
 216 #define MACRO_SIZE              8
 217 #define CONDITION_SIZE          12
 218 #define IO_FLAG_CONDITION_SIZE  9
 219
 220 void still_alive()
 221 {
 222 //      sync();
 223 //      usleep(200);
 224 }
 225
 226 static int nv_valid_reg(NVPtr pNv, uint32_t reg)
 227 {
 228         /* C51 has misaligned regs on purpose. Marvellous */
 229         if ((reg & 0x3 && pNv->VBIOS.chip_version != 0x51) ||
 230                         (reg & 0x2 && pNv->VBIOS.chip_version == 0x51)) {
 231                 ErrorF("========== misaligned reg 0x%08X ==========\n", reg);
 232                 return 0;
 233         }
 234
 235         #define WITHIN(x,y,z) ((x>=y)&&(x<y+z))
 236         if (WITHIN(reg,NV_PRAMIN_OFFSET,NV_PRAMIN_SIZE))
 237                 return 1;
 238         if (WITHIN(reg,NV_PCRTC0_OFFSET,NV_PCRTC0_SIZE))
 239                 return 1;
 240         if (WITHIN(reg,NV_PRAMDAC0_OFFSET,NV_PRAMDAC0_SIZE))
 241                 return 1;
 242         if (WITHIN(reg,NV_PFB_OFFSET,NV_PFB_SIZE))
 243                 return 1;
 244         if (WITHIN(reg,NV_PFIFO_OFFSET,NV_PFIFO_SIZE))
 245                 return 1;
 246         if (WITHIN(reg,NV_PGRAPH_OFFSET,NV_PGRAPH_SIZE))
 247                 return 1;
 248         if (WITHIN(reg,NV_PEXTDEV_OFFSET,NV_PEXTDEV_SIZE))
 249                 return 1;
 250         if (WITHIN(reg,NV_PTIMER_OFFSET,NV_PTIMER_SIZE))
 251                 return 1;
 252         if (WITHIN(reg,NV_PVIDEO_OFFSET,NV_PVIDEO_SIZE))
 253                 return 1;
 254         if (WITHIN(reg,NV_PMC_OFFSET,NV_PMC_SIZE))
 255                 return 1;
 256         if (WITHIN(reg,NV_FIFO_OFFSET,NV_FIFO_SIZE))
 257                 return 1;
 258         if (WITHIN(reg,NV_PCIO0_OFFSET,NV_PCIO0_SIZE))
 259                 return 1;
 260         if (WITHIN(reg,NV_PDIO0_OFFSET,NV_PDIO0_SIZE))
 261                 return 1;
 262         if (WITHIN(reg,NV_PVIO_OFFSET,NV_PVIO_SIZE))
 263                 return 1;
 264         if (WITHIN(reg,NV_PROM_OFFSET,NV_PROM_SIZE))
 265                 return 1;
 266         if (WITHIN(reg,NV_PRAMIN_ROM_OFFSET,NV_PROM_SIZE))
 267                 return 1;
 268         /* NV40+ PBUS */
 269         if (WITHIN(reg,0x88000,0x1000))
 270                 return 1;
 271         #undef WITHIN
 272
 273         ErrorF("========== unknown reg 0x%08X ==========\n", reg);
 274
 275         return 0;
 276 }
 277
 278 static uint32_t nv32_rd(ScrnInfoPtr pScrn, uint32_t reg)
 279 {
 280         NVPtr pNv = NVPTR(pScrn);
 281         uint32_t data;
 282
 283         if (!nv_valid_reg(pNv, reg))
 284                 return 0;
 285
 286         /* C51 sometimes uses regs with bit0 set in the address. For these
 287          * cases there should exist a translation in a BIOS table to an IO
 288          * port address which the BIOS uses for accessing the reg
 289          *
 290          * These only seem to appear for the power control regs to a flat panel
 291          * and in C51 mmio traces the normal regs for 0x1308 and 0x1310 are
 292          * used - hence the mask below. An S3 suspend-resume mmio trace from a
 293          * C51 will be required to see if this is true for the power microcode
 294          * in 0x14.., or whether the direct IO port access method is needed
 295          */
 296         if (reg & 0x1)
 297                 reg &= ~0x1;
 298
 299         data = pNv->REGS[reg/4];
 300
 301         if (DEBUGLEVEL >= 6)
 302                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 303                            "    Read:  Reg: 0x%08X, Data: 0x%08X\n", reg, data);
 304
 305         return data;
 306 }
 307
 308 static int nv32_wr(ScrnInfoPtr pScrn, uint32_t reg, uint32_t data)
 309 {
 310         NVPtr pNv = NVPTR(pScrn);
 311
 312         if (!nv_valid_reg(pNv, reg))
 313                 return 0;
 314
 315         /* see note in nv32_rd */
 316         if (reg & 0x1)
 317                 reg &= 0xfffffffe;
 318
 319         if (DEBUGLEVEL >= 8)
 320                 nv32_rd(pScrn, reg);
 321         if (DEBUGLEVEL >= 6)
 322                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 323                            "    Write: Reg: 0x%08X, Data: 0x%08X\n", reg, data);
 324
 325         if (pNv->VBIOS.execute) {
 326                 still_alive();
 327                 pNv->REGS[reg/4] = data;
 328         }
 329
 330         return 1;
 331 }
 332
 333 static uint8_t nv_idx_port_rd(ScrnInfoPtr pScrn, uint16_t port, uint8_t index)
 334 {
 335         NVPtr pNv = NVPTR(pScrn);
 336         volatile uint8_t *ptr = crtchead ? pNv->PCIO1 : pNv->PCIO0;
 337         uint8_t data;
 338
 339         VGA_WR08(ptr, port, index);
 340         data = VGA_RD08(ptr, port + 1);
 341
 342         if (DEBUGLEVEL >= 6)
 343                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 344                            "    Indexed read:  Port: 0x%04X, Index: 0x%02X, Head: 0x%02X, Data: 0x%02X\n",
 345                            port, index, crtchead, data);
 346
 347         return data;
 348 }
 349
 350 static void nv_idx_port_wr(ScrnInfoPtr pScrn, uint16_t port, uint8_t index, uint8_t data)
 351 {
 352         NVPtr pNv = NVPTR(pScrn);
 353         volatile uint8_t *ptr;
 354
 355         /* The current head is maintained in a file scope variable crtchead.
 356          * We trap changes to CRTCX_OWNER and update the head variable
 357          * and hence the register set written.
 358          * As CRTCX_OWNER only exists on CRTC0, we update crtchead to head0
 359          * in advance of the write, and to head1 after the write
 360          */
 361         if (port == CRTC_INDEX_COLOR && index == NV_VGA_CRTCX_OWNER && data != NV_VGA_CRTCX_OWNER_HEADB)
 362                 crtchead = 0;
 363         ptr = crtchead ? pNv->PCIO1 : pNv->PCIO0;
 364
 365         if (DEBUGLEVEL >= 8)
 366                 nv_idx_port_rd(pScrn, port, index);
 367         if (DEBUGLEVEL >= 6)
 368                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 369                            "    Indexed write: Port: 0x%04X, Index: 0x%02X, Head: 0x%02X, Data: 0x%02X\n",
 370                            port, index, crtchead, data);
 371
 372         if (pNv->VBIOS.execute) {
 373                 still_alive();
 374                 VGA_WR08(ptr, port, index);
 375                 VGA_WR08(ptr, port + 1, data);
 376         }
 377
 378         if (port == CRTC_INDEX_COLOR && index == NV_VGA_CRTCX_OWNER && data == NV_VGA_CRTCX_OWNER_HEADB)
 379                 crtchead = 1;
 380 }
 381
 382 #define ACCESS_UNLOCK 0
 383 #define ACCESS_LOCK 1
 384 static void crtc_access(ScrnInfoPtr pScrn, Bool lock)
 385 {
 386         NVPtr pNv = NVPTR(pScrn);
 387         int savedhead = crtchead;
 388         uint8_t cr11;
 389
 390         /* necessary external dependancy (twoHeads) */
 391         if (pNv->twoHeads)
 392                 nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_OWNER, NV_VGA_CRTCX_OWNER_HEADA);
 393         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_LOCK, lock ? 0x99 : 0x57);
 394         cr11 = nv_idx_port_rd(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_VSYNCE);
 395         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_VSYNCE, lock ? cr11 | 0x80 : cr11 & ~0x80);
 396
 397         if (pNv->twoHeads) {
 398                 nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_OWNER, NV_VGA_CRTCX_OWNER_HEADB);
 399                 nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_LOCK, lock ? 0x99 : 0x57);
 400                 cr11 = nv_idx_port_rd(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_VSYNCE);
 401                 nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_VSYNCE, lock ? cr11 | 0x80 : cr11 & ~0x80);
 402         }
 403
 404         crtchead = savedhead;
 405 }
 406
 407 static Bool io_flag_condition(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, uint8_t cond)
 408 {
 409         /* The IO flag condition entry has 2 bytes for the CRTC port; 1 byte
 410          * for the CRTC index; 1 byte for the mask to apply to the value
 411          * retrieved from the CRTC; 1 byte for the shift right to apply to the
 412          * masked CRTC value; 2 bytes for the offset to the flag array, to
 413          * which the shifted value is added; 1 byte for the mask applied to the
 414          * value read from the flag array; and 1 byte for the value to compare
 415          * against the masked byte from the flag table.
 416          */
 417
 418         uint16_t condptr = bios->io_flag_condition_tbl_ptr + cond * IO_FLAG_CONDITION_SIZE;
 419         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[condptr])));
 420         uint8_t crtcindex = bios->data[condptr + 2];
 421         uint8_t mask = bios->data[condptr + 3];
 422         uint8_t shift = bios->data[condptr + 4];
 423         uint16_t flagarray = le16_to_cpu(*((uint16_t *)(&bios->data[condptr + 5])));
 424         uint8_t flagarraymask = bios->data[condptr + 7];
 425         uint8_t cmpval = bios->data[condptr + 8];
 426         uint8_t data;
 427
 428         if (DEBUGLEVEL >= 6)
 429                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 430                            "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, Shift: 0x%02X, FlagArray: 0x%04X, FAMask: 0x%02X, Cmpval: 0x%02X\n",
 431                            offset, crtcport, crtcindex, mask, shift, flagarray, flagarraymask, cmpval);
 432
 433         data = nv_idx_port_rd(pScrn, crtcport, crtcindex);
 434
 435         data = bios->data[flagarray + ((data & mask) >> shift)];
 436         data &= flagarraymask;
 437
 438         if (DEBUGLEVEL >= 6)
 439                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 440                            "0x%04X: Checking if 0x%02X equals 0x%02X\n",
 441                            offset, data, cmpval);
 442
 443         if (data == cmpval)
 444                 return TRUE;
 445
 446         return FALSE;
 447 }
 448
 449 uint32_t getMNP_single(ScrnInfoPtr pScrn, uint32_t clk, int *bestNM, int *bestlog2P)
 450 {
 451         /* Find M, N and P for a single stage PLL
 452          *
 453          * Note that some bioses (NV3x) have lookup tables of precomputed MNP
 454          * values, but we're too lazy to use those atm
 455          *
 456          * "clk" parameter in kHz
 457          * returns calculated clock
 458          */
 459
 460         bios_t *bios = &NVPTR(pScrn)->VBIOS;
 461         int maxM = 0, M, N;
 462         int maxlog2P, log2P, P;
 463         int crystal = 0;
 464         uint32_t minvco = bios->fminvco;
 465         uint32_t maxvco = bios->fmaxvco;
 466         int clkP;
 467         int calcclk, delta;
 468         unsigned int bestdelta = UINT_MAX;
 469         uint32_t bestclk = 0;
 470
 471         unsigned int crystal_strap_mask = 1 << 6;
 472         /* open coded pNv->twoHeads test */
 473         if (bios->chip_version > 0x10 && bios->chip_version != 0x15 &&
 474             bios->chip_version != 0x1a && bios->chip_version != 0x20)
 475                 crystal_strap_mask |= 1 << 22;
 476         switch (nv32_rd(pScrn, NV_PEXTDEV_BOOT_0) & crystal_strap_mask) {
 477         case 0:
 478                 maxM = 13;
 479                 crystal = 13500;
 480                 break;
 481         case (1 << 6):
 482                 maxM = 14;
 483                 crystal = 14318;
 484                 break;
 485         case (1 << 22):
 486         case (1 << 22 | 1 << 6):
 487                 maxM = 14;
 488                 crystal = 27000;
 489                 break;
 490         }
 491
 492         /* this division verified for nv20, nv28 (Haiku), nv34 -- nv17 is guessed */
 493         /* possibly correlated with introduction of 27MHz crystal */
 494         if (bios->chip_version <= 0x16 || bios->chip_version == 0x20) {
 495                 if (clk > 250000)
 496                         maxM = 6;
 497                 if (clk > 340000)
 498                         maxM = 2;
 499                 maxlog2P = 4;
 500         } else {
 501                 if (clk > 150000)
 502                         maxM = 6;
 503                 if (clk > 200000)
 504                         maxM = 4;
 505                 if (clk > 340000)
 506                         maxM = 2;
 507                 maxlog2P = 5;
 508         }
 509
 510         if ((clk << maxlog2P) < minvco) {
 511                 minvco = clk << maxlog2P;
 512                 maxvco = minvco * 2;
 513         }
 514         if (clk + clk/200 > maxvco)     /* +0.5% */
 515                 maxvco = clk + clk/200;
 516
 517         /* NV34 goes maxlog2P->0, NV20 goes 0->maxlog2P */
 518         for (log2P = 0; log2P <= maxlog2P; log2P++) {
 519                 P = 1 << log2P;
 520                 clkP = clk * P;
 521                 if (clkP < minvco)
 522                         continue;
 523                 if (clkP > maxvco)
 524                         return bestclk;
 525
 526                 /* nv_hw.c in nv driver uses 7 and 8 for minM */
 527                 for (M = 1; M <= maxM; M++) {
 528                         /* add crystal/2 to round better */
 529                         N = (clkP * M + crystal/2) / crystal;
 530                         if (N > 256)    /* we lost */
 531                                 goto nextP;
 532
 533                         /* more rounding additions */
 534                         calcclk = ((N * crystal + P/2) / P + M/2) / M;
 535                         delta = abs(calcclk - clk);
 536                         /* we do an exhaustive search rather than terminating
 537                          * on an optimality condition...
 538                          */
 539                         if (delta < bestdelta) {
 540                                 bestdelta = delta;
 541                                 bestclk = calcclk;
 542                                 *bestNM = N << 8 | M;
 543                                 *bestlog2P = log2P;
 544                                 if (delta == 0) /* except this one */
 545                                         return bestclk;
 546                         }
 547                 }
 548 nextP:
 549                 continue;
 550         }
 551
 552         return bestclk;
 553 }
 554
 555 Bool get_pll_limits(ScrnInfoPtr pScrn, uint32_t reg, struct pll_lims *pll_lim);
 556
 557 int getMNP_double(ScrnInfoPtr pScrn, uint32_t reg, int clk, int *bestNM1, int *bestNM2, int *bestlog2P)
 558 {
 559         /* Find M, N and P for a two stage PLL
 560          *
 561          * Note that some bioses (NV30+) have lookup tables of precomputed MNP
 562          * values, but we're too lazy to use those atm
 563          *
 564          * "clk" parameter in kHz
 565          * returns calculated clock
 566          */
 567
 568         struct pll_lims pll_lim;
 569
 570         /* high regs (such as in the mac g5 table) are not -= 4 */
 571         if (reg > 0x405c)
 572                 reg += 4;
 573         if (!get_pll_limits(pScrn, reg - 4, &pll_lim))
 574                 return 0;
 575
 576         int minvco1 = pll_lim.vco1.minfreq, maxvco1 = pll_lim.vco1.maxfreq;
 577         int minvco2 = pll_lim.vco2.minfreq, maxvco2 = pll_lim.vco2.maxfreq;
 578         int minU1 = pll_lim.vco1.min_inputfreq, minU2 = pll_lim.vco2.min_inputfreq;
 579         int maxU1 = pll_lim.vco1.max_inputfreq, maxU2 = pll_lim.vco2.max_inputfreq;
 580         int minM1 = pll_lim.vco1.min_m, maxM1 = pll_lim.vco1.max_m;
 581         int minN1 = pll_lim.vco1.min_n, maxN1 = pll_lim.vco1.max_n;
 582         int minM2 = pll_lim.vco2.min_m, maxM2 = pll_lim.vco2.max_m;
 583         int minN2 = pll_lim.vco2.min_n, maxN2 = pll_lim.vco2.max_n;
 584         Bool fixedgain2 = (minM2 == maxM2 && minN2 == maxN2);
 585         int crystal = 0;
 586         int M1, N1, M2, N2, log2P;
 587         int clkP, calcclk1, calcclk2, calcclkout;
 588         int delta, bestdelta = INT_MAX;
 589         int bestclk = 0;
 590
 591         if (pll_lim.refclk)
 592                 crystal = pll_lim.refclk;
 593         else
 594                 switch (nv32_rd(pScrn, NV_PEXTDEV_BOOT_0) & (1 << 22 | 1 << 6)) {
 595                 case 0:
 596                         crystal = 13500;
 597                         break;
 598                 case (1 << 6):
 599                         crystal = 14318;
 600                         break;
 601                 case (1 << 22):
 602                         crystal = 27000;
 603                         break;
 604                 case (1 << 22 | 1 << 6):
 605                         crystal = 25000;
 606                         break;
 607                 }
 608
 609         int vco2 = (maxvco2 - maxvco2/200) / 2;
 610         for (log2P = 0; log2P < 6 && clk <= (vco2 >> log2P); log2P++) /* log2P is maximum of 6 */
 611                 ;
 612         clkP = clk << log2P;
 613
 614         if (maxvco2 < clk + clk/200)    /* +0.5% */
 615                 maxvco2 = clk + clk/200;
 616
 617         for (M1 = minM1; M1 <= maxM1; M1++) {
 618                 if (crystal/M1 < minU1)
 619                         return bestclk;
 620                 if (crystal/M1 > maxU1)
 621                         continue;
 622
 623                 for (N1 = minN1; N1 <= maxN1; N1++) {
 624                         calcclk1 = crystal * N1 / M1;
 625                         if (calcclk1 < minvco1)
 626                                 continue;
 627                         if (calcclk1 > maxvco1)
 628                                 break;
 629
 630                         for (M2 = minM2; M2 <= maxM2; M2++) {
 631                                 if (calcclk1/M2 < minU2)
 632                                         break;
 633                                 if (calcclk1/M2 > maxU2)
 634                                         continue;
 635
 636                                 /* add calcclk1/2 to round better */
 637                                 N2 = (clkP * M2 + calcclk1/2) / calcclk1;
 638                                 if (N2 < minN2)
 639                                         continue;
 640                                 if (N2 > maxN2)
 641                                         break;
 642
 643                                 if (!fixedgain2) {
 644                                         if (N2/M2 < 4 || N2/M2 > 10)
 645                                                 continue;
 646
 647                                         calcclk2 = calcclk1 * N2 / M2;
 648                                         if (calcclk2 < minvco2)
 649                                                 break;
 650                                         if (calcclk2 > maxvco2)
 651                                                 continue;
 652                                 } else
 653                                         calcclk2 = calcclk1;
 654
 655                                 calcclkout = calcclk2 >> log2P;
 656                                 delta = abs(calcclkout - clk);
 657                                 /* we do an exhaustive search rather than terminating
 658                                  * on an optimality condition...
 659                                  */
 660                                 if (delta < bestdelta) {
 661                                         bestdelta = delta;
 662                                         bestclk = calcclkout;
 663                                         *bestNM1 = N1 << 8 | M1;
 664                                         *bestNM2 = N2 << 8 | M2;
 665                                         *bestlog2P = log2P;
 666                                         if (delta == 0) /* except this one */
 667                                                 return bestclk;
 668                                 }
 669                         }
 670                 }
 671         }
 672
 673         return bestclk;
 674 }
 675
 676 static void setPLL_single(ScrnInfoPtr pScrn, uint32_t reg, int NM, int log2P)
 677 {
 678         uint32_t pll;
 679
 680         pll = nv32_rd(pScrn, reg);
 681         if (pll == (log2P << 16 | NM))
 682                 return; /* already set */
 683
 684 #if 0
 685         //this stuff is present on my nv34 and something similar on the nv31
 686         //it is not on nv20, and I don't know how useful or necessary it is
 687
 688         uint32_t saved_1584, shift_1584;
 689         Bool frob1584 = FALSE;
 690         switch (reg) {
 691         case 0x680500:
 692                 shift_1584 = 0;
 693                 frob1584 = TRUE;
 694                 break;
 695         case 0x680504:
 696                 shift_1584 = 4;
 697                 frob1584 = TRUE;
 698                 break;
 699         case 0x680508:
 700                 shift_1584 = 8;
 701                 frob1584 = TRUE;
 702                 break;
 703         case 0x680520:
 704                 shift_1584 = 12;
 705                 frob1584 = TRUE;
 706                 break;
 707         }
 708
 709         if (frob1584) {
 710                 saved_1584 = nv32_rd(pScrn, 0x00001584);
 711                 nv32_wr(pScrn, 0x00001584, (saved_1584 & ~(0xf << shift_1584)) | 1 << shift_1584);
 712         }
 713 #endif
 714
 715         /* write NM first */
 716         pll = (pll & 0xffff0000) | NM;
 717         nv32_wr(pScrn, reg, pll);
 718
 719         /* wait a bit */
 720         usleep(64000);
 721         nv32_rd(pScrn, reg);
 722
 723         /* then write P as well */
 724         nv32_wr(pScrn, reg, (pll & 0xfff8ffff) | log2P << 16);
 725
 726 #if 0
 727         if (frob1584)
 728                 nv32_wr(pScrn, 0x00001584, saved_1584);
 729 #endif
 730 }
 731
 732 static void setPLL_double_highregs(ScrnInfoPtr pScrn, uint32_t reg1, int NM1, int NM2, int log2P)
 733 {
 734         bios_t *bios = &NVPTR(pScrn)->VBIOS;
 735         uint32_t reg2 = reg1 + ((reg1 == 0x680520) ? 0x5c : 0x70);
 736         uint32_t oldpll1 = nv32_rd(pScrn, reg1), oldpll2 = nv32_rd(pScrn, reg2);
 737         uint32_t pll1 = (oldpll1 & 0xfff80000) | log2P << 16 | NM1;
 738         uint32_t pll2 = (oldpll2 & 0x7fff0000) | 1 << 31 | NM2;
 739         uint32_t saved1584 = 0, savedc040 = 0, maskc040 = ~0;
 740         int shift1584 = -1;
 741
 742         if (oldpll1 == pll1 && oldpll2 == pll2)
 743                 return; /* already set */
 744
 745         if (reg1 == 0x680500) {
 746                 shift1584 = 0;
 747                 maskc040 = ~(3 << 20);
 748         }
 749         if (reg1 == 0x680504) {
 750                 shift1584 = 4;
 751                 maskc040 = ~(3 << 22);
 752         }
 753         if (shift1584 >= 0) {
 754                 saved1584 = nv32_rd(pScrn, 0x1584);
 755                 nv32_wr(pScrn, 0x1584, (saved1584 & ~(0xf << shift1584)) | 1 << shift1584);
 756         }
 757
 758         if (bios->chip_version >= 0x40) {
 759                 savedc040 = nv32_rd(pScrn, 0xc040);
 760                 nv32_wr(pScrn, 0xc040, savedc040 & maskc040);
 761
 762                 if (reg1 == 0x680508)
 763                         nv32_wr(pScrn, 0x680580, nv32_rd(pScrn, 0x680580) & ~(1 << 28));
 764                 if (reg1 == 0x680520)
 765                         nv32_wr(pScrn, 0x680580, nv32_rd(pScrn, 0x680580) & ~(1 << 8));
 766         }
 767
 768         nv32_wr(pScrn, reg2, pll2);
 769         nv32_wr(pScrn, reg1, pll1);
 770
 771         if (shift1584 >= 0) {
 772                 nv32_wr(pScrn, 0x1584, saved1584);
 773                 if (bios->chip_version >= 0x40)
 774                         nv32_wr(pScrn, 0xc040, savedc040);
 775         }
 776 }
 777
 778 static void setPLL_double_lowregs(ScrnInfoPtr pScrn, uint32_t NMNMreg, int NM1, int NM2, int log2P)
 779 {
 780         /* When setting PLLs, there is a merry game of disabling and enabling
 781          * various bits of hardware during the process. This function is a
 782          * synthesis of six nv40 traces, nearly each card doing a subtly
 783          * different thing. With luck all the necessary bits for each card are
 784          * combined herein. Without luck it deviates from each card's formula
 785          * so as to not work on any :)
 786          */
 787
 788         uint32_t Preg = NMNMreg - 4;
 789         uint32_t oldPval = nv32_rd(pScrn, Preg);
 790         uint32_t NMNM = NM2 << 16 | NM1;
 791         uint32_t Pval = (oldPval & ((Preg == 0x4020) ? ~(0x11 << 16) : ~(1 << 16))) | 0xc << 28 | log2P << 16;
 792         uint32_t saved4600 = 0;
 793         /* some cards have different maskc040s */
 794         uint32_t maskc040 = ~(3 << 14), savedc040;
 795
 796         if (nv32_rd(pScrn, NMNMreg) == NMNM && (oldPval & 0xc0070000) == Pval)
 797                 return;
 798
 799         if (Preg == 0x4000)
 800                 maskc040 = ~0x333;
 801         if (Preg == 0x4058)
 802                 maskc040 = ~(3 << 26);
 803
 804         if (Preg == 0x4020) {
 805                 struct pll_lims pll_lim;
 806                 uint8_t Pval2;
 807
 808                 if (!get_pll_limits(pScrn, Preg, &pll_lim))
 809                         return;
 810
 811                 Pval2 = log2P + pll_lim.p_bias;
 812                 if (Pval2 > pll_lim.max_p)
 813                         Pval2 = pll_lim.max_p;
 814                 Pval |= 1 << 28 | Pval2 << 20;
 815
 816                 saved4600 = nv32_rd(pScrn, 0x4600);
 817                 nv32_wr(pScrn, 0x4600, saved4600 | 1 << 31);
 818         }
 819
 820         nv32_wr(pScrn, Preg, oldPval | 1 << 28);
 821         nv32_wr(pScrn, Preg, Pval & ~(1 << 30));
 822         if (Preg == 0x4020) {
 823                 Pval |= 1 << 23 | 1 << 12;
 824                 nv32_wr(pScrn, 0x4020, Pval & ~(3 << 30));
 825                 nv32_wr(pScrn, 0x4038, Pval & ~(3 << 30));
 826         }
 827
 828         savedc040 = nv32_rd(pScrn, 0xc040);
 829         nv32_wr(pScrn, 0xc040, savedc040 & maskc040);
 830
 831         nv32_wr(pScrn, NMNMreg, NMNM);
 832         if (NMNMreg == 0x4024)
 833                 nv32_wr(pScrn, 0x403c, NMNM);
 834
 835         nv32_wr(pScrn, Preg, Pval);
 836         if (Preg == 0x4020) {
 837                 Pval &= ~(1 << 23);
 838                 nv32_wr(pScrn, 0x4020, Pval);
 839                 nv32_wr(pScrn, 0x4038, Pval);
 840                 nv32_wr(pScrn, 0x4600, saved4600);
 841         }
 842
 843         nv32_wr(pScrn, 0xc040, savedc040);
 844
 845         if (Preg == 0x4020) {
 846                 nv32_wr(pScrn, 0x4020, Pval & ~(1 << 28));
 847                 nv32_wr(pScrn, 0x4038, Pval & ~(1 << 28));
 848         }
 849 }
 850
 851 static void setPLL(ScrnInfoPtr pScrn, bios_t *bios, uint32_t reg, uint32_t clk)
 852 {
 853         /* clk in kHz */
 854         int NM1 = 0xbeef, NM2 = 0xdead, log2P;
 855
 856         if (bios->chip_version >= 0x40 || bios->chip_version == 0x31 || bios->chip_version == 0x36) {
 857                 getMNP_double(pScrn, reg, clk, &NM1, &NM2, &log2P);
 858                 if (reg > 0x405c)
 859                         setPLL_double_highregs(pScrn, reg, NM1, NM2, log2P);
 860                 else
 861                         setPLL_double_lowregs(pScrn, reg, NM1, NM2, log2P);
 862         } else {
 863                 getMNP_single(pScrn, clk, &NM1, &log2P);
 864                 setPLL_single(pScrn, reg, NM1, log2P);
 865         }
 866 }
 867
 868 #if 0
 869 static Bool init_prog(ScrnInfoPtr pScrn, bios_t *bios, CARD16 offset, init_exec_t *iexec)
 870 {
 871         /* INIT_PROG   opcode: 0x31
 872          *
 873          * offset      (8  bit): opcode
 874          * offset + 1  (32 bit): reg
 875          * offset + 5  (32 bit): and mask
 876          * offset + 9  (8  bit): shift right
 877          * offset + 10 (8  bit): number of configurations
 878          * offset + 11 (32 bit): register
 879          * offset + 15 (32 bit): configuration 1
 880          * ...
 881          *
 882          * Starting at offset + 15 there are "number of configurations"
 883          * 32 bit values. To find out which configuration value to use
 884          * read "CRTC reg" on the CRTC controller with index "CRTC index"
 885          * and bitwise AND this value with "and mask" and then bit shift the
 886          * result "shift right" bits to the right.
 887          * Assign "register" with appropriate configuration value.
 888          */
 889
 890         CARD32 reg = *((CARD32 *) (&bios->data[offset + 1]));
 891         CARD32 and = *((CARD32 *) (&bios->data[offset + 5]));
 892         CARD8 shiftr = *((CARD8 *) (&bios->data[offset + 9]));
 893         CARD8 nr = *((CARD8 *) (&bios->data[offset + 10]));
 894         CARD32 reg2 = *((CARD32 *) (&bios->data[offset + 11]));
 895         CARD8 configuration;
 896         CARD32 configval, tmp;
 897
 898         if (iexec->execute) {
 899                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: REG: 0x%04X\n", offset,
 900                                 reg);
 901
 902                 tmp = nv32_rd(pScrn, reg);
 903                 configuration = (tmp & and) >> shiftr;
 904
 905                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CONFIGURATION TO USE: 0x%02X\n",
 906                                 offset, configuration);
 907
 908                 if (configuration <= nr) {
 909
 910                         configval =
 911                                 *((CARD32 *) (&bios->data[offset + 15 + configuration * 4]));
 912
 913                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: REG: 0x%08X, VALUE: 0x%08X\n", offset,
 914                                         reg2, configval);
 915
 916                         tmp = nv32_rd(pScrn, reg2);
 917                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CURRENT VALUE IS: 0x%08X\n",
 918                                 offset, tmp);
 919                         nv32_wr(pScrn, reg2, configval);
 920                 }
 921         }
 922         return TRUE;
 923 }
 924 #endif
 925
 926 static Bool init_io_restrict_prog(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
 927 {
 928         /* INIT_IO_RESTRICT_PROG   opcode: 0x32 ('2')
 929          *
 930          * offset      (8  bit): opcode
 931          * offset + 1  (16 bit): CRTC port
 932          * offset + 3  (8  bit): CRTC index
 933          * offset + 4  (8  bit): mask
 934          * offset + 5  (8  bit): shift
 935          * offset + 6  (8  bit): count
 936          * offset + 7  (32 bit): register
 937          * offset + 11 (32 bit): configuration 1
 938          * ...
 939          *
 940          * Starting at offset + 11 there are "count" 32 bit values.
 941          * To find out which value to use read index "CRTC index" on "CRTC port",
 942          * AND this value with "mask" and then bit shift right "shift" bits.
 943          * Read the appropriate value using this index and write to "register"
 944          */
 945
 946         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
 947         uint8_t crtcindex = bios->data[offset + 3];
 948         uint8_t mask = bios->data[offset + 4];
 949         uint8_t shift = bios->data[offset + 5];
 950         uint8_t count = bios->data[offset + 6];
 951         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 7])));
 952         uint8_t config;
 953         uint32_t configval;
 954
 955         if (!iexec->execute)
 956                 return TRUE;
 957
 958         if (DEBUGLEVEL >= 6)
 959                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 960                            "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
 961                            offset, crtcport, crtcindex, mask, shift, count, reg);
 962
 963         config = (nv_idx_port_rd(pScrn, crtcport, crtcindex) & mask) >> shift;
 964         if (config > count) {
 965                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 966                            "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
 967                            offset, config, count);
 968                 return FALSE;
 969         }
 970
 971         configval = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 11 + config * 4])));
 972
 973         if (DEBUGLEVEL >= 6)
 974                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 975                            "0x%04X: Writing config %02X\n", offset, config);
 976
 977         nv32_wr(pScrn, reg, configval);
 978
 979         return TRUE;
 980 }
 981
 982 static Bool init_repeat(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
 983 {
 984         /* INIT_REPEAT   opcode: 0x33 ('3')
 985          *
 986          * offset      (8 bit): opcode
 987          * offset + 1  (8 bit): count
 988          *
 989          * Execute script following this opcode up to INIT_REPEAT_END
 990          * "count" times
 991          */
 992
 993         uint8_t count = bios->data[offset + 1];
 994         uint8_t i;
 995
 996         /* no iexec->execute check by design */
 997
 998         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 999                    "0x%04X: REPEATING FOLLOWING SEGMENT %d TIMES\n",
1000                    offset, count);
1001
1002         iexec->repeat = TRUE;
1003
1004         /* count - 1, as the script block will execute once when we leave this
1005          * opcode -- this is compatible with bios behaviour as:
1006          * a) the block is always executed at least once, even if count == 0
1007          * b) the bios interpreter skips to the op following INIT_END_REPEAT,
1008          * while we don't
1009          */
1010         for (i = 0; i < count - 1; i++)
1011                 parse_init_table(pScrn, bios, offset + 2, iexec);
1012
1013         iexec->repeat = FALSE;
1014
1015         return TRUE;
1016 }
1017
1018 static Bool init_io_restrict_pll(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1019 {
1020         /* INIT_IO_RESTRICT_PLL   opcode: 0x34 ('4')
1021          *
1022          * offset      (8  bit): opcode
1023          * offset + 1  (16 bit): CRTC port
1024          * offset + 3  (8  bit): CRTC index
1025          * offset + 4  (8  bit): mask
1026          * offset + 5  (8  bit): shift
1027          * offset + 6  (8  bit): IO flag condition index
1028          * offset + 7  (8  bit): count
1029          * offset + 8  (32 bit): register
1030          * offset + 12 (16 bit): frequency 1
1031          * ...
1032          *
1033          * Starting at offset + 12 there are "count" 16 bit frequencies (10kHz).
1034          * Set PLL register "register" to coefficients for frequency n,
1035          * selected by reading index "CRTC index" of "CRTC port" ANDed with
1036          * "mask" and shifted right by "shift". If "IO flag condition index" > 0,
1037          * and condition met, double frequency before setting it.
1038          */
1039
1040         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
1041         uint8_t crtcindex = bios->data[offset + 3];
1042         uint8_t mask = bios->data[offset + 4];
1043         uint8_t shift = bios->data[offset + 5];
1044         int8_t io_flag_condition_idx = bios->data[offset + 6];
1045         uint8_t count = bios->data[offset + 7];
1046         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 8])));
1047         uint8_t config;
1048         uint16_t freq;
1049
1050         if (!iexec->execute)
1051                 return TRUE;
1052
1053         if (DEBUGLEVEL >= 6)
1054                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1055                            "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, Shift: 0x%02X, IO Flag Condition: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
1056                            offset, crtcport, crtcindex, mask, shift, io_flag_condition_idx, count, reg);
1057
1058         config = (nv_idx_port_rd(pScrn, crtcport, crtcindex) & mask) >> shift;
1059         if (config > count) {
1060                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1061                            "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
1062                            offset, config, count);
1063                 return FALSE;
1064         }
1065
1066         freq = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 12 + config * 2])));
1067
1068         if (io_flag_condition_idx > 0) {
1069                 if (io_flag_condition(pScrn, bios, offset, io_flag_condition_idx)) {
1070                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1071                                    "0x%04X: CONDITION FULFILLED - FREQ DOUBLED\n", offset);
1072                         freq *= 2;
1073                 } else
1074                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1075                                    "0x%04X: CONDITION IS NOT FULFILLED. FREQ UNCHANGED\n", offset);
1076         }
1077
1078         if (DEBUGLEVEL >= 6)
1079                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1080                            "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %d0kHz\n",
1081                            offset, reg, config, freq);
1082
1083         setPLL(pScrn, bios, reg, freq * 10);
1084
1085         return TRUE;
1086 }
1087
1088 static Bool init_end_repeat(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1089 {
1090         /* INIT_END_REPEAT   opcode: 0x36 ('6')
1091          *
1092          * offset      (8 bit): opcode
1093          *
1094          * Marks the end of the block for INIT_REPEAT to repeat
1095          */
1096
1097         /* no iexec->execute check by design */
1098
1099         /* iexec->repeat flag necessary to go past INIT_END_REPEAT opcode when
1100          * we're not in repeat mode
1101          */
1102         if (iexec->repeat)
1103                 return FALSE;
1104
1105         return TRUE;
1106 }
1107
1108 static Bool init_copy(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1109 {
1110         /* INIT_COPY   opcode: 0x37 ('7')
1111          *
1112          * offset      (8  bit): opcode
1113          * offset + 1  (32 bit): register
1114          * offset + 5  (8  bit): shift
1115          * offset + 6  (8  bit): srcmask
1116          * offset + 7  (16 bit): CRTC port
1117          * offset + 9  (8 bit): CRTC index
1118          * offset + 10  (8 bit): mask
1119          *
1120          * Read index "CRTC index" on "CRTC port", AND with "mask", OR with
1121          * (REGVAL("register") >> "shift" & "srcmask") and write-back to CRTC port
1122          */
1123
1124         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1125         uint8_t shift = bios->data[offset + 5];
1126         uint8_t srcmask = bios->data[offset + 6];
1127         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 7])));
1128         uint8_t crtcindex = bios->data[offset + 9];
1129         uint8_t mask = bios->data[offset + 10];
1130         uint32_t data;
1131         uint8_t crtcdata;
1132
1133         if (!iexec->execute)
1134                 return TRUE;
1135
1136         if (DEBUGLEVEL >= 6)
1137                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1138                            "0x%04X: Reg: 0x%08X, Shift: 0x%02X, SrcMask: 0x%02X, Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X\n",
1139                            offset, reg, shift, srcmask, crtcport, crtcindex, mask);
1140
1141         data = nv32_rd(pScrn, reg);
1142
1143         if (shift < 0x80)
1144                 data >>= shift;
1145         else
1146                 data <<= (0x100 - shift);
1147
1148         data &= srcmask;
1149
1150         crtcdata = (nv_idx_port_rd(pScrn, crtcport, crtcindex) & mask) | (uint8_t)data;
1151         nv_idx_port_wr(pScrn, crtcport, crtcindex, crtcdata);
1152
1153         return TRUE;
1154 }
1155
1156 static Bool init_not(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1157 {
1158         /* INIT_NOT   opcode: 0x38 ('8')
1159          *
1160          * offset      (8  bit): opcode
1161          *
1162          * Invert the current execute / no-execute condition (i.e. "else")
1163          */
1164         if (iexec->execute)
1165                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1166                            "0x%04X: ------ SKIPPING FOLLOWING COMMANDS  ------\n", offset);
1167         else
1168                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1169                            "0x%04X: ------ EXECUTING FOLLOWING COMMANDS ------\n", offset);
1170
1171         iexec->execute = !iexec->execute;
1172         return TRUE;
1173 }
1174
1175 static Bool init_io_flag_condition(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1176 {
1177         /* INIT_IO_FLAG_CONDITION   opcode: 0x39 ('9')
1178          *
1179          * offset      (8 bit): opcode
1180          * offset + 1  (8 bit): condition number
1181          *
1182          * Check condition "condition number" in the IO flag condition table.
1183          * If condition not met skip subsequent opcodes until condition
1184          * is inverted (INIT_NOT), or we hit INIT_RESUME
1185          */
1186
1187         uint8_t cond = bios->data[offset + 1];
1188
1189         if (!iexec->execute)
1190                 return TRUE;
1191
1192         if (io_flag_condition(pScrn, bios, offset, cond))
1193                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1194                            "0x%04X: CONDITION FULFILLED - CONTINUING TO EXECUTE\n", offset);
1195         else {
1196                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1197                            "0x%04X: CONDITION IS NOT FULFILLED\n", offset);
1198                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1199                            "0x%04X: ------ SKIPPING FOLLOWING COMMANDS  ------\n", offset);
1200                 iexec->execute = FALSE;
1201         }
1202
1203         return TRUE;
1204 }
1205
1206 Bool init_idx_addr_latched(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1207 {
1208         /* INIT_INDEX_ADDRESS_LATCHED   opcode: 0x49 ('I')
1209          *
1210          * offset      (8  bit): opcode
1211          * offset + 1  (32 bit): control register
1212          * offset + 5  (32 bit): data register
1213          * offset + 9  (32 bit): mask
1214          * offset + 13 (32 bit): data
1215          * offset + 17 (8  bit): count
1216          * offset + 18 (8  bit): address 1
1217          * offset + 19 (8  bit): data 1
1218          * ...
1219          *
1220          * For each of "count" address and data pairs, write "data n" to "data register",
1221          * read the current value of "control register", and write it back once ANDed
1222          * with "mask", ORed with "data", and ORed with "address n"
1223          */
1224
1225         uint32_t controlreg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1226         uint32_t datareg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
1227         uint32_t mask = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 9])));
1228         uint32_t data = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 13])));
1229         uint8_t count = bios->data[offset + 17];
1230         uint32_t value;
1231         int i;
1232
1233         if (!iexec->execute)
1234                 return TRUE;
1235
1236         if (DEBUGLEVEL >= 6)
1237                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1238                            "0x%04X: ControlReg: 0x%08X, DataReg: 0x%08X, Mask: 0x%08X, Data: 0x%08X, Count: 0x%02X\n",
1239                            offset, controlreg, datareg, mask, data, count);
1240
1241         for (i = 0; i < count; i++) {
1242                 uint8_t instaddress = bios->data[offset + 18 + i * 2];
1243                 uint8_t instdata = bios->data[offset + 19 + i * 2];
1244
1245                 if (DEBUGLEVEL >= 6)
1246                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1247                                    "0x%04X: Address: 0x%02X, Data: 0x%02X\n", offset, instaddress, instdata);
1248
1249                 nv32_wr(pScrn, datareg, instdata);
1250                 value = (nv32_rd(pScrn, controlreg) & mask) | data | instaddress;
1251                 nv32_wr(pScrn, controlreg, value);
1252         }
1253
1254         return TRUE;
1255 }
1256
1257 static Bool init_io_restrict_pll2(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1258 {
1259         /* INIT_IO_RESTRICT_PLL2   opcode: 0x4A ('J')
1260          *
1261          * offset      (8  bit): opcode
1262          * offset + 1  (16 bit): CRTC port
1263          * offset + 3  (8  bit): CRTC index
1264          * offset + 4  (8  bit): mask
1265          * offset + 5  (8  bit): shift
1266          * offset + 6  (8  bit): count
1267          * offset + 7  (32 bit): register
1268          * offset + 11 (32 bit): frequency 1
1269          * ...
1270          *
1271          * Starting at offset + 11 there are "count" 32 bit frequencies (kHz).
1272          * Set PLL register "register" to coefficients for frequency n,
1273          * selected by reading index "CRTC index" of "CRTC port" ANDed with
1274          * "mask" and shifted right by "shift".
1275          */
1276
1277         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
1278         uint8_t crtcindex = bios->data[offset + 3];
1279         uint8_t mask = bios->data[offset + 4];
1280         uint8_t shift = bios->data[offset + 5];
1281         uint8_t count = bios->data[offset + 6];
1282         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 7])));
1283         uint8_t config;
1284         uint32_t freq;
1285
1286         if (!iexec->execute)
1287                 return TRUE;
1288
1289         if (DEBUGLEVEL >= 6)
1290                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1291                            "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
1292                            offset, crtcport, crtcindex, mask, shift, count, reg);
1293
1294         if (!reg)
1295                 return TRUE;
1296
1297         config = (nv_idx_port_rd(pScrn, crtcport, crtcindex) & mask) >> shift;
1298         if (config > count) {
1299                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1300                            "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
1301                            offset, config, count);
1302                 return FALSE;
1303         }
1304
1305         freq = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 11 + config * 4])));
1306
1307         if (DEBUGLEVEL >= 6)
1308                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1309                            "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %dkHz\n",
1310                            offset, reg, config, freq);
1311
1312         setPLL(pScrn, bios, reg, freq);
1313
1314         return TRUE;
1315 }
1316
1317 static Bool init_pll2(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1318 {
1319         /* INIT_PLL2   opcode: 0x4B ('K')
1320          *
1321          * offset      (8  bit): opcode
1322          * offset + 1  (32 bit): register
1323          * offset + 5  (32 bit): freq
1324          *
1325          * Set PLL register "register" to coefficients for frequency "freq"
1326          */
1327
1328         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1329         uint32_t freq = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
1330
1331         if (!iexec->execute)
1332                 return TRUE;
1333
1334         if (DEBUGLEVEL >= 6)
1335                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1336                            "0x%04X: Reg: 0x%04X, Freq: %dkHz\n",
1337                            offset, reg, freq);
1338
1339         setPLL(pScrn, bios, reg, freq);
1340
1341         return TRUE;
1342 }
1343
1344 static uint32_t get_tmds_index_reg(ScrnInfoPtr pScrn, uint8_t mlv)
1345 {
1346         /* For mlv < 0x80, it is an index into a table of TMDS base addresses
1347          * For mlv == 0x80 use the "or" value of the dcb_entry indexed by CR58 for CR57 = 0
1348          * to index a table of offsets to the basic 0x6808b0 address
1349          * For mlv == 0x81 use the "or" value of the dcb_entry indexed by CR58 for CR57 = 0
1350          * to index a table of offsets to the basic 0x6808b0 address, and then flip the offset by 8
1351          */
1352
1353         NVPtr pNv = NVPTR(pScrn);
1354         int pramdac_offset[13] = {0, 0, 0x8, 0, 0x2000, 0, 0, 0, 0x2008, 0, 0, 0, 0x2000};
1355         uint32_t pramdac_table[4] = {0x6808b0, 0x6808b8, 0x6828b0, 0x6828b8};
1356
1357         if (mlv >= 0x80) {
1358                 /* here we assume that the DCB table has already been parsed */
1359                 uint8_t dcb_entry;
1360                 int dacoffset;
1361                 /* This register needs to be written to set index for reading CR58 */
1362                 nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, 0x57, 0);
1363                 dcb_entry = nv_idx_port_rd(pScrn, CRTC_INDEX_COLOR, 0x58);
1364                 if (dcb_entry > pNv->dcb_table.entries) {
1365                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1366                                    "CR58 doesn't have a valid DCB entry currently (%02X)\n", dcb_entry);
1367                         return FALSE;
1368                 }
1369                 dacoffset = pramdac_offset[pNv->dcb_table.entry[dcb_entry].or];
1370                 if (mlv == 0x81)
1371                         dacoffset ^= 8;
1372                 return (0x6808b0 + dacoffset);
1373         } else {
1374                 if (mlv > (sizeof(pramdac_table) / sizeof(uint32_t))) {
1375                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1376                                    "Magic Lookup Value too big (%02X)\n", mlv);
1377                         return FALSE;
1378                 }
1379                 return pramdac_table[mlv];
1380         }
1381 }
1382
1383 static Bool init_tmds(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1384 {
1385         /* INIT_TMDS   opcode: 0x4F ('O')       (non-canon name)
1386          *
1387          * offset      (8 bit): opcode
1388          * offset + 1  (8 bit): magic lookup value
1389          * offset + 2  (8 bit): TMDS address
1390          * offset + 3  (8 bit): mask
1391          * offset + 4  (8 bit): data
1392          *
1393          * Read the data reg for TMDS address "TMDS address", AND it with mask
1394          * and OR it with data, then write it back
1395          * "magic lookup value" determines which TMDS base address register is used --
1396          * see get_tmds_index_reg()
1397          */
1398
1399         uint8_t mlv = bios->data[offset + 1];
1400         uint32_t tmdsaddr = bios->data[offset + 2];
1401         uint8_t mask = bios->data[offset + 3];
1402         uint8_t data = bios->data[offset + 4];
1403         uint32_t reg, value;
1404
1405         if (!iexec->execute)
1406                 return TRUE;
1407
1408         if (DEBUGLEVEL >= 6)
1409                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1410                            "0x%04X: MagicLookupValue: 0x%02X, TMDSAddr: 0x%02X, Mask: 0x%02X, Data: 0x%02X\n",
1411                            offset, mlv, tmdsaddr, mask, data);
1412
1413         reg = get_tmds_index_reg(pScrn, mlv);
1414
1415         nv32_wr(pScrn, reg, tmdsaddr | 0x10000);
1416         value = (nv32_rd(pScrn, reg + 4) & mask) | data;
1417         nv32_wr(pScrn, reg + 4, value);
1418         nv32_wr(pScrn, reg, tmdsaddr);
1419
1420         return TRUE;
1421 }
1422
1423 Bool init_zm_tmds_group(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1424 {
1425         /* INIT_ZM_TMDS_GROUP   opcode: 0x50 ('P')      (non-canon name)
1426          *
1427          * offset      (8 bit): opcode
1428          * offset + 1  (8 bit): magic lookup value
1429          * offset + 2  (8 bit): count
1430          * offset + 3  (8 bit): addr 1
1431          * offset + 4  (8 bit): data 1
1432          * ...
1433          *
1434          * For each of "count" TMDS address and data pairs write "data n" to "addr n"
1435          * "magic lookup value" determines which TMDS base address register is used --
1436          * see get_tmds_index_reg()
1437          */
1438
1439         uint8_t mlv = bios->data[offset + 1];
1440         uint8_t count = bios->data[offset + 2];
1441         uint32_t reg;
1442         int i;
1443
1444         if (!iexec->execute)
1445                 return TRUE;
1446
1447         if (DEBUGLEVEL >= 6)
1448                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1449                            "0x%04X: MagicLookupValue: 0x%02X, Count: 0x%02X\n",
1450                            offset, mlv, count);
1451
1452         reg = get_tmds_index_reg(pScrn, mlv);
1453
1454         for (i = 0; i < count; i++) {
1455                 uint8_t tmdsaddr = bios->data[offset + 3 + i * 2];
1456                 uint8_t tmdsdata = bios->data[offset + 4 + i * 2];
1457
1458                 nv32_wr(pScrn, reg + 4, tmdsdata);
1459                 nv32_wr(pScrn, reg, tmdsaddr);
1460         }
1461
1462         return TRUE;
1463 }
1464
1465 Bool init_cr_idx_adr_latch(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1466 {
1467         /* INIT_CR_INDEX_ADDRESS_LATCHED   opcode: 0x51 ('Q')
1468          *
1469          * offset      (8 bit): opcode
1470          * offset + 1  (8 bit): CRTC index1
1471          * offset + 2  (8 bit): CRTC index2
1472          * offset + 3  (8 bit): baseaddr
1473          * offset + 4  (8 bit): count
1474          * offset + 5  (8 bit): data 1
1475          * ...
1476          *
1477          * For each of "count" address and data pairs, write "baseaddr + n" to
1478          * "CRTC index1" and "data n" to "CRTC index2"
1479          * Once complete, restore initial value read from "CRTC index1"
1480          */
1481         uint8_t crtcindex1 = bios->data[offset + 1];
1482         uint8_t crtcindex2 = bios->data[offset + 2];
1483         uint8_t baseaddr = bios->data[offset + 3];
1484         uint8_t count = bios->data[offset + 4];
1485         uint8_t oldaddr, data;
1486         int i;
1487
1488         if (!iexec->execute)
1489                 return TRUE;
1490
1491         if (DEBUGLEVEL >= 6)
1492                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1493                            "0x%04X: Index1: 0x%02X, Index2: 0x%02X, BaseAddr: 0x%02X, Count: 0x%02X\n",
1494                            offset, crtcindex1, crtcindex2, baseaddr, count);
1495
1496         oldaddr = nv_idx_port_rd(pScrn, CRTC_INDEX_COLOR, crtcindex1);
1497
1498         for (i = 0; i < count; i++) {
1499                 nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, crtcindex1, baseaddr + i);
1500
1501                 data = bios->data[offset + 5 + i];
1502                 nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, crtcindex2, data);
1503         }
1504
1505         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, crtcindex1, oldaddr);
1506
1507         return TRUE;
1508 }
1509
1510 Bool init_cr(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1511 {
1512         /* INIT_CR   opcode: 0x52 ('R')
1513          *
1514          * offset      (8  bit): opcode
1515          * offset + 1  (8  bit): CRTC index
1516          * offset + 2  (8  bit): mask
1517          * offset + 3  (8  bit): data
1518          *
1519          * Assign the value of at "CRTC index" ANDed with mask and ORed with data
1520          * back to "CRTC index"
1521          */
1522
1523         uint8_t crtcindex = bios->data[offset + 1];
1524         uint8_t mask = bios->data[offset + 2];
1525         uint8_t data = bios->data[offset + 3];
1526         uint8_t value;
1527
1528         if (!iexec->execute)
1529                 return TRUE;
1530
1531         if (DEBUGLEVEL >= 6)
1532                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1533                            "0x%04X: Index: 0x%02X, Mask: 0x%02X, Data: 0x%02X\n",
1534                            offset, crtcindex, mask, data);
1535
1536         value = (nv_idx_port_rd(pScrn, CRTC_INDEX_COLOR, crtcindex) & mask) | data;
1537         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, crtcindex, value);
1538
1539         return TRUE;
1540 }
1541
1542 static Bool init_zm_cr(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1543 {
1544         /* INIT_ZM_CR   opcode: 0x53 ('S')
1545          *
1546          * offset      (8 bit): opcode
1547          * offset + 1  (8 bit): CRTC index
1548          * offset + 2  (8 bit): value
1549          *
1550          * Assign "value" to CRTC register with index "CRTC index".
1551          */
1552
1553         uint8_t crtcindex = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1554         uint8_t data = bios->data[offset + 2];
1555
1556         if (!iexec->execute)
1557                 return TRUE;
1558
1559         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, crtcindex, data);
1560
1561         return TRUE;
1562 }
1563
1564 static Bool init_zm_cr_group(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1565 {
1566         /* INIT_ZM_CR_GROUP   opcode: 0x54 ('T')
1567          *
1568          * offset      (8 bit): opcode
1569          * offset + 1  (8 bit): count
1570          * offset + 2  (8 bit): CRTC index 1
1571          * offset + 3  (8 bit): value 1
1572          * ...
1573          *
1574          * For "count", assign "value n" to CRTC register with index "CRTC index n".
1575          */
1576
1577         uint8_t count = bios->data[offset + 1];
1578         int i;
1579
1580         if (!iexec->execute)
1581                 return TRUE;
1582
1583         for (i = 0; i < count; i++)
1584                 init_zm_cr(pScrn, bios, offset + 2 + 2 * i - 1, iexec);
1585
1586         return TRUE;
1587 }
1588
1589 static Bool init_condition_time(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1590 {
1591         /* INIT_CONDITION_TIME   opcode: 0x56 ('V')
1592          *
1593          * offset      (8 bit): opcode
1594          * offset + 1  (8 bit): condition number
1595          * offset + 2  (8 bit): retries / 50
1596          *
1597          * Check condition "condition number" in the condition table.
1598          * The condition table entry has 4 bytes for the address of the
1599          * register to check, 4 bytes for a mask and 4 for a test value.
1600          * If condition not met sleep for 2ms, and repeat upto "retries" times.
1601          * If still not met after retries, clear execution flag for this table.
1602          */
1603
1604         uint8_t cond = bios->data[offset + 1];
1605         uint16_t retries = bios->data[offset + 2];
1606         uint16_t condptr = bios->condition_tbl_ptr + cond * CONDITION_SIZE;
1607         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[condptr])));
1608         uint32_t mask = le32_to_cpu(*((uint32_t *)(&bios->data[condptr + 4])));
1609         uint32_t cmpval = le32_to_cpu(*((uint32_t *)(&bios->data[condptr + 8])));
1610         uint32_t data = 0;
1611
1612         if (!iexec->execute)
1613                 return TRUE;
1614
1615         retries *= 50;
1616
1617         if (DEBUGLEVEL >= 6)
1618                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1619                            "0x%04X: Cond: 0x%02X, Retries: 0x%02X\n", offset, cond, retries);
1620
1621         for (; retries > 0; retries--) {
1622                 data = nv32_rd(pScrn, reg) & mask;
1623
1624                 if (DEBUGLEVEL >= 6)
1625                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1626                                    "0x%04X: Checking if 0x%08X equals 0x%08X\n",
1627                                    offset, data, cmpval);
1628
1629                 if (data != cmpval) {
1630                         if (DEBUGLEVEL >= 6)
1631                                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1632                                            "0x%04X: Condition not met, sleeping for 2ms\n", offset);
1633                         usleep(2000);
1634                 } else {
1635                         if (DEBUGLEVEL >= 6)
1636                                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1637                                            "0x%04X: Condition met, continuing\n", offset);
1638                         break;
1639                 }
1640         }
1641
1642         if (data != cmpval) {
1643                 if (DEBUGLEVEL >= 6)
1644                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1645                                    "0x%04X: Condition still not met, skiping following opcodes\n", offset);
1646                 iexec->execute = FALSE;
1647         }
1648
1649         return TRUE;
1650 }
1651
1652 static Bool init_zm_reg_sequence(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1653 {
1654         /* INIT_ZM_REG_SEQUENCE   opcode: 0x58 ('X')
1655          *
1656          * offset      (8  bit): opcode
1657          * offset + 1  (32 bit): base register
1658          * offset + 5  (8  bit): count
1659          * offset + 6  (32 bit): value 1
1660          * ...
1661          *
1662          * Starting at offset + 6 there are "count" 32 bit values.
1663          * For "count" iterations set "base register" + 4 * current_iteration
1664          * to "value current_iteration"
1665          */
1666
1667         uint32_t basereg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1668         uint32_t count = bios->data[offset + 5];
1669         int i;
1670
1671         if (!iexec->execute)
1672                 return TRUE;
1673
1674         if (DEBUGLEVEL >= 6)
1675                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1676                            "0x%04X: BaseReg: 0x%08X, Count: 0x%02X\n",
1677                            offset, basereg, count);
1678
1679         for (i = 0; i < count; i++) {
1680                 uint32_t reg = basereg + i * 4;
1681                 uint32_t data = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 6 + i * 4])));
1682
1683                 nv32_wr(pScrn, reg, data);
1684         }
1685
1686         return TRUE;
1687 }
1688
1689 #if 0
1690 static Bool init_indirect_reg(ScrnInfoPtr pScrn, bios_t *bios, CARD16 offset, init_exec_t *iexec)
1691 {
1692         /* INIT_INDIRECT_REG opcode: 0x5A
1693          *
1694          * offset      (8  bit): opcode
1695          * offset + 1  (32 bit): register
1696          * offset + 5  (16 bit): adress offset (in bios)
1697          *
1698          * Lookup value at offset data in the bios and write it to reg
1699          */
1700         CARD32 reg = *((CARD32 *) (&bios->data[offset + 1]));
1701         CARD16 data = le16_to_cpu(*((CARD16 *) (&bios->data[offset + 5])));
1702         CARD32 data2 = bios->data[data];
1703
1704         if (iexec->execute) {
1705                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1706                                 "0x%04X: REG: 0x%04X, DATA AT: 0x%04X, VALUE IS: 0x%08X\n",
1707                                 offset, reg, data, data2);
1708
1709                 if (DEBUGLEVEL >= 6) {
1710                         CARD32 tmpval;
1711                         tmpval = nv32_rd(pScrn, reg);
1712                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CURRENT VALUE IS: 0x%08X\n", offset, tmpval);
1713                 }
1714
1715                 nv32_wr(pScrn, reg, data2);
1716         }
1717         return TRUE;
1718 }
1719 #endif
1720
1721 static Bool init_sub_direct(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1722 {
1723         /* INIT_SUB_DIRECT   opcode: 0x5B ('[')
1724          *
1725          * offset      (8  bit): opcode
1726          * offset + 1  (16 bit): subroutine offset (in bios)
1727          *
1728          * Calls a subroutine that will execute commands until INIT_DONE
1729          * is found.
1730          */
1731
1732         uint16_t sub_offset = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
1733
1734         if (!iexec->execute)
1735                 return TRUE;
1736
1737         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: EXECUTING SUB-ROUTINE AT 0x%04X\n",
1738                         offset, sub_offset);
1739
1740         parse_init_table(pScrn, bios, sub_offset, iexec);
1741
1742         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: END OF SUB-ROUTINE AT 0x%04X\n",
1743                         offset, sub_offset);
1744
1745         return TRUE;
1746 }
1747
1748 static Bool init_copy_nv_reg(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1749 {
1750         /* INIT_COPY_NV_REG   opcode: 0x5F ('_')
1751          *
1752          * offset      (8  bit): opcode
1753          * offset + 1  (32 bit): src reg
1754          * offset + 5  (8  bit): shift
1755          * offset + 6  (32 bit): src mask
1756          * offset + 10 (32 bit): xor
1757          * offset + 14 (32 bit): dst reg
1758          * offset + 18 (32 bit): dst mask
1759          *
1760          * Shift REGVAL("src reg") right by (signed) "shift", AND result with
1761          * "src mask", then XOR with "xor". Write this OR'd with
1762          * (REGVAL("dst reg") AND'd with "dst mask") to "dst reg"
1763          */
1764
1765         uint32_t srcreg = *((uint32_t *)(&bios->data[offset + 1]));
1766         uint8_t shift = bios->data[offset + 5];
1767         uint32_t srcmask = *((uint32_t *)(&bios->data[offset + 6]));
1768         uint32_t xor = *((uint32_t *)(&bios->data[offset + 10]));
1769         uint32_t dstreg = *((uint32_t *)(&bios->data[offset + 14]));
1770         uint32_t dstmask = *((uint32_t *)(&bios->data[offset + 18]));
1771         uint32_t srcvalue, dstvalue;
1772
1773         if (!iexec->execute)
1774                 return TRUE;
1775
1776         if (DEBUGLEVEL >= 6)
1777                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1778                            "0x%04X: SrcReg: 0x%08X, Shift: 0x%02X, SrcMask: 0x%08X, Xor: 0x%08X, DstReg: 0x%08X, DstMask: 0x%08X\n",
1779                            offset, srcreg, shift, srcmask, xor, dstreg, dstmask);
1780
1781         srcvalue = nv32_rd(pScrn, srcreg);
1782
1783         if (shift < 0x80)
1784                 srcvalue >>= shift;
1785         else
1786                 srcvalue <<= (0x100 - shift);
1787
1788         srcvalue = (srcvalue & srcmask) ^ xor;
1789
1790         dstvalue = nv32_rd(pScrn, dstreg) & dstmask;
1791
1792         nv32_wr(pScrn, dstreg, dstvalue | srcvalue);
1793
1794         return TRUE;
1795 }
1796
1797 static Bool init_zm_index_io(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1798 {
1799         /* INIT_ZM_INDEX_IO   opcode: 0x62 ('b')
1800          *
1801          * offset      (8  bit): opcode
1802          * offset + 1  (16 bit): CRTC port
1803          * offset + 3  (8  bit): CRTC index
1804          * offset + 4  (8  bit): data
1805          *
1806          * Write "data" to index "CRTC index" of "CRTC port"
1807          */
1808         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
1809         uint8_t crtcindex = bios->data[offset + 3];
1810         uint8_t data = bios->data[offset + 4];
1811
1812         if (!iexec->execute)
1813                 return TRUE;
1814
1815         nv_idx_port_wr(pScrn, crtcport, crtcindex, data);
1816
1817         return TRUE;
1818 }
1819
1820 static Bool init_compute_mem(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1821 {
1822         /* INIT_COMPUTE_MEM   opcode: 0x63 ('c')
1823          *
1824          * offset      (8 bit): opcode
1825          *
1826          * This opcode is meant to set NV_PFB_CFG0 (0x100200) appropriately so
1827          * that the hardware can correctly calculate how much VRAM it has
1828          * (and subsequently report that value in 0x10020C)
1829          *
1830          * The implementation of this opcode in general consists of two parts:
1831          * 1) determination of the memory bus width
1832          * 2) determination of how many of the card's RAM pads have ICs attached
1833          *
1834          * 1) is done by a cunning combination of writes to offsets 0x1c and
1835          * 0x3c in the framebuffer, and seeing whether the written values are
1836          * read back correctly. This then affects bits 4-7 of NV_PFB_CFG0
1837          *
1838          * 2) is done by a cunning combination of writes to an offset slightly
1839          * less than the maximum memory reported by 0x10020C, then seeing if
1840          * the test pattern can be read back. This then affects bits 12-15 of
1841          * NV_PFB_CFG0
1842          *
1843          * In this context a "cunning combination" may include multiple reads
1844          * and writes to varying locations, often alternating the test pattern
1845          * and 0, doubtless to make sure buffers are filled, residual charges
1846          * on tracks are removed etc.
1847          *
1848          * Unfortunately, the "cunning combination"s mentioned above, and the
1849          * changes to the bits in NV_PFB_CFG0 differ with nearly every bios
1850          * trace I have.
1851          *
1852          * Therefore, we cheat and assume the value of NV_PFB_CFG0 with which
1853          * we started was correct, and use that instead
1854          */
1855
1856         /* no iexec->execute check by design */
1857
1858         /* on every card I've seen, this step gets done for us earlier in the init scripts
1859         uint8_t crdata = nv_idx_port_rd(pScrn, VGA_SEQ_INDEX, 0x01);
1860         nv_idx_port_wr(pScrn, VGA_SEQ_INDEX, 0x01, crdata | 0x20);
1861         */
1862
1863         /* this also has probably been done in the scripts, but an mmio trace of
1864          * s3 resume shows nvidia doing it anyway (unlike the VGA_SEQ_INDEX write)
1865          */
1866         nv32_wr(pScrn, NV_PFB_REFCTRL, NV_PFB_REFCTRL_VALID_1);
1867
1868         /* write back the saved configuration value */
1869         nv32_wr(pScrn, NV_PFB_CFG0, saved_nv_pfb_cfg0);
1870
1871         return TRUE;
1872 }
1873
1874 static Bool init_reset(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1875 {
1876         /* INIT_RESET   opcode: 0x65 ('e')
1877          *
1878          * offset      (8  bit): opcode
1879          * offset + 1  (32 bit): register
1880          * offset + 5  (32 bit): value1
1881          * offset + 9  (32 bit): value2
1882          *
1883          * Assign "value1" to "register", then assign "value2" to "register"
1884          */
1885
1886         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1887         uint32_t value1 = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
1888         uint32_t value2 = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 9])));
1889         uint32_t pci_nv_19, pci_nv_20;
1890
1891         /* no iexec->execute check by design */
1892
1893         pci_nv_19 = nv32_rd(pScrn, NV_PBUS_PCI_NV_19);
1894         nv32_wr(pScrn, NV_PBUS_PCI_NV_19, 0);
1895         nv32_wr(pScrn, reg, value1);
1896
1897         usleep(10);
1898
1899         nv32_wr(pScrn, reg, value2);
1900         nv32_wr(pScrn, NV_PBUS_PCI_NV_19, pci_nv_19);
1901
1902         pci_nv_20 = nv32_rd(pScrn, NV_PBUS_PCI_NV_20);
1903         pci_nv_20 &= ~NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED;     /* 0xfffffffe */
1904         nv32_wr(pScrn, NV_PBUS_PCI_NV_20, pci_nv_20);
1905
1906         return TRUE;
1907 }
1908
1909 #if 0
1910 static Bool init_index_io8(ScrnInfoPtr pScrn, bios_t *bios, CARD16 offset, init_exec_t *iexec)
1911 {
1912         /* INIT_INDEX_IO8   opcode: 0x69
1913          *
1914          * offset      (8  bit): opcode
1915          * offset + 1  (16 bit): CRTC reg
1916          * offset + 3  (8  bit): and mask
1917          * offset + 4  (8  bit): or with
1918          *
1919          *
1920          */
1921
1922         NVPtr pNv = NVPTR(pScrn);
1923         volatile CARD8 *ptr = crtchead ? pNv->PCIO1 : pNv->PCIO0;
1924         CARD16 reg = le16_to_cpu(*((CARD16 *)(&bios->data[offset + 1])));
1925         CARD8 and  = *((CARD8 *)(&bios->data[offset + 3]));
1926         CARD8 or = *((CARD8 *)(&bios->data[offset + 4]));
1927         CARD8 data;
1928
1929         if (iexec->execute) {
1930                 data = (VGA_RD08(ptr, reg) & and) | or;
1931
1932                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1933                                 "0x%04X: CRTC REG: 0x%04X, VALUE: 0x%02X\n",
1934                                 offset, reg, data);
1935                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CURRENT VALUE IS: 0x%02X\n", offset,
1936                                 VGA_RD08(ptr, reg));
1937
1938 #ifdef PERFORM_WRITE
1939                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "init_index_io8 crtcreg 0x%X value 0x%X\n",reg,data);
1940                 still_alive();
1941                 VGA_WR08(ptr, reg, data);
1942 #endif
1943         }
1944         return TRUE;
1945 }
1946 #endif
1947
1948 static Bool init_sub(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1949 {
1950         /* INIT_SUB   opcode: 0x6B ('k')
1951          *
1952          * offset      (8 bit): opcode
1953          * offset + 1  (8 bit): script number
1954          *
1955          * Execute script number "script number", as a subroutine
1956          */
1957
1958         uint8_t sub = bios->data[offset + 1];
1959
1960         if (!iexec->execute)
1961                 return TRUE;
1962
1963         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1964                    "0x%04X: EXECUTING SUB-SCRIPT %d\n", offset, sub);
1965
1966         parse_init_table(pScrn, bios,
1967                          le16_to_cpu(*((uint16_t *)(&bios->data[bios->init_script_tbls_ptr + sub * 2]))),
1968                          iexec);
1969
1970         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1971                    "0x%04X: END OF SUB-SCRIPT %d\n", offset, sub);
1972
1973         return TRUE;
1974 }
1975
1976 #if 0
1977 static Bool init_ram_condition(ScrnInfoPtr pScrn, bios_t *bios, CARD16 offset, init_exec_t *iexec)
1978 {
1979         /* INIT_RAM_CONDITION   opcode: 0x6D
1980          *
1981          * offset      (8  bit): opcode
1982          * offset + 1  (8  bit): and mask
1983          * offset + 2  (8  bit): cmpval
1984          *
1985          * Test if (NV_PFB_BOOT & and mask) matches cmpval
1986          */
1987         NVPtr pNv = NVPTR(pScrn);
1988         CARD8 and = *((CARD8 *) (&bios->data[offset + 1]));
1989         CARD8 cmpval = *((CARD8 *) (&bios->data[offset + 2]));
1990         CARD32 data;
1991
1992         if (iexec->execute) {
1993                 data=(pNv->PFB[NV_PFB_BOOT/4])&and;
1994
1995                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1996                                 "0x%04X: CHECKING IF REGVAL: 0x%08X equals COND: 0x%08X\n",
1997                                 offset, data, cmpval);
1998
1999                 if (data == cmpval) {
2000                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2001                                         "0x%04X: CONDITION FULFILLED - CONTINUING TO EXECUTE\n",
2002                                         offset);
2003                 } else {
2004                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CONDITION IS NOT FULFILLED\n", offset);
2005                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2006                                         "0x%04X: ------ SKIPPING FOLLOWING COMMANDS  ------\n", offset);
2007                         iexec->execute = FALSE;
2008                 }
2009         }
2010         return TRUE;
2011 }
2012 #endif
2013
2014 static Bool init_nv_reg(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2015 {
2016         /* INIT_NV_REG   opcode: 0x6E ('n')
2017          *
2018          * offset      (8  bit): opcode
2019          * offset + 1  (32 bit): register
2020          * offset + 5  (32 bit): mask
2021          * offset + 9  (32 bit): data
2022          *
2023          * Assign ((REGVAL("register") & "mask") | "data") to "register"
2024          */
2025
2026         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
2027         uint32_t mask = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
2028         uint32_t data = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 9])));
2029
2030         if (!iexec->execute)
2031                 return TRUE;
2032
2033         if (DEBUGLEVEL >= 6)
2034                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2035                            "0x%04X: Reg: 0x%08X, Mask: 0x%08X, Data: 0x%08X\n",
2036                            offset, reg, mask, data);
2037
2038         nv32_wr(pScrn, reg, (nv32_rd(pScrn, reg) & mask) | data);
2039
2040         return TRUE;
2041 }
2042
2043 static Bool init_macro(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2044 {
2045         /* INIT_MACRO   opcode: 0x6F ('o')
2046          *
2047          * offset      (8 bit): opcode
2048          * offset + 1  (8 bit): macro number
2049          *
2050          * Look up macro index "macro number" in the macro index table.
2051          * The macro index table entry has 1 byte for the index in the macro table,
2052          * and 1 byte for the number of times to repeat the macro.
2053          * The macro table entry has 4 bytes for the register address and
2054          * 4 bytes for the value to write to that register
2055          */
2056
2057         uint8_t macro_index_tbl_idx = bios->data[offset + 1];
2058         uint16_t tmp = bios->macro_index_tbl_ptr + (macro_index_tbl_idx * MACRO_INDEX_SIZE);
2059         uint8_t macro_tbl_idx = bios->data[tmp];
2060         uint8_t count = bios->data[tmp + 1];
2061         uint32_t reg, data;
2062         int i;
2063
2064         if (!iexec->execute)
2065                 return TRUE;
2066
2067         if (DEBUGLEVEL >= 6)
2068                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2069                            "0x%04X: Macro: 0x%02X, MacroTableIndex: 0x%02X, Count: 0x%02X\n",
2070                            offset, macro_index_tbl_idx, macro_tbl_idx, count);
2071
2072         for (i = 0; i < count; i++) {
2073                 uint16_t macroentryptr = bios->macro_tbl_ptr + (macro_tbl_idx + i) * MACRO_SIZE;
2074
2075                 reg = le32_to_cpu(*((uint32_t *)(&bios->data[macroentryptr])));
2076                 data = le32_to_cpu(*((uint32_t *)(&bios->data[macroentryptr + 4])));
2077
2078                 nv32_wr(pScrn, reg, data);
2079         }
2080
2081         return TRUE;
2082 }
2083
2084 static Bool init_done(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2085 {
2086         /* INIT_DONE   opcode: 0x71 ('q')
2087          *
2088          * offset      (8  bit): opcode
2089          *
2090          * End the current script
2091          */
2092
2093         /* mild retval abuse to stop parsing this table */
2094         return FALSE;
2095 }
2096
2097 static Bool init_resume(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2098 {
2099         /* INIT_RESUME   opcode: 0x72 ('r')
2100          *
2101          * offset      (8  bit): opcode
2102          *
2103          * End the current execute / no-execute condition
2104          */
2105
2106         if (iexec->execute)
2107                 return TRUE;
2108
2109         iexec->execute = TRUE;;
2110         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2111                    "0x%04X: ---- EXECUTING FOLLOWING COMMANDS ----\n", offset);
2112
2113         return TRUE;
2114 }
2115
2116 #if 0
2117 static Bool init_ram_condition2(ScrnInfoPtr pScrn, bios_t *bios, CARD16 offset, init_exec_t *iexec)
2118 {
2119         /* INIT_RAM_CONDITION2   opcode: 0x73
2120          *
2121          * offset      (8  bit): opcode
2122          * offset + 1  (8  bit): and mask
2123          * offset + 2  (8  bit): cmpval
2124          *
2125          * Test if (NV_EXTDEV_BOOT & and mask) matches cmpval
2126          */
2127         NVPtr pNv = NVPTR(pScrn);
2128         CARD32 and = *((CARD32 *) (&bios->data[offset + 1]));
2129         CARD32 cmpval = *((CARD32 *) (&bios->data[offset + 5]));
2130         CARD32 data;
2131
2132         if (iexec->execute) {
2133                 data=(nvReadEXTDEV(pNv, NV_PEXTDEV_BOOT))&and;
2134
2135                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2136                                 "0x%04X: CHECKING IF REGVAL: 0x%08X equals COND: 0x%08X\n",
2137                                 offset, data, cmpval);
2138
2139                 if (data == cmpval) {
2140                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2141                                         "0x%04X: CONDITION FULFILLED - CONTINUING TO EXECUTE\n",
2142                                         offset);
2143                 } else {
2144                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CONDITION IS NOT FULFILLED\n", offset);
2145                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2146                                         "0x%04X: ------ SKIPPING FOLLOWING COMMANDS  ------\n", offset);
2147                         iexec->execute = FALSE;
2148                 }
2149         }
2150         return TRUE;
2151 }
2152 #endif
2153
2154 static Bool init_time(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2155 {
2156         /* INIT_TIME   opcode: 0x74 ('t')
2157          *
2158          * offset      (8  bit): opcode
2159          * offset + 1  (16 bit): time
2160          *
2161          * Sleep for "time" microseconds.
2162          */
2163
2164         uint16_t time = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
2165
2166         if (!iexec->execute)
2167                 return TRUE;
2168
2169         if (DEBUGLEVEL >= 6)
2170                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2171                            "0x%04X: Sleeping for 0x%04X microseconds\n", offset, time);
2172
2173         usleep(time);
2174
2175         return TRUE;
2176 }
2177
2178 static Bool init_condition(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2179 {
2180         /* INIT_CONDITION   opcode: 0x75 ('u')
2181          *
2182          * offset      (8 bit): opcode
2183          * offset + 1  (8 bit): condition number
2184          *
2185          * Check condition "condition number" in the condition table.
2186          * The condition table entry has 4 bytes for the address of the
2187          * register to check, 4 bytes for a mask and 4 for a test value.
2188          * If condition not met skip subsequent opcodes until condition
2189          * is inverted (INIT_NOT), or we hit INIT_RESUME
2190          */
2191
2192         uint8_t cond = bios->data[offset + 1];
2193         uint16_t condptr = bios->condition_tbl_ptr + cond * CONDITION_SIZE;
2194         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[condptr])));
2195         uint32_t mask = le32_to_cpu(*((uint32_t *)(&bios->data[condptr + 4])));
2196         uint32_t cmpval = le32_to_cpu(*((uint32_t *)(&bios->data[condptr + 8])));
2197         uint32_t data;
2198
2199         if (!iexec->execute)
2200                 return TRUE;
2201
2202         if (DEBUGLEVEL >= 6)
2203                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2204                            "0x%04X: Cond: 0x%02X, Reg: 0x%08X, Mask: 0x%08X, Cmpval: 0x%08X\n",
2205                            offset, cond, reg, mask, cmpval);
2206
2207         data = nv32_rd(pScrn, reg) & mask;
2208
2209         if (DEBUGLEVEL >= 6)
2210                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2211                            "0x%04X: Checking if 0x%08X equals 0x%08X\n",
2212                            offset, data, cmpval);
2213
2214         if (data == cmpval) {
2215                 if (DEBUGLEVEL >= 6)
2216                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2217                                    "0x%04X: CONDITION FULFILLED - CONTINUING TO EXECUTE\n", offset);
2218         } else {
2219                 if (DEBUGLEVEL >= 6)
2220                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2221                                    "0x%04X: CONDITION IS NOT FULFILLED\n", offset);
2222                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2223                            "0x%04X: ------ SKIPPING FOLLOWING COMMANDS  ------\n", offset);
2224                 iexec->execute = FALSE;
2225         }
2226
2227         return TRUE;
2228 }
2229
2230 static Bool init_index_io(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2231 {
2232         /* INIT_INDEX_IO   opcode: 0x78 ('x')
2233          *
2234          * offset      (8  bit): opcode
2235          * offset + 1  (16 bit): CRTC port
2236          * offset + 3  (8  bit): CRTC index
2237          * offset + 4  (8  bit): mask
2238          * offset + 5  (8  bit): data
2239          *
2240          * Read value at index "CRTC index" on "CRTC port", AND with "mask", OR with "data", write-back
2241          */
2242
2243         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
2244         uint8_t crtcindex = bios->data[offset + 3];
2245         uint8_t mask = bios->data[offset + 4];
2246         uint8_t data = bios->data[offset + 5];
2247         uint8_t value;
2248
2249         if (!iexec->execute)
2250                 return TRUE;
2251
2252         if (DEBUGLEVEL >= 6)
2253                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2254                            "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, Data: 0x%02X\n",
2255                            offset, crtcport, crtcindex, mask, data);
2256
2257         value = (nv_idx_port_rd(pScrn, crtcport, crtcindex) & mask) | data;
2258         nv_idx_port_wr(pScrn, crtcport, crtcindex, value);
2259
2260         return TRUE;
2261 }
2262
2263 static Bool init_pll(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2264 {
2265         /* INIT_PLL   opcode: 0x79 ('y')
2266          *
2267          * offset      (8  bit): opcode
2268          * offset + 1  (32 bit): register
2269          * offset + 5  (16 bit): freq
2270          *
2271          * Set PLL register "register" to coefficients for frequency (10kHz) "freq"
2272          */
2273
2274         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
2275         uint16_t freq = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 5])));
2276
2277         if (!iexec->execute)
2278                 return TRUE;
2279
2280         if (DEBUGLEVEL >= 6)
2281                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2282                            "0x%04X: Reg: 0x%08X, Freq: %d0kHz\n",
2283                            offset, reg, freq);
2284
2285         setPLL(pScrn, bios, reg, freq * 10);
2286
2287         return TRUE;
2288 }
2289
2290 static Bool init_zm_reg(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2291 {
2292         /* INIT_ZM_REG   opcode: 0x7A ('z')
2293          *
2294          * offset      (8  bit): opcode
2295          * offset + 1  (32 bit): register
2296          * offset + 5  (32 bit): value
2297          *
2298          * Assign "value" to "register"
2299          */
2300
2301         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
2302         uint32_t value = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
2303
2304         if (!iexec->execute)
2305                 return TRUE;
2306
2307         nv32_wr(pScrn, reg, value);
2308
2309         return TRUE;
2310 }
2311
2312 /* hack to avoid moving the itbl_entry array before this function */
2313 int init_ram_restrict_zm_reg_group_blocklen = 0;
2314
2315 static Bool init_ram_restrict_zm_reg_group(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2316 {
2317         /* INIT_RAM_RESTRICT_ZM_REG_GROUP   opcode: 0x8F ('')
2318          *
2319          * offset      (8  bit): opcode
2320          * offset + 1  (32 bit): reg
2321          * offset + 5  (8  bit): regincrement
2322          * offset + 6  (8  bit): count
2323          * offset + 7  (32 bit): value 1,1
2324          * ...
2325          *
2326          * Use the RAMCFG strap of PEXTDEV_BOOT as an index into the table at
2327          * ram_restrict_table_ptr. The value read from here is 'n', and
2328          * "value 1,n" gets written to "reg". This repeats "count" times and on
2329          * each iteration 'm', "reg" increases by "regincrement" and
2330          * "value m,n" is used. The extent of n is limited by a number read
2331          * from the 'M' BIT table, herein called "blocklen"
2332          */
2333
2334         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
2335         uint8_t regincrement = bios->data[offset + 5];
2336         uint8_t count = bios->data[offset + 6];
2337         uint32_t strap_ramcfg, data;
2338         uint16_t blocklen;
2339         uint8_t index;
2340         int i;
2341
2342         /* previously set by 'M' BIT table */
2343         blocklen = init_ram_restrict_zm_reg_group_blocklen;
2344
2345         if (!iexec->execute)
2346                 return TRUE;
2347
2348         if (!blocklen) {
2349                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2350                            "0x%04X: Zero block length - has the M table been parsed?\n", offset);
2351                 return FALSE;
2352         }
2353
2354         strap_ramcfg = (nv32_rd(pScrn, NV_PEXTDEV_BOOT_0) >> 2) & 0xf;
2355         index = bios->data[bios->ram_restrict_tbl_ptr + strap_ramcfg];
2356
2357         if (DEBUGLEVEL >= 6)
2358                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2359                            "0x%04X: Reg: 0x%08X, RegIncrement: 0x%02X, Count: 0x%02X, StrapRamCfg: 0x%02X, Index: 0x%02X\n",
2360                            offset, reg, regincrement, count, strap_ramcfg, index);
2361
2362         for (i = 0; i < count; i++) {
2363                 data = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 7 + index * 4 + blocklen * i])));
2364
2365                 nv32_wr(pScrn, reg, data);
2366
2367                 reg += regincrement;
2368         }
2369
2370         return TRUE;
2371 }
2372
2373 static Bool init_copy_zm_reg(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2374 {
2375         /* INIT_COPY_ZM_REG   opcode: 0x90 ('')
2376          *
2377          * offset      (8  bit): opcode
2378          * offset + 1  (32 bit): src reg
2379          * offset + 5  (32 bit): dst reg
2380          *
2381          * Put contents of "src reg" into "dst reg"
2382          */
2383
2384         uint32_t srcreg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
2385         uint32_t dstreg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
2386
2387         if (!iexec->execute)
2388                 return TRUE;
2389
2390         nv32_wr(pScrn, dstreg, nv32_rd(pScrn, srcreg));
2391
2392         return TRUE;
2393 }
2394
2395 static Bool init_zm_reg_group_addr_latched(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2396 {
2397         /* INIT_ZM_REG_GROUP_ADDRESS_LATCHED   opcode: 0x91 ('')
2398          *
2399          * offset      (8  bit): opcode
2400          * offset + 1  (32 bit): src reg
2401          * offset + 5  (8  bit): count
2402          * offset + 6  (32 bit): data 1
2403          * ...
2404          *
2405          * For each of "count" values write "data n" to "src reg"
2406          */
2407
2408         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
2409         uint8_t count = bios->data[offset + 5];
2410         int i;
2411
2412         if (!iexec->execute)
2413                 return TRUE;
2414
2415         for (i = 0; i < count; i++) {
2416                 uint32_t data = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 6 + 4 * i])));
2417                 nv32_wr(pScrn, reg, data);
2418         }
2419
2420         return TRUE;
2421 }
2422
2423 static Bool init_reserved(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
2424 {
2425         /* INIT_RESERVED   opcode: 0x92 ('')
2426          *
2427          * offset      (8 bit): opcode
2428          *
2429          * Seemingly does nothing
2430          */
2431
2432         return TRUE;
2433 }
2434
2435 static init_tbl_entry_t itbl_entry[] = {
2436         /* command name                       , id  , length  , offset  , mult    , command handler                 */
2437 //      { "INIT_PROG"                         , 0x31, 15      , 10      , 4       , init_prog                       },
2438         { "INIT_IO_RESTRICT_PROG"             , 0x32, 11      , 6       , 4       , init_io_restrict_prog           },
2439         { "INIT_REPEAT"                       , 0x33, 2       , 0       , 0       , init_repeat                     },
2440         { "INIT_IO_RESTRICT_PLL"              , 0x34, 12      , 7       , 2       , init_io_restrict_pll            },
2441         { "INIT_END_REPEAT"                   , 0x36, 1       , 0       , 0       , init_end_repeat                 },
2442         { "INIT_COPY"                         , 0x37, 11      , 0       , 0       , init_copy                       },
2443         { "INIT_NOT"                          , 0x38, 1       , 0       , 0       , init_not                        },
2444         { "INIT_IO_FLAG_CONDITION"            , 0x39, 2       , 0       , 0       , init_io_flag_condition          },
2445         { "INIT_INDEX_ADDRESS_LATCHED"        , 0x49, 18      , 17      , 2       , init_idx_addr_latched           },
2446         { "INIT_IO_RESTRICT_PLL2"             , 0x4A, 11      , 6       , 4       , init_io_restrict_pll2           },
2447         { "INIT_PLL2"                         , 0x4B, 9       , 0       , 0       , init_pll2                       },
2448 /*      { "INIT_I2C_BYTE"                     , 0x4C, x       , x       , x       , init_i2c_byte                   }, */
2449 /*      { "INIT_ZM_I2C_BYTE"                  , 0x4D, x       , x       , x       , init_zm_i2c_byte                }, */
2450 /*      { "INIT_ZM_I2C"                       , 0x4E, x       , x       , x       , init_zm_i2c                     }, */
2451         { "INIT_TMDS"                         , 0x4F, 5       , 0       , 0       , init_tmds                       },
2452         { "INIT_ZM_TMDS_GROUP"                , 0x50, 3       , 2       , 2       , init_zm_tmds_group              },
2453         { "INIT_CR_INDEX_ADDRESS_LATCHED"     , 0x51, 5       , 4       , 1       , init_cr_idx_adr_latch           },
2454         { "INIT_CR"                           , 0x52, 4       , 0       , 0       , init_cr                         },
2455         { "INIT_ZM_CR"                        , 0x53, 3       , 0       , 0       , init_zm_cr                      },
2456         { "INIT_ZM_CR_GROUP"                  , 0x54, 2       , 1       , 2       , init_zm_cr_group                },
2457         { "INIT_CONDITION_TIME"               , 0x56, 3       , 0       , 0       , init_condition_time             },
2458         { "INIT_ZM_REG_SEQUENCE"              , 0x58, 6       , 5       , 4       , init_zm_reg_sequence            },
2459 //      { "INIT_INDIRECT_REG"                 , 0x5A, 7       , 0       , 0       , init_indirect_reg               },
2460         { "INIT_SUB_DIRECT"                   , 0x5B, 3       , 0       , 0       , init_sub_direct                 },
2461         { "INIT_COPY_NV_REG"                  , 0x5F, 22      , 0       , 0       , init_copy_nv_reg                },
2462         { "INIT_ZM_INDEX_IO"                  , 0x62, 5       , 0       , 0       , init_zm_index_io                },
2463         { "INIT_COMPUTE_MEM"                  , 0x63, 1       , 0       , 0       , init_compute_mem                },
2464         { "INIT_RESET"                        , 0x65, 13      , 0       , 0       , init_reset                      },
2465 /*      { "INIT_NEXT"                         , 0x66, x       , x       , x       , init_next                       }, */
2466 /*      { "INIT_NEXT"                         , 0x67, x       , x       , x       , init_next                       }, */
2467 /*      { "INIT_NEXT"                         , 0x68, x       , x       , x       , init_next                       }, */
2468 //      { "INIT_INDEX_IO8"                    , 0x69, 5       , 0       , 0       , init_index_io8                  },
2469         { "INIT_SUB"                          , 0x6B, 2       , 0       , 0       , init_sub                        },
2470 //      { "INIT_RAM_CONDITION"                , 0x6D, 3       , 0       , 0       , init_ram_condition              },
2471         { "INIT_NV_REG"                       , 0x6E, 13      , 0       , 0       , init_nv_reg                     },
2472         { "INIT_MACRO"                        , 0x6F, 2       , 0       , 0       , init_macro                      },
2473         { "INIT_DONE"                         , 0x71, 1       , 0       , 0       , init_done                       },
2474         { "INIT_RESUME"                       , 0x72, 1       , 0       , 0       , init_resume                     },
2475 //      { "INIT_RAM_CONDITION2"               , 0x73, 9       , 0       , 0       , init_ram_condition2             },
2476         { "INIT_TIME"                         , 0x74, 3       , 0       , 0       , init_time                       },
2477         { "INIT_CONDITION"                    , 0x75, 2       , 0       , 0       , init_condition                  },
2478 /*      { "INIT_IO_CONDITION"                 , 0x76, x       , x       , x       , init_io_condition               }, */
2479         { "INIT_INDEX_IO"                     , 0x78, 6       , 0       , 0       , init_index_io                   },
2480         { "INIT_PLL"                          , 0x79, 7       , 0       , 0       , init_pll                        },
2481         { "INIT_ZM_REG"                       , 0x7A, 9       , 0       , 0       , init_zm_reg                     },
2482         /* INIT_RAM_RESTRICT_ZM_REG_GROUP's mult is loaded by M table in BIT */
2483         { "INIT_RAM_RESTRICT_ZM_REG_GROUP"    , 0x8F, 7       , 6       , 0       , init_ram_restrict_zm_reg_group  },
2484         { "INIT_COPY_ZM_REG"                  , 0x90, 9       , 0       , 0       , init_copy_zm_reg                },
2485         { "INIT_ZM_REG_GROUP_ADDRESS_LATCHED" , 0x91, 6       , 5       , 4       , init_zm_reg_group_addr_latched  },
2486         { "INIT_RESERVED"                     , 0x92, 1       , 0       , 0       , init_reserved                   },
2487         { 0                                   , 0   , 0       , 0       , 0       , 0                               }
2488 };
2489
2490 static unsigned int get_init_table_entry_length(bios_t *bios, unsigned int offset, int i)
2491 {
2492         /* Calculates the length of a given init table entry. */
2493         return itbl_entry[i].length + bios->data[offset + itbl_entry[i].length_offset]*itbl_entry[i].length_multiplier;
2494 }
2495
2496 static void parse_init_table(ScrnInfoPtr pScrn, bios_t *bios, unsigned int offset, init_exec_t *iexec)
2497 {
2498         /* Parses all commands in a init table. */
2499
2500         /* We start out executing all commands found in the
2501          * init table. Some op codes may change the status
2502          * of this variable to SKIP, which will cause
2503          * the following op codes to perform no operation until
2504          * the value is changed back to EXECUTE.
2505          */
2506         unsigned char id;
2507         int i;
2508
2509         int count=0;
2510         /* Loop until INIT_DONE causes us to break out of the loop
2511          * (or until offset > bios length just in case... )
2512          * (and no more than 10000 iterations just in case... ) */
2513         while ((offset < bios->length) && (count++ < 10000)) {
2514                 id = bios->data[offset];
2515
2516                 /* Find matching id in itbl_entry */
2517                 for (i = 0; itbl_entry[i].name && (itbl_entry[i].id != id); i++)
2518                         ;
2519
2520                 if (itbl_entry[i].name) {
2521                         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%04X: [ (0x%02X) - %s ]\n",
2522                                    offset, itbl_entry[i].id, itbl_entry[i].name);
2523
2524                         /* execute eventual command handler */
2525                         if (itbl_entry[i].handler)
2526                                 if (!(*itbl_entry[i].handler)(pScrn, bios, offset, iexec))
2527                                         break;
2528                 } else {
2529                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2530                                    "0x%04X: Init table command not found: 0x%02X\n", offset, id);
2531                         break;
2532                 }
2533
2534                 /* Add the offset of the current command including all data
2535                  * of that command. The offset will then be pointing on the
2536                  * next op code.
2537                  */
2538                 offset += get_init_table_entry_length(bios, offset, i);
2539         }
2540 }
2541
2542 static void parse_init_tables(ScrnInfoPtr pScrn, bios_t *bios)
2543 {
2544         /* Loops and calls parse_init_table() for each present table. */
2545
2546         int i = 0;
2547         uint16_t table;
2548         init_exec_t iexec = {TRUE, FALSE};
2549
2550         while ((table = le16_to_cpu(*((uint16_t *)(&bios->data[bios->init_script_tbls_ptr + i]))))) {
2551
2552                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%04X: Parsing init table %d\n",
2553                         table, i / 2);
2554
2555                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2556                            "0x%04X: ------ EXECUTING FOLLOWING COMMANDS ------\n", table);
2557                 still_alive();
2558                 parse_init_table(pScrn, bios, table, &iexec);
2559                 i += 2;
2560         }
2561 }
2562
2563 void link_head_and_output(ScrnInfoPtr pScrn, int head, int dcb_entry, Bool overrideval)
2564 {
2565         /* The BIOS scripts don't do this for us, sadly
2566          * Luckily we do know the values ;-)
2567          *
2568          * head < 0 indicates we wish to force a setting with the overrideval
2569          * (for VT restore etc.)
2570          */
2571
2572         NVPtr pNv = NVPTR(pScrn);
2573         int preferred_output = (ffs(pNv->dcb_table.entry[dcb_entry].or) & OUTPUT_1) >> 1;
2574         uint8_t tmds04 = 0x80;
2575         uint32_t tmds_ctrl, tmds_ctrl2;
2576
2577         /* Bit 3 crosswires output and bus. */
2578         if (head >= 0 && head != preferred_output)
2579                 tmds04 = 0x88;
2580         if (head < 0 && overrideval)
2581                 tmds04 = 0x88;
2582
2583         if (pNv->dcb_table.entry[dcb_entry].type == OUTPUT_LVDS)
2584                 tmds04 |= 0x01;
2585
2586         tmds_ctrl = NV_PRAMDAC0_OFFSET + (preferred_output ? NV_PRAMDAC0_SIZE : 0) + NV_RAMDAC_FP_TMDS_CONTROL;
2587         tmds_ctrl2 = NV_PRAMDAC0_OFFSET + (preferred_output ? NV_PRAMDAC0_SIZE : 0) + NV_RAMDAC_FP_TMDS_CONTROL_2;
2588
2589         Bool oldexecute = pNv->VBIOS.execute;
2590         pNv->VBIOS.execute = TRUE;
2591         nv32_wr(pScrn, tmds_ctrl + 4, tmds04);
2592         nv32_wr(pScrn, tmds_ctrl, 0x04);
2593         if (pNv->dcb_table.entry[dcb_entry].type == OUTPUT_LVDS && pNv->VBIOS.fp.dual_link)
2594                 nv32_wr(pScrn, tmds_ctrl2 + 4, tmds04 ^ 0x08);
2595         else {
2596                 /* I have encountered no dvi (dual-link or not) that sets to anything else. */
2597                 /* Does this change beyond the 165 MHz boundary? */
2598                 nv32_wr(pScrn, tmds_ctrl2 + 4, 0x0);
2599         }
2600         nv32_wr(pScrn, tmds_ctrl2, 0x04);
2601         pNv->VBIOS.execute = oldexecute;
2602 }
2603
2604 static void call_lvds_manufacturer_script(ScrnInfoPtr pScrn, int head, int dcb_entry, enum LVDS_script script)
2605 {
2606         NVPtr pNv = NVPTR(pScrn);
2607         bios_t *bios = &pNv->VBIOS;
2608         init_exec_t iexec = {TRUE, FALSE};
2609
2610         uint8_t sub = bios->data[bios->fp.xlated_entry + script];
2611         uint16_t scriptofs = le16_to_cpu(*((uint16_t *)(&bios->data[bios->init_script_tbls_ptr + sub * 2])));
2612         Bool power_off_for_reset;
2613         uint16_t off_on_delay;
2614
2615         if (!bios->fp.xlated_entry || !sub || !scriptofs)
2616                 return;
2617
2618         if (script == LVDS_INIT && bios->data[scriptofs] != 'q') {
2619                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "LVDS init script not stubbed\n");
2620                 return;
2621         }
2622
2623         power_off_for_reset = bios->data[bios->fp.xlated_entry] & 1;
2624         off_on_delay = le16_to_cpu(*(uint16_t *)&bios->data[bios->fp.xlated_entry + 7]);
2625
2626         if (script == LVDS_PANEL_ON && bios->fp.reset_after_pclk_change)
2627                 call_lvds_manufacturer_script(pScrn, head, dcb_entry, LVDS_RESET);
2628         if (script == LVDS_RESET && power_off_for_reset)
2629                 call_lvds_manufacturer_script(pScrn, head, dcb_entry, LVDS_PANEL_OFF);
2630
2631         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Calling LVDS script %d:\n", script);
2632         pNv->VBIOS.execute = TRUE;
2633         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_OWNER,
2634                    head ? NV_VGA_CRTCX_OWNER_HEADB : NV_VGA_CRTCX_OWNER_HEADA);
2635         parse_init_table(pScrn, bios, scriptofs, &iexec);
2636         pNv->VBIOS.execute = FALSE;
2637
2638         if (script == LVDS_PANEL_OFF)
2639                 usleep(off_on_delay * 1000);
2640         if (script == LVDS_RESET)
2641                 link_head_and_output(pScrn, head, dcb_entry, FALSE);
2642 }
2643
2644 static uint16_t clkcmptable(bios_t *bios, uint16_t clktable, int pxclk)
2645 {
2646         int compare_record_len, i = 0;
2647         uint16_t compareclk, scriptptr = 0;
2648
2649         if (bios->major_version < 5) /* pre BIT */
2650                 compare_record_len = 3;
2651         else
2652                 compare_record_len = 4;
2653
2654         do {
2655                 compareclk = le16_to_cpu(*((uint16_t *)&bios->data[clktable + compare_record_len * i]));
2656                 if (pxclk >= compareclk * 10) {
2657                         if (bios->major_version < 5) {
2658                                 uint8_t tmdssub = bios->data[clktable + 2 + compare_record_len * i];
2659                                 scriptptr = le16_to_cpu(*((uint16_t *)(&bios->data[bios->init_script_tbls_ptr + tmdssub * 2])));
2660                         } else
2661                                 scriptptr = le16_to_cpu(*((uint16_t *)&bios->data[clktable + 2 + compare_record_len * i]));
2662                         break;
2663                 }
2664                 i++;
2665         } while (compareclk);
2666
2667         return scriptptr;
2668 }
2669
2670 static void rundigitaloutscript(ScrnInfoPtr pScrn, uint16_t scriptptr, int head, int dcb_entry)
2671 {
2672         bios_t *bios = &NVPTR(pScrn)->VBIOS;
2673         init_exec_t iexec = {TRUE, FALSE};
2674
2675         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%04X: Parsing digital output script table\n", scriptptr);
2676         bios->execute = TRUE;
2677         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_OWNER,
2678                         head ? NV_VGA_CRTCX_OWNER_HEADB : NV_VGA_CRTCX_OWNER_HEADA);
2679         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, 0x57, 0);
2680         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, 0x58, dcb_entry);
2681         parse_init_table(pScrn, bios, scriptptr, &iexec);
2682         bios->execute = FALSE;
2683
2684         link_head_and_output(pScrn, head, dcb_entry, FALSE);
2685 }
2686
2687 static void run_lvds_table(ScrnInfoPtr pScrn, int head, int dcb_entry, enum LVDS_script script, int pxclk)
2688 {
2689         /* The BIT LVDS table's header has the information to setup the
2690          * necessary registers. Following the standard 4 byte header are:
2691          * A bitmask byte and a dual-link transition pxclk value for use in
2692          * selecting the init script when not using straps; 4 script pointers
2693          * for panel power, selected by output and on/off; and 8 table pointers
2694          * for panel init, the needed one determined by output, and bits in the
2695          * conf byte. These tables are similar to the TMDS tables, consisting
2696          * of a list of pxclks and script pointers.
2697          */
2698
2699         NVPtr pNv = NVPTR(pScrn);
2700         bios_t *bios = &pNv->VBIOS;
2701         unsigned int fpstrapping, outputset = (pNv->dcb_table.entry[dcb_entry].or == 4) ? 1 : 0;
2702         uint16_t scriptptr = 0, clktable;
2703         uint8_t clktableptr = 0;
2704
2705         fpstrapping = (nv32_rd(pScrn, NV_PEXTDEV_BOOT_0) >> 16) & 0xf;
2706
2707         if (script == LVDS_PANEL_ON && bios->fp.reset_after_pclk_change)
2708                 run_lvds_table(pScrn, head, dcb_entry, LVDS_RESET, pxclk);
2709         /* no sign of the "panel off for reset" bit, but it's safer to assume we should */
2710         if (script == LVDS_RESET)
2711                 run_lvds_table(pScrn, head, dcb_entry, LVDS_PANEL_OFF, pxclk);
2712
2713         /* for now we assume version 3.0 table - g80 support will need some changes */
2714
2715         switch (script) {
2716         case LVDS_INIT:
2717                 return;
2718         case LVDS_BACKLIGHT_ON: // check applicability of the script for this
2719         case LVDS_PANEL_ON:
2720                 scriptptr = le16_to_cpu(*(uint16_t *)&bios->data[bios->fp.lvdsmanufacturerpointer + 7 + outputset * 2]);
2721                 break;
2722         case LVDS_BACKLIGHT_OFF:        // check applicability of the script for this
2723         case LVDS_PANEL_OFF:
2724                 scriptptr = le16_to_cpu(*(uint16_t *)&bios->data[bios->fp.lvdsmanufacturerpointer + 11 + outputset * 2]);
2725                 break;
2726         case LVDS_RESET:
2727                 if (pNv->dcb_table.entry[dcb_entry].lvdsconf.use_straps_for_mode ||
2728                         (fpstrapping != 0x0f && bios->data[bios->fp.xlated_entry + 1] != 0x0f)) {
2729                         if (bios->fp.dual_link)
2730                                 clktableptr += 2;
2731                         if (bios->fp.BITbit1)
2732                                 clktableptr++;
2733                 } else {
2734                         uint8_t fallback = bios->data[bios->fp.lvdsmanufacturerpointer + 4];
2735                         int fallbackcmpval = (pNv->dcb_table.entry[dcb_entry].or == 4) ? 4 : 1;
2736
2737                         if (pxclk >= bios->fp.duallink_transition_clk) {
2738                                 clktableptr += 2;
2739                                 fallbackcmpval *= 2;
2740                         }
2741                         if (fallbackcmpval & fallback)
2742                                 clktableptr++;
2743                 }
2744
2745                 /* adding outputset * 8 may not be correct */
2746                 clktable = le16_to_cpu(*(uint16_t *)&bios->data[bios->fp.lvdsmanufacturerpointer + 15 + clktableptr * 2 + outputset * 8]);
2747                 if (!clktable) {
2748                         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Pixel clock comparison table not found\n");
2749                         return;
2750                 }
2751                 scriptptr = clkcmptable(bios, clktable, pxclk);
2752         }
2753
2754         if (!scriptptr) {
2755                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "LVDS output init script not found\n");
2756                 return;
2757         }
2758         rundigitaloutscript(pScrn, scriptptr, head, dcb_entry);
2759 }
2760
2761 void call_lvds_script(ScrnInfoPtr pScrn, int head, int dcb_entry, enum LVDS_script script, int pxclk)
2762 {
2763         /* LVDS operations are multiplexed in an effort to present a single API
2764          * which works with two vastly differing underlying structures.
2765          * This acts as the demux
2766          */
2767
2768         bios_t *bios = &NVPTR(pScrn)->VBIOS;
2769         uint8_t lvds_ver = bios->data[bios->fp.lvdsmanufacturerpointer];
2770
2771         if (!lvds_ver)
2772                 return;
2773
2774         if (lvds_ver < 0x30)
2775                 call_lvds_manufacturer_script(pScrn, head, dcb_entry, script);
2776         else
2777                 run_lvds_table(pScrn, head, dcb_entry, script, pxclk);
2778 }
2779
2780 struct fppointers {
2781         uint16_t fptablepointer;
2782         uint16_t fpxlatetableptr;
2783         uint16_t fpxlatemanufacturertableptr;
2784         int xlatwidth;
2785 };
2786
2787 static void parse_fp_mode_table(ScrnInfoPtr pScrn, bios_t *bios, struct fppointers *fpp)
2788 {
2789         unsigned int fpstrapping;
2790         uint8_t *fptable;
2791         uint8_t fptable_ver, headerlen = 0, recordlen, fpentries = 0xf, fpindex;
2792         int ofs;
2793         DisplayModePtr mode;
2794
2795         fpstrapping = (nv32_rd(pScrn, NV_PEXTDEV_BOOT_0) >> 16) & 0xf;
2796
2797         if (fpp->fptablepointer == 0x0 || fpp->fpxlatetableptr == 0x0) {
2798                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2799                            "Pointers to flat panel table invalid\n");
2800                 return;
2801         }
2802
2803         fptable = &bios->data[fpp->fptablepointer];
2804
2805         fptable_ver = fptable[0];
2806
2807         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2808                    "Found flat panel mode table revision %d.%d\n",
2809                    fptable_ver >> 4, fptable_ver & 0xf);
2810
2811         switch (fptable_ver) {
2812         /* BMP version 0x5.0x11 BIOSen have version 1 like tables, but no version field,
2813          * and miss one of the spread spectrum/PWM bytes.
2814          * This could affect early GF2Go parts (not seen any appropriate ROMs though).
2815          * Here we assume that a version of 0x05 matches this case (combining with a
2816          * BMP version check would be better), as the common case for the panel type
2817          * field is 0x0005, and that is in fact what we are reading the first byte of. */
2818         case 0x05:      /* some NV10, 11, 15, 16 */
2819                 recordlen = 42;
2820                 ofs = 6;
2821                 break;
2822         case 0x10:      /* some NV15/16, and NV11+ */
2823                 recordlen = 44;
2824                 ofs = 7;
2825                 break;
2826         case 0x20:      /* NV40+ */
2827                 headerlen = fptable[1];
2828                 recordlen = fptable[2];
2829                 fpentries = fptable[3];
2830                 /* fptable[4] is the minimum RAMDAC_FP_HCRTC->RAMDAC_FP_HSYNC_START gap.
2831                  * Only seen 0x4b (=75) which is what is used in nv_crtc.c anyway,
2832                  * so we're not using this table value for now
2833                  */
2834                 ofs = 0;
2835                 break;
2836         default:
2837                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2838                            "FP Table revision not currently supported\n");
2839                 return;
2840         }
2841
2842         fpindex = bios->data[fpp->fpxlatetableptr + fpstrapping * fpp->xlatwidth];
2843         if (fpindex > fpentries) {
2844                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2845                            "Bad flat panel table index\n");
2846                 return;
2847         }
2848
2849         /* reserved values - means that ddc or hard coded edid should be used */
2850         if (fpindex == 0xf && fpstrapping == 0xf) {
2851                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Ignoring FP table\n");
2852                 return;
2853         }
2854
2855         if (!(mode = xcalloc(1, sizeof(DisplayModeRec))))
2856                 return;
2857
2858         int modeofs = headerlen + recordlen * fpindex + ofs;
2859         mode->Clock = le16_to_cpu(*(uint16_t *)&fptable[modeofs]) * 10;
2860         mode->HDisplay = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 2]);
2861         mode->HSyncStart = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 10] + 1);
2862         mode->HSyncEnd = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 12] + 1);
2863         mode->HTotal = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 14] + 1);
2864         mode->VDisplay = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 16]);
2865         mode->VSyncStart = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 24] + 1);
2866         mode->VSyncEnd = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 26] + 1);
2867         mode->VTotal = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 28] + 1);
2868         mode->Flags |= (fptable[modeofs + 30] & 0x10) ? V_PHSYNC : V_NHSYNC;
2869         mode->Flags |= (fptable[modeofs + 30] & 0x1) ? V_PVSYNC : V_NVSYNC;
2870
2871         /* for version 1.0:
2872          * bytes 1-2 are "panel type", including bits on whether Colour/mono, single/dual link, and type (TFT etc.)
2873          * bytes 3-6 are bits per colour in RGBX
2874          * 11-12 is HDispEnd
2875          * 13-14 is HValid Start
2876          * 15-16 is HValid End
2877          * bytes 38-39 relate to spread spectrum settings
2878          * bytes 40-43 are something to do with PWM */
2879
2880         mode->prev = mode->next = NULL;
2881         mode->status = MODE_OK;
2882         mode->type = M_T_DRIVER | M_T_PREFERRED;
2883         xf86SetModeDefaultName(mode);
2884
2885 //      if (XF86_CRTC_CONFIG_PTR(pScrn)->debug_modes) {
2886                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2887                            "Found flat panel mode in BIOS tables:\n");
2888                 xf86PrintModeline(pScrn->scrnIndex, mode);
2889 //      }
2890
2891         bios->fp.native_mode = mode;
2892 }
2893
2894 static void parse_lvds_manufacturer_table_init(ScrnInfoPtr pScrn, bios_t *bios, struct fppointers *fpp)
2895 {
2896         /* The LVDS table changed considerably with BIT bioses. Previously
2897          * there was a header of version and record length, followed by several
2898          * records, indexed by a seperate xlat table, indexed in turn by the fp
2899          * strap in EXTDEV_BOOT. Each record had a config byte, followed by 6
2900          * script numbers for use by INIT_SUB which controlled panel init and
2901          * power, and finally a dword of ms to sleep between power off and on
2902          * operations.
2903          *
2904          * The BIT LVDS table has the typical BIT table header: version byte,
2905          * header length byte, record length byte, and a byte for the maximum
2906          * number of records that can be held in the table. At byte 5 in the
2907          * header is the dual-link transition pxclk (in 10s kHz) - if straps
2908          * are not being used for the panel, this specifies the frequency at
2909          * which modes should be set up in the dual link style.
2910          *
2911          * The table following the header serves as an integrated config and
2912          * xlat table: the records in the table are indexed by the FP strap
2913          * nibble in EXTDEV_BOOT, and each record has two bytes - the first as
2914          * a config byte, the second for indexing the fp mode table pointed to
2915          * by the BIT 'D' table
2916          */
2917
2918         unsigned int fpstrapping, lvdsmanufacturerindex = 0;
2919         uint8_t lvds_ver, headerlen, recordlen;
2920
2921         fpstrapping = (nv32_rd(pScrn, NV_PEXTDEV_BOOT_0) >> 16) & 0xf;
2922
2923         if (bios->fp.lvdsmanufacturerpointer == 0x0) {
2924                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2925                            "Pointer to LVDS manufacturer table invalid\n");
2926                 return;
2927         }
2928
2929         lvds_ver = bios->data[bios->fp.lvdsmanufacturerpointer];
2930
2931         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2932                    "Found LVDS manufacturer table revision %d.%d\n",
2933                    lvds_ver >> 4, lvds_ver & 0xf);
2934
2935         switch (lvds_ver) {
2936         case 0x0a:      /* pre NV40 */
2937                 lvdsmanufacturerindex = bios->data[fpp->fpxlatemanufacturertableptr + fpstrapping];
2938
2939                 headerlen = 2;
2940                 recordlen = bios->data[bios->fp.lvdsmanufacturerpointer + 1];
2941
2942                 break;
2943         case 0x30:      /* NV4x */
2944                 lvdsmanufacturerindex = fpstrapping;
2945                 headerlen = bios->data[bios->fp.lvdsmanufacturerpointer + 1];
2946                 if (headerlen < 0x1f) {
2947                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2948                                    "LVDS table header not understood\n");
2949                         return;
2950                 }
2951                 recordlen = bios->data[bios->fp.lvdsmanufacturerpointer + 2];
2952                 break;
2953         case 0x40:      /* It changed again with gf8 :o( */
2954         default:
2955                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2956                            "LVDS table revision not currently supported\n");
2957                 return;
2958         }
2959
2960         uint16_t lvdsofs = bios->fp.xlated_entry = bios->fp.lvdsmanufacturerpointer + headerlen + recordlen * lvdsmanufacturerindex;
2961         switch (lvds_ver) {
2962         case 0x0a:
2963                 bios->fp.reset_after_pclk_change = bios->data[lvdsofs] & 2;
2964                 bios->fp.dual_link = bios->data[lvdsofs] & 4;
2965                 bios->fp.if_is_18bit = !(bios->data[lvdsofs] & 16);
2966                 break;
2967         case 0x30:
2968                 /* no sign of the "reset for panel on" bit, but it's safer to assume we should */
2969                 bios->fp.reset_after_pclk_change = TRUE;
2970                 bios->fp.dual_link = bios->data[lvdsofs] & 1;
2971                 bios->fp.BITbit1 = bios->data[lvdsofs] & 2;
2972                 /* BMP likely has something like this, but I have no dump to point to where it is */
2973                 bios->fp.duallink_transition_clk = le16_to_cpu(*(uint16_t *)&bios->data[bios->fp.lvdsmanufacturerpointer + 5]) * 10;
2974                 fpp->fpxlatetableptr = bios->fp.lvdsmanufacturerpointer + headerlen + 1;
2975                 fpp->xlatwidth = recordlen;
2976                 break;
2977         }
2978 }
2979
2980 void run_tmds_table(ScrnInfoPtr pScrn, int dcb_entry, int head, int pxclk)
2981 {
2982         /* the dcb_entry parameter is the index of the appropriate DCB entry
2983          * the pxclk parameter is in kHz
2984          *
2985          * This runs the TMDS regs setting code found on BIT bios cards
2986          *
2987          * For ffs(or) == 1 use the first table, for ffs(or) == 2 and
2988          * ffs(or) == 3, use the second.
2989          */
2990
2991         NVPtr pNv = NVPTR(pScrn);
2992         bios_t *bios = &pNv->VBIOS;
2993         uint16_t clktable = 0, scriptptr;
2994
2995         if (pNv->dcb_table.entry[dcb_entry].location) /* off chip */
2996                 return;
2997
2998         switch (ffs(pNv->dcb_table.entry[dcb_entry].or)) {
2999         case 1:
3000                 clktable = bios->tmds.output0_script_ptr;
3001                 break;
3002         case 2:
3003         case 3:
3004                 clktable = bios->tmds.output1_script_ptr;
3005                 break;
3006         }
3007
3008         if (!clktable) {
3009                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Pixel clock comparison table not found\n");
3010                 return;
3011         }
3012
3013         scriptptr = clkcmptable(bios, clktable, pxclk);
3014
3015         if (!scriptptr) {
3016                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "TMDS output init script not found\n");
3017                 return;
3018         }
3019
3020         rundigitaloutscript(pScrn, scriptptr, head, dcb_entry);
3021 }
3022
3023 static void parse_bios_version(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset)
3024 {
3025         /* offset + 0  (8 bits): Micro version
3026          * offset + 1  (8 bits): Minor version
3027          * offset + 2  (8 bits): Chip version
3028          * offset + 3  (8 bits): Major version
3029          */
3030
3031         bios->major_version = bios->data[offset + 3];
3032         bios->chip_version = bios->data[offset + 2];
3033         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Bios version %02x.%02x.%02x.%02x\n",
3034                    bios->data[offset + 3], bios->data[offset + 2],
3035                    bios->data[offset + 1], bios->data[offset]);
3036 }
3037
3038 //int getMNP_double_plltype(ScrnInfoPtr pScrn, enum pll_types plltype, int clk, int *NM1, int *NM2, int *log2P)
3039 int get_pll_limits_plltype(ScrnInfoPtr pScrn, enum pll_types plltype, struct pll_lims *pll_lim)
3040 {
3041         /*
3042          * Here we just try to find a register matching plltype in the PLL
3043          * limits table. The table is better explained in get_pll_limits below.
3044          */
3045
3046         bios_t *bios = &NVPTR(pScrn)->VBIOS;
3047
3048         if (!bios->pll_limit_tbl_ptr) {
3049                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Pointer to PLL limits table invalid\n");
3050                 return 0;
3051         }
3052
3053         switch (bios->data[bios->pll_limit_tbl_ptr]) {
3054         case 0x10:
3055                 return get_pll_limits(pScrn, 0, pll_lim);
3056 //              return getMNP_double(pScrn, 0, clk, NM1, NM2, log2P);
3057         case 0x20:
3058         case 0x21:
3059                 {
3060                 uint8_t headerlen = bios->data[bios->pll_limit_tbl_ptr + 1];
3061                 uint8_t recordlen = bios->data[bios->pll_limit_tbl_ptr + 2];
3062                 uint8_t entries = bios->data[bios->pll_limit_tbl_ptr + 3];
3063                 uint16_t plloffs = bios->pll_limit_tbl_ptr + headerlen;
3064                 int i;
3065                 uint32_t reg = 0;
3066
3067                 for (i = 1; i < entries; i++) {
3068                         uint32_t cmpreg = le32_to_cpu(*((uint32_t *)(&bios->data[plloffs + recordlen * i])));
3069
3070                         if (plltype == VPLL1 && (cmpreg == 0x680508 || cmpreg == 0x4010)) {
3071                                 reg = cmpreg;
3072                                 break;
3073                         }
3074                         if (plltype == VPLL2 && (cmpreg == 0x680520 || cmpreg == 0x4018)) {
3075                                 reg = cmpreg;
3076                                 break;
3077                         }
3078                 }
3079
3080                 return get_pll_limits(pScrn, reg, pll_lim);
3081 //              return getMNP_double(pScrn, reg, clk, NM1, NM2, log2P);
3082                 }
3083         default:
3084                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3085                            "PLL limits table revision not currently supported\n");
3086                 return 0;
3087         }
3088 }
3089
3090 Bool get_pll_limits(ScrnInfoPtr pScrn, uint32_t reg, struct pll_lims *pll_lim)
3091 {
3092         /* PLL limits table
3093          *
3094          * Version 0x10: NV31
3095          * One byte header (version), one record of 24 bytes
3096          * Version 0x11: NV36 - Not implemented
3097          * Seems to have same record style as 0x10, but 3 records rather than 1
3098          * Version 0x20: Found on Geforce 6 cards
3099          * Trivial 4 byte BIT header. 31 (0x1f) byte record length
3100          * Version 0x21: Found on Geforce 7, 8 and some Geforce 6 cards
3101          * 5 byte header, fifth byte of unknown purpose. 35 (0x23) byte record length
3102          */
3103
3104         bios_t *bios = &NVPTR(pScrn)->VBIOS;
3105         uint8_t pll_lim_ver, headerlen, recordlen, entries;
3106         int pllindex = 0, i;
3107
3108         if (!bios->pll_limit_tbl_ptr) {
3109                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Pointer to PLL limits table invalid\n");
3110                 return FALSE;
3111         }
3112
3113         pll_lim_ver = bios->data[bios->pll_limit_tbl_ptr];
3114
3115         if (DEBUGLEVEL >= 6)
3116                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3117                            "Found PLL limits table version 0x%X\n", pll_lim_ver);
3118
3119         switch (pll_lim_ver) {
3120         case 0x10:
3121                 headerlen = 1;
3122                 recordlen = 0x18;
3123                 entries = 1;
3124                 pllindex = 0;
3125                 break;
3126         case 0x20:
3127         case 0x21:
3128                 headerlen = bios->data[bios->pll_limit_tbl_ptr + 1];
3129                 recordlen = bios->data[bios->pll_limit_tbl_ptr + 2];
3130                 entries = bios->data[bios->pll_limit_tbl_ptr + 3];
3131                 break;
3132         default:
3133                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3134                            "PLL limits table revision not currently supported\n");
3135                 return FALSE;
3136         }
3137
3138         /* initialize all members to zero */
3139         memset (pll_lim, 0, sizeof(struct pll_lims));
3140
3141         if (pll_lim_ver == 0x10) {
3142                 uint16_t plloffs = bios->pll_limit_tbl_ptr + headerlen + recordlen * pllindex;
3143
3144                 pll_lim->vco1.minfreq = le32_to_cpu(*((uint32_t *)(&bios->data[plloffs])));
3145                 pll_lim->vco1.maxfreq = le32_to_cpu(*((uint32_t *)(&bios->data[plloffs + 4])));
3146                 pll_lim->vco2.minfreq = le32_to_cpu(*((uint32_t *)(&bios->data[plloffs + 8])));
3147                 pll_lim->vco2.maxfreq = le32_to_cpu(*((uint32_t *)(&bios->data[plloffs + 12])));
3148                 pll_lim->vco1.min_inputfreq = le32_to_cpu(*((uint32_t *)(&bios->data[plloffs + 16])));
3149                 pll_lim->vco2.min_inputfreq = le32_to_cpu(*((uint32_t *)(&bios->data[plloffs + 20])));
3150                 pll_lim->vco1.max_inputfreq = pll_lim->vco2.max_inputfreq = INT_MAX;
3151
3152                 /* these values taken from nv31. nv30, nv36 might do better with different ones */
3153                 pll_lim->vco1.min_n = 0x1;
3154                 pll_lim->vco1.max_n = 0xff;
3155                 pll_lim->vco1.min_m = 0x1;
3156                 pll_lim->vco1.max_m = 0xd;
3157                 pll_lim->vco2.min_n = 0x4;
3158                 pll_lim->vco2.max_n = 0x46;
3159                 if (bios->chip_version == 0x30)
3160                        /* only 5 bits available for N2 on nv30 */
3161                         pll_lim->vco2.max_n = 0x1f;
3162                 if (bios->chip_version == 0x31)
3163                         /* on nv31, N2 is compared to maxN2 (0x46) and maxM2 (0x4),
3164                          * so set maxN2 to 0x4 and save a comparison
3165                          */
3166                         pll_lim->vco2.max_n = 0x4;
3167                 pll_lim->vco2.min_m = 0x1;
3168                 pll_lim->vco2.max_m = 0x4;
3169         } else {        /* ver 0x20, 0x21 */
3170                 uint16_t plloffs = bios->pll_limit_tbl_ptr + headerlen;
3171
3172                 /* first entry is default match, if nothing better. warn if reg field nonzero */
3173                 if (le32_to_cpu(*((uint32_t *)&bios->data[plloffs])))
3174                         xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
3175                                    "Default PLL limit entry has non-zero register field\n");
3176
3177                 for (i = 1; i < entries; i++)
3178                         if (le32_to_cpu(*((uint32_t *)&bios->data[plloffs + recordlen * i])) == reg) {
3179                                 pllindex = i;
3180                                 break;
3181                         }
3182
3183                 plloffs += recordlen * pllindex;
3184
3185                 if (DEBUGLEVEL >= 6)
3186                         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Loading PLL limits for reg 0x%08x\n",
3187                                    pllindex ? reg : 0);
3188
3189                 /* frequencies are stored in tables in MHz, kHz are more useful, so we convert */
3190
3191                 /* What output frequencies can each VCO generate? */
3192                 pll_lim->vco1.minfreq = le16_to_cpu(*((uint16_t *)(&bios->data[plloffs + 4]))) * 1000;
3193                 pll_lim->vco1.maxfreq = le16_to_cpu(*((uint16_t *)(&bios->data[plloffs + 6]))) * 1000;
3194                 pll_lim->vco2.minfreq = le16_to_cpu(*((uint16_t *)(&bios->data[plloffs + 8]))) * 1000;
3195                 pll_lim->vco2.maxfreq = le16_to_cpu(*((uint16_t *)(&bios->data[plloffs + 10]))) * 1000;
3196
3197                 /* What input frequencies do they accept (past the m-divider)? */
3198                 pll_lim->vco1.min_inputfreq = le16_to_cpu(*((uint16_t *)(&bios->data[plloffs + 12]))) * 1000;
3199                 pll_lim->vco2.min_inputfreq = le16_to_cpu(*((uint16_t *)(&bios->data[plloffs + 14]))) * 1000;
3200                 pll_lim->vco1.max_inputfreq = le16_to_cpu(*((uint16_t *)(&bios->data[plloffs + 16]))) * 1000;
3201                 pll_lim->vco2.max_inputfreq = le16_to_cpu(*((uint16_t *)(&bios->data[plloffs + 18]))) * 1000;
3202
3203                 /* What values are accepted as multiplier and divider? */
3204                 pll_lim->vco1.min_n = bios->data[plloffs + 20];
3205                 pll_lim->vco1.max_n = bios->data[plloffs + 21];
3206                 pll_lim->vco1.min_m = bios->data[plloffs + 22];
3207                 pll_lim->vco1.max_m = bios->data[plloffs + 23];
3208                 pll_lim->vco2.min_n = bios->data[plloffs + 24];
3209                 pll_lim->vco2.max_n = bios->data[plloffs + 25];
3210                 pll_lim->vco2.min_m = bios->data[plloffs + 26];
3211                 pll_lim->vco2.max_m = bios->data[plloffs + 27];
3212
3213                 pll_lim->min_p = bios->data[plloffs + 28];
3214                 pll_lim->max_p = bios->data[plloffs + 29];
3215                 pll_lim->p_bias = bios->data[plloffs + 30];
3216
3217                 if (recordlen > 0x22)
3218                         pll_lim->refclk = le32_to_cpu(*((uint32_t *)&bios->data[plloffs + 31]));
3219         }
3220
3221 #if 1 /* for easy debugging */
3222         ErrorF("pll.vco1.minfreq: %d\n", pll_lim->vco1.minfreq);
3223         ErrorF("pll.vco1.maxfreq: %d\n", pll_lim->vco1.maxfreq);
3224         ErrorF("pll.vco2.minfreq: %d\n", pll_lim->vco2.minfreq);
3225         ErrorF("pll.vco2.maxfreq: %d\n", pll_lim->vco2.maxfreq);
3226
3227         ErrorF("pll.vco1.min_inputfreq: %d\n", pll_lim->vco1.min_inputfreq);
3228         ErrorF("pll.vco1.max_inputfreq: %d\n", pll_lim->vco1.max_inputfreq);
3229         ErrorF("pll.vco2.min_inputfreq: %d\n", pll_lim->vco2.min_inputfreq);
3230         ErrorF("pll.vco2.max_inputfreq: %d\n", pll_lim->vco2.max_inputfreq);
3231
3232         ErrorF("pll.vco1.min_n: %d\n", pll_lim->vco1.min_n);
3233         ErrorF("pll.vco1.max_n: %d\n", pll_lim->vco1.max_n);
3234         ErrorF("pll.vco1.min_m: %d\n", pll_lim->vco1.min_m);
3235         ErrorF("pll.vco1.max_m: %d\n", pll_lim->vco1.max_m);
3236         ErrorF("pll.vco2.min_n: %d\n", pll_lim->vco2.min_n);
3237         ErrorF("pll.vco2.max_n: %d\n", pll_lim->vco2.max_n);
3238         ErrorF("pll.vco2.min_m: %d\n", pll_lim->vco2.min_m);
3239         ErrorF("pll.vco2.max_m: %d\n", pll_lim->vco2.max_m);
3240
3241         ErrorF("pll.min_p: %d\n", pll_lim->min_p);
3242         ErrorF("pll.max_p: %d\n", pll_lim->max_p);
3243         ErrorF("pll.p_bias: %d\n", pll_lim->p_bias);
3244
3245         ErrorF("pll.refclk: %d\n", pll_lim->refclk);
3246 #endif
3247
3248         return TRUE;
3249 }
3250
3251 static int parse_bit_B_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry)
3252 {
3253         /* offset + 0  (32 bits): BIOS version dword
3254          *
3255          * There's a bunch of bits in this table other than the bios version
3256          * that we don't use - their use currently unknown
3257          */
3258
3259         if (bitentry->length < 0x4) {
3260                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3261                            "Do not understand B table entry\n");
3262                 return 0;
3263         }
3264
3265         parse_bios_version(pScrn, bios, bitentry->offset);
3266
3267         return 1;
3268 }
3269
3270 static int parse_bit_C_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry)
3271 {
3272         /* offset + 8  (16 bits): PLL limits table pointer
3273          *
3274          * There's more in here, but that's unknown.
3275          */
3276
3277         if (bitentry->length < 10) {
3278                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Do not understand C table entry\n");
3279                 return 0;
3280         }
3281
3282         bios->pll_limit_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 8])));
3283
3284         return 1;
3285 }
3286
3287 static int parse_bit_display_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry, struct fppointers *fpp)
3288 {
3289         /* Parses the flat panel table segment that the bit entry points to.
3290          * Starting at bitentry->offset:
3291          *
3292          * offset + 0  (16 bits): FIXME table pointer
3293          * offset + 2  (16 bits): mode table pointer
3294          */
3295
3296         if (bitentry->length != 4) {
3297                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3298                            "Do not understand BIT display table entry\n");
3299                 return 0;
3300         }
3301
3302         fpp->fptablepointer = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 2])));
3303
3304         return 1;
3305 }
3306
3307 static unsigned int parse_bit_init_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry)
3308 {
3309         /* Parses the init table segment that the bit entry points to.
3310          * Starting at bitentry->offset:
3311          *
3312          * offset + 0  (16 bits): init script tables pointer
3313          * offset + 2  (16 bits): macro index table pointer
3314          * offset + 4  (16 bits): macro table pointer
3315          * offset + 6  (16 bits): condition table pointer
3316          * offset + 8  (16 bits): io condition table pointer
3317          * offset + 10 (16 bits): io flag condition table pointer
3318          * offset + 12 (16 bits): init function table pointer
3319          *
3320          */
3321
3322         if (bitentry->length < 14) {
3323                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3324                            "Unable to recognize BIT init table entry\n");
3325                 return 0;
3326         }
3327
3328         bios->init_script_tbls_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset])));
3329         bios->macro_index_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 2])));
3330         bios->macro_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 4])));
3331         bios->condition_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 6])));
3332         bios->io_condition_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 8])));
3333         bios->io_flag_condition_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 10])));
3334         bios->init_function_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 12])));
3335
3336         return 1;
3337 }
3338
3339 static int parse_bit_i_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry)
3340 {
3341         /* offset + 13 (16 bits): pointer to table containing DAC load detection comparison values
3342          *
3343          * There's other things in this table, purpose unknown
3344          */
3345
3346         uint16_t offset;
3347
3348         if (bitentry->length < 15) {
3349                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3350                            "BIT i table not long enough for DAC load detection comparison table\n");
3351                 return 0;
3352         }
3353
3354         offset = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 13])));
3355
3356         /* doesn't exist on g80 */
3357         if (!offset)
3358                 return 1;
3359
3360         /* The first value in the table, following the header, is the comparison value
3361          * Purpose of subsequent values unknown - TV load detection?
3362          */
3363
3364         uint8_t version = bios->data[offset];
3365
3366         if (version != 0x00 && version != 0x10) {
3367                 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
3368                            "DAC load detection comparison table version %d.%d not known\n",
3369                            version >> 4, version & 0xf);
3370                 return 0;
3371         }
3372
3373         uint8_t headerlen = bios->data[offset + 1];
3374
3375         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3376                    "DAC load detection comparison table version %x found\n", version);
3377
3378         bios->dactestval = le32_to_cpu(*((uint32_t *)(&bios->data[offset + headerlen])));
3379
3380         return 1;
3381 }
3382
3383 static int parse_bit_lvds_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry, struct fppointers *fpp)
3384 {
3385         /* Parses the LVDS table segment that the bit entry points to.
3386          * Starting at bitentry->offset:
3387          *
3388          * offset + 0  (16 bits): LVDS strap xlate table pointer
3389          */
3390
3391         if (bitentry->length != 2) {
3392                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3393                            "Do not understand BIT LVDS table entry\n");
3394                 return 0;
3395         }
3396
3397         /* no idea if it's still called the LVDS manufacturer table, but the concept's close enough */
3398         bios->fp.lvdsmanufacturerpointer = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset])));
3399
3400         parse_lvds_manufacturer_table_init(pScrn, bios, fpp);
3401
3402         return 1;
3403 }
3404
3405 static int parse_bit_M_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry)
3406 {
3407         /* offset + 2  (8  bits): number of options in an INIT_RAM_RESTRICT_ZM_REG_GROUP opcode option set
3408          * offset + 3  (16 bits): pointer to strap xlate table for RAM restrict option selection
3409          *
3410          * There's a bunch of bits in this table other than the RAM restrict
3411          * stuff that we don't use - their use currently unknown
3412          */
3413
3414         int i;
3415
3416         /* Older bios versions don't have a sufficiently long table for what we want */
3417         if (bitentry->length < 0x5)
3418                 return 1;
3419
3420         /* set up multiplier for INIT_RAM_RESTRICT_ZM_REG_GROUP */
3421         for (i = 0; itbl_entry[i].name && (itbl_entry[i].id != 0x8f); i++)
3422                 ;
3423         itbl_entry[i].length_multiplier = bios->data[bitentry->offset + 2] * 4;
3424         init_ram_restrict_zm_reg_group_blocklen = itbl_entry[i].length_multiplier;
3425
3426         bios->ram_restrict_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 3])));
3427
3428         return 1;
3429 }
3430
3431 static int parse_bit_tmds_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry)
3432 {
3433         /* Parses the pointer to the TMDS table
3434          *
3435          * Starting at bitentry->offset:
3436          *
3437          * offset + 0  (16 bits): TMDS table pointer
3438          *
3439          * The TMDS table is typically found just before the DCB table, with a
3440          * characteristic signature of 0x11,0x13 (1.1 being version, 0x13 being
3441          * length?)
3442          *
3443          * At offset +7 is a pointer to a script, which I don't know how to run yet
3444          * At offset +9 is a pointer to another script, likewise
3445          * Offset +11 has a pointer to a table where the first word is a pxclk
3446          * frequency and the second word a pointer to a script, which should be
3447          * run if the comparison pxclk frequency is less than the pxclk desired.
3448          * This repeats for decreasing comparison frequencies
3449          * Offset +13 has a pointer to a similar table
3450          * The selection of table (and possibly +7/+9 script) is dictated by
3451          * "or" from the DCB.
3452          */
3453
3454         uint16_t tmdstableptr, script1, script2;
3455
3456         if (bitentry->length != 2) {
3457                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3458                            "Do not understand BIT TMDS table entry\n");
3459                 return 0;
3460         }
3461
3462         tmdstableptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset])));
3463
3464         if (tmdstableptr == 0x0) {
3465                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Pointer to TMDS table invalid\n");
3466                 return 0;
3467         }
3468
3469         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Found TMDS table revision %d.%d\n",
3470                    bios->data[tmdstableptr] >> 4, bios->data[tmdstableptr] & 0xf);
3471
3472         /* These two scripts are odd: they don't seem to get run even when they are not stubbed */
3473         script1 = le16_to_cpu(*((uint16_t *)&bios->data[tmdstableptr + 7]));
3474         script2 = le16_to_cpu(*((uint16_t *)&bios->data[tmdstableptr + 9]));
3475         if (bios->data[script1] != 'q' || bios->data[script2] != 'q')
3476                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "TMDS table script pointers not stubbed\n");
3477
3478         bios->tmds.output0_script_ptr = le16_to_cpu(*((uint16_t *)&bios->data[tmdstableptr + 11]));
3479         bios->tmds.output1_script_ptr = le16_to_cpu(*((uint16_t *)&bios->data[tmdstableptr + 13]));
3480
3481         return 1;
3482 }
3483
3484 static void parse_bit_structure(ScrnInfoPtr pScrn, bios_t *bios, unsigned int offset)
3485 {
3486         bit_entry_t bitentry;
3487         char done = 0;
3488         struct fppointers fpp;
3489         NVPtr pNv = NVPTR(pScrn);
3490
3491         memset(&fpp, 0, sizeof(struct fppointers));
3492
3493         while (!done) {
3494                 bitentry.id[0] = bios->data[offset];
3495                 bitentry.id[1] = bios->data[offset + 1];
3496                 bitentry.length = le16_to_cpu(*((uint16_t *)&bios->data[offset + 2]));
3497                 bitentry.offset = le16_to_cpu(*((uint16_t *)&bios->data[offset + 4]));
3498
3499                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3500                            "0x%04X: Found BIT command with id 0x%02X (%c)\n",
3501                            offset, bitentry.id[0], bitentry.id[0]);
3502
3503                 switch (bitentry.id[0]) {
3504                 case 0:
3505                         /* id[0] = 0 and id[1] = 0 ==> end of BIT struture */
3506                         if (bitentry.id[1] == 0)
3507                                 done = 1;
3508                         break;
3509                 case 'B':
3510                         parse_bit_B_tbl_entry(pScrn, bios, &bitentry);
3511                         break;
3512                 case 'C':
3513                         parse_bit_C_tbl_entry(pScrn, bios, &bitentry);
3514                         break;
3515                 case 'D':
3516                         parse_bit_display_tbl_entry(pScrn, bios, &bitentry, &fpp);
3517                         break;
3518                 case 'I':
3519                         parse_bit_init_tbl_entry(pScrn, bios, &bitentry);
3520                         break;
3521                 case 'i':
3522                         parse_bit_i_tbl_entry(pScrn, bios, &bitentry);
3523                         break;
3524                 case 'L':
3525                         parse_bit_lvds_tbl_entry(pScrn, bios, &bitentry, &fpp);
3526                         break;
3527                 case 'M': /* memory? */
3528                         parse_bit_M_tbl_entry(pScrn, bios, &bitentry);
3529                         break;
3530                 case 'T':
3531                         parse_bit_tmds_tbl_entry(pScrn, bios, &bitentry);
3532                         break;
3533                 }
3534
3535                 offset += sizeof(bit_entry_t);
3536         }
3537
3538         /* C and M tables have to be parsed before init can run */
3539         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3540                    "Parsing previously deferred init table entry\n");
3541         parse_init_tables(pScrn, bios);
3542
3543         /* If it's not a laptop, you probably don't care about LVDS */
3544         /* FIXME: detect mobile BIOS? */
3545         if (!pNv->Mobile)
3546                 return;
3547
3548         /* Need D and L tables parsed before doing this */
3549         parse_fp_mode_table(pScrn, bios, &fpp);
3550 }
3551
3552 static void parse_bmp_structure(ScrnInfoPtr pScrn, bios_t *bios, unsigned int offset)
3553 {
3554         /* Parse the BMP structure for useful things
3555          *
3556          * offset +   5: BMP major version
3557          * offset +   6: BMP minor version
3558          * offset +  10: BCD encoded BIOS version
3559          *
3560          * offset +  18: init script table pointer (for bios versions < 5.10h)
3561          * offset +  20: extra init script table pointer (for bios versions < 5.10h)
3562          *
3563          * offset +  24: FIXME
3564          * offset +  26: FIXME
3565          * offset +  28: FIXME
3566          *
3567          * offset +  54: index of I2C CRTC pair to use for CRT output
3568          * offset +  55: index of I2C CRTC pair to use for TV output
3569          * offset +  56: index of I2C CRTC pair to use for flat panel output
3570          * offset +  58: write CRTC index for I2C pair 0
3571          * offset +  59: read CRTC index for I2C pair 0
3572          * offset +  60: write CRTC index for I2C pair 1
3573          * offset +  61: read CRTC index for I2C pair 1
3574          *
3575          * offset +  67: maximum internal PLL frequency (single stage PLL)
3576          * offset +  71: minimum internal PLL frequency (single stage PLL)
3577          *
3578          * offset +  75: script table pointers, as for parse_bit_init_tbl_entry
3579          *
3580          * offset +  89: TMDS single link output A table pointer
3581          * offset +  91: TMDS single link output B table pointer
3582          * offset + 105: flat panel timings table pointer
3583          * offset + 107: flat panel strapping translation table pointer
3584          * offset + 117: LVDS manufacturer panel config table pointer
3585          * offset + 119: LVDS manufacturer strapping translation table pointer
3586          *
3587          * offset + 142: PLL limits table pointer
3588          */
3589
3590         NVPtr pNv = NVPTR(pScrn);
3591         uint16_t bmplength;
3592         struct fppointers fpp;
3593         memset(&fpp, 0, sizeof(struct fppointers));
3594
3595         uint8_t bmp_version_major = bios->data[offset + 5];
3596         uint8_t bmp_version_minor = bios->data[offset + 6];
3597
3598         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "BMP version %d.%d\n",
3599                    bmp_version_major, bmp_version_minor);
3600
3601         /* version 6 could theoretically exist, but I suspect BIT happened instead */
3602         if (bmp_version_major < 2 || bmp_version_major > 5) {
3603                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "You have an unsupported BMP version. Please send in your bios\n");
3604                 return;
3605         }
3606
3607         if (bmp_version_major == 2)
3608                 bmplength = 48; /* exact for 2.01 - not sure if minor version used in versions < 5 */
3609         else if (bmp_version_major == 3)
3610                 bmplength = 54; /* guessed - mem init tables added in this version */
3611         else if (bmp_version_major == 4 || bmp_version_minor < 0x1) /* don't know if 5.0 exists... */
3612                 bmplength = 62; /* guessed - BMP I2C indices added in version 4*/
3613         else if (bmp_version_minor < 0x6)
3614                 bmplength = 67; /* exact for 5.01 */
3615         else if (bmp_version_minor < 0x10)
3616                 bmplength = 75; /* exact for 5.06 */
3617         else if (bmp_version_minor == 0x10)
3618                 bmplength = 89; /* exact for 5.10h */
3619         else if (bmp_version_minor < 0x14)
3620                 bmplength = 118; /* exact for 5.11h */
3621         else if (bmp_version_minor < 0x24) /* not sure of version where pll limits came in;
3622                                             * certainly exist by 0x24 though */
3623                 /* length not exact: this is long enough to get lvds members */
3624                 bmplength = 123;
3625         else
3626                 /* length not exact: this is long enough to get pll limit member */
3627                 bmplength = 144;
3628
3629         /* checksum */
3630         if (nv_cksum(bios->data + offset, 8)) {
3631                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Bad BMP checksum\n");
3632                 return;
3633         }
3634
3635         parse_bios_version(pScrn, bios, offset + 10);
3636
3637         bios->init_script_tbls_ptr = le16_to_cpu(*(uint16_t *)&bios->data[offset + 18]);
3638         bios->extra_init_script_tbl_ptr = le16_to_cpu(*(uint16_t *)&bios->data[offset + 20]);
3639
3640 #if 0
3641         // FIXME needed for pre v16? - haiku uses this in its COMPUTE_MEM on early biosen
3642         if (bmp_version_major > 2) {
3643                 uint16_t meminittbl = le16_to_cpu(*(uint16_t *)&bios->data[offset + 24]);
3644                 uint16_t sdrmemseqtbl = le16_to_cpu(*(uint16_t *)&bios->data[offset + 26]);
3645                 uint16_t ddrmemseqtbl = le16_to_cpu(*(uint16_t *)&bios->data[offset + 28]);
3646         }
3647 #endif
3648
3649         uint16_t legacy_i2c_offset = 0x48;      /* BMP version 2 & 3 */
3650         if (bmplength > 61)
3651                 legacy_i2c_offset = offset + 54;
3652         bios->legacy_i2c_indices.crt = bios->data[legacy_i2c_offset];
3653         bios->legacy_i2c_indices.tv = bios->data[legacy_i2c_offset + 1];
3654         bios->legacy_i2c_indices.panel = bios->data[legacy_i2c_offset + 2];
3655         pNv->dcb_table.i2c_write[0] = bios->data[legacy_i2c_offset + 4];
3656         pNv->dcb_table.i2c_read[0] = bios->data[legacy_i2c_offset + 5];
3657         pNv->dcb_table.i2c_write[1] = bios->data[legacy_i2c_offset + 6];
3658         pNv->dcb_table.i2c_read[1] = bios->data[legacy_i2c_offset + 7];
3659
3660         if (bmplength > 74) {
3661                 bios->fmaxvco = le32_to_cpu(*((uint32_t *)&bios->data[offset + 67]));
3662                 bios->fminvco = le32_to_cpu(*((uint32_t *)&bios->data[offset + 71]));
3663         }
3664         if (bmplength > 88) {
3665                 bit_entry_t initbitentry;
3666                 initbitentry.length = 14;
3667                 initbitentry.offset = offset + 75;
3668                 parse_bit_init_tbl_entry(pScrn, bios, &initbitentry);
3669         }
3670         if (bmplength > 92) {
3671                 bios->tmds.output0_script_ptr = le16_to_cpu(*((uint16_t *)&bios->data[offset + 89]));
3672                 bios->tmds.output1_script_ptr = le16_to_cpu(*((uint16_t *)&bios->data[offset + 91]));
3673         }
3674         if (bmplength > 108) {
3675                 fpp.fptablepointer = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 105])));
3676                 fpp.fpxlatetableptr = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 107])));
3677                 fpp.xlatwidth = 1;
3678         }
3679         if (bmplength > 120) {
3680                 bios->fp.lvdsmanufacturerpointer = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 117])));
3681                 fpp.fpxlatemanufacturertableptr = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 119])));
3682         }
3683         if (bmplength > 143)
3684                 bios->pll_limit_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 142])));
3685
3686         /* want pll_limit_tbl_ptr set (if available) before init is run */
3687         if (bmp_version_major < 5 || bmp_version_minor < 0x10) {
3688                 init_exec_t iexec = {TRUE, FALSE};
3689                 parse_init_table(pScrn, bios, bios->init_script_tbls_ptr, &iexec);
3690                 parse_init_table(pScrn, bios, bios->extra_init_script_tbl_ptr, &iexec);
3691         } else
3692                 parse_init_tables(pScrn, bios);
3693
3694         /* If it's not a laptop, you probably don't care about fptables */
3695         /* FIXME: detect mobile BIOS? */
3696         if (!pNv->Mobile)
3697                 return;
3698
3699         parse_fp_mode_table(pScrn, bios, &fpp);
3700         parse_lvds_manufacturer_table_init(pScrn, bios, &fpp);
3701         /* I've never seen a valid LVDS_INIT script, so we'll do a test for it here */
3702         call_lvds_script(pScrn, 0, 0, LVDS_INIT, 0);
3703 }
3704
3705 static uint16_t findstr(uint8_t *data, int n, const uint8_t *str, int len)
3706 {
3707         int i, j;
3708
3709         for (i = 0; i <= (n - len); i++) {
3710                 for (j = 0; j < len; j++)
3711                         if (data[i + j] != str[j])
3712                                 break;
3713                 if (j == len)
3714                         return i;
3715         }
3716
3717         return 0;
3718 }
3719
3720 static Bool parse_dcb_entry(ScrnInfoPtr pScrn, uint8_t dcb_version, uint32_t conn, uint32_t conf, struct dcb_entry *entry)
3721 {
3722         NVPtr pNv = NVPTR(pScrn);
3723
3724         memset(entry, 0, sizeof (struct dcb_entry));
3725
3726         /* safe defaults for a crt */
3727         entry->type = 0;
3728         entry->i2c_index = 0;
3729         entry->heads = 1;
3730         entry->bus = 0;
3731         entry->location = 0;
3732         entry->or = 1;
3733         entry->duallink_possible = FALSE;
3734
3735         if (dcb_version >= 0x20) {
3736                 entry->type = conn & 0xf;
3737                 entry->i2c_index = (conn >> 4) & 0xf;
3738                 entry->heads = (conn >> 8) & 0xf;
3739                 entry->bus = (conn >> 16) & 0xf;
3740                 entry->location = (conn >> 20) & 0xf;
3741                 entry->or = (conn >> 24) & 0xf;
3742                 /* Normal entries consist of a single bit, but dual link has the
3743                  * adjacent more significant bit set too
3744                  */
3745                 if ((1 << (ffs(entry->or) - 1)) * 3 == entry->or)
3746                         entry->duallink_possible = TRUE;
3747
3748                 switch (entry->type) {
3749                 case OUTPUT_LVDS:
3750                         if (conf & 0xfffffffa)
3751                                 ErrorF("Unknown LVDS configuration bits, please report\n");
3752                         if (conf & 0x1)
3753                                 entry->lvdsconf.use_straps_for_mode = TRUE;
3754                         if (conf & 0x4)
3755                                 entry->lvdsconf.use_power_scripts = TRUE;
3756                         break;
3757                 }
3758         } else if (dcb_version >= 0x14 ) {
3759                 if (conn != 0xf0003f00 && conn != 0xf2204301 && conn != 0xf2045f14 && conn != 0xf2205004 && conn != 0xf4204011) {
3760                         ErrorF("Unknown DCB 1.4 / 1.5 entry, please report\n");
3761                         /* cause output setting to fail, so message is seen */
3762                         pNv->dcb_table.entries = 0;
3763                         return FALSE;
3764                 }
3765                 /* most of the below is a "best guess" atm */
3766                 entry->type = conn & 0xf;
3767                 if (entry->type == 4) { /* digital */
3768                         if (conn & 0x10)
3769                                 entry->type = OUTPUT_LVDS;
3770                         else
3771                                 /* FIXME: do we need to add a DVI-A analogue output in this case,
3772                                  * assuming this connector is DVI-I, not pure DVI-D?
3773                                  */
3774                                 entry->type = OUTPUT_TMDS;
3775                 }
3776                 /* what's in bits 5-13? could be some brooktree/chrontel/philips thing, in tv case */
3777                 entry->i2c_index = (conn >> 14) & 0xf;
3778                 /* raw heads field is in range 0-1, so move to 1-2 */
3779                 entry->heads = ((conn >> 18) & 0x7) + 1;
3780                 entry->location = (conn >> 21) & 0xf;
3781                 entry->bus = (conn >> 25) & 0x7;
3782                 /* set or to be same as heads -- hopefully safe enough */
3783                 entry->or = entry->heads;
3784
3785                 switch (entry->type) {
3786                 case OUTPUT_LVDS:
3787                         /* these are probably buried in conn's unknown bits */
3788                         entry->lvdsconf.use_straps_for_mode = TRUE;
3789                         entry->lvdsconf.use_power_scripts = TRUE;
3790                         break;
3791                 }
3792         } else if (dcb_version >= 0x12) {
3793                 /* use the defaults for a crt
3794                  * v1.2 tables often have other entries though - need a trace
3795                  */
3796                 entry->type = conn & 0xf;       // this is valid, but will probably confuse the randr stuff
3797                 entry->type = 0;
3798         } else { /* pre DCB / v1.1 - use the safe defaults for a crt */
3799                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3800                            "No information in BIOS output table; assuming a CRT output exists\n");
3801                 entry->i2c_index = pNv->VBIOS.legacy_i2c_indices.crt;
3802         }
3803
3804         pNv->dcb_table.entries++;
3805
3806         return TRUE;
3807 }
3808
3809 static void
3810 read_dcb_i2c_table(ScrnInfoPtr pScrn, bios_t *bios, uint8_t dcb_version, uint16_t i2ctabptr)
3811 {
3812         NVPtr pNv = NVPTR(pScrn);
3813         uint8_t *i2ctable;
3814         uint8_t headerlen = 0;
3815         int i2c_entries;
3816         int recordoffset = 0, rdofs = 1, wrofs = 0;
3817         int i;
3818
3819         i2c_entries = MAX_NUM_DCB_ENTRIES;
3820         memset(pNv->dcb_table.i2c_read, 0, sizeof(pNv->dcb_table.i2c_read));
3821         memset(pNv->dcb_table.i2c_write, 0, sizeof(pNv->dcb_table.i2c_write));
3822
3823         i2ctable = &bios->data[i2ctabptr];
3824
3825         if (dcb_version >= 0x30) {
3826                 if (i2ctable[0] != dcb_version) { /* necessary? */
3827                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3828                                    "DCB I2C table version mismatch (%02X vs %02X)\n",
3829                                    i2ctable[0], dcb_version);
3830                         return;
3831                 }
3832                 headerlen = i2ctable[1];
3833                 i2c_entries = i2ctable[2];
3834                 if (i2ctable[0] >= 0x40) {
3835                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3836                                    "G80 DCB I2C table detected, arrgh\n"); /* they're plain weird */
3837                         return;
3838                 }
3839         }
3840         /* it's your own fault if you call this function on a DCB 1.1 BIOS --
3841          * the below assumes DCB 1.2
3842          */
3843         if (dcb_version < 0x14) {
3844                 recordoffset = 2;
3845                 rdofs = 0;
3846                 wrofs = 1;
3847         }
3848
3849         for (i = 0; i < i2c_entries; i++)
3850                 if (i2ctable[headerlen + 4 * i + 3] != 0xff) {
3851                         pNv->dcb_table.i2c_read[i] = i2ctable[headerlen + recordoffset + rdofs + 4 * i];
3852                         pNv->dcb_table.i2c_write[i] = i2ctable[headerlen + recordoffset + wrofs + 4 * i];
3853                 }
3854 }
3855
3856 static unsigned int parse_dcb_table(ScrnInfoPtr pScrn, bios_t *bios)
3857 {
3858         NVPtr pNv = NVPTR(pScrn);
3859         uint16_t dcbptr, i2ctabptr = 0;
3860         uint8_t *dcbtable;
3861         uint8_t dcb_version, headerlen = 0x4, entries = MAX_NUM_DCB_ENTRIES;
3862         Bool configblock = TRUE;
3863         int recordlength = 8, confofs = 4;
3864         int i;
3865
3866         pNv->dcb_table.entries = 0;
3867
3868         /* get the offset from 0x36 */
3869         dcbptr = le16_to_cpu(*(uint16_t *)&bios->data[0x36]);
3870
3871         if (dcbptr == 0x0) {
3872                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3873                            "No Display Configuration Block pointer found\n");
3874                 /* this situation likely means a really old card, pre DCB, so we'll add the safe CRT entry */
3875                 parse_dcb_entry(pScrn, 0, 0, 0, &pNv->dcb_table.entry[0]);
3876                 return 1;
3877         }
3878
3879         dcbtable = &bios->data[dcbptr];
3880
3881         /* get DCB version */
3882         dcb_version = dcbtable[0];
3883         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3884                    "Display Configuration Block version %d.%d found\n",
3885                    dcb_version >> 4, dcb_version & 0xf);
3886
3887         if (dcb_version >= 0x20) { /* NV17+ */
3888                 uint32_t sig;
3889
3890                 if (dcb_version >= 0x30) { /* NV40+ */
3891                         headerlen = dcbtable[1];
3892                         entries = dcbtable[2];
3893                         i2ctabptr = le16_to_cpu(*(uint16_t *)&dcbtable[4]);
3894                         sig = le32_to_cpu(*(uint32_t *)&dcbtable[6]);
3895
3896                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3897                                    "DCB header length %02X, with %02X possible entries\n",
3898                                    headerlen, entries);
3899                 } else {
3900                         /* dcb_block_count = *(dcbtable[1]); */
3901                         i2ctabptr = le16_to_cpu(*(uint16_t *)&dcbtable[2]);
3902                         sig = le32_to_cpu(*(uint32_t *)&dcbtable[4]);
3903                         headerlen = 8;
3904                 }
3905
3906                 if (sig != 0x4edcbdcb) {
3907                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3908                                    "Bad Display Configuration Block signature (%08X)\n", sig);
3909                         return 0;
3910                 }
3911         } else if (dcb_version >= 0x14) { /* some NV15/16, and NV11+ */
3912                 char sig[8];
3913
3914                 memset(sig, 0, 8);
3915                 strncpy(sig, (char *)&dcbtable[-7], 7);
3916                 /* dcb_block_count = *(dcbtable[1]); */
3917                 i2ctabptr = le16_to_cpu(*(uint16_t *)&dcbtable[2]);
3918                 recordlength = 10;
3919                 confofs = 6;
3920
3921                 if (strcmp(sig, "DEV_REC")) {
3922                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3923                                    "Bad Display Configuration Block signature (%s)\n", sig);
3924                         return 0;
3925                 }
3926         } else if (dcb_version >= 0x12) { /* some NV6/10, and NV15+ */
3927                 /* dcb_block_count = *(dcbtable[1]); */
3928                 i2ctabptr = le16_to_cpu(*(uint16_t *)&dcbtable[2]);
3929                 configblock = FALSE;
3930         } else {        /* NV5+, maybe NV4 */
3931                 /* DCB 1.1 seems to be quite unhelpful - we'll just add the safe CRT entry */
3932                 parse_dcb_entry(pScrn, dcb_version, 0, 0, &pNv->dcb_table.entry[0]);
3933                 return 1;
3934         }
3935
3936         if (entries >= MAX_NUM_DCB_ENTRIES)
3937                 entries = MAX_NUM_DCB_ENTRIES;
3938
3939         for (i = 0; i < entries; i++) {
3940                 uint32_t connection, config = 0;
3941
3942                 connection = le32_to_cpu(*(uint32_t *)&dcbtable[headerlen + recordlength * i]);
3943                 if (configblock)
3944                         config = le32_to_cpu(*(uint32_t *)&dcbtable[headerlen + confofs + recordlength * i]);
3945
3946                 /* Should we allow discontinuous DCBs? Certainly DCB I2C tables
3947                  * can be discontinuous */
3948                 if ((connection & 0x0000000f) == 0x0000000f) /* end of records */
3949                         break;
3950
3951                 ErrorF("Raw DCB entry %d: %08x %08x\n", i, connection, config);
3952                 if (!parse_dcb_entry(pScrn, dcb_version, connection, config, &pNv->dcb_table.entry[i]))
3953                         break;
3954         }
3955
3956         read_dcb_i2c_table(pScrn, bios, dcb_version, i2ctabptr);
3957
3958         /* DCB v2.0, in particular, lists each output combination separately.
3959          * Here we merge compatible entries to have fewer outputs, with more options
3960          */
3961         for (i = 0; i < pNv->dcb_table.entries; i++) {
3962                 struct dcb_entry *ient = &pNv->dcb_table.entry[i];
3963                 int j;
3964
3965                 for (j = i + 1; j < pNv->dcb_table.entries; j++) {
3966                         struct dcb_entry *jent = &pNv->dcb_table.entry[j];
3967
3968                         if (jent->type == 100) /* already merged entry */
3969                                 continue;
3970
3971                         if (jent->i2c_index == ient->i2c_index && jent->type == ient->type && jent->location == ient->location) {
3972                                 /* only merge heads field when output field is the same --
3973                                  * we could merge output field for same heads, but dual link,
3974                                  * the resultant need to make several merging passes, and lack
3975                                  * of applicable real life cases has deterred this so far
3976                                  */
3977                                 if (jent->or == ient->or) {
3978                                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3979                                                    "Merging DCB entries %d and %d\n", i, j);
3980                                         ient->heads |= jent->heads;
3981                                         jent->type = 100; /* dummy value */
3982                                 }
3983                         }
3984                 }
3985         }
3986
3987         /* Compact entries merged into others out of dcb_table */
3988         int newentries = 0;
3989         for (i = 0; i < pNv->dcb_table.entries; i++) {
3990                 if ( pNv->dcb_table.entry[i].type == 100 )
3991                         continue;
3992
3993                 if (newentries != i)
3994                         memcpy(&pNv->dcb_table.entry[newentries], &pNv->dcb_table.entry[i], sizeof(struct dcb_entry));
3995                 newentries++;
3996         }
3997
3998         pNv->dcb_table.entries = newentries;
3999
4000         return pNv->dcb_table.entries;
4001 }
4002
4003 static void load_nv17_hw_sequencer_ucode(ScrnInfoPtr pScrn, bios_t *bios, uint16_t hwsq_offset, int entry)
4004 {
4005         /* BMP based cards, from NV17, need a microcode loading to correctly
4006          * control the GPIO etc for LVDS panels
4007          *
4008          * BIT based cards seem to do this directly in the init scripts
4009          *
4010          * The microcode entries are found by the "HWSQ" signature.
4011          * The header following has the number of entries, and the entry size
4012          *
4013          * An entry consists of a dword to write to the sequencer control reg
4014          * (0x00001304), followed by the ucode bytes, written sequentially,
4015          * starting at reg 0x00001400
4016          */
4017
4018         uint8_t bytes_to_write;
4019         int i;
4020
4021         if (bios->data[hwsq_offset] <= entry) {
4022                 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
4023                            "Too few entries in HW sequencer table for requested entry\n");
4024                 return;
4025         }
4026
4027         bytes_to_write = bios->data[hwsq_offset + 1];
4028
4029         if (bytes_to_write != 36) {
4030                 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "Unknown HW sequencer entry size\n");
4031                 return;
4032         }
4033
4034         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Loading NV17 power sequencing microcode\n");
4035
4036         uint16_t hwsq_entry_offset = hwsq_offset + 2 + entry * bytes_to_write;
4037
4038         /* set sequencer control */
4039         nv32_wr(pScrn, 0x00001304, le32_to_cpu(*(uint32_t *)&bios->data[hwsq_entry_offset]));
4040         bytes_to_write -= 4;
4041
4042         /* write ucode */
4043         for (i = 0; i < bytes_to_write; i += 4)
4044                 nv32_wr(pScrn, 0x00001400 + i, le32_to_cpu(*(uint32_t *)&bios->data[hwsq_entry_offset + i + 4]));
4045
4046         /* twiddle 0x1098 */
4047         nv32_wr(pScrn, 0x00001098, nv32_rd(pScrn, 0x00001098) | 0x18);
4048 }
4049
4050 static void read_bios_edid(ScrnInfoPtr pScrn)
4051 {
4052         bios_t *bios = &NVPTR(pScrn)->VBIOS;
4053         const uint8_t edid_sig[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
4054         uint16_t offset = 0, newoffset;
4055         int searchlen = NV_PROM_SIZE, i;
4056
4057         while (searchlen) {
4058                 if (!(newoffset = findstr(&bios->data[offset], searchlen, edid_sig, 8)))
4059                         return;
4060                 offset += newoffset;
4061                 if (!nv_cksum(&bios->data[offset], EDID1_LEN))
4062                         break;
4063
4064                 searchlen -= offset;
4065                 offset++;
4066         }
4067
4068         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Found EDID in BIOS\n");
4069
4070         bios->fp.edid = xalloc(EDID1_LEN);
4071         for (i = 0; i < EDID1_LEN; i++)
4072                 bios->fp.edid[i] = bios->data[offset + i];
4073 }
4074
4075 Bool NVInitVBIOS(ScrnInfoPtr pScrn)
4076 {
4077         NVPtr pNv = NVPTR(pScrn);
4078
4079         memset(&pNv->VBIOS, 0, sizeof(bios_t));
4080         pNv->VBIOS.data = xalloc(NV_PROM_SIZE);
4081
4082         if (!NVShadowVBIOS(pScrn, pNv->VBIOS.data)) {
4083                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
4084                            "No valid BIOS image found\n");
4085                 xfree(pNv->VBIOS.data);
4086                 return FALSE;
4087         }
4088
4089         pNv->VBIOS.length = pNv->VBIOS.data[2] * 512;
4090         if (pNv->VBIOS.length > NV_PROM_SIZE)
4091                 pNv->VBIOS.length = NV_PROM_SIZE;
4092
4093         return TRUE;
4094 }
4095
4096 Bool NVRunVBIOSInit(ScrnInfoPtr pScrn)
4097 {
4098         NVPtr pNv = NVPTR(pScrn);
4099         const uint8_t bmp_signature[] = { 0xff, 0x7f, 'N', 'V', 0x0 };
4100         const uint8_t bit_signature[] = { 'B', 'I', 'T' };
4101         int offset, ret = 0;
4102
4103         crtc_access(pScrn, ACCESS_UNLOCK);
4104
4105         if ((offset = findstr(pNv->VBIOS.data, pNv->VBIOS.length, bit_signature, sizeof(bit_signature)))) {
4106                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "BIT BIOS found\n");
4107                 parse_bit_structure(pScrn, &pNv->VBIOS, offset + 4);
4108         } else if ((offset = findstr(pNv->VBIOS.data, pNv->VBIOS.length, bmp_signature, sizeof(bmp_signature)))) {
4109                 const uint8_t hwsq_signature[] = { 'H', 'W', 'S', 'Q' };
4110                 int hwsq_offset;
4111
4112                 if ((hwsq_offset = findstr(pNv->VBIOS.data, pNv->VBIOS.length, hwsq_signature, sizeof(hwsq_signature))))
4113                         /* always use entry 0? */
4114                         load_nv17_hw_sequencer_ucode(pScrn, &pNv->VBIOS, hwsq_offset + sizeof(hwsq_signature), 0);
4115
4116                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "BMP BIOS found\n");
4117                 parse_bmp_structure(pScrn, &pNv->VBIOS, offset);
4118         } else {
4119                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
4120                            "No known BIOS signature found\n");
4121                 ret = 1;
4122         }
4123
4124         crtc_access(pScrn, ACCESS_LOCK);
4125
4126         if (ret)
4127                 return FALSE;
4128
4129         return TRUE;
4130 }
4131
4132 unsigned int NVParseBios(ScrnInfoPtr pScrn)
4133 {
4134         NVPtr pNv = NVPTR(pScrn);
4135         uint32_t saved_nv_pextdev_boot_0;
4136
4137         if (!NVInitVBIOS(pScrn))
4138                 return 0;
4139
4140         /* these will need remembering across a suspend */
4141         saved_nv_pextdev_boot_0 = nv32_rd(pScrn, NV_PEXTDEV_BOOT_0);
4142         saved_nv_pfb_cfg0 = nv32_rd(pScrn, NV_PFB_CFG0);
4143
4144         pNv->VBIOS.execute = FALSE;
4145
4146         nv32_wr(pScrn, NV_PEXTDEV_BOOT_0, saved_nv_pextdev_boot_0);
4147
4148         if (!NVRunVBIOSInit(pScrn))
4149                 return 0;
4150
4151         if (parse_dcb_table(pScrn, &pNv->VBIOS))
4152                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
4153                            "Found %d entries in DCB\n", pNv->dcb_table.entries);
4154
4155         if (pNv->Mobile && !pNv->VBIOS.fp.native_mode)
4156                 read_bios_edid(pScrn);
4157
4158         return 1;
4159 }