drivers/gpu/drm/nouveau/nouveau_bios.c

   1 /*
   2  * Copyright 2005-2006 Erik Waling
   3  * Copyright 2006 Stephane Marchesin
   4  * Copyright 2007-2009 Stuart Bennett
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  20  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  21  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24
  25 #include "drmP.h"
  26 #define NV_DEBUG_NOTRACE
  27 #include "nouveau_drv.h"
  28 #include "nouveau_hw.h"
  29 #include "nouveau_encoder.h"
  30
  31 #include <linux/io-mapping.h>
  32
  33 /* these defines are made up */
  34 #define NV_CIO_CRE_44_HEADA 0x0
  35 #define NV_CIO_CRE_44_HEADB 0x3
  36 #define FEATURE_MOBILE 0x10     /* also FEATURE_QUADRO for BMP */
  37 #define LEGACY_I2C_CRT 0x80
  38 #define LEGACY_I2C_PANEL 0x81
  39 #define LEGACY_I2C_TV 0x82
  40
  41 #define EDID1_LEN 128
  42
  43 #define BIOSLOG(sip, fmt, arg...) NV_DEBUG(sip->dev, fmt, ##arg)
  44 #define LOG_OLD_VALUE(x)
  45
  46 struct init_exec {
  47         bool execute;
  48         bool repeat;
  49 };
  50
  51 static bool nv_cksum(const uint8_t *data, unsigned int length)
  52 {
  53         /*
  54          * There's a few checksums in the BIOS, so here's a generic checking
  55          * function.
  56          */
  57         int i;
  58         uint8_t sum = 0;
  59
  60         for (i = 0; i < length; i++)
  61                 sum += data[i];
  62
  63         if (sum)
  64                 return true;
  65
  66         return false;
  67 }
  68
  69 static int
  70 score_vbios(struct drm_device *dev, const uint8_t *data, const bool writeable)
  71 {
  72         if (!(data[0] == 0x55 && data[1] == 0xAA)) {
  73                 NV_TRACEWARN(dev, "... BIOS signature not found\n");
  74                 return 0;
  75         }
  76
  77         if (nv_cksum(data, data[2] * 512)) {
  78                 NV_TRACEWARN(dev, "... BIOS checksum invalid\n");
  79                 /* if a ro image is somewhat bad, it's probably all rubbish */
  80                 return writeable ? 2 : 1;
  81         } else
  82                 NV_TRACE(dev, "... appears to be valid\n");
  83
  84         return 3;
  85 }
  86
  87 static void load_vbios_prom(struct drm_device *dev, uint8_t *data)
  88 {
  89         struct drm_nouveau_private *dev_priv = dev->dev_private;
  90         uint32_t pci_nv_20, save_pci_nv_20;
  91         int pcir_ptr;
  92         int i;
  93
  94         if (dev_priv->card_type >= NV_50)
  95                 pci_nv_20 = 0x88050;
  96         else
  97                 pci_nv_20 = NV_PBUS_PCI_NV_20;
  98
  99         /* enable ROM access */
 100         save_pci_nv_20 = nvReadMC(dev, pci_nv_20);
 101         nvWriteMC(dev, pci_nv_20,
 102                   save_pci_nv_20 & ~NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED);
 103
 104         /* bail if no rom signature */
 105         if (nv_rd08(dev, NV_PROM_OFFSET) != 0x55 ||
 106             nv_rd08(dev, NV_PROM_OFFSET + 1) != 0xaa)
 107                 goto out;
 108
 109         /* additional check (see note below) - read PCI record header */
 110         pcir_ptr = nv_rd08(dev, NV_PROM_OFFSET + 0x18) |
 111                    nv_rd08(dev, NV_PROM_OFFSET + 0x19) << 8;
 112         if (nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr) != 'P' ||
 113             nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr + 1) != 'C' ||
 114             nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr + 2) != 'I' ||
 115             nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr + 3) != 'R')
 116                 goto out;
 117
 118         /* on some 6600GT/6800LE prom reads are messed up.  nvclock alleges a
 119          * a good read may be obtained by waiting or re-reading (cargocult: 5x)
 120          * each byte.  we'll hope pramin has something usable instead
 121          */
 122         for (i = 0; i < NV_PROM_SIZE; i++)
 123                 data[i] = nv_rd08(dev, NV_PROM_OFFSET + i);
 124
 125 out:
 126         /* disable ROM access */
 127         nvWriteMC(dev, pci_nv_20,
 128                   save_pci_nv_20 | NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED);
 129 }
 130
 131 static void load_vbios_pramin(struct drm_device *dev, uint8_t *data)
 132 {
 133         struct drm_nouveau_private *dev_priv = dev->dev_private;
 134         uint32_t old_bar0_pramin = 0;
 135         int i;
 136
 137         if (dev_priv->card_type >= NV_50) {
 138                 uint32_t vbios_vram = (nv_rd32(dev, 0x619f04) & ~0xff) << 8;
 139
 140                 if (!vbios_vram)
 141                         vbios_vram = (nv_rd32(dev, 0x1700) << 16) + 0xf0000;
 142
 143                 old_bar0_pramin = nv_rd32(dev, 0x1700);
 144                 nv_wr32(dev, 0x1700, vbios_vram >> 16);
 145         }
 146
 147         /* bail if no rom signature */
 148         if (nv_rd08(dev, NV_PRAMIN_OFFSET) != 0x55 ||
 149             nv_rd08(dev, NV_PRAMIN_OFFSET + 1) != 0xaa)
 150                 goto out;
 151
 152         for (i = 0; i < NV_PROM_SIZE; i++)
 153                 data[i] = nv_rd08(dev, NV_PRAMIN_OFFSET + i);
 154
 155 out:
 156         if (dev_priv->card_type >= NV_50)
 157                 nv_wr32(dev, 0x1700, old_bar0_pramin);
 158 }
 159
 160 static void load_vbios_pci(struct drm_device *dev, uint8_t *data)
 161 {
 162         void __iomem *rom = NULL;
 163         size_t rom_len;
 164         int ret;
 165
 166         ret = pci_enable_rom(dev->pdev);
 167         if (ret)
 168                 return;
 169
 170         rom = pci_map_rom(dev->pdev, &rom_len);
 171         if (!rom)
 172                 goto out;
 173         memcpy_fromio(data, rom, rom_len);
 174         pci_unmap_rom(dev->pdev, rom);
 175
 176 out:
 177         pci_disable_rom(dev->pdev);
 178 }
 179
 180 static void load_vbios_acpi(struct drm_device *dev, uint8_t *data)
 181 {
 182         int i;
 183         int ret;
 184         int size = 64 * 1024;
 185
 186         if (!nouveau_acpi_rom_supported(dev->pdev))
 187                 return;
 188
 189         for (i = 0; i < (size / ROM_BIOS_PAGE); i++) {
 190                 ret = nouveau_acpi_get_bios_chunk(data,
 191                                                   (i * ROM_BIOS_PAGE),
 192                                                   ROM_BIOS_PAGE);
 193                 if (ret <= 0)
 194                         break;
 195         }
 196         return;
 197 }
 198
 199 struct methods {
 200         const char desc[8];
 201         void (*loadbios)(struct drm_device *, uint8_t *);
 202         const bool rw;
 203 };
 204
 205 static struct methods shadow_methods[] = {
 206         { "PRAMIN", load_vbios_pramin, true },
 207         { "PROM", load_vbios_prom, false },
 208         { "PCIROM", load_vbios_pci, true },
 209         { "ACPI", load_vbios_acpi, true },
 210 };
 211 #define NUM_SHADOW_METHODS ARRAY_SIZE(shadow_methods)
 212
 213 static bool NVShadowVBIOS(struct drm_device *dev, uint8_t *data)
 214 {
 215         struct methods *methods = shadow_methods;
 216         int testscore = 3;
 217         int scores[NUM_SHADOW_METHODS], i;
 218
 219         if (nouveau_vbios) {
 220                 for (i = 0; i < NUM_SHADOW_METHODS; i++)
 221                         if (!strcasecmp(nouveau_vbios, methods[i].desc))
 222                                 break;
 223
 224                 if (i < NUM_SHADOW_METHODS) {
 225                         NV_INFO(dev, "Attempting to use BIOS image from %s\n",
 226                                 methods[i].desc);
 227
 228                         methods[i].loadbios(dev, data);
 229                         if (score_vbios(dev, data, methods[i].rw))
 230                                 return true;
 231                 }
 232
 233                 NV_ERROR(dev, "VBIOS source \'%s\' invalid\n", nouveau_vbios);
 234         }
 235
 236         for (i = 0; i < NUM_SHADOW_METHODS; i++) {
 237                 NV_TRACE(dev, "Attempting to load BIOS image from %s\n",
 238                          methods[i].desc);
 239                 data[0] = data[1] = 0;  /* avoid reuse of previous image */
 240                 methods[i].loadbios(dev, data);
 241                 scores[i] = score_vbios(dev, data, methods[i].rw);
 242                 if (scores[i] == testscore)
 243                         return true;
 244         }
 245
 246         while (--testscore > 0) {
 247                 for (i = 0; i < NUM_SHADOW_METHODS; i++) {
 248                         if (scores[i] == testscore) {
 249                                 NV_TRACE(dev, "Using BIOS image from %s\n",
 250                                          methods[i].desc);
 251                                 methods[i].loadbios(dev, data);
 252                                 return true;
 253                         }
 254                 }
 255         }
 256
 257         NV_ERROR(dev, "No valid BIOS image found\n");
 258         return false;
 259 }
 260
 261 struct init_tbl_entry {
 262         char *name;
 263         uint8_t id;
 264         /* Return:
 265          *  > 0: success, length of opcode
 266          *    0: success, but abort further parsing of table (INIT_DONE etc)
 267          *  < 0: failure, table parsing will be aborted
 268          */
 269         int (*handler)(struct nvbios *, uint16_t, struct init_exec *);
 270 };
 271
 272 static int parse_init_table(struct nvbios *, unsigned int, struct init_exec *);
 273
 274 #define MACRO_INDEX_SIZE        2
 275 #define MACRO_SIZE              8
 276 #define CONDITION_SIZE          12
 277 #define IO_FLAG_CONDITION_SIZE  9
 278 #define IO_CONDITION_SIZE       5
 279 #define MEM_INIT_SIZE           66
 280
 281 static void still_alive(void)
 282 {
 283 #if 0
 284         sync();
 285         msleep(2);
 286 #endif
 287 }
 288
 289 static uint32_t
 290 munge_reg(struct nvbios *bios, uint32_t reg)
 291 {
 292         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
 293         struct dcb_entry *dcbent = bios->display.output;
 294
 295         if (dev_priv->card_type < NV_50)
 296                 return reg;
 297
 298         if (reg & 0x40000000) {
 299                 BUG_ON(!dcbent);
 300
 301                 reg += (ffs(dcbent->or) - 1) * 0x800;
 302                 if ((reg & 0x20000000) && !(dcbent->sorconf.link & 1))
 303                         reg += 0x00000080;
 304         }
 305
 306         reg &= ~0x60000000;
 307         return reg;
 308 }
 309
 310 static int
 311 valid_reg(struct nvbios *bios, uint32_t reg)
 312 {
 313         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
 314         struct drm_device *dev = bios->dev;
 315
 316         /* C51 has misaligned regs on purpose. Marvellous */
 317         if (reg & 0x2 ||
 318             (reg & 0x1 && dev_priv->vbios.chip_version != 0x51))
 319                 NV_ERROR(dev, "======= misaligned reg 0x%08X =======\n", reg);
 320
 321         /* warn on C51 regs that haven't been verified accessible in tracing */
 322         if (reg & 0x1 && dev_priv->vbios.chip_version == 0x51 &&
 323             reg != 0x130d && reg != 0x1311 && reg != 0x60081d)
 324                 NV_WARN(dev, "=== C51 misaligned reg 0x%08X not verified ===\n",
 325                         reg);
 326
 327         if (reg >= (8*1024*1024)) {
 328                 NV_ERROR(dev, "=== reg 0x%08x out of mapped bounds ===\n", reg);
 329                 return 0;
 330         }
 331
 332         return 1;
 333 }
 334
 335 static bool
 336 valid_idx_port(struct nvbios *bios, uint16_t port)
 337 {
 338         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
 339         struct drm_device *dev = bios->dev;
 340
 341         /*
 342          * If adding more ports here, the read/write functions below will need
 343          * updating so that the correct mmio range (PRMCIO, PRMDIO, PRMVIO) is
 344          * used for the port in question
 345          */
 346         if (dev_priv->card_type < NV_50) {
 347                 if (port == NV_CIO_CRX__COLOR)
 348                         return true;
 349                 if (port == NV_VIO_SRX)
 350                         return true;
 351         } else {
 352                 if (port == NV_CIO_CRX__COLOR)
 353                         return true;
 354         }
 355
 356         NV_ERROR(dev, "========== unknown indexed io port 0x%04X ==========\n",
 357                  port);
 358
 359         return false;
 360 }
 361
 362 static bool
 363 valid_port(struct nvbios *bios, uint16_t port)
 364 {
 365         struct drm_device *dev = bios->dev;
 366
 367         /*
 368          * If adding more ports here, the read/write functions below will need
 369          * updating so that the correct mmio range (PRMCIO, PRMDIO, PRMVIO) is
 370          * used for the port in question
 371          */
 372         if (port == NV_VIO_VSE2)
 373                 return true;
 374
 375         NV_ERROR(dev, "========== unknown io port 0x%04X ==========\n", port);
 376
 377         return false;
 378 }
 379
 380 static uint32_t
 381 bios_rd32(struct nvbios *bios, uint32_t reg)
 382 {
 383         uint32_t data;
 384
 385         reg = munge_reg(bios, reg);
 386         if (!valid_reg(bios, reg))
 387                 return 0;
 388
 389         /*
 390          * C51 sometimes uses regs with bit0 set in the address. For these
 391          * cases there should exist a translation in a BIOS table to an IO
 392          * port address which the BIOS uses for accessing the reg
 393          *
 394          * These only seem to appear for the power control regs to a flat panel,
 395          * and the GPIO regs at 0x60081*.  In C51 mmio traces the normal regs
 396          * for 0x1308 and 0x1310 are used - hence the mask below.  An S3
 397          * suspend-resume mmio trace from a C51 will be required to see if this
 398          * is true for the power microcode in 0x14.., or whether the direct IO
 399          * port access method is needed
 400          */
 401         if (reg & 0x1)
 402                 reg &= ~0x1;
 403
 404         data = nv_rd32(bios->dev, reg);
 405
 406         BIOSLOG(bios, " Read:  Reg: 0x%08X, Data: 0x%08X\n", reg, data);
 407
 408         return data;
 409 }
 410
 411 static void
 412 bios_wr32(struct nvbios *bios, uint32_t reg, uint32_t data)
 413 {
 414         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
 415
 416         reg = munge_reg(bios, reg);
 417         if (!valid_reg(bios, reg))
 418                 return;
 419
 420         /* see note in bios_rd32 */
 421         if (reg & 0x1)
 422                 reg &= 0xfffffffe;
 423
 424         LOG_OLD_VALUE(bios_rd32(bios, reg));
 425         BIOSLOG(bios, " Write: Reg: 0x%08X, Data: 0x%08X\n", reg, data);
 426
 427         if (dev_priv->vbios.execute) {
 428                 still_alive();
 429                 nv_wr32(bios->dev, reg, data);
 430         }
 431 }
 432
 433 static uint8_t
 434 bios_idxprt_rd(struct nvbios *bios, uint16_t port, uint8_t index)
 435 {
 436         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
 437         struct drm_device *dev = bios->dev;
 438         uint8_t data;
 439
 440         if (!valid_idx_port(bios, port))
 441                 return 0;
 442
 443         if (dev_priv->card_type < NV_50) {
 444                 if (port == NV_VIO_SRX)
 445                         data = NVReadVgaSeq(dev, bios->state.crtchead, index);
 446                 else    /* assume NV_CIO_CRX__COLOR */
 447                         data = NVReadVgaCrtc(dev, bios->state.crtchead, index);
 448         } else {
 449                 uint32_t data32;
 450
 451                 data32 = bios_rd32(bios, NV50_PDISPLAY_VGACRTC(index & ~3));
 452                 data = (data32 >> ((index & 3) << 3)) & 0xff;
 453         }
 454
 455         BIOSLOG(bios, " Indexed IO read:  Port: 0x%04X, Index: 0x%02X, "
 456                       "Head: 0x%02X, Data: 0x%02X\n",
 457                 port, index, bios->state.crtchead, data);
 458         return data;
 459 }
 460
 461 static void
 462 bios_idxprt_wr(struct nvbios *bios, uint16_t port, uint8_t index, uint8_t data)
 463 {
 464         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
 465         struct drm_device *dev = bios->dev;
 466
 467         if (!valid_idx_port(bios, port))
 468                 return;
 469
 470         /*
 471          * The current head is maintained in the nvbios member  state.crtchead.
 472          * We trap changes to CR44 and update the head variable and hence the
 473          * register set written.
 474          * As CR44 only exists on CRTC0, we update crtchead to head0 in advance
 475          * of the write, and to head1 after the write
 476          */
 477         if (port == NV_CIO_CRX__COLOR && index == NV_CIO_CRE_44 &&
 478             data != NV_CIO_CRE_44_HEADB)
 479                 bios->state.crtchead = 0;
 480
 481         LOG_OLD_VALUE(bios_idxprt_rd(bios, port, index));
 482         BIOSLOG(bios, " Indexed IO write: Port: 0x%04X, Index: 0x%02X, "
 483                       "Head: 0x%02X, Data: 0x%02X\n",
 484                 port, index, bios->state.crtchead, data);
 485
 486         if (bios->execute && dev_priv->card_type < NV_50) {
 487                 still_alive();
 488                 if (port == NV_VIO_SRX)
 489                         NVWriteVgaSeq(dev, bios->state.crtchead, index, data);
 490                 else    /* assume NV_CIO_CRX__COLOR */
 491                         NVWriteVgaCrtc(dev, bios->state.crtchead, index, data);
 492         } else
 493         if (bios->execute) {
 494                 uint32_t data32, shift = (index & 3) << 3;
 495
 496                 still_alive();
 497
 498                 data32  = bios_rd32(bios, NV50_PDISPLAY_VGACRTC(index & ~3));
 499                 data32 &= ~(0xff << shift);
 500                 data32 |= (data << shift);
 501                 bios_wr32(bios, NV50_PDISPLAY_VGACRTC(index & ~3), data32);
 502         }
 503
 504         if (port == NV_CIO_CRX__COLOR &&
 505             index == NV_CIO_CRE_44 && data == NV_CIO_CRE_44_HEADB)
 506                 bios->state.crtchead = 1;
 507 }
 508
 509 static uint8_t
 510 bios_port_rd(struct nvbios *bios, uint16_t port)
 511 {
 512         uint8_t data, head = bios->state.crtchead;
 513
 514         if (!valid_port(bios, port))
 515                 return 0;
 516
 517         data = NVReadPRMVIO(bios->dev, head, NV_PRMVIO0_OFFSET + port);
 518
 519         BIOSLOG(bios, " IO read:  Port: 0x%04X, Head: 0x%02X, Data: 0x%02X\n",
 520                 port, head, data);
 521
 522         return data;
 523 }
 524
 525 static void
 526 bios_port_wr(struct nvbios *bios, uint16_t port, uint8_t data)
 527 {
 528         int head = bios->state.crtchead;
 529
 530         if (!valid_port(bios, port))
 531                 return;
 532
 533         LOG_OLD_VALUE(bios_port_rd(bios, port));
 534         BIOSLOG(bios, " IO write: Port: 0x%04X, Head: 0x%02X, Data: 0x%02X\n",
 535                 port, head, data);
 536
 537         if (!bios->execute)
 538                 return;
 539
 540         still_alive();
 541         NVWritePRMVIO(bios->dev, head, NV_PRMVIO0_OFFSET + port, data);
 542 }
 543
 544 static bool
 545 io_flag_condition_met(struct nvbios *bios, uint16_t offset, uint8_t cond)
 546 {
 547         /*
 548          * The IO flag condition entry has 2 bytes for the CRTC port; 1 byte
 549          * for the CRTC index; 1 byte for the mask to apply to the value
 550          * retrieved from the CRTC; 1 byte for the shift right to apply to the
 551          * masked CRTC value; 2 bytes for the offset to the flag array, to
 552          * which the shifted value is added; 1 byte for the mask applied to the
 553          * value read from the flag array; and 1 byte for the value to compare
 554          * against the masked byte from the flag table.
 555          */
 556
 557         uint16_t condptr = bios->io_flag_condition_tbl_ptr + cond * IO_FLAG_CONDITION_SIZE;
 558         uint16_t crtcport = ROM16(bios->data[condptr]);
 559         uint8_t crtcindex = bios->data[condptr + 2];
 560         uint8_t mask = bios->data[condptr + 3];
 561         uint8_t shift = bios->data[condptr + 4];
 562         uint16_t flagarray = ROM16(bios->data[condptr + 5]);
 563         uint8_t flagarraymask = bios->data[condptr + 7];
 564         uint8_t cmpval = bios->data[condptr + 8];
 565         uint8_t data;
 566
 567         BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
 568                       "Shift: 0x%02X, FlagArray: 0x%04X, FAMask: 0x%02X, "
 569                       "Cmpval: 0x%02X\n",
 570                 offset, crtcport, crtcindex, mask, shift, flagarray, flagarraymask, cmpval);
 571
 572         data = bios_idxprt_rd(bios, crtcport, crtcindex);
 573
 574         data = bios->data[flagarray + ((data & mask) >> shift)];
 575         data &= flagarraymask;
 576
 577         BIOSLOG(bios, "0x%04X: Checking if 0x%02X equals 0x%02X\n",
 578                 offset, data, cmpval);
 579
 580         return (data == cmpval);
 581 }
 582
 583 static bool
 584 bios_condition_met(struct nvbios *bios, uint16_t offset, uint8_t cond)
 585 {
 586         /*
 587          * The condition table entry has 4 bytes for the address of the
 588          * register to check, 4 bytes for a mask to apply to the register and
 589          * 4 for a test comparison value
 590          */
 591
 592         uint16_t condptr = bios->condition_tbl_ptr + cond * CONDITION_SIZE;
 593         uint32_t reg = ROM32(bios->data[condptr]);
 594         uint32_t mask = ROM32(bios->data[condptr + 4]);
 595         uint32_t cmpval = ROM32(bios->data[condptr + 8]);
 596         uint32_t data;
 597
 598         BIOSLOG(bios, "0x%04X: Cond: 0x%02X, Reg: 0x%08X, Mask: 0x%08X\n",
 599                 offset, cond, reg, mask);
 600
 601         data = bios_rd32(bios, reg) & mask;
 602
 603         BIOSLOG(bios, "0x%04X: Checking if 0x%08X equals 0x%08X\n",
 604                 offset, data, cmpval);
 605
 606         return (data == cmpval);
 607 }
 608
 609 static bool
 610 io_condition_met(struct nvbios *bios, uint16_t offset, uint8_t cond)
 611 {
 612         /*
 613          * The IO condition entry has 2 bytes for the IO port address; 1 byte
 614          * for the index to write to io_port; 1 byte for the mask to apply to
 615          * the byte read from io_port+1; and 1 byte for the value to compare
 616          * against the masked byte.
 617          */
 618
 619         uint16_t condptr = bios->io_condition_tbl_ptr + cond * IO_CONDITION_SIZE;
 620         uint16_t io_port = ROM16(bios->data[condptr]);
 621         uint8_t port_index = bios->data[condptr + 2];
 622         uint8_t mask = bios->data[condptr + 3];
 623         uint8_t cmpval = bios->data[condptr + 4];
 624
 625         uint8_t data = bios_idxprt_rd(bios, io_port, port_index) & mask;
 626
 627         BIOSLOG(bios, "0x%04X: Checking if 0x%02X equals 0x%02X\n",
 628                 offset, data, cmpval);
 629
 630         return (data == cmpval);
 631 }
 632
 633 static int
 634 nv50_pll_set(struct drm_device *dev, uint32_t reg, uint32_t clk)
 635 {
 636         struct drm_nouveau_private *dev_priv = dev->dev_private;
 637         uint32_t reg0 = nv_rd32(dev, reg + 0);
 638         uint32_t reg1 = nv_rd32(dev, reg + 4);
 639         struct nouveau_pll_vals pll;
 640         struct pll_lims pll_limits;
 641         int ret;
 642
 643         ret = get_pll_limits(dev, reg, &pll_limits);
 644         if (ret)
 645                 return ret;
 646
 647         clk = nouveau_calc_pll_mnp(dev, &pll_limits, clk, &pll);
 648         if (!clk)
 649                 return -ERANGE;
 650
 651         reg0 = (reg0 & 0xfff8ffff) | (pll.log2P << 16);
 652         reg1 = (reg1 & 0xffff0000) | (pll.N1 << 8) | pll.M1;
 653
 654         if (dev_priv->vbios.execute) {
 655                 still_alive();
 656                 nv_wr32(dev, reg + 4, reg1);
 657                 nv_wr32(dev, reg + 0, reg0);
 658         }
 659
 660         return 0;
 661 }
 662
 663 static int
 664 setPLL(struct nvbios *bios, uint32_t reg, uint32_t clk)
 665 {
 666         struct drm_device *dev = bios->dev;
 667         struct drm_nouveau_private *dev_priv = dev->dev_private;
 668         /* clk in kHz */
 669         struct pll_lims pll_lim;
 670         struct nouveau_pll_vals pllvals;
 671         int ret;
 672
 673         if (dev_priv->card_type >= NV_50)
 674                 return nv50_pll_set(dev, reg, clk);
 675
 676         /* high regs (such as in the mac g5 table) are not -= 4 */
 677         ret = get_pll_limits(dev, reg > 0x405c ? reg : reg - 4, &pll_lim);
 678         if (ret)
 679                 return ret;
 680
 681         clk = nouveau_calc_pll_mnp(dev, &pll_lim, clk, &pllvals);
 682         if (!clk)
 683                 return -ERANGE;
 684
 685         if (bios->execute) {
 686                 still_alive();
 687                 nouveau_hw_setpll(dev, reg, &pllvals);
 688         }
 689
 690         return 0;
 691 }
 692
 693 static int dcb_entry_idx_from_crtchead(struct drm_device *dev)
 694 {
 695         struct drm_nouveau_private *dev_priv = dev->dev_private;
 696         struct nvbios *bios = &dev_priv->vbios;
 697
 698         /*
 699          * For the results of this function to be correct, CR44 must have been
 700          * set (using bios_idxprt_wr to set crtchead), CR58 set for CR57 = 0,
 701          * and the DCB table parsed, before the script calling the function is
 702          * run.  run_digital_op_script is example of how to do such setup
 703          */
 704
 705         uint8_t dcb_entry = NVReadVgaCrtc5758(dev, bios->state.crtchead, 0);
 706
 707         if (dcb_entry > bios->dcb.entries) {
 708                 NV_ERROR(dev, "CR58 doesn't have a valid DCB entry currently "
 709                                 "(%02X)\n", dcb_entry);
 710                 dcb_entry = 0x7f;       /* unused / invalid marker */
 711         }
 712
 713         return dcb_entry;
 714 }
 715
 716 static int
 717 read_dcb_i2c_entry(struct drm_device *dev, int dcb_version, uint8_t *i2ctable, int index, struct dcb_i2c_entry *i2c)
 718 {
 719         uint8_t dcb_i2c_ver = dcb_version, headerlen = 0, entry_len = 4;
 720         int i2c_entries = DCB_MAX_NUM_I2C_ENTRIES;
 721         int recordoffset = 0, rdofs = 1, wrofs = 0;
 722         uint8_t port_type = 0;
 723
 724         if (!i2ctable)
 725                 return -EINVAL;
 726
 727         if (dcb_version >= 0x30) {
 728                 if (i2ctable[0] != dcb_version) /* necessary? */
 729                         NV_WARN(dev,
 730                                 "DCB I2C table version mismatch (%02X vs %02X)\n",
 731                                 i2ctable[0], dcb_version);
 732                 dcb_i2c_ver = i2ctable[0];
 733                 headerlen = i2ctable[1];
 734                 if (i2ctable[2] <= DCB_MAX_NUM_I2C_ENTRIES)
 735                         i2c_entries = i2ctable[2];
 736                 else
 737                         NV_WARN(dev,
 738                                 "DCB I2C table has more entries than indexable "
 739                                 "(%d entries, max %d)\n", i2ctable[2],
 740                                 DCB_MAX_NUM_I2C_ENTRIES);
 741                 entry_len = i2ctable[3];
 742                 /* [4] is i2c_default_indices, read in parse_dcb_table() */
 743         }
 744         /*
 745          * It's your own fault if you call this function on a DCB 1.1 BIOS --
 746          * the test below is for DCB 1.2
 747          */
 748         if (dcb_version < 0x14) {
 749                 recordoffset = 2;
 750                 rdofs = 0;
 751                 wrofs = 1;
 752         }
 753
 754         if (index == 0xf)
 755                 return 0;
 756         if (index >= i2c_entries) {
 757                 NV_ERROR(dev, "DCB I2C index too big (%d >= %d)\n",
 758                          index, i2ctable[2]);
 759                 return -ENOENT;
 760         }
 761         if (i2ctable[headerlen + entry_len * index + 3] == 0xff) {
 762                 NV_ERROR(dev, "DCB I2C entry invalid\n");
 763                 return -EINVAL;
 764         }
 765
 766         if (dcb_i2c_ver >= 0x30) {
 767                 port_type = i2ctable[headerlen + recordoffset + 3 + entry_len * index];
 768
 769                 /*
 770                  * Fixup for chips using same address offset for read and
 771                  * write.
 772                  */
 773                 if (port_type == 4)     /* seen on C51 */
 774                         rdofs = wrofs = 1;
 775                 if (port_type >= 5)     /* G80+ */
 776                         rdofs = wrofs = 0;
 777         }
 778
 779         if (dcb_i2c_ver >= 0x40) {
 780                 if (port_type != 5 && port_type != 6)
 781                         NV_WARN(dev, "DCB I2C table has port type %d\n", port_type);
 782
 783                 i2c->entry = ROM32(i2ctable[headerlen + recordoffset + entry_len * index]);
 784         }
 785
 786         i2c->port_type = port_type;
 787         i2c->read = i2ctable[headerlen + recordoffset + rdofs + entry_len * index];
 788         i2c->write = i2ctable[headerlen + recordoffset + wrofs + entry_len * index];
 789
 790         return 0;
 791 }
 792
 793 static struct nouveau_i2c_chan *
 794 init_i2c_device_find(struct drm_device *dev, int i2c_index)
 795 {
 796         struct drm_nouveau_private *dev_priv = dev->dev_private;
 797         struct dcb_table *dcb = &dev_priv->vbios.dcb;
 798
 799         if (i2c_index == 0xff) {
 800                 /* note: dcb_entry_idx_from_crtchead needs pre-script set-up */
 801                 int idx = dcb_entry_idx_from_crtchead(dev), shift = 0;
 802                 int default_indices = dcb->i2c_default_indices;
 803
 804                 if (idx != 0x7f && dcb->entry[idx].i2c_upper_default)
 805                         shift = 4;
 806
 807                 i2c_index = (default_indices >> shift) & 0xf;
 808         }
 809         if (i2c_index == 0x80)  /* g80+ */
 810                 i2c_index = dcb->i2c_default_indices & 0xf;
 811         else
 812         if (i2c_index == 0x81)
 813                 i2c_index = (dcb->i2c_default_indices & 0xf0) >> 4;
 814
 815         if (i2c_index >= DCB_MAX_NUM_I2C_ENTRIES) {
 816                 NV_ERROR(dev, "invalid i2c_index 0x%x\n", i2c_index);
 817                 return NULL;
 818         }
 819
 820         /* Make sure i2c table entry has been parsed, it may not
 821          * have been if this is a bus not referenced by a DCB encoder
 822          */
 823         read_dcb_i2c_entry(dev, dcb->version, dcb->i2c_table,
 824                            i2c_index, &dcb->i2c[i2c_index]);
 825
 826         return nouveau_i2c_find(dev, i2c_index);
 827 }
 828
 829 static uint32_t
 830 get_tmds_index_reg(struct drm_device *dev, uint8_t mlv)
 831 {
 832         /*
 833          * For mlv < 0x80, it is an index into a table of TMDS base addresses.
 834          * For mlv == 0x80 use the "or" value of the dcb_entry indexed by
 835          * CR58 for CR57 = 0 to index a table of offsets to the basic
 836          * 0x6808b0 address.
 837          * For mlv == 0x81 use the "or" value of the dcb_entry indexed by
 838          * CR58 for CR57 = 0 to index a table of offsets to the basic
 839          * 0x6808b0 address, and then flip the offset by 8.
 840          */
 841
 842         struct drm_nouveau_private *dev_priv = dev->dev_private;
 843         struct nvbios *bios = &dev_priv->vbios;
 844         const int pramdac_offset[13] = {
 845                 0, 0, 0x8, 0, 0x2000, 0, 0, 0, 0x2008, 0, 0, 0, 0x2000 };
 846         const uint32_t pramdac_table[4] = {
 847                 0x6808b0, 0x6808b8, 0x6828b0, 0x6828b8 };
 848
 849         if (mlv >= 0x80) {
 850                 int dcb_entry, dacoffset;
 851
 852                 /* note: dcb_entry_idx_from_crtchead needs pre-script set-up */
 853                 dcb_entry = dcb_entry_idx_from_crtchead(dev);
 854                 if (dcb_entry == 0x7f)
 855                         return 0;
 856                 dacoffset = pramdac_offset[bios->dcb.entry[dcb_entry].or];
 857                 if (mlv == 0x81)
 858                         dacoffset ^= 8;
 859                 return 0x6808b0 + dacoffset;
 860         } else {
 861                 if (mlv >= ARRAY_SIZE(pramdac_table)) {
 862                         NV_ERROR(dev, "Magic Lookup Value too big (%02X)\n",
 863                                                                         mlv);
 864                         return 0;
 865                 }
 866                 return pramdac_table[mlv];
 867         }
 868 }
 869
 870 static int
 871 init_io_restrict_prog(struct nvbios *bios, uint16_t offset,
 872                       struct init_exec *iexec)
 873 {
 874         /*
 875          * INIT_IO_RESTRICT_PROG   opcode: 0x32 ('2')
 876          *
 877          * offset      (8  bit): opcode
 878          * offset + 1  (16 bit): CRTC port
 879          * offset + 3  (8  bit): CRTC index
 880          * offset + 4  (8  bit): mask
 881          * offset + 5  (8  bit): shift
 882          * offset + 6  (8  bit): count
 883          * offset + 7  (32 bit): register
 884          * offset + 11 (32 bit): configuration 1
 885          * ...
 886          *
 887          * Starting at offset + 11 there are "count" 32 bit values.
 888          * To find out which value to use read index "CRTC index" on "CRTC
 889          * port", AND this value with "mask" and then bit shift right "shift"
 890          * bits.  Read the appropriate value using this index and write to
 891          * "register"
 892          */
 893
 894         uint16_t crtcport = ROM16(bios->data[offset + 1]);
 895         uint8_t crtcindex = bios->data[offset + 3];
 896         uint8_t mask = bios->data[offset + 4];
 897         uint8_t shift = bios->data[offset + 5];
 898         uint8_t count = bios->data[offset + 6];
 899         uint32_t reg = ROM32(bios->data[offset + 7]);
 900         uint8_t config;
 901         uint32_t configval;
 902         int len = 11 + count * 4;
 903
 904         if (!iexec->execute)
 905                 return len;
 906
 907         BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
 908                       "Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
 909                 offset, crtcport, crtcindex, mask, shift, count, reg);
 910
 911         config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift;
 912         if (config > count) {
 913                 NV_ERROR(bios->dev,
 914                          "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
 915                          offset, config, count);
 916                 return len;
 917         }
 918
 919         configval = ROM32(bios->data[offset + 11 + config * 4]);
 920
 921         BIOSLOG(bios, "0x%04X: Writing config %02X\n", offset, config);
 922
 923         bios_wr32(bios, reg, configval);
 924
 925         return len;
 926 }
 927
 928 static int
 929 init_repeat(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
 930 {
 931         /*
 932          * INIT_REPEAT   opcode: 0x33 ('3')
 933          *
 934          * offset      (8 bit): opcode
 935          * offset + 1  (8 bit): count
 936          *
 937          * Execute script following this opcode up to INIT_REPEAT_END
 938          * "count" times
 939          */
 940
 941         uint8_t count = bios->data[offset + 1];
 942         uint8_t i;
 943
 944         /* no iexec->execute check by design */
 945
 946         BIOSLOG(bios, "0x%04X: Repeating following segment %d times\n",
 947                 offset, count);
 948
 949         iexec->repeat = true;
 950
 951         /*
 952          * count - 1, as the script block will execute once when we leave this
 953          * opcode -- this is compatible with bios behaviour as:
 954          * a) the block is always executed at least once, even if count == 0
 955          * b) the bios interpreter skips to the op following INIT_END_REPEAT,
 956          * while we don't
 957          */
 958         for (i = 0; i < count - 1; i++)
 959                 parse_init_table(bios, offset + 2, iexec);
 960
 961         iexec->repeat = false;
 962
 963         return 2;
 964 }
 965
 966 static int
 967 init_io_restrict_pll(struct nvbios *bios, uint16_t offset,
 968                      struct init_exec *iexec)
 969 {
 970         /*
 971          * INIT_IO_RESTRICT_PLL   opcode: 0x34 ('4')
 972          *
 973          * offset      (8  bit): opcode
 974          * offset + 1  (16 bit): CRTC port
 975          * offset + 3  (8  bit): CRTC index
 976          * offset + 4  (8  bit): mask
 977          * offset + 5  (8  bit): shift
 978          * offset + 6  (8  bit): IO flag condition index
 979          * offset + 7  (8  bit): count
 980          * offset + 8  (32 bit): register
 981          * offset + 12 (16 bit): frequency 1
 982          * ...
 983          *
 984          * Starting at offset + 12 there are "count" 16 bit frequencies (10kHz).
 985          * Set PLL register "register" to coefficients for frequency n,
 986          * selected by reading index "CRTC index" of "CRTC port" ANDed with
 987          * "mask" and shifted right by "shift".
 988          *
 989          * If "IO flag condition index" > 0, and condition met, double
 990          * frequency before setting it.
 991          */
 992
 993         uint16_t crtcport = ROM16(bios->data[offset + 1]);
 994         uint8_t crtcindex = bios->data[offset + 3];
 995         uint8_t mask = bios->data[offset + 4];
 996         uint8_t shift = bios->data[offset + 5];
 997         int8_t io_flag_condition_idx = bios->data[offset + 6];
 998         uint8_t count = bios->data[offset + 7];
 999         uint32_t reg = ROM32(bios->data[offset + 8]);
1000         uint8_t config;
1001         uint16_t freq;
1002         int len = 12 + count * 2;
1003
1004         if (!iexec->execute)
1005                 return len;
1006
1007         BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
1008                       "Shift: 0x%02X, IO Flag Condition: 0x%02X, "
1009                       "Count: 0x%02X, Reg: 0x%08X\n",
1010                 offset, crtcport, crtcindex, mask, shift,
1011                 io_flag_condition_idx, count, reg);
1012
1013         config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift;
1014         if (config > count) {
1015                 NV_ERROR(bios->dev,
1016                          "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
1017                          offset, config, count);
1018                 return len;
1019         }
1020
1021         freq = ROM16(bios->data[offset + 12 + config * 2]);
1022
1023         if (io_flag_condition_idx > 0) {
1024                 if (io_flag_condition_met(bios, offset, io_flag_condition_idx)) {
1025                         BIOSLOG(bios, "0x%04X: Condition fulfilled -- "
1026                                       "frequency doubled\n", offset);
1027                         freq *= 2;
1028                 } else
1029                         BIOSLOG(bios, "0x%04X: Condition not fulfilled -- "
1030                                       "frequency unchanged\n", offset);
1031         }
1032
1033         BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %d0kHz\n",
1034                 offset, reg, config, freq);
1035
1036         setPLL(bios, reg, freq * 10);
1037
1038         return len;
1039 }
1040
1041 static int
1042 init_end_repeat(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1043 {
1044         /*
1045          * INIT_END_REPEAT   opcode: 0x36 ('6')
1046          *
1047          * offset      (8 bit): opcode
1048          *
1049          * Marks the end of the block for INIT_REPEAT to repeat
1050          */
1051
1052         /* no iexec->execute check by design */
1053
1054         /*
1055          * iexec->repeat flag necessary to go past INIT_END_REPEAT opcode when
1056          * we're not in repeat mode
1057          */
1058         if (iexec->repeat)
1059                 return 0;
1060
1061         return 1;
1062 }
1063
1064 static int
1065 init_copy(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1066 {
1067         /*
1068          * INIT_COPY   opcode: 0x37 ('7')
1069          *
1070          * offset      (8  bit): opcode
1071          * offset + 1  (32 bit): register
1072          * offset + 5  (8  bit): shift
1073          * offset + 6  (8  bit): srcmask
1074          * offset + 7  (16 bit): CRTC port
1075          * offset + 9  (8 bit): CRTC index
1076          * offset + 10  (8 bit): mask
1077          *
1078          * Read index "CRTC index" on "CRTC port", AND with "mask", OR with
1079          * (REGVAL("register") >> "shift" & "srcmask") and write-back to CRTC
1080          * port
1081          */
1082
1083         uint32_t reg = ROM32(bios->data[offset + 1]);
1084         uint8_t shift = bios->data[offset + 5];
1085         uint8_t srcmask = bios->data[offset + 6];
1086         uint16_t crtcport = ROM16(bios->data[offset + 7]);
1087         uint8_t crtcindex = bios->data[offset + 9];
1088         uint8_t mask = bios->data[offset + 10];
1089         uint32_t data;
1090         uint8_t crtcdata;
1091
1092         if (!iexec->execute)
1093                 return 11;
1094
1095         BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Shift: 0x%02X, SrcMask: 0x%02X, "
1096                       "Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X\n",
1097                 offset, reg, shift, srcmask, crtcport, crtcindex, mask);
1098
1099         data = bios_rd32(bios, reg);
1100
1101         if (shift < 0x80)
1102                 data >>= shift;
1103         else
1104                 data <<= (0x100 - shift);
1105
1106         data &= srcmask;
1107
1108         crtcdata  = bios_idxprt_rd(bios, crtcport, crtcindex) & mask;
1109         crtcdata |= (uint8_t)data;
1110         bios_idxprt_wr(bios, crtcport, crtcindex, crtcdata);
1111
1112         return 11;
1113 }
1114
1115 static int
1116 init_not(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1117 {
1118         /*
1119          * INIT_NOT   opcode: 0x38 ('8')
1120          *
1121          * offset      (8  bit): opcode
1122          *
1123          * Invert the current execute / no-execute condition (i.e. "else")
1124          */
1125         if (iexec->execute)
1126                 BIOSLOG(bios, "0x%04X: ------ Skipping following commands  ------\n", offset);
1127         else
1128                 BIOSLOG(bios, "0x%04X: ------ Executing following commands ------\n", offset);
1129
1130         iexec->execute = !iexec->execute;
1131         return 1;
1132 }
1133
1134 static int
1135 init_io_flag_condition(struct nvbios *bios, uint16_t offset,
1136                        struct init_exec *iexec)
1137 {
1138         /*
1139          * INIT_IO_FLAG_CONDITION   opcode: 0x39 ('9')
1140          *
1141          * offset      (8 bit): opcode
1142          * offset + 1  (8 bit): condition number
1143          *
1144          * Check condition "condition number" in the IO flag condition table.
1145          * If condition not met skip subsequent opcodes until condition is
1146          * inverted (INIT_NOT), or we hit INIT_RESUME
1147          */
1148
1149         uint8_t cond = bios->data[offset + 1];
1150
1151         if (!iexec->execute)
1152                 return 2;
1153
1154         if (io_flag_condition_met(bios, offset, cond))
1155                 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
1156         else {
1157                 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
1158                 iexec->execute = false;
1159         }
1160
1161         return 2;
1162 }
1163
1164 static int
1165 init_dp_condition(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1166 {
1167         /*
1168          * INIT_DP_CONDITION   opcode: 0x3A ('')
1169          *
1170          * offset      (8 bit): opcode
1171          * offset + 1  (8 bit): "sub" opcode
1172          * offset + 2  (8 bit): unknown
1173          *
1174          */
1175
1176         struct bit_displayport_encoder_table *dpe = NULL;
1177         struct dcb_entry *dcb = bios->display.output;
1178         struct drm_device *dev = bios->dev;
1179         uint8_t cond = bios->data[offset + 1];
1180         int dummy;
1181
1182         BIOSLOG(bios, "0x%04X: subop 0x%02X\n", offset, cond);
1183
1184         if (!iexec->execute)
1185                 return 3;
1186
1187         dpe = nouveau_bios_dp_table(dev, dcb, &dummy);
1188         if (!dpe) {
1189                 NV_ERROR(dev, "0x%04X: INIT_3A: no encoder table!!\n", offset);
1190                 return 3;
1191         }
1192
1193         switch (cond) {
1194         case 0:
1195         {
1196                 struct dcb_connector_table_entry *ent =
1197                         &bios->dcb.connector.entry[dcb->connector];
1198
1199                 if (ent->type != DCB_CONNECTOR_eDP)
1200                         iexec->execute = false;
1201         }
1202                 break;
1203         case 1:
1204         case 2:
1205                 if (!(dpe->unknown & cond))
1206                         iexec->execute = false;
1207                 break;
1208         case 5:
1209         {
1210                 struct nouveau_i2c_chan *auxch;
1211                 int ret;
1212
1213                 auxch = nouveau_i2c_find(dev, bios->display.output->i2c_index);
1214                 if (!auxch) {
1215                         NV_ERROR(dev, "0x%04X: couldn't get auxch\n", offset);
1216                         return 3;
1217                 }
1218
1219                 ret = nouveau_dp_auxch(auxch, 9, 0xd, &cond, 1);
1220                 if (ret) {
1221                         NV_ERROR(dev, "0x%04X: auxch rd fail: %d\n", offset, ret);
1222                         return 3;
1223                 }
1224
1225                 if (!(cond & 1))
1226                         iexec->execute = false;
1227         }
1228                 break;
1229         default:
1230                 NV_WARN(dev, "0x%04X: unknown INIT_3A op: %d\n", offset, cond);
1231                 break;
1232         }
1233
1234         if (iexec->execute)
1235                 BIOSLOG(bios, "0x%04X: continuing to execute\n", offset);
1236         else
1237                 BIOSLOG(bios, "0x%04X: skipping following commands\n", offset);
1238
1239         return 3;
1240 }
1241
1242 static int
1243 init_op_3b(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1244 {
1245         /*
1246          * INIT_3B   opcode: 0x3B ('')
1247          *
1248          * offset      (8 bit): opcode
1249          * offset + 1  (8 bit): crtc index
1250          *
1251          */
1252
1253         uint8_t or = ffs(bios->display.output->or) - 1;
1254         uint8_t index = bios->data[offset + 1];
1255         uint8_t data;
1256
1257         if (!iexec->execute)
1258                 return 2;
1259
1260         data = bios_idxprt_rd(bios, 0x3d4, index);
1261         bios_idxprt_wr(bios, 0x3d4, index, data & ~(1 << or));
1262         return 2;
1263 }
1264
1265 static int
1266 init_op_3c(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1267 {
1268         /*
1269          * INIT_3C   opcode: 0x3C ('')
1270          *
1271          * offset      (8 bit): opcode
1272          * offset + 1  (8 bit): crtc index
1273          *
1274          */
1275
1276         uint8_t or = ffs(bios->display.output->or) - 1;
1277         uint8_t index = bios->data[offset + 1];
1278         uint8_t data;
1279
1280         if (!iexec->execute)
1281                 return 2;
1282
1283         data = bios_idxprt_rd(bios, 0x3d4, index);
1284         bios_idxprt_wr(bios, 0x3d4, index, data | (1 << or));
1285         return 2;
1286 }
1287
1288 static int
1289 init_idx_addr_latched(struct nvbios *bios, uint16_t offset,
1290                       struct init_exec *iexec)
1291 {
1292         /*
1293          * INIT_INDEX_ADDRESS_LATCHED   opcode: 0x49 ('I')
1294          *
1295          * offset      (8  bit): opcode
1296          * offset + 1  (32 bit): control register
1297          * offset + 5  (32 bit): data register
1298          * offset + 9  (32 bit): mask
1299          * offset + 13 (32 bit): data
1300          * offset + 17 (8  bit): count
1301          * offset + 18 (8  bit): address 1
1302          * offset + 19 (8  bit): data 1
1303          * ...
1304          *
1305          * For each of "count" address and data pairs, write "data n" to
1306          * "data register", read the current value of "control register",
1307          * and write it back once ANDed with "mask", ORed with "data",
1308          * and ORed with "address n"
1309          */
1310
1311         uint32_t controlreg = ROM32(bios->data[offset + 1]);
1312         uint32_t datareg = ROM32(bios->data[offset + 5]);
1313         uint32_t mask = ROM32(bios->data[offset + 9]);
1314         uint32_t data = ROM32(bios->data[offset + 13]);
1315         uint8_t count = bios->data[offset + 17];
1316         int len = 18 + count * 2;
1317         uint32_t value;
1318         int i;
1319
1320         if (!iexec->execute)
1321                 return len;
1322
1323         BIOSLOG(bios, "0x%04X: ControlReg: 0x%08X, DataReg: 0x%08X, "
1324                       "Mask: 0x%08X, Data: 0x%08X, Count: 0x%02X\n",
1325                 offset, controlreg, datareg, mask, data, count);
1326
1327         for (i = 0; i < count; i++) {
1328                 uint8_t instaddress = bios->data[offset + 18 + i * 2];
1329                 uint8_t instdata = bios->data[offset + 19 + i * 2];
1330
1331                 BIOSLOG(bios, "0x%04X: Address: 0x%02X, Data: 0x%02X\n",
1332                         offset, instaddress, instdata);
1333
1334                 bios_wr32(bios, datareg, instdata);
1335                 value  = bios_rd32(bios, controlreg) & mask;
1336                 value |= data;
1337                 value |= instaddress;
1338                 bios_wr32(bios, controlreg, value);
1339         }
1340
1341         return len;
1342 }
1343
1344 static int
1345 init_io_restrict_pll2(struct nvbios *bios, uint16_t offset,
1346                       struct init_exec *iexec)
1347 {
1348         /*
1349          * INIT_IO_RESTRICT_PLL2   opcode: 0x4A ('J')
1350          *
1351          * offset      (8  bit): opcode
1352          * offset + 1  (16 bit): CRTC port
1353          * offset + 3  (8  bit): CRTC index
1354          * offset + 4  (8  bit): mask
1355          * offset + 5  (8  bit): shift
1356          * offset + 6  (8  bit): count
1357          * offset + 7  (32 bit): register
1358          * offset + 11 (32 bit): frequency 1
1359          * ...
1360          *
1361          * Starting at offset + 11 there are "count" 32 bit frequencies (kHz).
1362          * Set PLL register "register" to coefficients for frequency n,
1363          * selected by reading index "CRTC index" of "CRTC port" ANDed with
1364          * "mask" and shifted right by "shift".
1365          */
1366
1367         uint16_t crtcport = ROM16(bios->data[offset + 1]);
1368         uint8_t crtcindex = bios->data[offset + 3];
1369         uint8_t mask = bios->data[offset + 4];
1370         uint8_t shift = bios->data[offset + 5];
1371         uint8_t count = bios->data[offset + 6];
1372         uint32_t reg = ROM32(bios->data[offset + 7]);
1373         int len = 11 + count * 4;
1374         uint8_t config;
1375         uint32_t freq;
1376
1377         if (!iexec->execute)
1378                 return len;
1379
1380         BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
1381                       "Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
1382                 offset, crtcport, crtcindex, mask, shift, count, reg);
1383
1384         if (!reg)
1385                 return len;
1386
1387         config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift;
1388         if (config > count) {
1389                 NV_ERROR(bios->dev,
1390                          "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
1391                          offset, config, count);
1392                 return len;
1393         }
1394
1395         freq = ROM32(bios->data[offset + 11 + config * 4]);
1396
1397         BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %dkHz\n",
1398                 offset, reg, config, freq);
1399
1400         setPLL(bios, reg, freq);
1401
1402         return len;
1403 }
1404
1405 static int
1406 init_pll2(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1407 {
1408         /*
1409          * INIT_PLL2   opcode: 0x4B ('K')
1410          *
1411          * offset      (8  bit): opcode
1412          * offset + 1  (32 bit): register
1413          * offset + 5  (32 bit): freq
1414          *
1415          * Set PLL register "register" to coefficients for frequency "freq"
1416          */
1417
1418         uint32_t reg = ROM32(bios->data[offset + 1]);
1419         uint32_t freq = ROM32(bios->data[offset + 5]);
1420
1421         if (!iexec->execute)
1422                 return 9;
1423
1424         BIOSLOG(bios, "0x%04X: Reg: 0x%04X, Freq: %dkHz\n",
1425                 offset, reg, freq);
1426
1427         setPLL(bios, reg, freq);
1428         return 9;
1429 }
1430
1431 static int
1432 init_i2c_byte(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1433 {
1434         /*
1435          * INIT_I2C_BYTE   opcode: 0x4C ('L')
1436          *
1437          * offset      (8 bit): opcode
1438          * offset + 1  (8 bit): DCB I2C table entry index
1439          * offset + 2  (8 bit): I2C slave address
1440          * offset + 3  (8 bit): count
1441          * offset + 4  (8 bit): I2C register 1
1442          * offset + 5  (8 bit): mask 1
1443          * offset + 6  (8 bit): data 1
1444          * ...
1445          *
1446          * For each of "count" registers given by "I2C register n" on the device
1447          * addressed by "I2C slave address" on the I2C bus given by
1448          * "DCB I2C table entry index", read the register, AND the result with
1449          * "mask n" and OR it with "data n" before writing it back to the device
1450          */
1451
1452         struct drm_device *dev = bios->dev;
1453         uint8_t i2c_index = bios->data[offset + 1];
1454         uint8_t i2c_address = bios->data[offset + 2] >> 1;
1455         uint8_t count = bios->data[offset + 3];
1456         struct nouveau_i2c_chan *chan;
1457         int len = 4 + count * 3;
1458         int ret, i;
1459
1460         if (!iexec->execute)
1461                 return len;
1462
1463         BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, "
1464                       "Count: 0x%02X\n",
1465                 offset, i2c_index, i2c_address, count);
1466
1467         chan = init_i2c_device_find(dev, i2c_index);
1468         if (!chan) {
1469                 NV_ERROR(dev, "0x%04X: i2c bus not found\n", offset);
1470                 return len;
1471         }
1472
1473         for (i = 0; i < count; i++) {
1474                 uint8_t reg = bios->data[offset + 4 + i * 3];
1475                 uint8_t mask = bios->data[offset + 5 + i * 3];
1476                 uint8_t data = bios->data[offset + 6 + i * 3];
1477                 union i2c_smbus_data val;
1478
1479                 ret = i2c_smbus_xfer(&chan->adapter, i2c_address, 0,
1480                                      I2C_SMBUS_READ, reg,
1481                                      I2C_SMBUS_BYTE_DATA, &val);
1482                 if (ret < 0) {
1483                         NV_ERROR(dev, "0x%04X: i2c rd fail: %d\n", offset, ret);
1484                         return len;
1485                 }
1486
1487                 BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Value: 0x%02X, "
1488                               "Mask: 0x%02X, Data: 0x%02X\n",
1489                         offset, reg, val.byte, mask, data);
1490
1491                 if (!bios->execute)
1492                         continue;
1493
1494                 val.byte &= mask;
1495                 val.byte |= data;
1496                 ret = i2c_smbus_xfer(&chan->adapter, i2c_address, 0,
1497                                      I2C_SMBUS_WRITE, reg,
1498                                      I2C_SMBUS_BYTE_DATA, &val);
1499                 if (ret < 0) {
1500                         NV_ERROR(dev, "0x%04X: i2c wr fail: %d\n", offset, ret);
1501                         return len;
1502                 }
1503         }
1504
1505         return len;
1506 }
1507
1508 static int
1509 init_zm_i2c_byte(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1510 {
1511         /*
1512          * INIT_ZM_I2C_BYTE   opcode: 0x4D ('M')
1513          *
1514          * offset      (8 bit): opcode
1515          * offset + 1  (8 bit): DCB I2C table entry index
1516          * offset + 2  (8 bit): I2C slave address
1517          * offset + 3  (8 bit): count
1518          * offset + 4  (8 bit): I2C register 1
1519          * offset + 5  (8 bit): data 1
1520          * ...
1521          *
1522          * For each of "count" registers given by "I2C register n" on the device
1523          * addressed by "I2C slave address" on the I2C bus given by
1524          * "DCB I2C table entry index", set the register to "data n"
1525          */
1526
1527         struct drm_device *dev = bios->dev;
1528         uint8_t i2c_index = bios->data[offset + 1];
1529         uint8_t i2c_address = bios->data[offset + 2] >> 1;
1530         uint8_t count = bios->data[offset + 3];
1531         struct nouveau_i2c_chan *chan;
1532         int len = 4 + count * 2;
1533         int ret, i;
1534
1535         if (!iexec->execute)
1536                 return len;
1537
1538         BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, "
1539                       "Count: 0x%02X\n",
1540                 offset, i2c_index, i2c_address, count);
1541
1542         chan = init_i2c_device_find(dev, i2c_index);
1543         if (!chan) {
1544                 NV_ERROR(dev, "0x%04X: i2c bus not found\n", offset);
1545                 return len;
1546         }
1547
1548         for (i = 0; i < count; i++) {
1549                 uint8_t reg = bios->data[offset + 4 + i * 2];
1550                 union i2c_smbus_data val;
1551
1552                 val.byte = bios->data[offset + 5 + i * 2];
1553
1554                 BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Data: 0x%02X\n",
1555                         offset, reg, val.byte);
1556
1557                 if (!bios->execute)
1558                         continue;
1559
1560                 ret = i2c_smbus_xfer(&chan->adapter, i2c_address, 0,
1561                                      I2C_SMBUS_WRITE, reg,
1562                                      I2C_SMBUS_BYTE_DATA, &val);
1563                 if (ret < 0) {
1564                         NV_ERROR(dev, "0x%04X: i2c wr fail: %d\n", offset, ret);
1565                         return len;
1566                 }
1567         }
1568
1569         return len;
1570 }
1571
1572 static int
1573 init_zm_i2c(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1574 {
1575         /*
1576          * INIT_ZM_I2C   opcode: 0x4E ('N')
1577          *
1578          * offset      (8 bit): opcode
1579          * offset + 1  (8 bit): DCB I2C table entry index
1580          * offset + 2  (8 bit): I2C slave address
1581          * offset + 3  (8 bit): count
1582          * offset + 4  (8 bit): data 1
1583          * ...
1584          *
1585          * Send "count" bytes ("data n") to the device addressed by "I2C slave
1586          * address" on the I2C bus given by "DCB I2C table entry index"
1587          */
1588
1589         struct drm_device *dev = bios->dev;
1590         uint8_t i2c_index = bios->data[offset + 1];
1591         uint8_t i2c_address = bios->data[offset + 2] >> 1;
1592         uint8_t count = bios->data[offset + 3];
1593         int len = 4 + count;
1594         struct nouveau_i2c_chan *chan;
1595         struct i2c_msg msg;
1596         uint8_t data[256];
1597         int ret, i;
1598
1599         if (!iexec->execute)
1600                 return len;
1601
1602         BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, "
1603                       "Count: 0x%02X\n",
1604                 offset, i2c_index, i2c_address, count);
1605
1606         chan = init_i2c_device_find(dev, i2c_index);
1607         if (!chan) {
1608                 NV_ERROR(dev, "0x%04X: i2c bus not found\n", offset);
1609                 return len;
1610         }
1611
1612         for (i = 0; i < count; i++) {
1613                 data[i] = bios->data[offset + 4 + i];
1614
1615                 BIOSLOG(bios, "0x%04X: Data: 0x%02X\n", offset, data[i]);
1616         }
1617
1618         if (bios->execute) {
1619                 msg.addr = i2c_address;
1620                 msg.flags = 0;
1621                 msg.len = count;
1622                 msg.buf = data;
1623                 ret = i2c_transfer(&chan->adapter, &msg, 1);
1624                 if (ret != 1) {
1625                         NV_ERROR(dev, "0x%04X: i2c wr fail: %d\n", offset, ret);
1626                         return len;
1627                 }
1628         }
1629
1630         return len;
1631 }
1632
1633 static int
1634 init_tmds(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1635 {
1636         /*
1637          * INIT_TMDS   opcode: 0x4F ('O')       (non-canon name)
1638          *
1639          * offset      (8 bit): opcode
1640          * offset + 1  (8 bit): magic lookup value
1641          * offset + 2  (8 bit): TMDS address
1642          * offset + 3  (8 bit): mask
1643          * offset + 4  (8 bit): data
1644          *
1645          * Read the data reg for TMDS address "TMDS address", AND it with mask
1646          * and OR it with data, then write it back
1647          * "magic lookup value" determines which TMDS base address register is
1648          * used -- see get_tmds_index_reg()
1649          */
1650
1651         struct drm_device *dev = bios->dev;
1652         uint8_t mlv = bios->data[offset + 1];
1653         uint32_t tmdsaddr = bios->data[offset + 2];
1654         uint8_t mask = bios->data[offset + 3];
1655         uint8_t data = bios->data[offset + 4];
1656         uint32_t reg, value;
1657
1658         if (!iexec->execute)
1659                 return 5;
1660
1661         BIOSLOG(bios, "0x%04X: MagicLookupValue: 0x%02X, TMDSAddr: 0x%02X, "
1662                       "Mask: 0x%02X, Data: 0x%02X\n",
1663                 offset, mlv, tmdsaddr, mask, data);
1664
1665         reg = get_tmds_index_reg(bios->dev, mlv);
1666         if (!reg) {
1667                 NV_ERROR(dev, "0x%04X: no tmds_index_reg\n", offset);
1668                 return 5;
1669         }
1670
1671         bios_wr32(bios, reg,
1672                   tmdsaddr | NV_PRAMDAC_FP_TMDS_CONTROL_WRITE_DISABLE);
1673         value = (bios_rd32(bios, reg + 4) & mask) | data;
1674         bios_wr32(bios, reg + 4, value);
1675         bios_wr32(bios, reg, tmdsaddr);
1676
1677         return 5;
1678 }
1679
1680 static int
1681 init_zm_tmds_group(struct nvbios *bios, uint16_t offset,
1682                    struct init_exec *iexec)
1683 {
1684         /*
1685          * INIT_ZM_TMDS_GROUP   opcode: 0x50 ('P')      (non-canon name)
1686          *
1687          * offset      (8 bit): opcode
1688          * offset + 1  (8 bit): magic lookup value
1689          * offset + 2  (8 bit): count
1690          * offset + 3  (8 bit): addr 1
1691          * offset + 4  (8 bit): data 1
1692          * ...
1693          *
1694          * For each of "count" TMDS address and data pairs write "data n" to
1695          * "addr n".  "magic lookup value" determines which TMDS base address
1696          * register is used -- see get_tmds_index_reg()
1697          */
1698
1699         struct drm_device *dev = bios->dev;
1700         uint8_t mlv = bios->data[offset + 1];
1701         uint8_t count = bios->data[offset + 2];
1702         int len = 3 + count * 2;
1703         uint32_t reg;
1704         int i;
1705
1706         if (!iexec->execute)
1707                 return len;
1708
1709         BIOSLOG(bios, "0x%04X: MagicLookupValue: 0x%02X, Count: 0x%02X\n",
1710                 offset, mlv, count);
1711
1712         reg = get_tmds_index_reg(bios->dev, mlv);
1713         if (!reg) {
1714                 NV_ERROR(dev, "0x%04X: no tmds_index_reg\n", offset);
1715                 return len;
1716         }
1717
1718         for (i = 0; i < count; i++) {
1719                 uint8_t tmdsaddr = bios->data[offset + 3 + i * 2];
1720                 uint8_t tmdsdata = bios->data[offset + 4 + i * 2];
1721
1722                 bios_wr32(bios, reg + 4, tmdsdata);
1723                 bios_wr32(bios, reg, tmdsaddr);
1724         }
1725
1726         return len;
1727 }
1728
1729 static int
1730 init_cr_idx_adr_latch(struct nvbios *bios, uint16_t offset,
1731                       struct init_exec *iexec)
1732 {
1733         /*
1734          * INIT_CR_INDEX_ADDRESS_LATCHED   opcode: 0x51 ('Q')
1735          *
1736          * offset      (8 bit): opcode
1737          * offset + 1  (8 bit): CRTC index1
1738          * offset + 2  (8 bit): CRTC index2
1739          * offset + 3  (8 bit): baseaddr
1740          * offset + 4  (8 bit): count
1741          * offset + 5  (8 bit): data 1
1742          * ...
1743          *
1744          * For each of "count" address and data pairs, write "baseaddr + n" to
1745          * "CRTC index1" and "data n" to "CRTC index2"
1746          * Once complete, restore initial value read from "CRTC index1"
1747          */
1748         uint8_t crtcindex1 = bios->data[offset + 1];
1749         uint8_t crtcindex2 = bios->data[offset + 2];
1750         uint8_t baseaddr = bios->data[offset + 3];
1751         uint8_t count = bios->data[offset + 4];
1752         int len = 5 + count;
1753         uint8_t oldaddr, data;
1754         int i;
1755
1756         if (!iexec->execute)
1757                 return len;
1758
1759         BIOSLOG(bios, "0x%04X: Index1: 0x%02X, Index2: 0x%02X, "
1760                       "BaseAddr: 0x%02X, Count: 0x%02X\n",
1761                 offset, crtcindex1, crtcindex2, baseaddr, count);
1762
1763         oldaddr = bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, crtcindex1);
1764
1765         for (i = 0; i < count; i++) {
1766                 bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex1,
1767                                      baseaddr + i);
1768                 data = bios->data[offset + 5 + i];
1769                 bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex2, data);
1770         }
1771
1772         bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex1, oldaddr);
1773
1774         return len;
1775 }
1776
1777 static int
1778 init_cr(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1779 {
1780         /*
1781          * INIT_CR   opcode: 0x52 ('R')
1782          *
1783          * offset      (8  bit): opcode
1784          * offset + 1  (8  bit): CRTC index
1785          * offset + 2  (8  bit): mask
1786          * offset + 3  (8  bit): data
1787          *
1788          * Assign the value of at "CRTC index" ANDed with mask and ORed with
1789          * data back to "CRTC index"
1790          */
1791
1792         uint8_t crtcindex = bios->data[offset + 1];
1793         uint8_t mask = bios->data[offset + 2];
1794         uint8_t data = bios->data[offset + 3];
1795         uint8_t value;
1796
1797         if (!iexec->execute)
1798                 return 4;
1799
1800         BIOSLOG(bios, "0x%04X: Index: 0x%02X, Mask: 0x%02X, Data: 0x%02X\n",
1801                 offset, crtcindex, mask, data);
1802
1803         value  = bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, crtcindex) & mask;
1804         value |= data;
1805         bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex, value);
1806
1807         return 4;
1808 }
1809
1810 static int
1811 init_zm_cr(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1812 {
1813         /*
1814          * INIT_ZM_CR   opcode: 0x53 ('S')
1815          *
1816          * offset      (8 bit): opcode
1817          * offset + 1  (8 bit): CRTC index
1818          * offset + 2  (8 bit): value
1819          *
1820          * Assign "value" to CRTC register with index "CRTC index".
1821          */
1822
1823         uint8_t crtcindex = ROM32(bios->data[offset + 1]);
1824         uint8_t data = bios->data[offset + 2];
1825
1826         if (!iexec->execute)
1827                 return 3;
1828
1829         bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex, data);
1830
1831         return 3;
1832 }
1833
1834 static int
1835 init_zm_cr_group(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1836 {
1837         /*
1838          * INIT_ZM_CR_GROUP   opcode: 0x54 ('T')
1839          *
1840          * offset      (8 bit): opcode
1841          * offset + 1  (8 bit): count
1842          * offset + 2  (8 bit): CRTC index 1
1843          * offset + 3  (8 bit): value 1
1844          * ...
1845          *
1846          * For "count", assign "value n" to CRTC register with index
1847          * "CRTC index n".
1848          */
1849
1850         uint8_t count = bios->data[offset + 1];
1851         int len = 2 + count * 2;
1852         int i;
1853
1854         if (!iexec->execute)
1855                 return len;
1856
1857         for (i = 0; i < count; i++)
1858                 init_zm_cr(bios, offset + 2 + 2 * i - 1, iexec);
1859
1860         return len;
1861 }
1862
1863 static int
1864 init_condition_time(struct nvbios *bios, uint16_t offset,
1865                     struct init_exec *iexec)
1866 {
1867         /*
1868          * INIT_CONDITION_TIME   opcode: 0x56 ('V')
1869          *
1870          * offset      (8 bit): opcode
1871          * offset + 1  (8 bit): condition number
1872          * offset + 2  (8 bit): retries / 50
1873          *
1874          * Check condition "condition number" in the condition table.
1875          * Bios code then sleeps for 2ms if the condition is not met, and
1876          * repeats up to "retries" times, but on one C51 this has proved
1877          * insufficient.  In mmiotraces the driver sleeps for 20ms, so we do
1878          * this, and bail after "retries" times, or 2s, whichever is less.
1879          * If still not met after retries, clear execution flag for this table.
1880          */
1881
1882         uint8_t cond = bios->data[offset + 1];
1883         uint16_t retries = bios->data[offset + 2] * 50;
1884         unsigned cnt;
1885
1886         if (!iexec->execute)
1887                 return 3;
1888
1889         if (retries > 100)
1890                 retries = 100;
1891
1892         BIOSLOG(bios, "0x%04X: Condition: 0x%02X, Retries: 0x%02X\n",
1893                 offset, cond, retries);
1894
1895         if (!bios->execute) /* avoid 2s delays when "faking" execution */
1896                 retries = 1;
1897
1898         for (cnt = 0; cnt < retries; cnt++) {
1899                 if (bios_condition_met(bios, offset, cond)) {
1900                         BIOSLOG(bios, "0x%04X: Condition met, continuing\n",
1901                                                                 offset);
1902                         break;
1903                 } else {
1904                         BIOSLOG(bios, "0x%04X: "
1905                                 "Condition not met, sleeping for 20ms\n",
1906                                                                 offset);
1907                         msleep(20);
1908                 }
1909         }
1910
1911         if (!bios_condition_met(bios, offset, cond)) {
1912                 NV_WARN(bios->dev,
1913                         "0x%04X: Condition still not met after %dms, "
1914                         "skipping following opcodes\n", offset, 20 * retries);
1915                 iexec->execute = false;
1916         }
1917
1918         return 3;
1919 }
1920
1921 static int
1922 init_ltime(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1923 {
1924         /*
1925          * INIT_LTIME   opcode: 0x57 ('V')
1926          *
1927          * offset      (8  bit): opcode
1928          * offset + 1  (16 bit): time
1929          *
1930          * Sleep for "time" milliseconds.
1931          */
1932
1933         unsigned time = ROM16(bios->data[offset + 1]);
1934
1935         if (!iexec->execute)
1936                 return 3;
1937
1938         BIOSLOG(bios, "0x%04X: Sleeping for 0x%04X milliseconds\n",
1939                 offset, time);
1940
1941         msleep(time);
1942
1943         return 3;
1944 }
1945
1946 static int
1947 init_zm_reg_sequence(struct nvbios *bios, uint16_t offset,
1948                      struct init_exec *iexec)
1949 {
1950         /*
1951          * INIT_ZM_REG_SEQUENCE   opcode: 0x58 ('X')
1952          *
1953          * offset      (8  bit): opcode
1954          * offset + 1  (32 bit): base register
1955          * offset + 5  (8  bit): count
1956          * offset + 6  (32 bit): value 1
1957          * ...
1958          *
1959          * Starting at offset + 6 there are "count" 32 bit values.
1960          * For "count" iterations set "base register" + 4 * current_iteration
1961          * to "value current_iteration"
1962          */
1963
1964         uint32_t basereg = ROM32(bios->data[offset + 1]);
1965         uint32_t count = bios->data[offset + 5];
1966         int len = 6 + count * 4;
1967         int i;
1968
1969         if (!iexec->execute)
1970                 return len;
1971
1972         BIOSLOG(bios, "0x%04X: BaseReg: 0x%08X, Count: 0x%02X\n",
1973                 offset, basereg, count);
1974
1975         for (i = 0; i < count; i++) {
1976                 uint32_t reg = basereg + i * 4;
1977                 uint32_t data = ROM32(bios->data[offset + 6 + i * 4]);
1978
1979                 bios_wr32(bios, reg, data);
1980         }
1981
1982         return len;
1983 }
1984
1985 static int
1986 init_sub_direct(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1987 {
1988         /*
1989          * INIT_SUB_DIRECT   opcode: 0x5B ('[')
1990          *
1991          * offset      (8  bit): opcode
1992          * offset + 1  (16 bit): subroutine offset (in bios)
1993          *
1994          * Calls a subroutine that will execute commands until INIT_DONE
1995          * is found.
1996          */
1997
1998         uint16_t sub_offset = ROM16(bios->data[offset + 1]);
1999
2000         if (!iexec->execute)
2001                 return 3;
2002
2003         BIOSLOG(bios, "0x%04X: Executing subroutine at 0x%04X\n",
2004                 offset, sub_offset);
2005
2006         parse_init_table(bios, sub_offset, iexec);
2007
2008         BIOSLOG(bios, "0x%04X: End of 0x%04X subroutine\n", offset, sub_offset);
2009
2010         return 3;
2011 }
2012
2013 static int
2014 init_i2c_if(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2015 {
2016         /*
2017          * INIT_I2C_IF   opcode: 0x5E ('^')
2018          *
2019          * offset      (8 bit): opcode
2020          * offset + 1  (8 bit): DCB I2C table entry index
2021          * offset + 2  (8 bit): I2C slave address
2022          * offset + 3  (8 bit): I2C register
2023          * offset + 4  (8 bit): mask
2024          * offset + 5  (8 bit): data
2025          *
2026          * Read the register given by "I2C register" on the device addressed
2027          * by "I2C slave address" on the I2C bus given by "DCB I2C table
2028          * entry index". Compare the result AND "mask" to "data".
2029          * If they're not equal, skip subsequent opcodes until condition is
2030          * inverted (INIT_NOT), or we hit INIT_RESUME
2031          */
2032
2033         uint8_t i2c_index = bios->data[offset + 1];
2034         uint8_t i2c_address = bios->data[offset + 2] >> 1;
2035         uint8_t reg = bios->data[offset + 3];
2036         uint8_t mask = bios->data[offset + 4];
2037         uint8_t data = bios->data[offset + 5];
2038         struct nouveau_i2c_chan *chan;
2039         union i2c_smbus_data val;
2040         int ret;
2041
2042         /* no execute check by design */
2043
2044         BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X\n",
2045                 offset, i2c_index, i2c_address);
2046
2047         chan = init_i2c_device_find(bios->dev, i2c_index);
2048         if (!chan)
2049                 return -ENODEV;
2050
2051         ret = i2c_smbus_xfer(&chan->adapter, i2c_address, 0,
2052                              I2C_SMBUS_READ, reg,
2053                              I2C_SMBUS_BYTE_DATA, &val);
2054         if (ret < 0) {
2055                 BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Value: [no device], "
2056                               "Mask: 0x%02X, Data: 0x%02X\n",
2057                         offset, reg, mask, data);
2058                 iexec->execute = 0;
2059                 return 6;
2060         }
2061
2062         BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Value: 0x%02X, "
2063                       "Mask: 0x%02X, Data: 0x%02X\n",
2064                 offset, reg, val.byte, mask, data);
2065
2066         iexec->execute = ((val.byte & mask) == data);
2067
2068         return 6;
2069 }
2070
2071 static int
2072 init_copy_nv_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2073 {
2074         /*
2075          * INIT_COPY_NV_REG   opcode: 0x5F ('_')
2076          *
2077          * offset      (8  bit): opcode
2078          * offset + 1  (32 bit): src reg
2079          * offset + 5  (8  bit): shift
2080          * offset + 6  (32 bit): src mask
2081          * offset + 10 (32 bit): xor
2082          * offset + 14 (32 bit): dst reg
2083          * offset + 18 (32 bit): dst mask
2084          *
2085          * Shift REGVAL("src reg") right by (signed) "shift", AND result with
2086          * "src mask", then XOR with "xor". Write this OR'd with
2087          * (REGVAL("dst reg") AND'd with "dst mask") to "dst reg"
2088          */
2089
2090         uint32_t srcreg = *((uint32_t *)(&bios->data[offset + 1]));
2091         uint8_t shift = bios->data[offset + 5];
2092         uint32_t srcmask = *((uint32_t *)(&bios->data[offset + 6]));
2093         uint32_t xor = *((uint32_t *)(&bios->data[offset + 10]));
2094         uint32_t dstreg = *((uint32_t *)(&bios->data[offset + 14]));
2095         uint32_t dstmask = *((uint32_t *)(&bios->data[offset + 18]));
2096         uint32_t srcvalue, dstvalue;
2097
2098         if (!iexec->execute)
2099                 return 22;
2100
2101         BIOSLOG(bios, "0x%04X: SrcReg: 0x%08X, Shift: 0x%02X, SrcMask: 0x%08X, "
2102                       "Xor: 0x%08X, DstReg: 0x%08X, DstMask: 0x%08X\n",
2103                 offset, srcreg, shift, srcmask, xor, dstreg, dstmask);
2104
2105         srcvalue = bios_rd32(bios, srcreg);
2106
2107         if (shift < 0x80)
2108                 srcvalue >>= shift;
2109         else
2110                 srcvalue <<= (0x100 - shift);
2111
2112         srcvalue = (srcvalue & srcmask) ^ xor;
2113
2114         dstvalue = bios_rd32(bios, dstreg) & dstmask;
2115
2116         bios_wr32(bios, dstreg, dstvalue | srcvalue);
2117
2118         return 22;
2119 }
2120
2121 static int
2122 init_zm_index_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2123 {
2124         /*
2125          * INIT_ZM_INDEX_IO   opcode: 0x62 ('b')
2126          *
2127          * offset      (8  bit): opcode
2128          * offset + 1  (16 bit): CRTC port
2129          * offset + 3  (8  bit): CRTC index
2130          * offset + 4  (8  bit): data
2131          *
2132          * Write "data" to index "CRTC index" of "CRTC port"
2133          */
2134         uint16_t crtcport = ROM16(bios->data[offset + 1]);
2135         uint8_t crtcindex = bios->data[offset + 3];
2136         uint8_t data = bios->data[offset + 4];
2137
2138         if (!iexec->execute)
2139                 return 5;
2140
2141         bios_idxprt_wr(bios, crtcport, crtcindex, data);
2142
2143         return 5;
2144 }
2145
2146 static inline void
2147 bios_md32(struct nvbios *bios, uint32_t reg,
2148           uint32_t mask, uint32_t val)
2149 {
2150         bios_wr32(bios, reg, (bios_rd32(bios, reg) & ~mask) | val);
2151 }
2152
2153 static uint32_t
2154 peek_fb(struct drm_device *dev, struct io_mapping *fb,
2155         uint32_t off)
2156 {
2157         uint32_t val = 0;
2158
2159         if (off < pci_resource_len(dev->pdev, 1)) {
2160                 uint8_t __iomem *p =
2161                         io_mapping_map_atomic_wc(fb, off & PAGE_MASK);
2162
2163                 val = ioread32(p + (off & ~PAGE_MASK));
2164
2165                 io_mapping_unmap_atomic(p);
2166         }
2167
2168         return val;
2169 }
2170
2171 static void
2172 poke_fb(struct drm_device *dev, struct io_mapping *fb,
2173         uint32_t off, uint32_t val)
2174 {
2175         if (off < pci_resource_len(dev->pdev, 1)) {
2176                 uint8_t __iomem *p =
2177                         io_mapping_map_atomic_wc(fb, off & PAGE_MASK);
2178
2179                 iowrite32(val, p + (off & ~PAGE_MASK));
2180                 wmb();
2181
2182                 io_mapping_unmap_atomic(p);
2183         }
2184 }
2185
2186 static inline bool
2187 read_back_fb(struct drm_device *dev, struct io_mapping *fb,
2188              uint32_t off, uint32_t val)
2189 {
2190         poke_fb(dev, fb, off, val);
2191         return val == peek_fb(dev, fb, off);
2192 }
2193
2194 static int
2195 nv04_init_compute_mem(struct nvbios *bios)
2196 {
2197         struct drm_device *dev = bios->dev;
2198         uint32_t patt = 0xdeadbeef;
2199         struct io_mapping *fb;
2200         int i;
2201
2202         /* Map the framebuffer aperture */
2203         fb = io_mapping_create_wc(pci_resource_start(dev->pdev, 1),
2204                                   pci_resource_len(dev->pdev, 1));
2205         if (!fb)
2206                 return -ENOMEM;
2207
2208         /* Sequencer and refresh off */
2209         NVWriteVgaSeq(dev, 0, 1, NVReadVgaSeq(dev, 0, 1) | 0x20);
2210         bios_md32(bios, NV04_PFB_DEBUG_0, 0, NV04_PFB_DEBUG_0_REFRESH_OFF);
2211
2212         bios_md32(bios, NV04_PFB_BOOT_0, ~0,
2213                   NV04_PFB_BOOT_0_RAM_AMOUNT_16MB |
2214                   NV04_PFB_BOOT_0_RAM_WIDTH_128 |
2215                   NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_16MBIT);
2216
2217         for (i = 0; i < 4; i++)
2218                 poke_fb(dev, fb, 4 * i, patt);
2219
2220         poke_fb(dev, fb, 0x400000, patt + 1);
2221
2222         if (peek_fb(dev, fb, 0) == patt + 1) {
2223                 bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_TYPE,
2224                           NV04_PFB_BOOT_0_RAM_TYPE_SDRAM_16MBIT);
2225                 bios_md32(bios, NV04_PFB_DEBUG_0,
2226                           NV04_PFB_DEBUG_0_REFRESH_OFF, 0);
2227
2228                 for (i = 0; i < 4; i++)
2229                         poke_fb(dev, fb, 4 * i, patt);
2230
2231                 if ((peek_fb(dev, fb, 0xc) & 0xffff) != (patt & 0xffff))
2232                         bios_md32(bios, NV04_PFB_BOOT_0,
2233                                   NV04_PFB_BOOT_0_RAM_WIDTH_128 |
2234                                   NV04_PFB_BOOT_0_RAM_AMOUNT,
2235                                   NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
2236
2237         } else if ((peek_fb(dev, fb, 0xc) & 0xffff0000) !=
2238                    (patt & 0xffff0000)) {
2239                 bios_md32(bios, NV04_PFB_BOOT_0,
2240                           NV04_PFB_BOOT_0_RAM_WIDTH_128 |
2241                           NV04_PFB_BOOT_0_RAM_AMOUNT,
2242                           NV04_PFB_BOOT_0_RAM_AMOUNT_4MB);
2243
2244         } else if (peek_fb(dev, fb, 0) != patt) {
2245                 if (read_back_fb(dev, fb, 0x800000, patt))
2246                         bios_md32(bios, NV04_PFB_BOOT_0,
2247                                   NV04_PFB_BOOT_0_RAM_AMOUNT,
2248                                   NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
2249                 else
2250                         bios_md32(bios, NV04_PFB_BOOT_0,
2251                                   NV04_PFB_BOOT_0_RAM_AMOUNT,
2252                                   NV04_PFB_BOOT_0_RAM_AMOUNT_4MB);
2253
2254                 bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_TYPE,
2255                           NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_8MBIT);
2256
2257         } else if (!read_back_fb(dev, fb, 0x800000, patt)) {
2258                 bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
2259                           NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
2260
2261         }
2262
2263         /* Refresh on, sequencer on */
2264         bios_md32(bios, NV04_PFB_DEBUG_0, NV04_PFB_DEBUG_0_REFRESH_OFF, 0);
2265         NVWriteVgaSeq(dev, 0, 1, NVReadVgaSeq(dev, 0, 1) & ~0x20);
2266
2267         io_mapping_free(fb);
2268         return 0;
2269 }
2270
2271 static const uint8_t *
2272 nv05_memory_config(struct nvbios *bios)
2273 {
2274         /* Defaults for BIOSes lacking a memory config table */
2275         static const uint8_t default_config_tab[][2] = {
2276                 { 0x24, 0x00 },
2277                 { 0x28, 0x00 },
2278                 { 0x24, 0x01 },
2279                 { 0x1f, 0x00 },
2280                 { 0x0f, 0x00 },
2281                 { 0x17, 0x00 },
2282                 { 0x06, 0x00 },
2283                 { 0x00, 0x00 }
2284         };
2285         int i = (bios_rd32(bios, NV_PEXTDEV_BOOT_0) &
2286                  NV_PEXTDEV_BOOT_0_RAMCFG) >> 2;
2287
2288         if (bios->legacy.mem_init_tbl_ptr)
2289                 return &bios->data[bios->legacy.mem_init_tbl_ptr + 2 * i];
2290         else
2291                 return default_config_tab[i];
2292 }
2293
2294 static int
2295 nv05_init_compute_mem(struct nvbios *bios)
2296 {
2297         struct drm_device *dev = bios->dev;
2298         const uint8_t *ramcfg = nv05_memory_config(bios);
2299         uint32_t patt = 0xdeadbeef;
2300         struct io_mapping *fb;
2301         int i, v;
2302
2303         /* Map the framebuffer aperture */
2304         fb = io_mapping_create_wc(pci_resource_start(dev->pdev, 1),
2305                                   pci_resource_len(dev->pdev, 1));
2306         if (!fb)
2307                 return -ENOMEM;
2308
2309         /* Sequencer off */
2310         NVWriteVgaSeq(dev, 0, 1, NVReadVgaSeq(dev, 0, 1) | 0x20);
2311
2312         if (bios_rd32(bios, NV04_PFB_BOOT_0) & NV04_PFB_BOOT_0_UMA_ENABLE)
2313                 goto out;
2314
2315         bios_md32(bios, NV04_PFB_DEBUG_0, NV04_PFB_DEBUG_0_REFRESH_OFF, 0);
2316
2317         /* If present load the hardcoded scrambling table */
2318         if (bios->legacy.mem_init_tbl_ptr) {
2319                 uint32_t *scramble_tab = (uint32_t *)&bios->data[
2320                         bios->legacy.mem_init_tbl_ptr + 0x10];
2321
2322                 for (i = 0; i < 8; i++)
2323                         bios_wr32(bios, NV04_PFB_SCRAMBLE(i),
2324                                   ROM32(scramble_tab[i]));
2325         }
2326
2327         /* Set memory type/width/length defaults depending on the straps */
2328         bios_md32(bios, NV04_PFB_BOOT_0, 0x3f, ramcfg[0]);
2329
2330         if (ramcfg[1] & 0x80)
2331                 bios_md32(bios, NV04_PFB_CFG0, 0, NV04_PFB_CFG0_SCRAMBLE);
2332
2333         bios_md32(bios, NV04_PFB_CFG1, 0x700001, (ramcfg[1] & 1) << 20);
2334         bios_md32(bios, NV04_PFB_CFG1, 0, 1);
2335
2336         /* Probe memory bus width */
2337         for (i = 0; i < 4; i++)
2338                 poke_fb(dev, fb, 4 * i, patt);
2339
2340         if (peek_fb(dev, fb, 0xc) != patt)
2341                 bios_md32(bios, NV04_PFB_BOOT_0,
2342                           NV04_PFB_BOOT_0_RAM_WIDTH_128, 0);
2343
2344         /* Probe memory length */
2345         v = bios_rd32(bios, NV04_PFB_BOOT_0) & NV04_PFB_BOOT_0_RAM_AMOUNT;
2346
2347         if (v == NV04_PFB_BOOT_0_RAM_AMOUNT_32MB &&
2348             (!read_back_fb(dev, fb, 0x1000000, ++patt) ||
2349              !read_back_fb(dev, fb, 0, ++patt)))
2350                 bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
2351                           NV04_PFB_BOOT_0_RAM_AMOUNT_16MB);
2352
2353         if (v == NV04_PFB_BOOT_0_RAM_AMOUNT_16MB &&
2354             !read_back_fb(dev, fb, 0x800000, ++patt))
2355                 bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
2356                           NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
2357
2358         if (!read_back_fb(dev, fb, 0x400000, ++patt))
2359                 bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
2360                           NV04_PFB_BOOT_0_RAM_AMOUNT_4MB);
2361
2362 out:
2363         /* Sequencer on */
2364         NVWriteVgaSeq(dev, 0, 1, NVReadVgaSeq(dev, 0, 1) & ~0x20);
2365
2366         io_mapping_free(fb);
2367         return 0;
2368 }
2369
2370 static int
2371 nv10_init_compute_mem(struct nvbios *bios)
2372 {
2373         struct drm_device *dev = bios->dev;
2374         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
2375         const int mem_width[] = { 0x10, 0x00, 0x20 };
2376         const int mem_width_count = (dev_priv->chipset >= 0x17 ? 3 : 2);
2377         uint32_t patt = 0xdeadbeef;
2378         struct io_mapping *fb;
2379         int i, j, k;
2380
2381         /* Map the framebuffer aperture */
2382         fb = io_mapping_create_wc(pci_resource_start(dev->pdev, 1),
2383                                   pci_resource_len(dev->pdev, 1));
2384         if (!fb)
2385                 return -ENOMEM;
2386
2387         bios_wr32(bios, NV10_PFB_REFCTRL, NV10_PFB_REFCTRL_VALID_1);
2388
2389         /* Probe memory bus width */
2390         for (i = 0; i < mem_width_count; i++) {
2391                 bios_md32(bios, NV04_PFB_CFG0, 0x30, mem_width[i]);
2392
2393                 for (j = 0; j < 4; j++) {
2394                         for (k = 0; k < 4; k++)
2395                                 poke_fb(dev, fb, 0x1c, 0);
2396
2397                         poke_fb(dev, fb, 0x1c, patt);
2398                         poke_fb(dev, fb, 0x3c, 0);
2399
2400                         if (peek_fb(dev, fb, 0x1c) == patt)
2401                                 goto mem_width_found;
2402                 }
2403         }
2404
2405 mem_width_found:
2406         patt <<= 1;
2407
2408         /* Probe amount of installed memory */
2409         for (i = 0; i < 4; i++) {
2410                 int off = bios_rd32(bios, NV04_PFB_FIFO_DATA) - 0x100000;
2411
2412                 poke_fb(dev, fb, off, patt);
2413                 poke_fb(dev, fb, 0, 0);
2414
2415                 peek_fb(dev, fb, 0);
2416                 peek_fb(dev, fb, 0);
2417                 peek_fb(dev, fb, 0);
2418                 peek_fb(dev, fb, 0);
2419
2420                 if (peek_fb(dev, fb, off) == patt)
2421                         goto amount_found;
2422         }
2423
2424         /* IC missing - disable the upper half memory space. */
2425         bios_md32(bios, NV04_PFB_CFG0, 0x1000, 0);
2426
2427 amount_found:
2428         io_mapping_free(fb);
2429         return 0;
2430 }
2431
2432 static int
2433 nv20_init_compute_mem(struct nvbios *bios)
2434 {
2435         struct drm_device *dev = bios->dev;
2436         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
2437         uint32_t mask = (dev_priv->chipset >= 0x25 ? 0x300 : 0x900);
2438         uint32_t amount, off;
2439         struct io_mapping *fb;
2440
2441         /* Map the framebuffer aperture */
2442         fb = io_mapping_create_wc(pci_resource_start(dev->pdev, 1),
2443                                   pci_resource_len(dev->pdev, 1));
2444         if (!fb)
2445                 return -ENOMEM;
2446
2447         bios_wr32(bios, NV10_PFB_REFCTRL, NV10_PFB_REFCTRL_VALID_1);
2448
2449         /* Allow full addressing */
2450         bios_md32(bios, NV04_PFB_CFG0, 0, mask);
2451
2452         amount = bios_rd32(bios, NV04_PFB_FIFO_DATA);
2453         for (off = amount; off > 0x2000000; off -= 0x2000000)
2454                 poke_fb(dev, fb, off - 4, off);
2455
2456         amount = bios_rd32(bios, NV04_PFB_FIFO_DATA);
2457         if (amount != peek_fb(dev, fb, amount - 4))
2458                 /* IC missing - disable the upper half memory space. */
2459                 bios_md32(bios, NV04_PFB_CFG0, mask, 0);
2460
2461         io_mapping_free(fb);
2462         return 0;
2463 }
2464
2465 static int
2466 init_compute_mem(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2467 {
2468         /*
2469          * INIT_COMPUTE_MEM   opcode: 0x63 ('c')
2470          *
2471          * offset      (8 bit): opcode
2472          *
2473          * This opcode is meant to set the PFB memory config registers
2474          * appropriately so that we can correctly calculate how much VRAM it
2475          * has (on nv10 and better chipsets the amount of installed VRAM is
2476          * subsequently reported in NV_PFB_CSTATUS (0x10020C)).
2477          *
2478          * The implementation of this opcode in general consists of several
2479          * parts:
2480          *
2481          * 1) Determination of memory type and density. Only necessary for
2482          *    really old chipsets, the memory type reported by the strap bits
2483          *    (0x101000) is assumed to be accurate on nv05 and newer.
2484          *
2485          * 2) Determination of the memory bus width. Usually done by a cunning
2486          *    combination of writes to offsets 0x1c and 0x3c in the fb, and
2487          *    seeing whether the written values are read back correctly.
2488          *
2489          *    Only necessary on nv0x-nv1x and nv34, on the other cards we can
2490          *    trust the straps.
2491          *
2492          * 3) Determination of how many of the card's RAM pads have ICs
2493          *    attached, usually done by a cunning combination of writes to an
2494          *    offset slightly less than the maximum memory reported by
2495          *    NV_PFB_CSTATUS, then seeing if the test pattern can be read back.
2496          *
2497          * This appears to be a NOP on IGPs and NV4x or newer chipsets, both io
2498          * logs of the VBIOS and kmmio traces of the binary driver POSTing the
2499          * card show nothing being done for this opcode. Why is it still listed
2500          * in the table?!
2501          */
2502
2503         /* no iexec->execute check by design */
2504
2505         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
2506         int ret;
2507
2508         if (dev_priv->chipset >= 0x40 ||
2509             dev_priv->chipset == 0x1a ||
2510             dev_priv->chipset == 0x1f)
2511                 ret = 0;
2512         else if (dev_priv->chipset >= 0x20 &&
2513                  dev_priv->chipset != 0x34)
2514                 ret = nv20_init_compute_mem(bios);
2515         else if (dev_priv->chipset >= 0x10)
2516                 ret = nv10_init_compute_mem(bios);
2517         else if (dev_priv->chipset >= 0x5)
2518                 ret = nv05_init_compute_mem(bios);
2519         else
2520                 ret = nv04_init_compute_mem(bios);
2521
2522         if (ret)
2523                 return ret;
2524
2525         return 1;
2526 }
2527
2528 static int
2529 init_reset(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2530 {
2531         /*
2532          * INIT_RESET   opcode: 0x65 ('e')
2533          *
2534          * offset      (8  bit): opcode
2535          * offset + 1  (32 bit): register
2536          * offset + 5  (32 bit): value1
2537          * offset + 9  (32 bit): value2
2538          *
2539          * Assign "value1" to "register", then assign "value2" to "register"
2540          */
2541
2542         uint32_t reg = ROM32(bios->data[offset + 1]);
2543         uint32_t value1 = ROM32(bios->data[offset + 5]);
2544         uint32_t value2 = ROM32(bios->data[offset + 9]);
2545         uint32_t pci_nv_19, pci_nv_20;
2546
2547         /* no iexec->execute check by design */
2548
2549         pci_nv_19 = bios_rd32(bios, NV_PBUS_PCI_NV_19);
2550         bios_wr32(bios, NV_PBUS_PCI_NV_19, pci_nv_19 & ~0xf00);
2551
2552         bios_wr32(bios, reg, value1);
2553
2554         udelay(10);
2555
2556         bios_wr32(bios, reg, value2);
2557         bios_wr32(bios, NV_PBUS_PCI_NV_19, pci_nv_19);
2558
2559         pci_nv_20 = bios_rd32(bios, NV_PBUS_PCI_NV_20);
2560         pci_nv_20 &= ~NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED;     /* 0xfffffffe */
2561         bios_wr32(bios, NV_PBUS_PCI_NV_20, pci_nv_20);
2562
2563         return 13;
2564 }
2565
2566 static int
2567 init_configure_mem(struct nvbios *bios, uint16_t offset,
2568                    struct init_exec *iexec)
2569 {
2570         /*
2571          * INIT_CONFIGURE_MEM   opcode: 0x66 ('f')
2572          *
2573          * offset      (8 bit): opcode
2574          *
2575          * Equivalent to INIT_DONE on bios version 3 or greater.
2576          * For early bios versions, sets up the memory registers, using values
2577          * taken from the memory init table
2578          */
2579
2580         /* no iexec->execute check by design */
2581
2582         uint16_t meminitoffs = bios->legacy.mem_init_tbl_ptr + MEM_INIT_SIZE * (bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, NV_CIO_CRE_SCRATCH4__INDEX) >> 4);
2583         uint16_t seqtbloffs = bios->legacy.sdr_seq_tbl_ptr, meminitdata = meminitoffs + 6;
2584         uint32_t reg, data;
2585
2586         if (bios->major_version > 2)
2587                 return 0;
2588
2589         bios_idxprt_wr(bios, NV_VIO_SRX, NV_VIO_SR_CLOCK_INDEX, bios_idxprt_rd(
2590                        bios, NV_VIO_SRX, NV_VIO_SR_CLOCK_INDEX) | 0x20);
2591
2592         if (bios->data[meminitoffs] & 1)
2593                 seqtbloffs = bios->legacy.ddr_seq_tbl_ptr;
2594
2595         for (reg = ROM32(bios->data[seqtbloffs]);
2596              reg != 0xffffffff;
2597              reg = ROM32(bios->data[seqtbloffs += 4])) {
2598
2599                 switch (reg) {
2600                 case NV04_PFB_PRE:
2601                         data = NV04_PFB_PRE_CMD_PRECHARGE;
2602                         break;
2603                 case NV04_PFB_PAD:
2604                         data = NV04_PFB_PAD_CKE_NORMAL;
2605                         break;
2606                 case NV04_PFB_REF:
2607                         data = NV04_PFB_REF_CMD_REFRESH;
2608                         break;
2609                 default:
2610                         data = ROM32(bios->data[meminitdata]);
2611                         meminitdata += 4;
2612                         if (data == 0xffffffff)
2613                                 continue;
2614                 }
2615
2616                 bios_wr32(bios, reg, data);
2617         }
2618
2619         return 1;
2620 }
2621
2622 static int
2623 init_configure_clk(struct nvbios *bios, uint16_t offset,
2624                    struct init_exec *iexec)
2625 {
2626         /*
2627          * INIT_CONFIGURE_CLK   opcode: 0x67 ('g')
2628          *
2629          * offset      (8 bit): opcode
2630          *
2631          * Equivalent to INIT_DONE on bios version 3 or greater.
2632          * For early bios versions, sets up the NVClk and MClk PLLs, using
2633          * values taken from the memory init table
2634          */
2635
2636         /* no iexec->execute check by design */
2637
2638         uint16_t meminitoffs = bios->legacy.mem_init_tbl_ptr + MEM_INIT_SIZE * (bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, NV_CIO_CRE_SCRATCH4__INDEX) >> 4);
2639         int clock;
2640
2641         if (bios->major_version > 2)
2642                 return 0;
2643
2644         clock = ROM16(bios->data[meminitoffs + 4]) * 10;
2645         setPLL(bios, NV_PRAMDAC_NVPLL_COEFF, clock);
2646
2647         clock = ROM16(bios->data[meminitoffs + 2]) * 10;
2648         if (bios->data[meminitoffs] & 1) /* DDR */
2649                 clock *= 2;
2650         setPLL(bios, NV_PRAMDAC_MPLL_COEFF, clock);
2651
2652         return 1;
2653 }
2654
2655 static int
2656 init_configure_preinit(struct nvbios *bios, uint16_t offset,
2657                        struct init_exec *iexec)
2658 {
2659         /*
2660          * INIT_CONFIGURE_PREINIT   opcode: 0x68 ('h')
2661          *
2662          * offset      (8 bit): opcode
2663          *
2664          * Equivalent to INIT_DONE on bios version 3 or greater.
2665          * For early bios versions, does early init, loading ram and crystal
2666          * configuration from straps into CR3C
2667          */
2668
2669         /* no iexec->execute check by design */
2670
2671         uint32_t straps = bios_rd32(bios, NV_PEXTDEV_BOOT_0);
2672         uint8_t cr3c = ((straps << 2) & 0xf0) | (straps & 0x40) >> 6;
2673
2674         if (bios->major_version > 2)
2675                 return 0;
2676
2677         bios_idxprt_wr(bios, NV_CIO_CRX__COLOR,
2678                              NV_CIO_CRE_SCRATCH4__INDEX, cr3c);
2679
2680         return 1;
2681 }
2682
2683 static int
2684 init_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2685 {
2686         /*
2687          * INIT_IO   opcode: 0x69 ('i')
2688          *
2689          * offset      (8  bit): opcode
2690          * offset + 1  (16 bit): CRTC port
2691          * offset + 3  (8  bit): mask
2692          * offset + 4  (8  bit): data
2693          *
2694          * Assign ((IOVAL("crtc port") & "mask") | "data") to "crtc port"
2695          */
2696
2697         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
2698         uint16_t crtcport = ROM16(bios->data[offset + 1]);
2699         uint8_t mask = bios->data[offset + 3];
2700         uint8_t data = bios->data[offset + 4];
2701
2702         if (!iexec->execute)
2703                 return 5;
2704
2705         BIOSLOG(bios, "0x%04X: Port: 0x%04X, Mask: 0x%02X, Data: 0x%02X\n",
2706                 offset, crtcport, mask, data);
2707
2708         /*
2709          * I have no idea what this does, but NVIDIA do this magic sequence
2710          * in the places where this INIT_IO happens..
2711          */
2712         if (dev_priv->card_type >= NV_50 && crtcport == 0x3c3 && data == 1) {
2713                 int i;
2714
2715                 bios_wr32(bios, 0x614100, (bios_rd32(
2716                           bios, 0x614100) & 0x0fffffff) | 0x00800000);
2717
2718                 bios_wr32(bios, 0x00e18c, bios_rd32(
2719                           bios, 0x00e18c) | 0x00020000);
2720
2721                 bios_wr32(bios, 0x614900, (bios_rd32(
2722                           bios, 0x614900) & 0x0fffffff) | 0x00800000);
2723
2724                 bios_wr32(bios, 0x000200, bios_rd32(
2725                           bios, 0x000200) & ~0x40000000);
2726
2727                 mdelay(10);
2728
2729                 bios_wr32(bios, 0x00e18c, bios_rd32(
2730                           bios, 0x00e18c) & ~0x00020000);
2731
2732                 bios_wr32(bios, 0x000200, bios_rd32(
2733                           bios, 0x000200) | 0x40000000);
2734
2735                 bios_wr32(bios, 0x614100, 0x00800018);
2736                 bios_wr32(bios, 0x614900, 0x00800018);
2737
2738                 mdelay(10);
2739
2740                 bios_wr32(bios, 0x614100, 0x10000018);
2741                 bios_wr32(bios, 0x614900, 0x10000018);
2742
2743                 for (i = 0; i < 3; i++)
2744                         bios_wr32(bios, 0x614280 + (i*0x800), bios_rd32(
2745                                   bios, 0x614280 + (i*0x800)) & 0xf0f0f0f0);
2746
2747                 for (i = 0; i < 2; i++)
2748                         bios_wr32(bios, 0x614300 + (i*0x800), bios_rd32(
2749                                   bios, 0x614300 + (i*0x800)) & 0xfffff0f0);
2750
2751                 for (i = 0; i < 3; i++)
2752                         bios_wr32(bios, 0x614380 + (i*0x800), bios_rd32(
2753                                   bios, 0x614380 + (i*0x800)) & 0xfffff0f0);
2754
2755                 for (i = 0; i < 2; i++)
2756                         bios_wr32(bios, 0x614200 + (i*0x800), bios_rd32(
2757                                   bios, 0x614200 + (i*0x800)) & 0xfffffff0);
2758
2759                 for (i = 0; i < 2; i++)
2760                         bios_wr32(bios, 0x614108 + (i*0x800), bios_rd32(
2761                                   bios, 0x614108 + (i*0x800)) & 0x0fffffff);
2762                 return 5;
2763         }
2764
2765         bios_port_wr(bios, crtcport, (bios_port_rd(bios, crtcport) & mask) |
2766                                                                         data);
2767         return 5;
2768 }
2769
2770 static int
2771 init_sub(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2772 {
2773         /*
2774          * INIT_SUB   opcode: 0x6B ('k')
2775          *
2776          * offset      (8 bit): opcode
2777          * offset + 1  (8 bit): script number
2778          *
2779          * Execute script number "script number", as a subroutine
2780          */
2781
2782         uint8_t sub = bios->data[offset + 1];
2783
2784         if (!iexec->execute)
2785                 return 2;
2786
2787         BIOSLOG(bios, "0x%04X: Calling script %d\n", offset, sub);
2788
2789         parse_init_table(bios,
2790                          ROM16(bios->data[bios->init_script_tbls_ptr + sub * 2]),
2791                          iexec);
2792
2793         BIOSLOG(bios, "0x%04X: End of script %d\n", offset, sub);
2794
2795         return 2;
2796 }
2797
2798 static int
2799 init_ram_condition(struct nvbios *bios, uint16_t offset,
2800                    struct init_exec *iexec)
2801 {
2802         /*
2803          * INIT_RAM_CONDITION   opcode: 0x6D ('m')
2804          *
2805          * offset      (8 bit): opcode
2806          * offset + 1  (8 bit): mask
2807          * offset + 2  (8 bit): cmpval
2808          *
2809          * Test if (NV04_PFB_BOOT_0 & "mask") equals "cmpval".
2810          * If condition not met skip subsequent opcodes until condition is
2811          * inverted (INIT_NOT), or we hit INIT_RESUME
2812          */
2813
2814         uint8_t mask = bios->data[offset + 1];
2815         uint8_t cmpval = bios->data[offset + 2];
2816         uint8_t data;
2817
2818         if (!iexec->execute)
2819                 return 3;
2820
2821         data = bios_rd32(bios, NV04_PFB_BOOT_0) & mask;
2822
2823         BIOSLOG(bios, "0x%04X: Checking if 0x%08X equals 0x%08X\n",
2824                 offset, data, cmpval);
2825
2826         if (data == cmpval)
2827                 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
2828         else {
2829                 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
2830                 iexec->execute = false;
2831         }
2832
2833         return 3;
2834 }
2835
2836 static int
2837 init_nv_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2838 {
2839         /*
2840          * INIT_NV_REG   opcode: 0x6E ('n')
2841          *
2842          * offset      (8  bit): opcode
2843          * offset + 1  (32 bit): register
2844          * offset + 5  (32 bit): mask
2845          * offset + 9  (32 bit): data
2846          *
2847          * Assign ((REGVAL("register") & "mask") | "data") to "register"
2848          */
2849
2850         uint32_t reg = ROM32(bios->data[offset + 1]);
2851         uint32_t mask = ROM32(bios->data[offset + 5]);
2852         uint32_t data = ROM32(bios->data[offset + 9]);
2853
2854         if (!iexec->execute)
2855                 return 13;
2856
2857         BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Mask: 0x%08X, Data: 0x%08X\n",
2858                 offset, reg, mask, data);
2859
2860         bios_wr32(bios, reg, (bios_rd32(bios, reg) & mask) | data);
2861
2862         return 13;
2863 }
2864
2865 static int
2866 init_macro(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2867 {
2868         /*
2869          * INIT_MACRO   opcode: 0x6F ('o')
2870          *
2871          * offset      (8 bit): opcode
2872          * offset + 1  (8 bit): macro number
2873          *
2874          * Look up macro index "macro number" in the macro index table.
2875          * The macro index table entry has 1 byte for the index in the macro
2876          * table, and 1 byte for the number of times to repeat the macro.
2877          * The macro table entry has 4 bytes for the register address and
2878          * 4 bytes for the value to write to that register
2879          */
2880
2881         uint8_t macro_index_tbl_idx = bios->data[offset + 1];
2882         uint16_t tmp = bios->macro_index_tbl_ptr + (macro_index_tbl_idx * MACRO_INDEX_SIZE);
2883         uint8_t macro_tbl_idx = bios->data[tmp];
2884         uint8_t count = bios->data[tmp + 1];
2885         uint32_t reg, data;
2886         int i;
2887
2888         if (!iexec->execute)
2889                 return 2;
2890
2891         BIOSLOG(bios, "0x%04X: Macro: 0x%02X, MacroTableIndex: 0x%02X, "
2892                       "Count: 0x%02X\n",
2893                 offset, macro_index_tbl_idx, macro_tbl_idx, count);
2894
2895         for (i = 0; i < count; i++) {
2896                 uint16_t macroentryptr = bios->macro_tbl_ptr + (macro_tbl_idx + i) * MACRO_SIZE;
2897
2898                 reg = ROM32(bios->data[macroentryptr]);
2899                 data = ROM32(bios->data[macroentryptr + 4]);
2900
2901                 bios_wr32(bios, reg, data);
2902         }
2903
2904         return 2;
2905 }
2906
2907 static int
2908 init_done(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2909 {
2910         /*
2911          * INIT_DONE   opcode: 0x71 ('q')
2912          *
2913          * offset      (8  bit): opcode
2914          *
2915          * End the current script
2916          */
2917
2918         /* mild retval abuse to stop parsing this table */
2919         return 0;
2920 }
2921
2922 static int
2923 init_resume(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2924 {
2925         /*
2926          * INIT_RESUME   opcode: 0x72 ('r')
2927          *
2928          * offset      (8  bit): opcode
2929          *
2930          * End the current execute / no-execute condition
2931          */
2932
2933         if (iexec->execute)
2934                 return 1;
2935
2936         iexec->execute = true;
2937         BIOSLOG(bios, "0x%04X: ---- Executing following commands ----\n", offset);
2938
2939         return 1;
2940 }
2941
2942 static int
2943 init_time(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2944 {
2945         /*
2946          * INIT_TIME   opcode: 0x74 ('t')
2947          *
2948          * offset      (8  bit): opcode
2949          * offset + 1  (16 bit): time
2950          *
2951          * Sleep for "time" microseconds.
2952          */
2953
2954         unsigned time = ROM16(bios->data[offset + 1]);
2955
2956         if (!iexec->execute)
2957                 return 3;
2958
2959         BIOSLOG(bios, "0x%04X: Sleeping for 0x%04X microseconds\n",
2960                 offset, time);
2961
2962         if (time < 1000)
2963                 udelay(time);
2964         else
2965                 msleep((time + 900) / 1000);
2966
2967         return 3;
2968 }
2969
2970 static int
2971 init_condition(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2972 {
2973         /*
2974          * INIT_CONDITION   opcode: 0x75 ('u')
2975          *
2976          * offset      (8 bit): opcode
2977          * offset + 1  (8 bit): condition number
2978          *
2979          * Check condition "condition number" in the condition table.
2980          * If condition not met skip subsequent opcodes until condition is
2981          * inverted (INIT_NOT), or we hit INIT_RESUME
2982          */
2983
2984         uint8_t cond = bios->data[offset + 1];
2985
2986         if (!iexec->execute)
2987                 return 2;
2988
2989         BIOSLOG(bios, "0x%04X: Condition: 0x%02X\n", offset, cond);
2990
2991         if (bios_condition_met(bios, offset, cond))
2992                 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
2993         else {
2994                 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
2995                 iexec->execute = false;
2996         }
2997
2998         return 2;
2999 }
3000
3001 static int
3002 init_io_condition(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
3003 {
3004         /*
3005          * INIT_IO_CONDITION  opcode: 0x76
3006          *
3007          * offset      (8 bit): opcode
3008          * offset + 1  (8 bit): condition number
3009          *
3010          * Check condition "condition number" in the io condition table.
3011          * If condition not met skip subsequent opcodes until condition is
3012          * inverted (INIT_NOT), or we hit INIT_RESUME
3013          */
3014
3015         uint8_t cond = bios->data[offset + 1];
3016
3017         if (!iexec->execute)
3018                 return 2;
3019
3020         BIOSLOG(bios, "0x%04X: IO condition: 0x%02X\n", offset, cond);
3021
3022         if (io_condition_met(bios, offset, cond))
3023                 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
3024         else {
3025                 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
3026                 iexec->execute = false;
3027         }
3028
3029         return 2;
3030 }
3031
3032 static int
3033 init_index_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
3034 {
3035         /*
3036          * INIT_INDEX_IO   opcode: 0x78 ('x')
3037          *
3038          * offset      (8  bit): opcode
3039          * offset + 1  (16 bit): CRTC port
3040          * offset + 3  (8  bit): CRTC index
3041          * offset + 4  (8  bit): mask
3042          * offset + 5  (8  bit): data
3043          *
3044          * Read value at index "CRTC index" on "CRTC port", AND with "mask",
3045          * OR with "data", write-back
3046          */
3047
3048         uint16_t crtcport = ROM16(bios->data[offset + 1]);
3049         uint8_t crtcindex = bios->data[offset + 3];
3050         uint8_t mask = bios->data[offset + 4];
3051         uint8_t data = bios->data[offset + 5];
3052         uint8_t value;
3053
3054         if (!iexec->execute)
3055                 return 6;
3056
3057         BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
3058                       "Data: 0x%02X\n",
3059                 offset, crtcport, crtcindex, mask, data);
3060
3061         value = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) | data;
3062         bios_idxprt_wr(bios, crtcport, crtcindex, value);
3063
3064         return 6;
3065 }
3066
3067 static int
3068 init_pll(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
3069 {
3070         /*