nouveau_bios.c revision 02faec09b2814b6ad3fd202e2f28b3c4b712a3f1
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 30/* these defines are made up */ 31#define NV_CIO_CRE_44_HEADA 0x0 32#define NV_CIO_CRE_44_HEADB 0x3 33#define FEATURE_MOBILE 0x10 /* also FEATURE_QUADRO for BMP */ 34#define LEGACY_I2C_CRT 0x80 35#define LEGACY_I2C_PANEL 0x81 36#define LEGACY_I2C_TV 0x82 37 38#define EDID1_LEN 128 39 40#define BIOSLOG(sip, fmt, arg...) NV_DEBUG(sip->dev, fmt, ##arg) 41#define LOG_OLD_VALUE(x) 42 43#define ROM16(x) le16_to_cpu(*(uint16_t *)&(x)) 44#define ROM32(x) le32_to_cpu(*(uint32_t *)&(x)) 45 46struct init_exec { 47 bool execute; 48 bool repeat; 49}; 50 51static 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 69static int 70score_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 87static 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 125out: 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 131static 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 155out: 156 if (dev_priv->card_type >= NV_50) 157 nv_wr32(dev, 0x1700, old_bar0_pramin); 158} 159 160static 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 176out: 177 pci_disable_rom(dev->pdev); 178} 179 180struct methods { 181 const char desc[8]; 182 void (*loadbios)(struct drm_device *, uint8_t *); 183 const bool rw; 184}; 185 186static struct methods nv04_methods[] = { 187 { "PROM", load_vbios_prom, false }, 188 { "PRAMIN", load_vbios_pramin, true }, 189 { "PCIROM", load_vbios_pci, true }, 190}; 191 192static struct methods nv50_methods[] = { 193 { "PRAMIN", load_vbios_pramin, true }, 194 { "PROM", load_vbios_prom, false }, 195 { "PCIROM", load_vbios_pci, true }, 196}; 197 198#define METHODCNT 3 199 200static bool NVShadowVBIOS(struct drm_device *dev, uint8_t *data) 201{ 202 struct drm_nouveau_private *dev_priv = dev->dev_private; 203 struct methods *methods; 204 int i; 205 int testscore = 3; 206 int scores[METHODCNT]; 207 208 if (nouveau_vbios) { 209 methods = nv04_methods; 210 for (i = 0; i < METHODCNT; i++) 211 if (!strcasecmp(nouveau_vbios, methods[i].desc)) 212 break; 213 214 if (i < METHODCNT) { 215 NV_INFO(dev, "Attempting to use BIOS image from %s\n", 216 methods[i].desc); 217 218 methods[i].loadbios(dev, data); 219 if (score_vbios(dev, data, methods[i].rw)) 220 return true; 221 } 222 223 NV_ERROR(dev, "VBIOS source \'%s\' invalid\n", nouveau_vbios); 224 } 225 226 if (dev_priv->card_type < NV_50) 227 methods = nv04_methods; 228 else 229 methods = nv50_methods; 230 231 for (i = 0; i < METHODCNT; i++) { 232 NV_TRACE(dev, "Attempting to load BIOS image from %s\n", 233 methods[i].desc); 234 data[0] = data[1] = 0; /* avoid reuse of previous image */ 235 methods[i].loadbios(dev, data); 236 scores[i] = score_vbios(dev, data, methods[i].rw); 237 if (scores[i] == testscore) 238 return true; 239 } 240 241 while (--testscore > 0) { 242 for (i = 0; i < METHODCNT; i++) { 243 if (scores[i] == testscore) { 244 NV_TRACE(dev, "Using BIOS image from %s\n", 245 methods[i].desc); 246 methods[i].loadbios(dev, data); 247 return true; 248 } 249 } 250 } 251 252 NV_ERROR(dev, "No valid BIOS image found\n"); 253 return false; 254} 255 256struct init_tbl_entry { 257 char *name; 258 uint8_t id; 259 int (*handler)(struct nvbios *, uint16_t, struct init_exec *); 260}; 261 262struct bit_entry { 263 uint8_t id[2]; 264 uint16_t length; 265 uint16_t offset; 266}; 267 268static int parse_init_table(struct nvbios *, unsigned int, struct init_exec *); 269 270#define MACRO_INDEX_SIZE 2 271#define MACRO_SIZE 8 272#define CONDITION_SIZE 12 273#define IO_FLAG_CONDITION_SIZE 9 274#define IO_CONDITION_SIZE 5 275#define MEM_INIT_SIZE 66 276 277static void still_alive(void) 278{ 279#if 0 280 sync(); 281 msleep(2); 282#endif 283} 284 285static uint32_t 286munge_reg(struct nvbios *bios, uint32_t reg) 287{ 288 struct drm_nouveau_private *dev_priv = bios->dev->dev_private; 289 struct dcb_entry *dcbent = bios->display.output; 290 291 if (dev_priv->card_type < NV_50) 292 return reg; 293 294 if (reg & 0x40000000) { 295 BUG_ON(!dcbent); 296 297 reg += (ffs(dcbent->or) - 1) * 0x800; 298 if ((reg & 0x20000000) && !(dcbent->sorconf.link & 1)) 299 reg += 0x00000080; 300 } 301 302 reg &= ~0x60000000; 303 return reg; 304} 305 306static int 307valid_reg(struct nvbios *bios, uint32_t reg) 308{ 309 struct drm_nouveau_private *dev_priv = bios->dev->dev_private; 310 struct drm_device *dev = bios->dev; 311 312 /* C51 has misaligned regs on purpose. Marvellous */ 313 if (reg & 0x2 || 314 (reg & 0x1 && dev_priv->vbios.chip_version != 0x51)) 315 NV_ERROR(dev, "======= misaligned reg 0x%08X =======\n", reg); 316 317 /* warn on C51 regs that haven't been verified accessible in tracing */ 318 if (reg & 0x1 && dev_priv->vbios.chip_version == 0x51 && 319 reg != 0x130d && reg != 0x1311 && reg != 0x60081d) 320 NV_WARN(dev, "=== C51 misaligned reg 0x%08X not verified ===\n", 321 reg); 322 323 if (reg >= (8*1024*1024)) { 324 NV_ERROR(dev, "=== reg 0x%08x out of mapped bounds ===\n", reg); 325 return 0; 326 } 327 328 return 1; 329} 330 331static bool 332valid_idx_port(struct nvbios *bios, uint16_t port) 333{ 334 struct drm_nouveau_private *dev_priv = bios->dev->dev_private; 335 struct drm_device *dev = bios->dev; 336 337 /* 338 * If adding more ports here, the read/write functions below will need 339 * updating so that the correct mmio range (PRMCIO, PRMDIO, PRMVIO) is 340 * used for the port in question 341 */ 342 if (dev_priv->card_type < NV_50) { 343 if (port == NV_CIO_CRX__COLOR) 344 return true; 345 if (port == NV_VIO_SRX) 346 return true; 347 } else { 348 if (port == NV_CIO_CRX__COLOR) 349 return true; 350 } 351 352 NV_ERROR(dev, "========== unknown indexed io port 0x%04X ==========\n", 353 port); 354 355 return false; 356} 357 358static bool 359valid_port(struct nvbios *bios, uint16_t port) 360{ 361 struct drm_device *dev = bios->dev; 362 363 /* 364 * If adding more ports here, the read/write functions below will need 365 * updating so that the correct mmio range (PRMCIO, PRMDIO, PRMVIO) is 366 * used for the port in question 367 */ 368 if (port == NV_VIO_VSE2) 369 return true; 370 371 NV_ERROR(dev, "========== unknown io port 0x%04X ==========\n", port); 372 373 return false; 374} 375 376static uint32_t 377bios_rd32(struct nvbios *bios, uint32_t reg) 378{ 379 uint32_t data; 380 381 reg = munge_reg(bios, reg); 382 if (!valid_reg(bios, reg)) 383 return 0; 384 385 /* 386 * C51 sometimes uses regs with bit0 set in the address. For these 387 * cases there should exist a translation in a BIOS table to an IO 388 * port address which the BIOS uses for accessing the reg 389 * 390 * These only seem to appear for the power control regs to a flat panel, 391 * and the GPIO regs at 0x60081*. In C51 mmio traces the normal regs 392 * for 0x1308 and 0x1310 are used - hence the mask below. An S3 393 * suspend-resume mmio trace from a C51 will be required to see if this 394 * is true for the power microcode in 0x14.., or whether the direct IO 395 * port access method is needed 396 */ 397 if (reg & 0x1) 398 reg &= ~0x1; 399 400 data = nv_rd32(bios->dev, reg); 401 402 BIOSLOG(bios, " Read: Reg: 0x%08X, Data: 0x%08X\n", reg, data); 403 404 return data; 405} 406 407static void 408bios_wr32(struct nvbios *bios, uint32_t reg, uint32_t data) 409{ 410 struct drm_nouveau_private *dev_priv = bios->dev->dev_private; 411 412 reg = munge_reg(bios, reg); 413 if (!valid_reg(bios, reg)) 414 return; 415 416 /* see note in bios_rd32 */ 417 if (reg & 0x1) 418 reg &= 0xfffffffe; 419 420 LOG_OLD_VALUE(bios_rd32(bios, reg)); 421 BIOSLOG(bios, " Write: Reg: 0x%08X, Data: 0x%08X\n", reg, data); 422 423 if (dev_priv->vbios.execute) { 424 still_alive(); 425 nv_wr32(bios->dev, reg, data); 426 } 427} 428 429static uint8_t 430bios_idxprt_rd(struct nvbios *bios, uint16_t port, uint8_t index) 431{ 432 struct drm_nouveau_private *dev_priv = bios->dev->dev_private; 433 struct drm_device *dev = bios->dev; 434 uint8_t data; 435 436 if (!valid_idx_port(bios, port)) 437 return 0; 438 439 if (dev_priv->card_type < NV_50) { 440 if (port == NV_VIO_SRX) 441 data = NVReadVgaSeq(dev, bios->state.crtchead, index); 442 else /* assume NV_CIO_CRX__COLOR */ 443 data = NVReadVgaCrtc(dev, bios->state.crtchead, index); 444 } else { 445 uint32_t data32; 446 447 data32 = bios_rd32(bios, NV50_PDISPLAY_VGACRTC(index & ~3)); 448 data = (data32 >> ((index & 3) << 3)) & 0xff; 449 } 450 451 BIOSLOG(bios, " Indexed IO read: Port: 0x%04X, Index: 0x%02X, " 452 "Head: 0x%02X, Data: 0x%02X\n", 453 port, index, bios->state.crtchead, data); 454 return data; 455} 456 457static void 458bios_idxprt_wr(struct nvbios *bios, uint16_t port, uint8_t index, uint8_t data) 459{ 460 struct drm_nouveau_private *dev_priv = bios->dev->dev_private; 461 struct drm_device *dev = bios->dev; 462 463 if (!valid_idx_port(bios, port)) 464 return; 465 466 /* 467 * The current head is maintained in the nvbios member state.crtchead. 468 * We trap changes to CR44 and update the head variable and hence the 469 * register set written. 470 * As CR44 only exists on CRTC0, we update crtchead to head0 in advance 471 * of the write, and to head1 after the write 472 */ 473 if (port == NV_CIO_CRX__COLOR && index == NV_CIO_CRE_44 && 474 data != NV_CIO_CRE_44_HEADB) 475 bios->state.crtchead = 0; 476 477 LOG_OLD_VALUE(bios_idxprt_rd(bios, port, index)); 478 BIOSLOG(bios, " Indexed IO write: Port: 0x%04X, Index: 0x%02X, " 479 "Head: 0x%02X, Data: 0x%02X\n", 480 port, index, bios->state.crtchead, data); 481 482 if (bios->execute && dev_priv->card_type < NV_50) { 483 still_alive(); 484 if (port == NV_VIO_SRX) 485 NVWriteVgaSeq(dev, bios->state.crtchead, index, data); 486 else /* assume NV_CIO_CRX__COLOR */ 487 NVWriteVgaCrtc(dev, bios->state.crtchead, index, data); 488 } else 489 if (bios->execute) { 490 uint32_t data32, shift = (index & 3) << 3; 491 492 still_alive(); 493 494 data32 = bios_rd32(bios, NV50_PDISPLAY_VGACRTC(index & ~3)); 495 data32 &= ~(0xff << shift); 496 data32 |= (data << shift); 497 bios_wr32(bios, NV50_PDISPLAY_VGACRTC(index & ~3), data32); 498 } 499 500 if (port == NV_CIO_CRX__COLOR && 501 index == NV_CIO_CRE_44 && data == NV_CIO_CRE_44_HEADB) 502 bios->state.crtchead = 1; 503} 504 505static uint8_t 506bios_port_rd(struct nvbios *bios, uint16_t port) 507{ 508 uint8_t data, head = bios->state.crtchead; 509 510 if (!valid_port(bios, port)) 511 return 0; 512 513 data = NVReadPRMVIO(bios->dev, head, NV_PRMVIO0_OFFSET + port); 514 515 BIOSLOG(bios, " IO read: Port: 0x%04X, Head: 0x%02X, Data: 0x%02X\n", 516 port, head, data); 517 518 return data; 519} 520 521static void 522bios_port_wr(struct nvbios *bios, uint16_t port, uint8_t data) 523{ 524 int head = bios->state.crtchead; 525 526 if (!valid_port(bios, port)) 527 return; 528 529 LOG_OLD_VALUE(bios_port_rd(bios, port)); 530 BIOSLOG(bios, " IO write: Port: 0x%04X, Head: 0x%02X, Data: 0x%02X\n", 531 port, head, data); 532 533 if (!bios->execute) 534 return; 535 536 still_alive(); 537 NVWritePRMVIO(bios->dev, head, NV_PRMVIO0_OFFSET + port, data); 538} 539 540static bool 541io_flag_condition_met(struct nvbios *bios, uint16_t offset, uint8_t cond) 542{ 543 /* 544 * The IO flag condition entry has 2 bytes for the CRTC port; 1 byte 545 * for the CRTC index; 1 byte for the mask to apply to the value 546 * retrieved from the CRTC; 1 byte for the shift right to apply to the 547 * masked CRTC value; 2 bytes for the offset to the flag array, to 548 * which the shifted value is added; 1 byte for the mask applied to the 549 * value read from the flag array; and 1 byte for the value to compare 550 * against the masked byte from the flag table. 551 */ 552 553 uint16_t condptr = bios->io_flag_condition_tbl_ptr + cond * IO_FLAG_CONDITION_SIZE; 554 uint16_t crtcport = ROM16(bios->data[condptr]); 555 uint8_t crtcindex = bios->data[condptr + 2]; 556 uint8_t mask = bios->data[condptr + 3]; 557 uint8_t shift = bios->data[condptr + 4]; 558 uint16_t flagarray = ROM16(bios->data[condptr + 5]); 559 uint8_t flagarraymask = bios->data[condptr + 7]; 560 uint8_t cmpval = bios->data[condptr + 8]; 561 uint8_t data; 562 563 BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, " 564 "Shift: 0x%02X, FlagArray: 0x%04X, FAMask: 0x%02X, " 565 "Cmpval: 0x%02X\n", 566 offset, crtcport, crtcindex, mask, shift, flagarray, flagarraymask, cmpval); 567 568 data = bios_idxprt_rd(bios, crtcport, crtcindex); 569 570 data = bios->data[flagarray + ((data & mask) >> shift)]; 571 data &= flagarraymask; 572 573 BIOSLOG(bios, "0x%04X: Checking if 0x%02X equals 0x%02X\n", 574 offset, data, cmpval); 575 576 return (data == cmpval); 577} 578 579static bool 580bios_condition_met(struct nvbios *bios, uint16_t offset, uint8_t cond) 581{ 582 /* 583 * The condition table entry has 4 bytes for the address of the 584 * register to check, 4 bytes for a mask to apply to the register and 585 * 4 for a test comparison value 586 */ 587 588 uint16_t condptr = bios->condition_tbl_ptr + cond * CONDITION_SIZE; 589 uint32_t reg = ROM32(bios->data[condptr]); 590 uint32_t mask = ROM32(bios->data[condptr + 4]); 591 uint32_t cmpval = ROM32(bios->data[condptr + 8]); 592 uint32_t data; 593 594 BIOSLOG(bios, "0x%04X: Cond: 0x%02X, Reg: 0x%08X, Mask: 0x%08X\n", 595 offset, cond, reg, mask); 596 597 data = bios_rd32(bios, reg) & mask; 598 599 BIOSLOG(bios, "0x%04X: Checking if 0x%08X equals 0x%08X\n", 600 offset, data, cmpval); 601 602 return (data == cmpval); 603} 604 605static bool 606io_condition_met(struct nvbios *bios, uint16_t offset, uint8_t cond) 607{ 608 /* 609 * The IO condition entry has 2 bytes for the IO port address; 1 byte 610 * for the index to write to io_port; 1 byte for the mask to apply to 611 * the byte read from io_port+1; and 1 byte for the value to compare 612 * against the masked byte. 613 */ 614 615 uint16_t condptr = bios->io_condition_tbl_ptr + cond * IO_CONDITION_SIZE; 616 uint16_t io_port = ROM16(bios->data[condptr]); 617 uint8_t port_index = bios->data[condptr + 2]; 618 uint8_t mask = bios->data[condptr + 3]; 619 uint8_t cmpval = bios->data[condptr + 4]; 620 621 uint8_t data = bios_idxprt_rd(bios, io_port, port_index) & mask; 622 623 BIOSLOG(bios, "0x%04X: Checking if 0x%02X equals 0x%02X\n", 624 offset, data, cmpval); 625 626 return (data == cmpval); 627} 628 629static int 630nv50_pll_set(struct drm_device *dev, uint32_t reg, uint32_t clk) 631{ 632 struct drm_nouveau_private *dev_priv = dev->dev_private; 633 uint32_t reg0 = nv_rd32(dev, reg + 0); 634 uint32_t reg1 = nv_rd32(dev, reg + 4); 635 struct nouveau_pll_vals pll; 636 struct pll_lims pll_limits; 637 int ret; 638 639 ret = get_pll_limits(dev, reg, &pll_limits); 640 if (ret) 641 return ret; 642 643 clk = nouveau_calc_pll_mnp(dev, &pll_limits, clk, &pll); 644 if (!clk) 645 return -ERANGE; 646 647 reg0 = (reg0 & 0xfff8ffff) | (pll.log2P << 16); 648 reg1 = (reg1 & 0xffff0000) | (pll.N1 << 8) | pll.M1; 649 650 if (dev_priv->vbios.execute) { 651 still_alive(); 652 nv_wr32(dev, reg + 4, reg1); 653 nv_wr32(dev, reg + 0, reg0); 654 } 655 656 return 0; 657} 658 659static int 660setPLL(struct nvbios *bios, uint32_t reg, uint32_t clk) 661{ 662 struct drm_device *dev = bios->dev; 663 struct drm_nouveau_private *dev_priv = dev->dev_private; 664 /* clk in kHz */ 665 struct pll_lims pll_lim; 666 struct nouveau_pll_vals pllvals; 667 int ret; 668 669 if (dev_priv->card_type >= NV_50) 670 return nv50_pll_set(dev, reg, clk); 671 672 /* high regs (such as in the mac g5 table) are not -= 4 */ 673 ret = get_pll_limits(dev, reg > 0x405c ? reg : reg - 4, &pll_lim); 674 if (ret) 675 return ret; 676 677 clk = nouveau_calc_pll_mnp(dev, &pll_lim, clk, &pllvals); 678 if (!clk) 679 return -ERANGE; 680 681 if (bios->execute) { 682 still_alive(); 683 nouveau_hw_setpll(dev, reg, &pllvals); 684 } 685 686 return 0; 687} 688 689static int dcb_entry_idx_from_crtchead(struct drm_device *dev) 690{ 691 struct drm_nouveau_private *dev_priv = dev->dev_private; 692 struct nvbios *bios = &dev_priv->vbios; 693 694 /* 695 * For the results of this function to be correct, CR44 must have been 696 * set (using bios_idxprt_wr to set crtchead), CR58 set for CR57 = 0, 697 * and the DCB table parsed, before the script calling the function is 698 * run. run_digital_op_script is example of how to do such setup 699 */ 700 701 uint8_t dcb_entry = NVReadVgaCrtc5758(dev, bios->state.crtchead, 0); 702 703 if (dcb_entry > bios->dcb.entries) { 704 NV_ERROR(dev, "CR58 doesn't have a valid DCB entry currently " 705 "(%02X)\n", dcb_entry); 706 dcb_entry = 0x7f; /* unused / invalid marker */ 707 } 708 709 return dcb_entry; 710} 711 712static struct nouveau_i2c_chan * 713init_i2c_device_find(struct drm_device *dev, int i2c_index) 714{ 715 struct drm_nouveau_private *dev_priv = dev->dev_private; 716 struct dcb_table *dcb = &dev_priv->vbios.dcb; 717 718 if (i2c_index == 0xff) { 719 /* note: dcb_entry_idx_from_crtchead needs pre-script set-up */ 720 int idx = dcb_entry_idx_from_crtchead(dev), shift = 0; 721 int default_indices = dcb->i2c_default_indices; 722 723 if (idx != 0x7f && dcb->entry[idx].i2c_upper_default) 724 shift = 4; 725 726 i2c_index = (default_indices >> shift) & 0xf; 727 } 728 if (i2c_index == 0x80) /* g80+ */ 729 i2c_index = dcb->i2c_default_indices & 0xf; 730 731 return nouveau_i2c_find(dev, i2c_index); 732} 733 734static uint32_t 735get_tmds_index_reg(struct drm_device *dev, uint8_t mlv) 736{ 737 /* 738 * For mlv < 0x80, it is an index into a table of TMDS base addresses. 739 * For mlv == 0x80 use the "or" value of the dcb_entry indexed by 740 * CR58 for CR57 = 0 to index a table of offsets to the basic 741 * 0x6808b0 address. 742 * For mlv == 0x81 use the "or" value of the dcb_entry indexed by 743 * CR58 for CR57 = 0 to index a table of offsets to the basic 744 * 0x6808b0 address, and then flip the offset by 8. 745 */ 746 747 struct drm_nouveau_private *dev_priv = dev->dev_private; 748 struct nvbios *bios = &dev_priv->vbios; 749 const int pramdac_offset[13] = { 750 0, 0, 0x8, 0, 0x2000, 0, 0, 0, 0x2008, 0, 0, 0, 0x2000 }; 751 const uint32_t pramdac_table[4] = { 752 0x6808b0, 0x6808b8, 0x6828b0, 0x6828b8 }; 753 754 if (mlv >= 0x80) { 755 int dcb_entry, dacoffset; 756 757 /* note: dcb_entry_idx_from_crtchead needs pre-script set-up */ 758 dcb_entry = dcb_entry_idx_from_crtchead(dev); 759 if (dcb_entry == 0x7f) 760 return 0; 761 dacoffset = pramdac_offset[bios->dcb.entry[dcb_entry].or]; 762 if (mlv == 0x81) 763 dacoffset ^= 8; 764 return 0x6808b0 + dacoffset; 765 } else { 766 if (mlv >= ARRAY_SIZE(pramdac_table)) { 767 NV_ERROR(dev, "Magic Lookup Value too big (%02X)\n", 768 mlv); 769 return 0; 770 } 771 return pramdac_table[mlv]; 772 } 773} 774 775static int 776init_io_restrict_prog(struct nvbios *bios, uint16_t offset, 777 struct init_exec *iexec) 778{ 779 /* 780 * INIT_IO_RESTRICT_PROG opcode: 0x32 ('2') 781 * 782 * offset (8 bit): opcode 783 * offset + 1 (16 bit): CRTC port 784 * offset + 3 (8 bit): CRTC index 785 * offset + 4 (8 bit): mask 786 * offset + 5 (8 bit): shift 787 * offset + 6 (8 bit): count 788 * offset + 7 (32 bit): register 789 * offset + 11 (32 bit): configuration 1 790 * ... 791 * 792 * Starting at offset + 11 there are "count" 32 bit values. 793 * To find out which value to use read index "CRTC index" on "CRTC 794 * port", AND this value with "mask" and then bit shift right "shift" 795 * bits. Read the appropriate value using this index and write to 796 * "register" 797 */ 798 799 uint16_t crtcport = ROM16(bios->data[offset + 1]); 800 uint8_t crtcindex = bios->data[offset + 3]; 801 uint8_t mask = bios->data[offset + 4]; 802 uint8_t shift = bios->data[offset + 5]; 803 uint8_t count = bios->data[offset + 6]; 804 uint32_t reg = ROM32(bios->data[offset + 7]); 805 uint8_t config; 806 uint32_t configval; 807 int len = 11 + count * 4; 808 809 if (!iexec->execute) 810 return len; 811 812 BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, " 813 "Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n", 814 offset, crtcport, crtcindex, mask, shift, count, reg); 815 816 config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift; 817 if (config > count) { 818 NV_ERROR(bios->dev, 819 "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n", 820 offset, config, count); 821 return 0; 822 } 823 824 configval = ROM32(bios->data[offset + 11 + config * 4]); 825 826 BIOSLOG(bios, "0x%04X: Writing config %02X\n", offset, config); 827 828 bios_wr32(bios, reg, configval); 829 830 return len; 831} 832 833static int 834init_repeat(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 835{ 836 /* 837 * INIT_REPEAT opcode: 0x33 ('3') 838 * 839 * offset (8 bit): opcode 840 * offset + 1 (8 bit): count 841 * 842 * Execute script following this opcode up to INIT_REPEAT_END 843 * "count" times 844 */ 845 846 uint8_t count = bios->data[offset + 1]; 847 uint8_t i; 848 849 /* no iexec->execute check by design */ 850 851 BIOSLOG(bios, "0x%04X: Repeating following segment %d times\n", 852 offset, count); 853 854 iexec->repeat = true; 855 856 /* 857 * count - 1, as the script block will execute once when we leave this 858 * opcode -- this is compatible with bios behaviour as: 859 * a) the block is always executed at least once, even if count == 0 860 * b) the bios interpreter skips to the op following INIT_END_REPEAT, 861 * while we don't 862 */ 863 for (i = 0; i < count - 1; i++) 864 parse_init_table(bios, offset + 2, iexec); 865 866 iexec->repeat = false; 867 868 return 2; 869} 870 871static int 872init_io_restrict_pll(struct nvbios *bios, uint16_t offset, 873 struct init_exec *iexec) 874{ 875 /* 876 * INIT_IO_RESTRICT_PLL opcode: 0x34 ('4') 877 * 878 * offset (8 bit): opcode 879 * offset + 1 (16 bit): CRTC port 880 * offset + 3 (8 bit): CRTC index 881 * offset + 4 (8 bit): mask 882 * offset + 5 (8 bit): shift 883 * offset + 6 (8 bit): IO flag condition index 884 * offset + 7 (8 bit): count 885 * offset + 8 (32 bit): register 886 * offset + 12 (16 bit): frequency 1 887 * ... 888 * 889 * Starting at offset + 12 there are "count" 16 bit frequencies (10kHz). 890 * Set PLL register "register" to coefficients for frequency n, 891 * selected by reading index "CRTC index" of "CRTC port" ANDed with 892 * "mask" and shifted right by "shift". 893 * 894 * If "IO flag condition index" > 0, and condition met, double 895 * frequency before setting it. 896 */ 897 898 uint16_t crtcport = ROM16(bios->data[offset + 1]); 899 uint8_t crtcindex = bios->data[offset + 3]; 900 uint8_t mask = bios->data[offset + 4]; 901 uint8_t shift = bios->data[offset + 5]; 902 int8_t io_flag_condition_idx = bios->data[offset + 6]; 903 uint8_t count = bios->data[offset + 7]; 904 uint32_t reg = ROM32(bios->data[offset + 8]); 905 uint8_t config; 906 uint16_t freq; 907 int len = 12 + count * 2; 908 909 if (!iexec->execute) 910 return len; 911 912 BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, " 913 "Shift: 0x%02X, IO Flag Condition: 0x%02X, " 914 "Count: 0x%02X, Reg: 0x%08X\n", 915 offset, crtcport, crtcindex, mask, shift, 916 io_flag_condition_idx, count, reg); 917 918 config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift; 919 if (config > count) { 920 NV_ERROR(bios->dev, 921 "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n", 922 offset, config, count); 923 return 0; 924 } 925 926 freq = ROM16(bios->data[offset + 12 + config * 2]); 927 928 if (io_flag_condition_idx > 0) { 929 if (io_flag_condition_met(bios, offset, io_flag_condition_idx)) { 930 BIOSLOG(bios, "0x%04X: Condition fulfilled -- " 931 "frequency doubled\n", offset); 932 freq *= 2; 933 } else 934 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- " 935 "frequency unchanged\n", offset); 936 } 937 938 BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %d0kHz\n", 939 offset, reg, config, freq); 940 941 setPLL(bios, reg, freq * 10); 942 943 return len; 944} 945 946static int 947init_end_repeat(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 948{ 949 /* 950 * INIT_END_REPEAT opcode: 0x36 ('6') 951 * 952 * offset (8 bit): opcode 953 * 954 * Marks the end of the block for INIT_REPEAT to repeat 955 */ 956 957 /* no iexec->execute check by design */ 958 959 /* 960 * iexec->repeat flag necessary to go past INIT_END_REPEAT opcode when 961 * we're not in repeat mode 962 */ 963 if (iexec->repeat) 964 return 0; 965 966 return 1; 967} 968 969static int 970init_copy(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 971{ 972 /* 973 * INIT_COPY opcode: 0x37 ('7') 974 * 975 * offset (8 bit): opcode 976 * offset + 1 (32 bit): register 977 * offset + 5 (8 bit): shift 978 * offset + 6 (8 bit): srcmask 979 * offset + 7 (16 bit): CRTC port 980 * offset + 9 (8 bit): CRTC index 981 * offset + 10 (8 bit): mask 982 * 983 * Read index "CRTC index" on "CRTC port", AND with "mask", OR with 984 * (REGVAL("register") >> "shift" & "srcmask") and write-back to CRTC 985 * port 986 */ 987 988 uint32_t reg = ROM32(bios->data[offset + 1]); 989 uint8_t shift = bios->data[offset + 5]; 990 uint8_t srcmask = bios->data[offset + 6]; 991 uint16_t crtcport = ROM16(bios->data[offset + 7]); 992 uint8_t crtcindex = bios->data[offset + 9]; 993 uint8_t mask = bios->data[offset + 10]; 994 uint32_t data; 995 uint8_t crtcdata; 996 997 if (!iexec->execute) 998 return 11; 999 1000 BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Shift: 0x%02X, SrcMask: 0x%02X, " 1001 "Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X\n", 1002 offset, reg, shift, srcmask, crtcport, crtcindex, mask); 1003 1004 data = bios_rd32(bios, reg); 1005 1006 if (shift < 0x80) 1007 data >>= shift; 1008 else 1009 data <<= (0x100 - shift); 1010 1011 data &= srcmask; 1012 1013 crtcdata = bios_idxprt_rd(bios, crtcport, crtcindex) & mask; 1014 crtcdata |= (uint8_t)data; 1015 bios_idxprt_wr(bios, crtcport, crtcindex, crtcdata); 1016 1017 return 11; 1018} 1019 1020static int 1021init_not(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1022{ 1023 /* 1024 * INIT_NOT opcode: 0x38 ('8') 1025 * 1026 * offset (8 bit): opcode 1027 * 1028 * Invert the current execute / no-execute condition (i.e. "else") 1029 */ 1030 if (iexec->execute) 1031 BIOSLOG(bios, "0x%04X: ------ Skipping following commands ------\n", offset); 1032 else 1033 BIOSLOG(bios, "0x%04X: ------ Executing following commands ------\n", offset); 1034 1035 iexec->execute = !iexec->execute; 1036 return 1; 1037} 1038 1039static int 1040init_io_flag_condition(struct nvbios *bios, uint16_t offset, 1041 struct init_exec *iexec) 1042{ 1043 /* 1044 * INIT_IO_FLAG_CONDITION opcode: 0x39 ('9') 1045 * 1046 * offset (8 bit): opcode 1047 * offset + 1 (8 bit): condition number 1048 * 1049 * Check condition "condition number" in the IO flag condition table. 1050 * If condition not met skip subsequent opcodes until condition is 1051 * inverted (INIT_NOT), or we hit INIT_RESUME 1052 */ 1053 1054 uint8_t cond = bios->data[offset + 1]; 1055 1056 if (!iexec->execute) 1057 return 2; 1058 1059 if (io_flag_condition_met(bios, offset, cond)) 1060 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset); 1061 else { 1062 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset); 1063 iexec->execute = false; 1064 } 1065 1066 return 2; 1067} 1068 1069static int 1070init_idx_addr_latched(struct nvbios *bios, uint16_t offset, 1071 struct init_exec *iexec) 1072{ 1073 /* 1074 * INIT_INDEX_ADDRESS_LATCHED opcode: 0x49 ('I') 1075 * 1076 * offset (8 bit): opcode 1077 * offset + 1 (32 bit): control register 1078 * offset + 5 (32 bit): data register 1079 * offset + 9 (32 bit): mask 1080 * offset + 13 (32 bit): data 1081 * offset + 17 (8 bit): count 1082 * offset + 18 (8 bit): address 1 1083 * offset + 19 (8 bit): data 1 1084 * ... 1085 * 1086 * For each of "count" address and data pairs, write "data n" to 1087 * "data register", read the current value of "control register", 1088 * and write it back once ANDed with "mask", ORed with "data", 1089 * and ORed with "address n" 1090 */ 1091 1092 uint32_t controlreg = ROM32(bios->data[offset + 1]); 1093 uint32_t datareg = ROM32(bios->data[offset + 5]); 1094 uint32_t mask = ROM32(bios->data[offset + 9]); 1095 uint32_t data = ROM32(bios->data[offset + 13]); 1096 uint8_t count = bios->data[offset + 17]; 1097 int len = 18 + count * 2; 1098 uint32_t value; 1099 int i; 1100 1101 if (!iexec->execute) 1102 return len; 1103 1104 BIOSLOG(bios, "0x%04X: ControlReg: 0x%08X, DataReg: 0x%08X, " 1105 "Mask: 0x%08X, Data: 0x%08X, Count: 0x%02X\n", 1106 offset, controlreg, datareg, mask, data, count); 1107 1108 for (i = 0; i < count; i++) { 1109 uint8_t instaddress = bios->data[offset + 18 + i * 2]; 1110 uint8_t instdata = bios->data[offset + 19 + i * 2]; 1111 1112 BIOSLOG(bios, "0x%04X: Address: 0x%02X, Data: 0x%02X\n", 1113 offset, instaddress, instdata); 1114 1115 bios_wr32(bios, datareg, instdata); 1116 value = bios_rd32(bios, controlreg) & mask; 1117 value |= data; 1118 value |= instaddress; 1119 bios_wr32(bios, controlreg, value); 1120 } 1121 1122 return len; 1123} 1124 1125static int 1126init_io_restrict_pll2(struct nvbios *bios, uint16_t offset, 1127 struct init_exec *iexec) 1128{ 1129 /* 1130 * INIT_IO_RESTRICT_PLL2 opcode: 0x4A ('J') 1131 * 1132 * offset (8 bit): opcode 1133 * offset + 1 (16 bit): CRTC port 1134 * offset + 3 (8 bit): CRTC index 1135 * offset + 4 (8 bit): mask 1136 * offset + 5 (8 bit): shift 1137 * offset + 6 (8 bit): count 1138 * offset + 7 (32 bit): register 1139 * offset + 11 (32 bit): frequency 1 1140 * ... 1141 * 1142 * Starting at offset + 11 there are "count" 32 bit frequencies (kHz). 1143 * Set PLL register "register" to coefficients for frequency n, 1144 * selected by reading index "CRTC index" of "CRTC port" ANDed with 1145 * "mask" and shifted right by "shift". 1146 */ 1147 1148 uint16_t crtcport = ROM16(bios->data[offset + 1]); 1149 uint8_t crtcindex = bios->data[offset + 3]; 1150 uint8_t mask = bios->data[offset + 4]; 1151 uint8_t shift = bios->data[offset + 5]; 1152 uint8_t count = bios->data[offset + 6]; 1153 uint32_t reg = ROM32(bios->data[offset + 7]); 1154 int len = 11 + count * 4; 1155 uint8_t config; 1156 uint32_t freq; 1157 1158 if (!iexec->execute) 1159 return len; 1160 1161 BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, " 1162 "Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n", 1163 offset, crtcport, crtcindex, mask, shift, count, reg); 1164 1165 if (!reg) 1166 return len; 1167 1168 config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift; 1169 if (config > count) { 1170 NV_ERROR(bios->dev, 1171 "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n", 1172 offset, config, count); 1173 return 0; 1174 } 1175 1176 freq = ROM32(bios->data[offset + 11 + config * 4]); 1177 1178 BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %dkHz\n", 1179 offset, reg, config, freq); 1180 1181 setPLL(bios, reg, freq); 1182 1183 return len; 1184} 1185 1186static int 1187init_pll2(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1188{ 1189 /* 1190 * INIT_PLL2 opcode: 0x4B ('K') 1191 * 1192 * offset (8 bit): opcode 1193 * offset + 1 (32 bit): register 1194 * offset + 5 (32 bit): freq 1195 * 1196 * Set PLL register "register" to coefficients for frequency "freq" 1197 */ 1198 1199 uint32_t reg = ROM32(bios->data[offset + 1]); 1200 uint32_t freq = ROM32(bios->data[offset + 5]); 1201 1202 if (!iexec->execute) 1203 return 9; 1204 1205 BIOSLOG(bios, "0x%04X: Reg: 0x%04X, Freq: %dkHz\n", 1206 offset, reg, freq); 1207 1208 setPLL(bios, reg, freq); 1209 return 9; 1210} 1211 1212static int 1213init_i2c_byte(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1214{ 1215 /* 1216 * INIT_I2C_BYTE opcode: 0x4C ('L') 1217 * 1218 * offset (8 bit): opcode 1219 * offset + 1 (8 bit): DCB I2C table entry index 1220 * offset + 2 (8 bit): I2C slave address 1221 * offset + 3 (8 bit): count 1222 * offset + 4 (8 bit): I2C register 1 1223 * offset + 5 (8 bit): mask 1 1224 * offset + 6 (8 bit): data 1 1225 * ... 1226 * 1227 * For each of "count" registers given by "I2C register n" on the device 1228 * addressed by "I2C slave address" on the I2C bus given by 1229 * "DCB I2C table entry index", read the register, AND the result with 1230 * "mask n" and OR it with "data n" before writing it back to the device 1231 */ 1232 1233 uint8_t i2c_index = bios->data[offset + 1]; 1234 uint8_t i2c_address = bios->data[offset + 2]; 1235 uint8_t count = bios->data[offset + 3]; 1236 int len = 4 + count * 3; 1237 struct nouveau_i2c_chan *chan; 1238 struct i2c_msg msg; 1239 int i; 1240 1241 if (!iexec->execute) 1242 return len; 1243 1244 BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, " 1245 "Count: 0x%02X\n", 1246 offset, i2c_index, i2c_address, count); 1247 1248 chan = init_i2c_device_find(bios->dev, i2c_index); 1249 if (!chan) 1250 return 0; 1251 1252 for (i = 0; i < count; i++) { 1253 uint8_t i2c_reg = bios->data[offset + 4 + i * 3]; 1254 uint8_t mask = bios->data[offset + 5 + i * 3]; 1255 uint8_t data = bios->data[offset + 6 + i * 3]; 1256 uint8_t value; 1257 1258 msg.addr = i2c_address; 1259 msg.flags = I2C_M_RD; 1260 msg.len = 1; 1261 msg.buf = &value; 1262 if (i2c_transfer(&chan->adapter, &msg, 1) != 1) 1263 return 0; 1264 1265 BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Value: 0x%02X, " 1266 "Mask: 0x%02X, Data: 0x%02X\n", 1267 offset, i2c_reg, value, mask, data); 1268 1269 value = (value & mask) | data; 1270 1271 if (bios->execute) { 1272 msg.addr = i2c_address; 1273 msg.flags = 0; 1274 msg.len = 1; 1275 msg.buf = &value; 1276 if (i2c_transfer(&chan->adapter, &msg, 1) != 1) 1277 return 0; 1278 } 1279 } 1280 1281 return len; 1282} 1283 1284static int 1285init_zm_i2c_byte(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1286{ 1287 /* 1288 * INIT_ZM_I2C_BYTE opcode: 0x4D ('M') 1289 * 1290 * offset (8 bit): opcode 1291 * offset + 1 (8 bit): DCB I2C table entry index 1292 * offset + 2 (8 bit): I2C slave address 1293 * offset + 3 (8 bit): count 1294 * offset + 4 (8 bit): I2C register 1 1295 * offset + 5 (8 bit): data 1 1296 * ... 1297 * 1298 * For each of "count" registers given by "I2C register n" on the device 1299 * addressed by "I2C slave address" on the I2C bus given by 1300 * "DCB I2C table entry index", set the register to "data n" 1301 */ 1302 1303 uint8_t i2c_index = bios->data[offset + 1]; 1304 uint8_t i2c_address = bios->data[offset + 2]; 1305 uint8_t count = bios->data[offset + 3]; 1306 int len = 4 + count * 2; 1307 struct nouveau_i2c_chan *chan; 1308 struct i2c_msg msg; 1309 int i; 1310 1311 if (!iexec->execute) 1312 return len; 1313 1314 BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, " 1315 "Count: 0x%02X\n", 1316 offset, i2c_index, i2c_address, count); 1317 1318 chan = init_i2c_device_find(bios->dev, i2c_index); 1319 if (!chan) 1320 return 0; 1321 1322 for (i = 0; i < count; i++) { 1323 uint8_t i2c_reg = bios->data[offset + 4 + i * 2]; 1324 uint8_t data = bios->data[offset + 5 + i * 2]; 1325 1326 BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Data: 0x%02X\n", 1327 offset, i2c_reg, data); 1328 1329 if (bios->execute) { 1330 msg.addr = i2c_address; 1331 msg.flags = 0; 1332 msg.len = 1; 1333 msg.buf = &data; 1334 if (i2c_transfer(&chan->adapter, &msg, 1) != 1) 1335 return 0; 1336 } 1337 } 1338 1339 return len; 1340} 1341 1342static int 1343init_zm_i2c(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1344{ 1345 /* 1346 * INIT_ZM_I2C opcode: 0x4E ('N') 1347 * 1348 * offset (8 bit): opcode 1349 * offset + 1 (8 bit): DCB I2C table entry index 1350 * offset + 2 (8 bit): I2C slave address 1351 * offset + 3 (8 bit): count 1352 * offset + 4 (8 bit): data 1 1353 * ... 1354 * 1355 * Send "count" bytes ("data n") to the device addressed by "I2C slave 1356 * address" on the I2C bus given by "DCB I2C table entry index" 1357 */ 1358 1359 uint8_t i2c_index = bios->data[offset + 1]; 1360 uint8_t i2c_address = bios->data[offset + 2]; 1361 uint8_t count = bios->data[offset + 3]; 1362 int len = 4 + count; 1363 struct nouveau_i2c_chan *chan; 1364 struct i2c_msg msg; 1365 uint8_t data[256]; 1366 int i; 1367 1368 if (!iexec->execute) 1369 return len; 1370 1371 BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, " 1372 "Count: 0x%02X\n", 1373 offset, i2c_index, i2c_address, count); 1374 1375 chan = init_i2c_device_find(bios->dev, i2c_index); 1376 if (!chan) 1377 return 0; 1378 1379 for (i = 0; i < count; i++) { 1380 data[i] = bios->data[offset + 4 + i]; 1381 1382 BIOSLOG(bios, "0x%04X: Data: 0x%02X\n", offset, data[i]); 1383 } 1384 1385 if (bios->execute) { 1386 msg.addr = i2c_address; 1387 msg.flags = 0; 1388 msg.len = count; 1389 msg.buf = data; 1390 if (i2c_transfer(&chan->adapter, &msg, 1) != 1) 1391 return 0; 1392 } 1393 1394 return len; 1395} 1396 1397static int 1398init_tmds(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1399{ 1400 /* 1401 * INIT_TMDS opcode: 0x4F ('O') (non-canon name) 1402 * 1403 * offset (8 bit): opcode 1404 * offset + 1 (8 bit): magic lookup value 1405 * offset + 2 (8 bit): TMDS address 1406 * offset + 3 (8 bit): mask 1407 * offset + 4 (8 bit): data 1408 * 1409 * Read the data reg for TMDS address "TMDS address", AND it with mask 1410 * and OR it with data, then write it back 1411 * "magic lookup value" determines which TMDS base address register is 1412 * used -- see get_tmds_index_reg() 1413 */ 1414 1415 uint8_t mlv = bios->data[offset + 1]; 1416 uint32_t tmdsaddr = bios->data[offset + 2]; 1417 uint8_t mask = bios->data[offset + 3]; 1418 uint8_t data = bios->data[offset + 4]; 1419 uint32_t reg, value; 1420 1421 if (!iexec->execute) 1422 return 5; 1423 1424 BIOSLOG(bios, "0x%04X: MagicLookupValue: 0x%02X, TMDSAddr: 0x%02X, " 1425 "Mask: 0x%02X, Data: 0x%02X\n", 1426 offset, mlv, tmdsaddr, mask, data); 1427 1428 reg = get_tmds_index_reg(bios->dev, mlv); 1429 if (!reg) 1430 return 0; 1431 1432 bios_wr32(bios, reg, 1433 tmdsaddr | NV_PRAMDAC_FP_TMDS_CONTROL_WRITE_DISABLE); 1434 value = (bios_rd32(bios, reg + 4) & mask) | data; 1435 bios_wr32(bios, reg + 4, value); 1436 bios_wr32(bios, reg, tmdsaddr); 1437 1438 return 5; 1439} 1440 1441static int 1442init_zm_tmds_group(struct nvbios *bios, uint16_t offset, 1443 struct init_exec *iexec) 1444{ 1445 /* 1446 * INIT_ZM_TMDS_GROUP opcode: 0x50 ('P') (non-canon name) 1447 * 1448 * offset (8 bit): opcode 1449 * offset + 1 (8 bit): magic lookup value 1450 * offset + 2 (8 bit): count 1451 * offset + 3 (8 bit): addr 1 1452 * offset + 4 (8 bit): data 1 1453 * ... 1454 * 1455 * For each of "count" TMDS address and data pairs write "data n" to 1456 * "addr n". "magic lookup value" determines which TMDS base address 1457 * register is used -- see get_tmds_index_reg() 1458 */ 1459 1460 uint8_t mlv = bios->data[offset + 1]; 1461 uint8_t count = bios->data[offset + 2]; 1462 int len = 3 + count * 2; 1463 uint32_t reg; 1464 int i; 1465 1466 if (!iexec->execute) 1467 return len; 1468 1469 BIOSLOG(bios, "0x%04X: MagicLookupValue: 0x%02X, Count: 0x%02X\n", 1470 offset, mlv, count); 1471 1472 reg = get_tmds_index_reg(bios->dev, mlv); 1473 if (!reg) 1474 return 0; 1475 1476 for (i = 0; i < count; i++) { 1477 uint8_t tmdsaddr = bios->data[offset + 3 + i * 2]; 1478 uint8_t tmdsdata = bios->data[offset + 4 + i * 2]; 1479 1480 bios_wr32(bios, reg + 4, tmdsdata); 1481 bios_wr32(bios, reg, tmdsaddr); 1482 } 1483 1484 return len; 1485} 1486 1487static int 1488init_cr_idx_adr_latch(struct nvbios *bios, uint16_t offset, 1489 struct init_exec *iexec) 1490{ 1491 /* 1492 * INIT_CR_INDEX_ADDRESS_LATCHED opcode: 0x51 ('Q') 1493 * 1494 * offset (8 bit): opcode 1495 * offset + 1 (8 bit): CRTC index1 1496 * offset + 2 (8 bit): CRTC index2 1497 * offset + 3 (8 bit): baseaddr 1498 * offset + 4 (8 bit): count 1499 * offset + 5 (8 bit): data 1 1500 * ... 1501 * 1502 * For each of "count" address and data pairs, write "baseaddr + n" to 1503 * "CRTC index1" and "data n" to "CRTC index2" 1504 * Once complete, restore initial value read from "CRTC index1" 1505 */ 1506 uint8_t crtcindex1 = bios->data[offset + 1]; 1507 uint8_t crtcindex2 = bios->data[offset + 2]; 1508 uint8_t baseaddr = bios->data[offset + 3]; 1509 uint8_t count = bios->data[offset + 4]; 1510 int len = 5 + count; 1511 uint8_t oldaddr, data; 1512 int i; 1513 1514 if (!iexec->execute) 1515 return len; 1516 1517 BIOSLOG(bios, "0x%04X: Index1: 0x%02X, Index2: 0x%02X, " 1518 "BaseAddr: 0x%02X, Count: 0x%02X\n", 1519 offset, crtcindex1, crtcindex2, baseaddr, count); 1520 1521 oldaddr = bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, crtcindex1); 1522 1523 for (i = 0; i < count; i++) { 1524 bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex1, 1525 baseaddr + i); 1526 data = bios->data[offset + 5 + i]; 1527 bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex2, data); 1528 } 1529 1530 bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex1, oldaddr); 1531 1532 return len; 1533} 1534 1535static int 1536init_cr(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1537{ 1538 /* 1539 * INIT_CR opcode: 0x52 ('R') 1540 * 1541 * offset (8 bit): opcode 1542 * offset + 1 (8 bit): CRTC index 1543 * offset + 2 (8 bit): mask 1544 * offset + 3 (8 bit): data 1545 * 1546 * Assign the value of at "CRTC index" ANDed with mask and ORed with 1547 * data back to "CRTC index" 1548 */ 1549 1550 uint8_t crtcindex = bios->data[offset + 1]; 1551 uint8_t mask = bios->data[offset + 2]; 1552 uint8_t data = bios->data[offset + 3]; 1553 uint8_t value; 1554 1555 if (!iexec->execute) 1556 return 4; 1557 1558 BIOSLOG(bios, "0x%04X: Index: 0x%02X, Mask: 0x%02X, Data: 0x%02X\n", 1559 offset, crtcindex, mask, data); 1560 1561 value = bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, crtcindex) & mask; 1562 value |= data; 1563 bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex, value); 1564 1565 return 4; 1566} 1567 1568static int 1569init_zm_cr(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1570{ 1571 /* 1572 * INIT_ZM_CR opcode: 0x53 ('S') 1573 * 1574 * offset (8 bit): opcode 1575 * offset + 1 (8 bit): CRTC index 1576 * offset + 2 (8 bit): value 1577 * 1578 * Assign "value" to CRTC register with index "CRTC index". 1579 */ 1580 1581 uint8_t crtcindex = ROM32(bios->data[offset + 1]); 1582 uint8_t data = bios->data[offset + 2]; 1583 1584 if (!iexec->execute) 1585 return 3; 1586 1587 bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex, data); 1588 1589 return 3; 1590} 1591 1592static int 1593init_zm_cr_group(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1594{ 1595 /* 1596 * INIT_ZM_CR_GROUP opcode: 0x54 ('T') 1597 * 1598 * offset (8 bit): opcode 1599 * offset + 1 (8 bit): count 1600 * offset + 2 (8 bit): CRTC index 1 1601 * offset + 3 (8 bit): value 1 1602 * ... 1603 * 1604 * For "count", assign "value n" to CRTC register with index 1605 * "CRTC index n". 1606 */ 1607 1608 uint8_t count = bios->data[offset + 1]; 1609 int len = 2 + count * 2; 1610 int i; 1611 1612 if (!iexec->execute) 1613 return len; 1614 1615 for (i = 0; i < count; i++) 1616 init_zm_cr(bios, offset + 2 + 2 * i - 1, iexec); 1617 1618 return len; 1619} 1620 1621static int 1622init_condition_time(struct nvbios *bios, uint16_t offset, 1623 struct init_exec *iexec) 1624{ 1625 /* 1626 * INIT_CONDITION_TIME opcode: 0x56 ('V') 1627 * 1628 * offset (8 bit): opcode 1629 * offset + 1 (8 bit): condition number 1630 * offset + 2 (8 bit): retries / 50 1631 * 1632 * Check condition "condition number" in the condition table. 1633 * Bios code then sleeps for 2ms if the condition is not met, and 1634 * repeats up to "retries" times, but on one C51 this has proved 1635 * insufficient. In mmiotraces the driver sleeps for 20ms, so we do 1636 * this, and bail after "retries" times, or 2s, whichever is less. 1637 * If still not met after retries, clear execution flag for this table. 1638 */ 1639 1640 uint8_t cond = bios->data[offset + 1]; 1641 uint16_t retries = bios->data[offset + 2] * 50; 1642 unsigned cnt; 1643 1644 if (!iexec->execute) 1645 return 3; 1646 1647 if (retries > 100) 1648 retries = 100; 1649 1650 BIOSLOG(bios, "0x%04X: Condition: 0x%02X, Retries: 0x%02X\n", 1651 offset, cond, retries); 1652 1653 if (!bios->execute) /* avoid 2s delays when "faking" execution */ 1654 retries = 1; 1655 1656 for (cnt = 0; cnt < retries; cnt++) { 1657 if (bios_condition_met(bios, offset, cond)) { 1658 BIOSLOG(bios, "0x%04X: Condition met, continuing\n", 1659 offset); 1660 break; 1661 } else { 1662 BIOSLOG(bios, "0x%04X: " 1663 "Condition not met, sleeping for 20ms\n", 1664 offset); 1665 msleep(20); 1666 } 1667 } 1668 1669 if (!bios_condition_met(bios, offset, cond)) { 1670 NV_WARN(bios->dev, 1671 "0x%04X: Condition still not met after %dms, " 1672 "skipping following opcodes\n", offset, 20 * retries); 1673 iexec->execute = false; 1674 } 1675 1676 return 3; 1677} 1678 1679static int 1680init_zm_reg_sequence(struct nvbios *bios, uint16_t offset, 1681 struct init_exec *iexec) 1682{ 1683 /* 1684 * INIT_ZM_REG_SEQUENCE opcode: 0x58 ('X') 1685 * 1686 * offset (8 bit): opcode 1687 * offset + 1 (32 bit): base register 1688 * offset + 5 (8 bit): count 1689 * offset + 6 (32 bit): value 1 1690 * ... 1691 * 1692 * Starting at offset + 6 there are "count" 32 bit values. 1693 * For "count" iterations set "base register" + 4 * current_iteration 1694 * to "value current_iteration" 1695 */ 1696 1697 uint32_t basereg = ROM32(bios->data[offset + 1]); 1698 uint32_t count = bios->data[offset + 5]; 1699 int len = 6 + count * 4; 1700 int i; 1701 1702 if (!iexec->execute) 1703 return len; 1704 1705 BIOSLOG(bios, "0x%04X: BaseReg: 0x%08X, Count: 0x%02X\n", 1706 offset, basereg, count); 1707 1708 for (i = 0; i < count; i++) { 1709 uint32_t reg = basereg + i * 4; 1710 uint32_t data = ROM32(bios->data[offset + 6 + i * 4]); 1711 1712 bios_wr32(bios, reg, data); 1713 } 1714 1715 return len; 1716} 1717 1718static int 1719init_sub_direct(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1720{ 1721 /* 1722 * INIT_SUB_DIRECT opcode: 0x5B ('[') 1723 * 1724 * offset (8 bit): opcode 1725 * offset + 1 (16 bit): subroutine offset (in bios) 1726 * 1727 * Calls a subroutine that will execute commands until INIT_DONE 1728 * is found. 1729 */ 1730 1731 uint16_t sub_offset = ROM16(bios->data[offset + 1]); 1732 1733 if (!iexec->execute) 1734 return 3; 1735 1736 BIOSLOG(bios, "0x%04X: Executing subroutine at 0x%04X\n", 1737 offset, sub_offset); 1738 1739 parse_init_table(bios, sub_offset, iexec); 1740 1741 BIOSLOG(bios, "0x%04X: End of 0x%04X subroutine\n", offset, sub_offset); 1742 1743 return 3; 1744} 1745 1746static int 1747init_copy_nv_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1748{ 1749 /* 1750 * INIT_COPY_NV_REG opcode: 0x5F ('_') 1751 * 1752 * offset (8 bit): opcode 1753 * offset + 1 (32 bit): src reg 1754 * offset + 5 (8 bit): shift 1755 * offset + 6 (32 bit): src mask 1756 * offset + 10 (32 bit): xor 1757 * offset + 14 (32 bit): dst reg 1758 * offset + 18 (32 bit): dst mask 1759 * 1760 * Shift REGVAL("src reg") right by (signed) "shift", AND result with 1761 * "src mask", then XOR with "xor". Write this OR'd with 1762 * (REGVAL("dst reg") AND'd with "dst mask") to "dst reg" 1763 */ 1764 1765 uint32_t srcreg = *((uint32_t *)(&bios->data[offset + 1])); 1766 uint8_t shift = bios->data[offset + 5]; 1767 uint32_t srcmask = *((uint32_t *)(&bios->data[offset + 6])); 1768 uint32_t xor = *((uint32_t *)(&bios->data[offset + 10])); 1769 uint32_t dstreg = *((uint32_t *)(&bios->data[offset + 14])); 1770 uint32_t dstmask = *((uint32_t *)(&bios->data[offset + 18])); 1771 uint32_t srcvalue, dstvalue; 1772 1773 if (!iexec->execute) 1774 return 22; 1775 1776 BIOSLOG(bios, "0x%04X: SrcReg: 0x%08X, Shift: 0x%02X, SrcMask: 0x%08X, " 1777 "Xor: 0x%08X, DstReg: 0x%08X, DstMask: 0x%08X\n", 1778 offset, srcreg, shift, srcmask, xor, dstreg, dstmask); 1779 1780 srcvalue = bios_rd32(bios, srcreg); 1781 1782 if (shift < 0x80) 1783 srcvalue >>= shift; 1784 else 1785 srcvalue <<= (0x100 - shift); 1786 1787 srcvalue = (srcvalue & srcmask) ^ xor; 1788 1789 dstvalue = bios_rd32(bios, dstreg) & dstmask; 1790 1791 bios_wr32(bios, dstreg, dstvalue | srcvalue); 1792 1793 return 22; 1794} 1795 1796static int 1797init_zm_index_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1798{ 1799 /* 1800 * INIT_ZM_INDEX_IO opcode: 0x62 ('b') 1801 * 1802 * offset (8 bit): opcode 1803 * offset + 1 (16 bit): CRTC port 1804 * offset + 3 (8 bit): CRTC index 1805 * offset + 4 (8 bit): data 1806 * 1807 * Write "data" to index "CRTC index" of "CRTC port" 1808 */ 1809 uint16_t crtcport = ROM16(bios->data[offset + 1]); 1810 uint8_t crtcindex = bios->data[offset + 3]; 1811 uint8_t data = bios->data[offset + 4]; 1812 1813 if (!iexec->execute) 1814 return 5; 1815 1816 bios_idxprt_wr(bios, crtcport, crtcindex, data); 1817 1818 return 5; 1819} 1820 1821static int 1822init_compute_mem(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1823{ 1824 /* 1825 * INIT_COMPUTE_MEM opcode: 0x63 ('c') 1826 * 1827 * offset (8 bit): opcode 1828 * 1829 * This opcode is meant to set NV_PFB_CFG0 (0x100200) appropriately so 1830 * that the hardware can correctly calculate how much VRAM it has 1831 * (and subsequently report that value in NV_PFB_CSTATUS (0x10020C)) 1832 * 1833 * The implementation of this opcode in general consists of two parts: 1834 * 1) determination of the memory bus width 1835 * 2) determination of how many of the card's RAM pads have ICs attached 1836 * 1837 * 1) is done by a cunning combination of writes to offsets 0x1c and 1838 * 0x3c in the framebuffer, and seeing whether the written values are 1839 * read back correctly. This then affects bits 4-7 of NV_PFB_CFG0 1840 * 1841 * 2) is done by a cunning combination of writes to an offset slightly 1842 * less than the maximum memory reported by NV_PFB_CSTATUS, then seeing 1843 * if the test pattern can be read back. This then affects bits 12-15 of 1844 * NV_PFB_CFG0 1845 * 1846 * In this context a "cunning combination" may include multiple reads 1847 * and writes to varying locations, often alternating the test pattern 1848 * and 0, doubtless to make sure buffers are filled, residual charges 1849 * on tracks are removed etc. 1850 * 1851 * Unfortunately, the "cunning combination"s mentioned above, and the 1852 * changes to the bits in NV_PFB_CFG0 differ with nearly every bios 1853 * trace I have. 1854 * 1855 * Therefore, we cheat and assume the value of NV_PFB_CFG0 with which 1856 * we started was correct, and use that instead 1857 */ 1858 1859 /* no iexec->execute check by design */ 1860 1861 /* 1862 * This appears to be a NOP on G8x chipsets, both io logs of the VBIOS 1863 * and kmmio traces of the binary driver POSTing the card show nothing 1864 * being done for this opcode. why is it still listed in the table?! 1865 */ 1866 1867 struct drm_nouveau_private *dev_priv = bios->dev->dev_private; 1868 1869 if (dev_priv->card_type >= NV_40) 1870 return 1; 1871 1872 /* 1873 * On every card I've seen, this step gets done for us earlier in 1874 * the init scripts 1875 uint8_t crdata = bios_idxprt_rd(dev, NV_VIO_SRX, 0x01); 1876 bios_idxprt_wr(dev, NV_VIO_SRX, 0x01, crdata | 0x20); 1877 */ 1878 1879 /* 1880 * This also has probably been done in the scripts, but an mmio trace of 1881 * s3 resume shows nvidia doing it anyway (unlike the NV_VIO_SRX write) 1882 */ 1883 bios_wr32(bios, NV_PFB_REFCTRL, NV_PFB_REFCTRL_VALID_1); 1884 1885 /* write back the saved configuration value */ 1886 bios_wr32(bios, NV_PFB_CFG0, bios->state.saved_nv_pfb_cfg0); 1887 1888 return 1; 1889} 1890 1891static int 1892init_reset(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 1893{ 1894 /* 1895 * INIT_RESET opcode: 0x65 ('e') 1896 * 1897 * offset (8 bit): opcode 1898 * offset + 1 (32 bit): register 1899 * offset + 5 (32 bit): value1 1900 * offset + 9 (32 bit): value2 1901 * 1902 * Assign "value1" to "register", then assign "value2" to "register" 1903 */ 1904 1905 uint32_t reg = ROM32(bios->data[offset + 1]); 1906 uint32_t value1 = ROM32(bios->data[offset + 5]); 1907 uint32_t value2 = ROM32(bios->data[offset + 9]); 1908 uint32_t pci_nv_19, pci_nv_20; 1909 1910 /* no iexec->execute check by design */ 1911 1912 pci_nv_19 = bios_rd32(bios, NV_PBUS_PCI_NV_19); 1913 bios_wr32(bios, NV_PBUS_PCI_NV_19, 0); 1914 bios_wr32(bios, reg, value1); 1915 1916 udelay(10); 1917 1918 bios_wr32(bios, reg, value2); 1919 bios_wr32(bios, NV_PBUS_PCI_NV_19, pci_nv_19); 1920 1921 pci_nv_20 = bios_rd32(bios, NV_PBUS_PCI_NV_20); 1922 pci_nv_20 &= ~NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED; /* 0xfffffffe */ 1923 bios_wr32(bios, NV_PBUS_PCI_NV_20, pci_nv_20); 1924 1925 return 13; 1926} 1927 1928static int 1929init_configure_mem(struct nvbios *bios, uint16_t offset, 1930 struct init_exec *iexec) 1931{ 1932 /* 1933 * INIT_CONFIGURE_MEM opcode: 0x66 ('f') 1934 * 1935 * offset (8 bit): opcode 1936 * 1937 * Equivalent to INIT_DONE on bios version 3 or greater. 1938 * For early bios versions, sets up the memory registers, using values 1939 * taken from the memory init table 1940 */ 1941 1942 /* no iexec->execute check by design */ 1943 1944 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); 1945 uint16_t seqtbloffs = bios->legacy.sdr_seq_tbl_ptr, meminitdata = meminitoffs + 6; 1946 uint32_t reg, data; 1947 1948 if (bios->major_version > 2) 1949 return 0; 1950 1951 bios_idxprt_wr(bios, NV_VIO_SRX, NV_VIO_SR_CLOCK_INDEX, bios_idxprt_rd( 1952 bios, NV_VIO_SRX, NV_VIO_SR_CLOCK_INDEX) | 0x20); 1953 1954 if (bios->data[meminitoffs] & 1) 1955 seqtbloffs = bios->legacy.ddr_seq_tbl_ptr; 1956 1957 for (reg = ROM32(bios->data[seqtbloffs]); 1958 reg != 0xffffffff; 1959 reg = ROM32(bios->data[seqtbloffs += 4])) { 1960 1961 switch (reg) { 1962 case NV_PFB_PRE: 1963 data = NV_PFB_PRE_CMD_PRECHARGE; 1964 break; 1965 case NV_PFB_PAD: 1966 data = NV_PFB_PAD_CKE_NORMAL; 1967 break; 1968 case NV_PFB_REF: 1969 data = NV_PFB_REF_CMD_REFRESH; 1970 break; 1971 default: 1972 data = ROM32(bios->data[meminitdata]); 1973 meminitdata += 4; 1974 if (data == 0xffffffff) 1975 continue; 1976 } 1977 1978 bios_wr32(bios, reg, data); 1979 } 1980 1981 return 1; 1982} 1983 1984static int 1985init_configure_clk(struct nvbios *bios, uint16_t offset, 1986 struct init_exec *iexec) 1987{ 1988 /* 1989 * INIT_CONFIGURE_CLK opcode: 0x67 ('g') 1990 * 1991 * offset (8 bit): opcode 1992 * 1993 * Equivalent to INIT_DONE on bios version 3 or greater. 1994 * For early bios versions, sets up the NVClk and MClk PLLs, using 1995 * values taken from the memory init table 1996 */ 1997 1998 /* no iexec->execute check by design */ 1999 2000 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); 2001 int clock; 2002 2003 if (bios->major_version > 2) 2004 return 0; 2005 2006 clock = ROM16(bios->data[meminitoffs + 4]) * 10; 2007 setPLL(bios, NV_PRAMDAC_NVPLL_COEFF, clock); 2008 2009 clock = ROM16(bios->data[meminitoffs + 2]) * 10; 2010 if (bios->data[meminitoffs] & 1) /* DDR */ 2011 clock *= 2; 2012 setPLL(bios, NV_PRAMDAC_MPLL_COEFF, clock); 2013 2014 return 1; 2015} 2016 2017static int 2018init_configure_preinit(struct nvbios *bios, uint16_t offset, 2019 struct init_exec *iexec) 2020{ 2021 /* 2022 * INIT_CONFIGURE_PREINIT opcode: 0x68 ('h') 2023 * 2024 * offset (8 bit): opcode 2025 * 2026 * Equivalent to INIT_DONE on bios version 3 or greater. 2027 * For early bios versions, does early init, loading ram and crystal 2028 * configuration from straps into CR3C 2029 */ 2030 2031 /* no iexec->execute check by design */ 2032 2033 uint32_t straps = bios_rd32(bios, NV_PEXTDEV_BOOT_0); 2034 uint8_t cr3c = ((straps << 2) & 0xf0) | (straps & (1 << 6)); 2035 2036 if (bios->major_version > 2) 2037 return 0; 2038 2039 bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, 2040 NV_CIO_CRE_SCRATCH4__INDEX, cr3c); 2041 2042 return 1; 2043} 2044 2045static int 2046init_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2047{ 2048 /* 2049 * INIT_IO opcode: 0x69 ('i') 2050 * 2051 * offset (8 bit): opcode 2052 * offset + 1 (16 bit): CRTC port 2053 * offset + 3 (8 bit): mask 2054 * offset + 4 (8 bit): data 2055 * 2056 * Assign ((IOVAL("crtc port") & "mask") | "data") to "crtc port" 2057 */ 2058 2059 struct drm_nouveau_private *dev_priv = bios->dev->dev_private; 2060 uint16_t crtcport = ROM16(bios->data[offset + 1]); 2061 uint8_t mask = bios->data[offset + 3]; 2062 uint8_t data = bios->data[offset + 4]; 2063 2064 if (!iexec->execute) 2065 return 5; 2066 2067 BIOSLOG(bios, "0x%04X: Port: 0x%04X, Mask: 0x%02X, Data: 0x%02X\n", 2068 offset, crtcport, mask, data); 2069 2070 /* 2071 * I have no idea what this does, but NVIDIA do this magic sequence 2072 * in the places where this INIT_IO happens.. 2073 */ 2074 if (dev_priv->card_type >= NV_50 && crtcport == 0x3c3 && data == 1) { 2075 int i; 2076 2077 bios_wr32(bios, 0x614100, (bios_rd32( 2078 bios, 0x614100) & 0x0fffffff) | 0x00800000); 2079 2080 bios_wr32(bios, 0x00e18c, bios_rd32( 2081 bios, 0x00e18c) | 0x00020000); 2082 2083 bios_wr32(bios, 0x614900, (bios_rd32( 2084 bios, 0x614900) & 0x0fffffff) | 0x00800000); 2085 2086 bios_wr32(bios, 0x000200, bios_rd32( 2087 bios, 0x000200) & ~0x40000000); 2088 2089 mdelay(10); 2090 2091 bios_wr32(bios, 0x00e18c, bios_rd32( 2092 bios, 0x00e18c) & ~0x00020000); 2093 2094 bios_wr32(bios, 0x000200, bios_rd32( 2095 bios, 0x000200) | 0x40000000); 2096 2097 bios_wr32(bios, 0x614100, 0x00800018); 2098 bios_wr32(bios, 0x614900, 0x00800018); 2099 2100 mdelay(10); 2101 2102 bios_wr32(bios, 0x614100, 0x10000018); 2103 bios_wr32(bios, 0x614900, 0x10000018); 2104 2105 for (i = 0; i < 3; i++) 2106 bios_wr32(bios, 0x614280 + (i*0x800), bios_rd32( 2107 bios, 0x614280 + (i*0x800)) & 0xf0f0f0f0); 2108 2109 for (i = 0; i < 2; i++) 2110 bios_wr32(bios, 0x614300 + (i*0x800), bios_rd32( 2111 bios, 0x614300 + (i*0x800)) & 0xfffff0f0); 2112 2113 for (i = 0; i < 3; i++) 2114 bios_wr32(bios, 0x614380 + (i*0x800), bios_rd32( 2115 bios, 0x614380 + (i*0x800)) & 0xfffff0f0); 2116 2117 for (i = 0; i < 2; i++) 2118 bios_wr32(bios, 0x614200 + (i*0x800), bios_rd32( 2119 bios, 0x614200 + (i*0x800)) & 0xfffffff0); 2120 2121 for (i = 0; i < 2; i++) 2122 bios_wr32(bios, 0x614108 + (i*0x800), bios_rd32( 2123 bios, 0x614108 + (i*0x800)) & 0x0fffffff); 2124 return 5; 2125 } 2126 2127 bios_port_wr(bios, crtcport, (bios_port_rd(bios, crtcport) & mask) | 2128 data); 2129 return 5; 2130} 2131 2132static int 2133init_sub(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2134{ 2135 /* 2136 * INIT_SUB opcode: 0x6B ('k') 2137 * 2138 * offset (8 bit): opcode 2139 * offset + 1 (8 bit): script number 2140 * 2141 * Execute script number "script number", as a subroutine 2142 */ 2143 2144 uint8_t sub = bios->data[offset + 1]; 2145 2146 if (!iexec->execute) 2147 return 2; 2148 2149 BIOSLOG(bios, "0x%04X: Calling script %d\n", offset, sub); 2150 2151 parse_init_table(bios, 2152 ROM16(bios->data[bios->init_script_tbls_ptr + sub * 2]), 2153 iexec); 2154 2155 BIOSLOG(bios, "0x%04X: End of script %d\n", offset, sub); 2156 2157 return 2; 2158} 2159 2160static int 2161init_ram_condition(struct nvbios *bios, uint16_t offset, 2162 struct init_exec *iexec) 2163{ 2164 /* 2165 * INIT_RAM_CONDITION opcode: 0x6D ('m') 2166 * 2167 * offset (8 bit): opcode 2168 * offset + 1 (8 bit): mask 2169 * offset + 2 (8 bit): cmpval 2170 * 2171 * Test if (NV_PFB_BOOT_0 & "mask") equals "cmpval". 2172 * If condition not met skip subsequent opcodes until condition is 2173 * inverted (INIT_NOT), or we hit INIT_RESUME 2174 */ 2175 2176 uint8_t mask = bios->data[offset + 1]; 2177 uint8_t cmpval = bios->data[offset + 2]; 2178 uint8_t data; 2179 2180 if (!iexec->execute) 2181 return 3; 2182 2183 data = bios_rd32(bios, NV_PFB_BOOT_0) & mask; 2184 2185 BIOSLOG(bios, "0x%04X: Checking if 0x%08X equals 0x%08X\n", 2186 offset, data, cmpval); 2187 2188 if (data == cmpval) 2189 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset); 2190 else { 2191 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset); 2192 iexec->execute = false; 2193 } 2194 2195 return 3; 2196} 2197 2198static int 2199init_nv_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2200{ 2201 /* 2202 * INIT_NV_REG opcode: 0x6E ('n') 2203 * 2204 * offset (8 bit): opcode 2205 * offset + 1 (32 bit): register 2206 * offset + 5 (32 bit): mask 2207 * offset + 9 (32 bit): data 2208 * 2209 * Assign ((REGVAL("register") & "mask") | "data") to "register" 2210 */ 2211 2212 uint32_t reg = ROM32(bios->data[offset + 1]); 2213 uint32_t mask = ROM32(bios->data[offset + 5]); 2214 uint32_t data = ROM32(bios->data[offset + 9]); 2215 2216 if (!iexec->execute) 2217 return 13; 2218 2219 BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Mask: 0x%08X, Data: 0x%08X\n", 2220 offset, reg, mask, data); 2221 2222 bios_wr32(bios, reg, (bios_rd32(bios, reg) & mask) | data); 2223 2224 return 13; 2225} 2226 2227static int 2228init_macro(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2229{ 2230 /* 2231 * INIT_MACRO opcode: 0x6F ('o') 2232 * 2233 * offset (8 bit): opcode 2234 * offset + 1 (8 bit): macro number 2235 * 2236 * Look up macro index "macro number" in the macro index table. 2237 * The macro index table entry has 1 byte for the index in the macro 2238 * table, and 1 byte for the number of times to repeat the macro. 2239 * The macro table entry has 4 bytes for the register address and 2240 * 4 bytes for the value to write to that register 2241 */ 2242 2243 uint8_t macro_index_tbl_idx = bios->data[offset + 1]; 2244 uint16_t tmp = bios->macro_index_tbl_ptr + (macro_index_tbl_idx * MACRO_INDEX_SIZE); 2245 uint8_t macro_tbl_idx = bios->data[tmp]; 2246 uint8_t count = bios->data[tmp + 1]; 2247 uint32_t reg, data; 2248 int i; 2249 2250 if (!iexec->execute) 2251 return 2; 2252 2253 BIOSLOG(bios, "0x%04X: Macro: 0x%02X, MacroTableIndex: 0x%02X, " 2254 "Count: 0x%02X\n", 2255 offset, macro_index_tbl_idx, macro_tbl_idx, count); 2256 2257 for (i = 0; i < count; i++) { 2258 uint16_t macroentryptr = bios->macro_tbl_ptr + (macro_tbl_idx + i) * MACRO_SIZE; 2259 2260 reg = ROM32(bios->data[macroentryptr]); 2261 data = ROM32(bios->data[macroentryptr + 4]); 2262 2263 bios_wr32(bios, reg, data); 2264 } 2265 2266 return 2; 2267} 2268 2269static int 2270init_done(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2271{ 2272 /* 2273 * INIT_DONE opcode: 0x71 ('q') 2274 * 2275 * offset (8 bit): opcode 2276 * 2277 * End the current script 2278 */ 2279 2280 /* mild retval abuse to stop parsing this table */ 2281 return 0; 2282} 2283 2284static int 2285init_resume(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2286{ 2287 /* 2288 * INIT_RESUME opcode: 0x72 ('r') 2289 * 2290 * offset (8 bit): opcode 2291 * 2292 * End the current execute / no-execute condition 2293 */ 2294 2295 if (iexec->execute) 2296 return 1; 2297 2298 iexec->execute = true; 2299 BIOSLOG(bios, "0x%04X: ---- Executing following commands ----\n", offset); 2300 2301 return 1; 2302} 2303 2304static int 2305init_time(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2306{ 2307 /* 2308 * INIT_TIME opcode: 0x74 ('t') 2309 * 2310 * offset (8 bit): opcode 2311 * offset + 1 (16 bit): time 2312 * 2313 * Sleep for "time" microseconds. 2314 */ 2315 2316 unsigned time = ROM16(bios->data[offset + 1]); 2317 2318 if (!iexec->execute) 2319 return 3; 2320 2321 BIOSLOG(bios, "0x%04X: Sleeping for 0x%04X microseconds\n", 2322 offset, time); 2323 2324 if (time < 1000) 2325 udelay(time); 2326 else 2327 msleep((time + 900) / 1000); 2328 2329 return 3; 2330} 2331 2332static int 2333init_condition(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2334{ 2335 /* 2336 * INIT_CONDITION opcode: 0x75 ('u') 2337 * 2338 * offset (8 bit): opcode 2339 * offset + 1 (8 bit): condition number 2340 * 2341 * Check condition "condition number" in the condition table. 2342 * If condition not met skip subsequent opcodes until condition is 2343 * inverted (INIT_NOT), or we hit INIT_RESUME 2344 */ 2345 2346 uint8_t cond = bios->data[offset + 1]; 2347 2348 if (!iexec->execute) 2349 return 2; 2350 2351 BIOSLOG(bios, "0x%04X: Condition: 0x%02X\n", offset, cond); 2352 2353 if (bios_condition_met(bios, offset, cond)) 2354 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset); 2355 else { 2356 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset); 2357 iexec->execute = false; 2358 } 2359 2360 return 2; 2361} 2362 2363static int 2364init_io_condition(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2365{ 2366 /* 2367 * INIT_IO_CONDITION opcode: 0x76 2368 * 2369 * offset (8 bit): opcode 2370 * offset + 1 (8 bit): condition number 2371 * 2372 * Check condition "condition number" in the io condition table. 2373 * If condition not met skip subsequent opcodes until condition is 2374 * inverted (INIT_NOT), or we hit INIT_RESUME 2375 */ 2376 2377 uint8_t cond = bios->data[offset + 1]; 2378 2379 if (!iexec->execute) 2380 return 2; 2381 2382 BIOSLOG(bios, "0x%04X: IO condition: 0x%02X\n", offset, cond); 2383 2384 if (io_condition_met(bios, offset, cond)) 2385 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset); 2386 else { 2387 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset); 2388 iexec->execute = false; 2389 } 2390 2391 return 2; 2392} 2393 2394static int 2395init_index_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2396{ 2397 /* 2398 * INIT_INDEX_IO opcode: 0x78 ('x') 2399 * 2400 * offset (8 bit): opcode 2401 * offset + 1 (16 bit): CRTC port 2402 * offset + 3 (8 bit): CRTC index 2403 * offset + 4 (8 bit): mask 2404 * offset + 5 (8 bit): data 2405 * 2406 * Read value at index "CRTC index" on "CRTC port", AND with "mask", 2407 * OR with "data", write-back 2408 */ 2409 2410 uint16_t crtcport = ROM16(bios->data[offset + 1]); 2411 uint8_t crtcindex = bios->data[offset + 3]; 2412 uint8_t mask = bios->data[offset + 4]; 2413 uint8_t data = bios->data[offset + 5]; 2414 uint8_t value; 2415 2416 if (!iexec->execute) 2417 return 6; 2418 2419 BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, " 2420 "Data: 0x%02X\n", 2421 offset, crtcport, crtcindex, mask, data); 2422 2423 value = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) | data; 2424 bios_idxprt_wr(bios, crtcport, crtcindex, value); 2425 2426 return 6; 2427} 2428 2429static int 2430init_pll(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2431{ 2432 /* 2433 * INIT_PLL opcode: 0x79 ('y') 2434 * 2435 * offset (8 bit): opcode 2436 * offset + 1 (32 bit): register 2437 * offset + 5 (16 bit): freq 2438 * 2439 * Set PLL register "register" to coefficients for frequency (10kHz) 2440 * "freq" 2441 */ 2442 2443 uint32_t reg = ROM32(bios->data[offset + 1]); 2444 uint16_t freq = ROM16(bios->data[offset + 5]); 2445 2446 if (!iexec->execute) 2447 return 7; 2448 2449 BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Freq: %d0kHz\n", offset, reg, freq); 2450 2451 setPLL(bios, reg, freq * 10); 2452 2453 return 7; 2454} 2455 2456static int 2457init_zm_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2458{ 2459 /* 2460 * INIT_ZM_REG opcode: 0x7A ('z') 2461 * 2462 * offset (8 bit): opcode 2463 * offset + 1 (32 bit): register 2464 * offset + 5 (32 bit): value 2465 * 2466 * Assign "value" to "register" 2467 */ 2468 2469 uint32_t reg = ROM32(bios->data[offset + 1]); 2470 uint32_t value = ROM32(bios->data[offset + 5]); 2471 2472 if (!iexec->execute) 2473 return 9; 2474 2475 if (reg == 0x000200) 2476 value |= 1; 2477 2478 bios_wr32(bios, reg, value); 2479 2480 return 9; 2481} 2482 2483static int 2484init_ram_restrict_pll(struct nvbios *bios, uint16_t offset, 2485 struct init_exec *iexec) 2486{ 2487 /* 2488 * INIT_RAM_RESTRICT_PLL opcode: 0x87 ('') 2489 * 2490 * offset (8 bit): opcode 2491 * offset + 1 (8 bit): PLL type 2492 * offset + 2 (32 bit): frequency 0 2493 * 2494 * Uses the RAMCFG strap of PEXTDEV_BOOT as an index into the table at 2495 * ram_restrict_table_ptr. The value read from there is used to select 2496 * a frequency from the table starting at 'frequency 0' to be 2497 * programmed into the PLL corresponding to 'type'. 2498 * 2499 * The PLL limits table on cards using this opcode has a mapping of 2500 * 'type' to the relevant registers. 2501 */ 2502 2503 struct drm_device *dev = bios->dev; 2504 uint32_t strap = (bios_rd32(bios, NV_PEXTDEV_BOOT_0) & 0x0000003c) >> 2; 2505 uint8_t index = bios->data[bios->ram_restrict_tbl_ptr + strap]; 2506 uint8_t type = bios->data[offset + 1]; 2507 uint32_t freq = ROM32(bios->data[offset + 2 + (index * 4)]); 2508 uint8_t *pll_limits = &bios->data[bios->pll_limit_tbl_ptr], *entry; 2509 int len = 2 + bios->ram_restrict_group_count * 4; 2510 int i; 2511 2512 if (!iexec->execute) 2513 return len; 2514 2515 if (!bios->pll_limit_tbl_ptr || (pll_limits[0] & 0xf0) != 0x30) { 2516 NV_ERROR(dev, "PLL limits table not version 3.x\n"); 2517 return len; /* deliberate, allow default clocks to remain */ 2518 } 2519 2520 entry = pll_limits + pll_limits[1]; 2521 for (i = 0; i < pll_limits[3]; i++, entry += pll_limits[2]) { 2522 if (entry[0] == type) { 2523 uint32_t reg = ROM32(entry[3]); 2524 2525 BIOSLOG(bios, "0x%04X: " 2526 "Type %02x Reg 0x%08x Freq %dKHz\n", 2527 offset, type, reg, freq); 2528 2529 setPLL(bios, reg, freq); 2530 return len; 2531 } 2532 } 2533 2534 NV_ERROR(dev, "PLL type 0x%02x not found in PLL limits table", type); 2535 return len; 2536} 2537 2538static int 2539init_8c(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2540{ 2541 /* 2542 * INIT_8C opcode: 0x8C ('') 2543 * 2544 * NOP so far.... 2545 * 2546 */ 2547 2548 return 1; 2549} 2550 2551static int 2552init_8d(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2553{ 2554 /* 2555 * INIT_8D opcode: 0x8D ('') 2556 * 2557 * NOP so far.... 2558 * 2559 */ 2560 2561 return 1; 2562} 2563 2564static int 2565init_gpio(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2566{ 2567 /* 2568 * INIT_GPIO opcode: 0x8E ('') 2569 * 2570 * offset (8 bit): opcode 2571 * 2572 * Loop over all entries in the DCB GPIO table, and initialise 2573 * each GPIO according to various values listed in each entry 2574 */ 2575 2576 struct drm_nouveau_private *dev_priv = bios->dev->dev_private; 2577 const uint32_t nv50_gpio_reg[4] = { 0xe104, 0xe108, 0xe280, 0xe284 }; 2578 const uint32_t nv50_gpio_ctl[2] = { 0xe100, 0xe28c }; 2579 int i; 2580 2581 if (dev_priv->card_type != NV_50) { 2582 NV_ERROR(bios->dev, "INIT_GPIO on unsupported chipset\n"); 2583 return -ENODEV; 2584 } 2585 2586 if (!iexec->execute) 2587 return 1; 2588 2589 for (i = 0; i < bios->dcb.gpio.entries; i++) { 2590 struct dcb_gpio_entry *gpio = &bios->dcb.gpio.entry[i]; 2591 uint32_t r, s, v; 2592 2593 BIOSLOG(bios, "0x%04X: Entry: 0x%08X\n", offset, gpio->entry); 2594 2595 r = nv50_gpio_reg[gpio->line >> 3]; 2596 s = (gpio->line & 0x07) << 2; 2597 v = bios_rd32(bios, r) & ~(0x00000003 << s); 2598 v |= (gpio->state[gpio->state_default] ^ 2) << s; 2599 bios_wr32(bios, r, v); 2600 2601 r = nv50_gpio_ctl[gpio->line >> 4]; 2602 s = (gpio->line & 0x0f); 2603 v = bios_rd32(bios, r) & ~(0x00010001 << s); 2604 switch ((gpio->entry & 0x06000000) >> 25) { 2605 case 1: 2606 v |= (0x00000001 << s); 2607 break; 2608 case 2: 2609 v |= (0x00010000 << s); 2610 break; 2611 default: 2612 break; 2613 } 2614 bios_wr32(bios, r, v); 2615 } 2616 2617 return 1; 2618} 2619 2620static int 2621init_ram_restrict_zm_reg_group(struct nvbios *bios, uint16_t offset, 2622 struct init_exec *iexec) 2623{ 2624 /* 2625 * INIT_RAM_RESTRICT_ZM_REG_GROUP opcode: 0x8F ('') 2626 * 2627 * offset (8 bit): opcode 2628 * offset + 1 (32 bit): reg 2629 * offset + 5 (8 bit): regincrement 2630 * offset + 6 (8 bit): count 2631 * offset + 7 (32 bit): value 1,1 2632 * ... 2633 * 2634 * Use the RAMCFG strap of PEXTDEV_BOOT as an index into the table at 2635 * ram_restrict_table_ptr. The value read from here is 'n', and 2636 * "value 1,n" gets written to "reg". This repeats "count" times and on 2637 * each iteration 'm', "reg" increases by "regincrement" and 2638 * "value m,n" is used. The extent of n is limited by a number read 2639 * from the 'M' BIT table, herein called "blocklen" 2640 */ 2641 2642 uint32_t reg = ROM32(bios->data[offset + 1]); 2643 uint8_t regincrement = bios->data[offset + 5]; 2644 uint8_t count = bios->data[offset + 6]; 2645 uint32_t strap_ramcfg, data; 2646 /* previously set by 'M' BIT table */ 2647 uint16_t blocklen = bios->ram_restrict_group_count * 4; 2648 int len = 7 + count * blocklen; 2649 uint8_t index; 2650 int i; 2651 2652 2653 if (!iexec->execute) 2654 return len; 2655 2656 if (!blocklen) { 2657 NV_ERROR(bios->dev, 2658 "0x%04X: Zero block length - has the M table " 2659 "been parsed?\n", offset); 2660 return 0; 2661 } 2662 2663 strap_ramcfg = (bios_rd32(bios, NV_PEXTDEV_BOOT_0) >> 2) & 0xf; 2664 index = bios->data[bios->ram_restrict_tbl_ptr + strap_ramcfg]; 2665 2666 BIOSLOG(bios, "0x%04X: Reg: 0x%08X, RegIncrement: 0x%02X, " 2667 "Count: 0x%02X, StrapRamCfg: 0x%02X, Index: 0x%02X\n", 2668 offset, reg, regincrement, count, strap_ramcfg, index); 2669 2670 for (i = 0; i < count; i++) { 2671 data = ROM32(bios->data[offset + 7 + index * 4 + blocklen * i]); 2672 2673 bios_wr32(bios, reg, data); 2674 2675 reg += regincrement; 2676 } 2677 2678 return len; 2679} 2680 2681static int 2682init_copy_zm_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2683{ 2684 /* 2685 * INIT_COPY_ZM_REG opcode: 0x90 ('') 2686 * 2687 * offset (8 bit): opcode 2688 * offset + 1 (32 bit): src reg 2689 * offset + 5 (32 bit): dst reg 2690 * 2691 * Put contents of "src reg" into "dst reg" 2692 */ 2693 2694 uint32_t srcreg = ROM32(bios->data[offset + 1]); 2695 uint32_t dstreg = ROM32(bios->data[offset + 5]); 2696 2697 if (!iexec->execute) 2698 return 9; 2699 2700 bios_wr32(bios, dstreg, bios_rd32(bios, srcreg)); 2701 2702 return 9; 2703} 2704 2705static int 2706init_zm_reg_group_addr_latched(struct nvbios *bios, uint16_t offset, 2707 struct init_exec *iexec) 2708{ 2709 /* 2710 * INIT_ZM_REG_GROUP_ADDRESS_LATCHED opcode: 0x91 ('') 2711 * 2712 * offset (8 bit): opcode 2713 * offset + 1 (32 bit): dst reg 2714 * offset + 5 (8 bit): count 2715 * offset + 6 (32 bit): data 1 2716 * ... 2717 * 2718 * For each of "count" values write "data n" to "dst reg" 2719 */ 2720 2721 uint32_t reg = ROM32(bios->data[offset + 1]); 2722 uint8_t count = bios->data[offset + 5]; 2723 int len = 6 + count * 4; 2724 int i; 2725 2726 if (!iexec->execute) 2727 return len; 2728 2729 for (i = 0; i < count; i++) { 2730 uint32_t data = ROM32(bios->data[offset + 6 + 4 * i]); 2731 bios_wr32(bios, reg, data); 2732 } 2733 2734 return len; 2735} 2736 2737static int 2738init_reserved(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2739{ 2740 /* 2741 * INIT_RESERVED opcode: 0x92 ('') 2742 * 2743 * offset (8 bit): opcode 2744 * 2745 * Seemingly does nothing 2746 */ 2747 2748 return 1; 2749} 2750 2751static int 2752init_96(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2753{ 2754 /* 2755 * INIT_96 opcode: 0x96 ('') 2756 * 2757 * offset (8 bit): opcode 2758 * offset + 1 (32 bit): sreg 2759 * offset + 5 (8 bit): sshift 2760 * offset + 6 (8 bit): smask 2761 * offset + 7 (8 bit): index 2762 * offset + 8 (32 bit): reg 2763 * offset + 12 (32 bit): mask 2764 * offset + 16 (8 bit): shift 2765 * 2766 */ 2767 2768 uint16_t xlatptr = bios->init96_tbl_ptr + (bios->data[offset + 7] * 2); 2769 uint32_t reg = ROM32(bios->data[offset + 8]); 2770 uint32_t mask = ROM32(bios->data[offset + 12]); 2771 uint32_t val; 2772 2773 val = bios_rd32(bios, ROM32(bios->data[offset + 1])); 2774 if (bios->data[offset + 5] < 0x80) 2775 val >>= bios->data[offset + 5]; 2776 else 2777 val <<= (0x100 - bios->data[offset + 5]); 2778 val &= bios->data[offset + 6]; 2779 2780 val = bios->data[ROM16(bios->data[xlatptr]) + val]; 2781 val <<= bios->data[offset + 16]; 2782 2783 if (!iexec->execute) 2784 return 17; 2785 2786 bios_wr32(bios, reg, (bios_rd32(bios, reg) & mask) | val); 2787 return 17; 2788} 2789 2790static int 2791init_97(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2792{ 2793 /* 2794 * INIT_97 opcode: 0x97 ('') 2795 * 2796 * offset (8 bit): opcode 2797 * offset + 1 (32 bit): register 2798 * offset + 5 (32 bit): mask 2799 * offset + 9 (32 bit): value 2800 * 2801 * Adds "value" to "register" preserving the fields specified 2802 * by "mask" 2803 */ 2804 2805 uint32_t reg = ROM32(bios->data[offset + 1]); 2806 uint32_t mask = ROM32(bios->data[offset + 5]); 2807 uint32_t add = ROM32(bios->data[offset + 9]); 2808 uint32_t val; 2809 2810 val = bios_rd32(bios, reg); 2811 val = (val & mask) | ((val + add) & ~mask); 2812 2813 if (!iexec->execute) 2814 return 13; 2815 2816 bios_wr32(bios, reg, val); 2817 return 13; 2818} 2819 2820static int 2821init_auxch(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2822{ 2823 /* 2824 * INIT_AUXCH opcode: 0x98 ('') 2825 * 2826 * offset (8 bit): opcode 2827 * offset + 1 (32 bit): address 2828 * offset + 5 (8 bit): count 2829 * offset + 6 (8 bit): mask 0 2830 * offset + 7 (8 bit): data 0 2831 * ... 2832 * 2833 */ 2834 2835 struct drm_device *dev = bios->dev; 2836 struct nouveau_i2c_chan *auxch; 2837 uint32_t addr = ROM32(bios->data[offset + 1]); 2838 uint8_t count = bios->data[offset + 5]; 2839 int len = 6 + count * 2; 2840 int ret, i; 2841 2842 if (!bios->display.output) { 2843 NV_ERROR(dev, "INIT_AUXCH: no active output\n"); 2844 return 0; 2845 } 2846 2847 auxch = init_i2c_device_find(dev, bios->display.output->i2c_index); 2848 if (!auxch) { 2849 NV_ERROR(dev, "INIT_AUXCH: couldn't get auxch %d\n", 2850 bios->display.output->i2c_index); 2851 return 0; 2852 } 2853 2854 if (!iexec->execute) 2855 return len; 2856 2857 offset += 6; 2858 for (i = 0; i < count; i++, offset += 2) { 2859 uint8_t data; 2860 2861 ret = nouveau_dp_auxch(auxch, 9, addr, &data, 1); 2862 if (ret) { 2863 NV_ERROR(dev, "INIT_AUXCH: rd auxch fail %d\n", ret); 2864 return 0; 2865 } 2866 2867 data &= bios->data[offset + 0]; 2868 data |= bios->data[offset + 1]; 2869 2870 ret = nouveau_dp_auxch(auxch, 8, addr, &data, 1); 2871 if (ret) { 2872 NV_ERROR(dev, "INIT_AUXCH: wr auxch fail %d\n", ret); 2873 return 0; 2874 } 2875 } 2876 2877 return len; 2878} 2879 2880static int 2881init_zm_auxch(struct nvbios *bios, uint16_t offset, struct init_exec *iexec) 2882{ 2883 /* 2884 * INIT_ZM_AUXCH opcode: 0x99 ('') 2885 * 2886 * offset (8 bit): opcode 2887 * offset + 1 (32 bit): address 2888 * offset + 5 (8 bit): count 2889 * offset + 6 (8 bit): data 0 2890 * ... 2891 * 2892 */ 2893 2894 struct drm_device *dev = bios->dev; 2895 struct nouveau_i2c_chan *auxch; 2896 uint32_t addr = ROM32(bios->data[offset + 1]); 2897 uint8_t count = bios->data[offset + 5]; 2898 int len = 6 + count; 2899 int ret, i; 2900 2901 if (!bios->display.output) { 2902 NV_ERROR(dev, "INIT_ZM_AUXCH: no active output\n"); 2903 return 0; 2904 } 2905 2906 auxch = init_i2c_device_find(dev, bios->display.output->i2c_index); 2907 if (!auxch) { 2908 NV_ERROR(dev, "INIT_ZM_AUXCH: couldn't get auxch %d\n", 2909 bios->display.output->i2c_index); 2910 return 0; 2911 } 2912 2913 if (!iexec->execute) 2914 return len; 2915 2916 offset += 6; 2917 for (i = 0; i < count; i++, offset++) { 2918 ret = nouveau_dp_auxch(auxch, 8, addr, &bios->data[offset], 1); 2919 if (ret) { 2920 NV_ERROR(dev, "INIT_ZM_AUXCH: wr auxch fail %d\n", ret); 2921 return 0; 2922 } 2923 } 2924 2925 return len; 2926} 2927 2928static struct init_tbl_entry itbl_entry[] = { 2929 /* command name , id , length , offset , mult , command handler */ 2930 /* INIT_PROG (0x31, 15, 10, 4) removed due to no example of use */ 2931 { "INIT_IO_RESTRICT_PROG" , 0x32, init_io_restrict_prog }, 2932 { "INIT_REPEAT" , 0x33, init_repeat }, 2933 { "INIT_IO_RESTRICT_PLL" , 0x34, init_io_restrict_pll }, 2934 { "INIT_END_REPEAT" , 0x36, init_end_repeat }, 2935 { "INIT_COPY" , 0x37, init_copy }, 2936 { "INIT_NOT" , 0x38, init_not }, 2937 { "INIT_IO_FLAG_CONDITION" , 0x39, init_io_flag_condition }, 2938 { "INIT_INDEX_ADDRESS_LATCHED" , 0x49, init_idx_addr_latched }, 2939 { "INIT_IO_RESTRICT_PLL2" , 0x4A, init_io_restrict_pll2 }, 2940 { "INIT_PLL2" , 0x4B, init_pll2 }, 2941 { "INIT_I2C_BYTE" , 0x4C, init_i2c_byte }, 2942 { "INIT_ZM_I2C_BYTE" , 0x4D, init_zm_i2c_byte }, 2943 { "INIT_ZM_I2C" , 0x4E, init_zm_i2c }, 2944 { "INIT_TMDS" , 0x4F, init_tmds }, 2945 { "INIT_ZM_TMDS_GROUP" , 0x50, init_zm_tmds_group }, 2946 { "INIT_CR_INDEX_ADDRESS_LATCHED" , 0x51, init_cr_idx_adr_latch }, 2947 { "INIT_CR" , 0x52, init_cr }, 2948 { "INIT_ZM_CR" , 0x53, init_zm_cr }, 2949 { "INIT_ZM_CR_GROUP" , 0x54, init_zm_cr_group }, 2950 { "INIT_CONDITION_TIME" , 0x56, init_condition_time }, 2951 { "INIT_ZM_REG_SEQUENCE" , 0x58, init_zm_reg_sequence }, 2952 /* INIT_INDIRECT_REG (0x5A, 7, 0, 0) removed due to no example of use */ 2953 { "INIT_SUB_DIRECT" , 0x5B, init_sub_direct }, 2954 { "INIT_COPY_NV_REG" , 0x5F, init_copy_nv_reg }, 2955 { "INIT_ZM_INDEX_IO" , 0x62, init_zm_index_io }, 2956 { "INIT_COMPUTE_MEM" , 0x63, init_compute_mem }, 2957 { "INIT_RESET" , 0x65, init_reset }, 2958 { "INIT_CONFIGURE_MEM" , 0x66, init_configure_mem }, 2959 { "INIT_CONFIGURE_CLK" , 0x67, init_configure_clk }, 2960 { "INIT_CONFIGURE_PREINIT" , 0x68, init_configure_preinit }, 2961 { "INIT_IO" , 0x69, init_io }, 2962 { "INIT_SUB" , 0x6B, init_sub }, 2963 { "INIT_RAM_CONDITION" , 0x6D, init_ram_condition }, 2964 { "INIT_NV_REG" , 0x6E, init_nv_reg }, 2965 { "INIT_MACRO" , 0x6F, init_macro }, 2966 { "INIT_DONE" , 0x71, init_done }, 2967 { "INIT_RESUME" , 0x72, init_resume }, 2968 /* INIT_RAM_CONDITION2 (0x73, 9, 0, 0) removed due to no example of use */ 2969 { "INIT_TIME" , 0x74, init_time }, 2970 { "INIT_CONDITION" , 0x75, init_condition }, 2971 { "INIT_IO_CONDITION" , 0x76, init_io_condition }, 2972 { "INIT_INDEX_IO" , 0x78, init_index_io }, 2973 { "INIT_PLL" , 0x79, init_pll }, 2974 { "INIT_ZM_REG" , 0x7A, init_zm_reg }, 2975 { "INIT_RAM_RESTRICT_PLL" , 0x87, init_ram_restrict_pll }, 2976 { "INIT_8C" , 0x8C, init_8c }, 2977 { "INIT_8D" , 0x8D, init_8d }, 2978 { "INIT_GPIO" , 0x8E, init_gpio }, 2979 { "INIT_RAM_RESTRICT_ZM_REG_GROUP" , 0x8F, init_ram_restrict_zm_reg_group }, 2980 { "INIT_COPY_ZM_REG" , 0x90, init_copy_zm_reg }, 2981 { "INIT_ZM_REG_GROUP_ADDRESS_LATCHED" , 0x91, init_zm_reg_group_addr_latched }, 2982 { "INIT_RESERVED" , 0x92, init_reserved }, 2983 { "INIT_96" , 0x96, init_96 }, 2984 { "INIT_97" , 0x97, init_97 }, 2985 { "INIT_AUXCH" , 0x98, init_auxch }, 2986 { "INIT_ZM_AUXCH" , 0x99, init_zm_auxch }, 2987 { NULL , 0 , NULL } 2988}; 2989 2990#define MAX_TABLE_OPS 1000 2991 2992static int 2993parse_init_table(struct nvbios *bios, unsigned int offset, 2994 struct init_exec *iexec) 2995{ 2996 /* 2997 * Parses all commands in an init table. 2998 * 2999 * We start out executing all commands found in the init table. Some 3000 * opcodes may change the status of iexec->execute to SKIP, which will 3001 * cause the following opcodes to perform no operation until the value 3002 * is changed back to EXECUTE. 3003 */ 3004 3005 int count = 0, i, res; 3006 uint8_t id; 3007 3008 /* 3009 * Loop until INIT_DONE causes us to break out of the loop 3010 * (or until offset > bios length just in case... ) 3011 * (and no more than MAX_TABLE_OPS iterations, just in case... ) 3012 */ 3013 while ((offset < bios->length) && (count++ < MAX_TABLE_OPS)) { 3014 id = bios->data[offset]; 3015 3016 /* Find matching id in itbl_entry */ 3017 for (i = 0; itbl_entry[i].name && (itbl_entry[i].id != id); i++) 3018 ; 3019 3020 if (itbl_entry[i].name) { 3021 BIOSLOG(bios, "0x%04X: [ (0x%02X) - %s ]\n", 3022 offset, itbl_entry[i].id, itbl_entry[i].name); 3023 3024 /* execute eventual command handler */ 3025 res = (*itbl_entry[i].handler)(bios, offset, iexec); 3026 if (!res) 3027 break; 3028 /* 3029 * Add the offset of the current command including all data 3030 * of that command. The offset will then be pointing on the 3031 * next op code. 3032 */ 3033 offset += res; 3034 } else { 3035 NV_ERROR(bios->dev, 3036 "0x%04X: Init table command not found: " 3037 "0x%02X\n", offset, id); 3038 return -ENOENT; 3039 } 3040 } 3041 3042 if (offset >= bios->length) 3043 NV_WARN(bios->dev, 3044 "Offset 0x%04X greater than known bios image length. " 3045 "Corrupt image?\n", offset); 3046 if (count >= MAX_TABLE_OPS) 3047 NV_WARN(bios->dev, 3048 "More than %d opcodes to a table is unlikely, " 3049 "is the bios image corrupt?\n", MAX_TABLE_OPS); 3050 3051 return 0; 3052} 3053 3054static void 3055parse_init_tables(struct nvbios *bios) 3056{ 3057 /* Loops and calls parse_init_table() for each present table. */ 3058 3059 int i = 0; 3060 uint16_t table; 3061 struct init_exec iexec = {true, false}; 3062 3063 if (bios->old_style_init) { 3064 if (bios->init_script_tbls_ptr) 3065 parse_init_table(bios, bios->init_script_tbls_ptr, &iexec); 3066 if (bios->extra_init_script_tbl_ptr) 3067 parse_init_table(bios, bios->extra_init_script_tbl_ptr, &iexec); 3068 3069 return; 3070 } 3071 3072 while ((table = ROM16(bios->data[bios->init_script_tbls_ptr + i]))) { 3073 NV_INFO(bios->dev, 3074 "Parsing VBIOS init table %d at offset 0x%04X\n", 3075 i / 2, table); 3076 BIOSLOG(bios, "0x%04X: ------ Executing following commands ------\n", table); 3077 3078 parse_init_table(bios, table, &iexec); 3079 i += 2; 3080 } 3081} 3082 3083static uint16_t clkcmptable(struct nvbios *bios, uint16_t clktable, int pxclk) 3084{ 3085 int compare_record_len, i = 0; 3086 uint16_t compareclk, scriptptr = 0; 3087 3088 if (bios->major_version < 5) /* pre BIT */ 3089 compare_record_len = 3; 3090 else 3091 compare_record_len = 4; 3092 3093 do { 3094 compareclk = ROM16(bios->data[clktable + compare_record_len * i]); 3095 if (pxclk >= compareclk * 10) { 3096 if (bios->major_version < 5) { 3097 uint8_t tmdssub = bios->data[clktable + 2 + compare_record_len * i]; 3098 scriptptr = ROM16(bios->data[bios->init_script_tbls_ptr + tmdssub * 2]); 3099 } else 3100 scriptptr = ROM16(bios->data[clktable + 2 + compare_record_len * i]); 3101 break; 3102 } 3103 i++; 3104 } while (compareclk); 3105 3106 return scriptptr; 3107} 3108 3109static void 3110run_digital_op_script(struct drm_device *dev, uint16_t scriptptr, 3111 struct dcb_entry *dcbent, int head, bool dl) 3112{ 3113 struct drm_nouveau_private *dev_priv = dev->dev_private; 3114 struct nvbios *bios = &dev_priv->vbios; 3115 struct init_exec iexec = {true, false}; 3116 3117 NV_TRACE(dev, "0x%04X: Parsing digital output script table\n", 3118 scriptptr); 3119 bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, NV_CIO_CRE_44, 3120 head ? NV_CIO_CRE_44_HEADB : NV_CIO_CRE_44_HEADA); 3121 /* note: if dcb entries have been merged, index may be misleading */ 3122 NVWriteVgaCrtc5758(dev, head, 0, dcbent->index); 3123 parse_init_table(bios, scriptptr, &iexec); 3124 3125 nv04_dfp_bind_head(dev, dcbent, head, dl); 3126} 3127 3128static int call_lvds_manufacturer_script(struct drm_device *dev, struct dcb_entry *dcbent, int head, enum LVDS_script script) 3129{ 3130 struct drm_nouveau_private *dev_priv = dev->dev_private; 3131 struct nvbios *bios = &dev_priv->vbios; 3132 uint8_t sub = bios->data[bios->fp.xlated_entry + script] + (bios->fp.link_c_increment && dcbent->or & OUTPUT_C ? 1 : 0); 3133 uint16_t scriptofs = ROM16(bios->data[bios->init_script_tbls_ptr + sub * 2]); 3134 3135 if (!bios->fp.xlated_entry || !sub || !scriptofs) 3136 return -EINVAL; 3137 3138 run_digital_op_script(dev, scriptofs, dcbent, head, bios->fp.dual_link); 3139 3140 if (script == LVDS_PANEL_OFF) { 3141 /* off-on delay in ms */ 3142 msleep(ROM16(bios->data[bios->fp.xlated_entry + 7])); 3143 } 3144#ifdef __powerpc__ 3145 /* Powerbook specific quirks */ 3146 if ((dev->pci_device & 0xffff) == 0x0179 || 3147 (dev->pci_device & 0xffff) == 0x0189 || 3148 (dev->pci_device & 0xffff) == 0x0329) { 3149 if (script == LVDS_RESET) { 3150 nv_write_tmds(dev, dcbent->or, 0, 0x02, 0x72); 3151 3152 } else if (script == LVDS_PANEL_ON) { 3153 bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL, 3154 bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL) 3155 | (1 << 31)); 3156 bios_wr32(bios, NV_PCRTC_GPIO_EXT, 3157 bios_rd32(bios, NV_PCRTC_GPIO_EXT) | 1); 3158 3159 } else if (script == LVDS_PANEL_OFF) { 3160 bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL, 3161 bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL) 3162 & ~(1 << 31)); 3163 bios_wr32(bios, NV_PCRTC_GPIO_EXT, 3164 bios_rd32(bios, NV_PCRTC_GPIO_EXT) & ~3); 3165 } 3166 } 3167#endif 3168 3169 return 0; 3170} 3171 3172static int run_lvds_table(struct drm_device *dev, struct dcb_entry *dcbent, int head, enum LVDS_script script, int pxclk) 3173{ 3174 /* 3175 * The BIT LVDS table's header has the information to setup the 3176 * necessary registers. Following the standard 4 byte header are: 3177 * A bitmask byte and a dual-link transition pxclk value for use in 3178 * selecting the init script when not using straps; 4 script pointers 3179 * for panel power, selected by output and on/off; and 8 table pointers 3180 * for panel init, the needed one determined by output, and bits in the 3181 * conf byte. These tables are similar to the TMDS tables, consisting 3182 * of a list of pxclks and script pointers. 3183 */ 3184 struct drm_nouveau_private *dev_priv = dev->dev_private; 3185 struct nvbios *bios = &dev_priv->vbios; 3186 unsigned int outputset = (dcbent->or == 4) ? 1 : 0; 3187 uint16_t scriptptr = 0, clktable; 3188 3189 /* 3190 * For now we assume version 3.0 table - g80 support will need some 3191 * changes 3192 */ 3193 3194 switch (script) { 3195 case LVDS_INIT: 3196 return -ENOSYS; 3197 case LVDS_BACKLIGHT_ON: 3198 case LVDS_PANEL_ON: 3199 scriptptr = ROM16(bios->data[bios->fp.lvdsmanufacturerpointer + 7 + outputset * 2]); 3200 break; 3201 case LVDS_BACKLIGHT_OFF: 3202 case LVDS_PANEL_OFF: 3203 scriptptr = ROM16(bios->data[bios->fp.lvdsmanufacturerpointer + 11 + outputset * 2]); 3204 break; 3205 case LVDS_RESET: 3206 clktable = bios->fp.lvdsmanufacturerpointer + 15; 3207 if (dcbent->or == 4) 3208 clktable += 8; 3209 3210 if (dcbent->lvdsconf.use_straps_for_mode) { 3211 if (bios->fp.dual_link) 3212 clktable += 4; 3213 if (bios->fp.if_is_24bit) 3214 clktable += 2; 3215 } else { 3216 /* using EDID */ 3217 int cmpval_24bit = (dcbent->or == 4) ? 4 : 1; 3218 3219 if (bios->fp.dual_link) { 3220 clktable += 4; 3221 cmpval_24bit <<= 1; 3222 } 3223 3224 if (bios->fp.strapless_is_24bit & cmpval_24bit) 3225 clktable += 2; 3226 } 3227 3228 clktable = ROM16(bios->data[clktable]); 3229 if (!clktable) { 3230 NV_ERROR(dev, "Pixel clock comparison table not found\n"); 3231 return -ENOENT; 3232 } 3233 scriptptr = clkcmptable(bios, clktable, pxclk); 3234 } 3235 3236 if (!scriptptr) { 3237 NV_ERROR(dev, "LVDS output init script not found\n"); 3238 return -ENOENT; 3239 } 3240 run_digital_op_script(dev, scriptptr, dcbent, head, bios->fp.dual_link); 3241 3242 return 0; 3243} 3244 3245int call_lvds_script(struct drm_device *dev, struct dcb_entry *dcbent, int head, enum LVDS_script script, int pxclk) 3246{ 3247 /* 3248 * LVDS operations are multiplexed in an effort to present a single API 3249 * which works with two vastly differing underlying structures. 3250 * This acts as the demux 3251 */ 3252 3253 struct drm_nouveau_private *dev_priv = dev->dev_private; 3254 struct nvbios *bios = &dev_priv->vbios; 3255 uint8_t lvds_ver = bios->data[bios->fp.lvdsmanufacturerpointer]; 3256 uint32_t sel_clk_binding, sel_clk; 3257 int ret; 3258 3259 if (bios->fp.last_script_invoc == (script << 1 | head) || !lvds_ver || 3260 (lvds_ver >= 0x30 && script == LVDS_INIT)) 3261 return 0; 3262 3263 if (!bios->fp.lvds_init_run) { 3264 bios->fp.lvds_init_run = true; 3265 call_lvds_script(dev, dcbent, head, LVDS_INIT, pxclk); 3266 } 3267 3268 if (script == LVDS_PANEL_ON && bios->fp.reset_after_pclk_change) 3269 call_lvds_script(dev, dcbent, head, LVDS_RESET, pxclk); 3270 if (script == LVDS_RESET && bios->fp.power_off_for_reset) 3271 call_lvds_script(dev, dcbent, head, LVDS_PANEL_OFF, pxclk); 3272 3273 NV_TRACE(dev, "Calling LVDS script %d:\n", script); 3274 3275 /* don't let script change pll->head binding */ 3276 sel_clk_binding = bios_rd32(bios, NV_PRAMDAC_SEL_CLK) & 0x50000; 3277 3278 if (lvds_ver < 0x30) 3279 ret = call_lvds_manufacturer_script(dev, dcbent, head, script); 3280 else 3281 ret = run_lvds_table(dev, dcbent, head, script, pxclk); 3282 3283 bios->fp.last_script_invoc = (script << 1 | head); 3284 3285 sel_clk = NVReadRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK) & ~0x50000; 3286 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, sel_clk | sel_clk_binding); 3287 /* some scripts set a value in NV_PBUS_POWERCTRL_2 and break video overlay */ 3288 nvWriteMC(dev, NV_PBUS_POWERCTRL_2, 0); 3289 3290 return ret; 3291} 3292 3293struct lvdstableheader { 3294 uint8_t lvds_ver, headerlen, recordlen; 3295}; 3296 3297static int parse_lvds_manufacturer_table_header(struct drm_device *dev, struct nvbios *bios, struct lvdstableheader *lth) 3298{ 3299 /* 3300 * BMP version (0xa) LVDS table has a simple header of version and 3301 * record length. The BIT LVDS table has the typical BIT table header: 3302 * version byte, header length byte, record length byte, and a byte for 3303 * the maximum number of records that can be held in the table. 3304 */ 3305 3306 uint8_t lvds_ver, headerlen, recordlen; 3307 3308 memset(lth, 0, sizeof(struct lvdstableheader)); 3309 3310 if (bios->fp.lvdsmanufacturerpointer == 0x0) { 3311 NV_ERROR(dev, "Pointer to LVDS manufacturer table invalid\n"); 3312 return -EINVAL; 3313 } 3314 3315 lvds_ver = bios->data[bios->fp.lvdsmanufacturerpointer]; 3316 3317 switch (lvds_ver) { 3318 case 0x0a: /* pre NV40 */ 3319 headerlen = 2; 3320 recordlen = bios->data[bios->fp.lvdsmanufacturerpointer + 1]; 3321 break; 3322 case 0x30: /* NV4x */ 3323 headerlen = bios->data[bios->fp.lvdsmanufacturerpointer + 1]; 3324 if (headerlen < 0x1f) { 3325 NV_ERROR(dev, "LVDS table header not understood\n"); 3326 return -EINVAL; 3327 } 3328 recordlen = bios->data[bios->fp.lvdsmanufacturerpointer + 2]; 3329 break; 3330 case 0x40: /* G80/G90 */ 3331 headerlen = bios->data[bios->fp.lvdsmanufacturerpointer + 1]; 3332 if (headerlen < 0x7) { 3333 NV_ERROR(dev, "LVDS table header not understood\n"); 3334 return -EINVAL; 3335 } 3336 recordlen = bios->data[bios->fp.lvdsmanufacturerpointer + 2]; 3337 break; 3338 default: 3339 NV_ERROR(dev, 3340 "LVDS table revision %d.%d not currently supported\n", 3341 lvds_ver >> 4, lvds_ver & 0xf); 3342 return -ENOSYS; 3343 } 3344 3345 lth->lvds_ver = lvds_ver; 3346 lth->headerlen = headerlen; 3347 lth->recordlen = recordlen; 3348 3349 return 0; 3350} 3351 3352static int 3353get_fp_strap(struct drm_device *dev, struct nvbios *bios) 3354{ 3355 struct drm_nouveau_private *dev_priv = dev->dev_private; 3356 3357 /* 3358 * The fp strap is normally dictated by the "User Strap" in 3359 * PEXTDEV_BOOT_0[20:16], but on BMP cards when bit 2 of the 3360 * Internal_Flags struct at 0x48 is set, the user strap gets overriden 3361 * by the PCI subsystem ID during POST, but not before the previous user 3362 * strap has been committed to CR58 for CR57=0xf on head A, which may be 3363 * read and used instead 3364 */ 3365 3366 if (bios->major_version < 5 && bios->data[0x48] & 0x4) 3367 return NVReadVgaCrtc5758(dev, 0, 0xf) & 0xf; 3368 3369 if (dev_priv->card_type >= NV_50) 3370 return (bios_rd32(bios, NV_PEXTDEV_BOOT_0) >> 24) & 0xf; 3371 else 3372 return (bios_rd32(bios, NV_PEXTDEV_BOOT_0) >> 16) & 0xf; 3373} 3374 3375static int parse_fp_mode_table(struct drm_device *dev, struct nvbios *bios) 3376{ 3377 uint8_t *fptable; 3378 uint8_t fptable_ver, headerlen = 0, recordlen, fpentries = 0xf, fpindex; 3379 int ret, ofs, fpstrapping; 3380 struct lvdstableheader lth; 3381 3382 if (bios->fp.fptablepointer == 0x0) { 3383 /* Apple cards don't have the fp table; the laptops use DDC */ 3384 /* The table is also missing on some x86 IGPs */ 3385#ifndef __powerpc__ 3386 NV_ERROR(dev, "Pointer to flat panel table invalid\n"); 3387#endif 3388 bios->digital_min_front_porch = 0x4b; 3389 return 0; 3390 } 3391 3392 fptable = &bios->data[bios->fp.fptablepointer]; 3393 fptable_ver = fptable[0]; 3394 3395 switch (fptable_ver) { 3396 /* 3397 * BMP version 0x5.0x11 BIOSen have version 1 like tables, but no 3398 * version field, and miss one of the spread spectrum/PWM bytes. 3399 * This could affect early GF2Go parts (not seen any appropriate ROMs 3400 * though). Here we assume that a version of 0x05 matches this case 3401 * (combining with a BMP version check would be better), as the 3402 * common case for the panel type field is 0x0005, and that is in 3403 * fact what we are reading the first byte of. 3404 */ 3405 case 0x05: /* some NV10, 11, 15, 16 */ 3406 recordlen = 42; 3407 ofs = -1; 3408 break; 3409 case 0x10: /* some NV15/16, and NV11+ */ 3410 recordlen = 44; 3411 ofs = 0; 3412 break; 3413 case 0x20: /* NV40+ */ 3414 headerlen = fptable[1]; 3415 recordlen = fptable[2]; 3416 fpentries = fptable[3]; 3417 /* 3418 * fptable[4] is the minimum 3419 * RAMDAC_FP_HCRTC -> RAMDAC_FP_HSYNC_START gap 3420 */ 3421 bios->digital_min_front_porch = fptable[4]; 3422 ofs = -7; 3423 break; 3424 default: 3425 NV_ERROR(dev, 3426 "FP table revision %d.%d not currently supported\n", 3427 fptable_ver >> 4, fptable_ver & 0xf); 3428 return -ENOSYS; 3429 } 3430 3431 if (!bios->is_mobile) /* !mobile only needs digital_min_front_porch */ 3432 return 0; 3433 3434 ret = parse_lvds_manufacturer_table_header(dev, bios, <h); 3435 if (ret) 3436 return ret; 3437 3438 if (lth.lvds_ver == 0x30 || lth.lvds_ver == 0x40) { 3439 bios->fp.fpxlatetableptr = bios->fp.lvdsmanufacturerpointer + 3440 lth.headerlen + 1; 3441 bios->fp.xlatwidth = lth.recordlen; 3442 } 3443 if (bios->fp.fpxlatetableptr == 0x0) { 3444 NV_ERROR(dev, "Pointer to flat panel xlat table invalid\n"); 3445 return -EINVAL; 3446 } 3447 3448 fpstrapping = get_fp_strap(dev, bios); 3449 3450 fpindex = bios->data[bios->fp.fpxlatetableptr + 3451 fpstrapping * bios->fp.xlatwidth]; 3452 3453 if (fpindex > fpentries) { 3454 NV_ERROR(dev, "Bad flat panel table index\n"); 3455 return -ENOENT; 3456 } 3457 3458 /* nv4x cards need both a strap value and fpindex of 0xf to use DDC */ 3459 if (lth.lvds_ver > 0x10) 3460 bios->fp_no_ddc = fpstrapping != 0xf || fpindex != 0xf; 3461 3462 /* 3463 * If either the strap or xlated fpindex value are 0xf there is no 3464 * panel using a strap-derived bios mode present. this condition 3465 * includes, but is different from, the DDC panel indicator above 3466 */ 3467 if (fpstrapping == 0xf || fpindex == 0xf) 3468 return 0; 3469 3470 bios->fp.mode_ptr = bios->fp.fptablepointer + headerlen + 3471 recordlen * fpindex + ofs; 3472 3473 NV_TRACE(dev, "BIOS FP mode: %dx%d (%dkHz pixel clock)\n", 3474 ROM16(bios->data[bios->fp.mode_ptr + 11]) + 1, 3475 ROM16(bios->data[bios->fp.mode_ptr + 25]) + 1, 3476 ROM16(bios->data[bios->fp.mode_ptr + 7]) * 10); 3477 3478 return 0; 3479} 3480 3481bool nouveau_bios_fp_mode(struct drm_device *dev, struct drm_display_mode *mode) 3482{ 3483 struct drm_nouveau_private *dev_priv = dev->dev_private; 3484 struct nvbios *bios = &dev_priv->vbios; 3485 uint8_t *mode_entry = &bios->data[bios->fp.mode_ptr]; 3486 3487 if (!mode) /* just checking whether we can produce a mode */ 3488 return bios->fp.mode_ptr; 3489 3490 memset(mode, 0, sizeof(struct drm_display_mode)); 3491 /* 3492 * For version 1.0 (version in byte 0): 3493 * bytes 1-2 are "panel type", including bits on whether Colour/mono, 3494 * single/dual link, and type (TFT etc.) 3495 * bytes 3-6 are bits per colour in RGBX 3496 */ 3497 mode->clock = ROM16(mode_entry[7]) * 10; 3498 /* bytes 9-10 is HActive */ 3499 mode->hdisplay = ROM16(mode_entry[11]) + 1; 3500 /* 3501 * bytes 13-14 is HValid Start 3502 * bytes 15-16 is HValid End 3503 */ 3504 mode->hsync_start = ROM16(mode_entry[17]) + 1; 3505 mode->hsync_end = ROM16(mode_entry[19]) + 1; 3506 mode->htotal = ROM16(mode_entry[21]) + 1; 3507 /* bytes 23-24, 27-30 similarly, but vertical */ 3508 mode->vdisplay = ROM16(mode_entry[25]) + 1; 3509 mode->vsync_start = ROM16(mode_entry[31]) + 1; 3510 mode->vsync_end = ROM16(mode_entry[33]) + 1; 3511 mode->vtotal = ROM16(mode_entry[35]) + 1; 3512 mode->flags |= (mode_entry[37] & 0x10) ? 3513 DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC; 3514 mode->flags |= (mode_entry[37] & 0x1) ? 3515 DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC; 3516 /* 3517 * bytes 38-39 relate to spread spectrum settings 3518 * bytes 40-43 are something to do with PWM 3519 */ 3520 3521 mode->status = MODE_OK; 3522 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; 3523 drm_mode_set_name(mode); 3524 return bios->fp.mode_ptr; 3525} 3526 3527int nouveau_bios_parse_lvds_table(struct drm_device *dev, int pxclk, bool *dl, bool *if_is_24bit) 3528{ 3529 /* 3530 * The LVDS table header is (mostly) described in 3531 * parse_lvds_manufacturer_table_header(): the BIT header additionally 3532 * contains the dual-link transition pxclk (in 10s kHz), at byte 5 - if 3533 * straps are not being used for the panel, this specifies the frequency 3534 * at which modes should be set up in the dual link style. 3535 * 3536 * Following the header, the BMP (ver 0xa) table has several records, 3537 * indexed by a separate xlat table, indexed in turn by the fp strap in 3538 * EXTDEV_BOOT. Each record had a config byte, followed by 6 script 3539 * numbers for use by INIT_SUB which controlled panel init and power, 3540 * and finally a dword of ms to sleep between power off and on 3541 * operations. 3542 * 3543 * In the BIT versions, the table following the header serves as an 3544 * integrated config and xlat table: the records in the table are 3545 * indexed by the FP strap nibble in EXTDEV_BOOT, and each record has 3546 * two bytes - the first as a config byte, the second for indexing the 3547 * fp mode table pointed to by the BIT 'D' table 3548 * 3549 * DDC is not used until after card init, so selecting the correct table 3550 * entry and setting the dual link flag for EDID equipped panels, 3551 * requiring tests against the native-mode pixel clock, cannot be done 3552 * until later, when this function should be called with non-zero pxclk 3553 */ 3554 struct drm_nouveau_private *dev_priv = dev->dev_private; 3555 struct nvbios *bios = &dev_priv->vbios; 3556 int fpstrapping = get_fp_strap(dev, bios), lvdsmanufacturerindex = 0; 3557 struct lvdstableheader lth; 3558 uint16_t lvdsofs; 3559 int ret, chip_version = bios->chip_version; 3560 3561 ret = parse_lvds_manufacturer_table_header(dev, bios, <h); 3562 if (ret) 3563 return ret; 3564 3565 switch (lth.lvds_ver) { 3566 case 0x0a: /* pre NV40 */ 3567 lvdsmanufacturerindex = bios->data[ 3568 bios->fp.fpxlatemanufacturertableptr + 3569 fpstrapping]; 3570 3571 /* we're done if this isn't the EDID panel case */ 3572 if (!pxclk) 3573 break; 3574 3575 if (chip_version < 0x25) { 3576 /* nv17 behaviour 3577 * 3578 * It seems the old style lvds script pointer is reused 3579 * to select 18/24 bit colour depth for EDID panels. 3580 */ 3581 lvdsmanufacturerindex = 3582 (bios->legacy.lvds_single_a_script_ptr & 1) ? 3583 2 : 0; 3584 if (pxclk >= bios->fp.duallink_transition_clk) 3585 lvdsmanufacturerindex++; 3586 } else if (chip_version < 0x30) { 3587 /* nv28 behaviour (off-chip encoder) 3588 * 3589 * nv28 does a complex dance of first using byte 121 of 3590 * the EDID to choose the lvdsmanufacturerindex, then 3591 * later attempting to match the EDID manufacturer and 3592 * product IDs in a table (signature 'pidt' (panel id 3593 * table?)), setting an lvdsmanufacturerindex of 0 and 3594 * an fp strap of the match index (or 0xf if none) 3595 */ 3596 lvdsmanufacturerindex = 0; 3597 } else { 3598 /* nv31, nv34 behaviour */ 3599 lvdsmanufacturerindex = 0; 3600 if (pxclk >= bios->fp.duallink_transition_clk) 3601 lvdsmanufacturerindex = 2; 3602 if (pxclk >= 140000) 3603 lvdsmanufacturerindex = 3; 3604 } 3605 3606 /* 3607 * nvidia set the high nibble of (cr57=f, cr58) to 3608 * lvdsmanufacturerindex in this case; we don't 3609 */ 3610 break; 3611 case 0x30: /* NV4x */ 3612 case 0x40: /* G80/G90 */ 3613 lvdsmanufacturerindex = fpstrapping; 3614 break; 3615 default: 3616 NV_ERROR(dev, "LVDS table revision not currently supported\n"); 3617 return -ENOSYS; 3618 } 3619 3620 lvdsofs = bios->fp.xlated_entry = bios->fp.lvdsmanufacturerpointer + lth.headerlen + lth.recordlen * lvdsmanufacturerindex; 3621 switch (lth.lvds_ver) { 3622 case 0x0a: 3623 bios->fp.power_off_for_reset = bios->data[lvdsofs] & 1; 3624 bios->fp.reset_after_pclk_change = bios->data[lvdsofs] & 2; 3625 bios->fp.dual_link = bios->data[lvdsofs] & 4; 3626 bios->fp.link_c_increment = bios->data[lvdsofs] & 8; 3627 *if_is_24bit = bios->data[lvdsofs] & 16; 3628 break; 3629 case 0x30: 3630 case 0x40: 3631 /* 3632 * No sign of the "power off for reset" or "reset for panel 3633 * on" bits, but it's safer to assume we should 3634 */ 3635 bios->fp.power_off_for_reset = true; 3636 bios->fp.reset_after_pclk_change = true; 3637 3638 /* 3639 * It's ok lvdsofs is wrong for nv4x edid case; dual_link is 3640 * over-written, and if_is_24bit isn't used 3641 */ 3642 bios->fp.dual_link = bios->data[lvdsofs] & 1; 3643 bios->fp.if_is_24bit = bios->data[lvdsofs] & 2; 3644 bios->fp.strapless_is_24bit = bios->data[bios->fp.lvdsmanufacturerpointer + 4]; 3645 bios->fp.duallink_transition_clk = ROM16(bios->data[bios->fp.lvdsmanufacturerpointer + 5]) * 10; 3646 break; 3647 } 3648 3649 /* Dell Latitude D620 reports a too-high value for the dual-link 3650 * transition freq, causing us to program the panel incorrectly. 3651 * 3652 * It doesn't appear the VBIOS actually uses its transition freq 3653 * (90000kHz), instead it uses the "Number of LVDS channels" field 3654 * out of the panel ID structure (http://www.spwg.org/). 3655 * 3656 * For the moment, a quirk will do :) 3657 */ 3658 if ((dev->pdev->device == 0x01d7) && 3659 (dev->pdev->subsystem_vendor == 0x1028) && 3660 (dev->pdev->subsystem_device == 0x01c2)) { 3661 bios->fp.duallink_transition_clk = 80000; 3662 } 3663 3664 /* set dual_link flag for EDID case */ 3665 if (pxclk && (chip_version < 0x25 || chip_version > 0x28)) 3666 bios->fp.dual_link = (pxclk >= bios->fp.duallink_transition_clk); 3667 3668 *dl = bios->fp.dual_link; 3669 3670 return 0; 3671} 3672 3673static uint8_t * 3674bios_output_config_match(struct drm_device *dev, struct dcb_entry *dcbent, 3675 uint16_t record, int record_len, int record_nr) 3676{ 3677 struct drm_nouveau_private *dev_priv = dev->dev_private; 3678 struct nvbios *bios = &dev_priv->vbios; 3679 uint32_t entry; 3680 uint16_t table; 3681 int i, v; 3682 3683 for (i = 0; i < record_nr; i++, record += record_len) { 3684 table = ROM16(bios->data[record]); 3685 if (!table) 3686 continue; 3687 entry = ROM32(bios->data[table]); 3688 3689 v = (entry & 0x000f0000) >> 16; 3690 if (!(v & dcbent->or)) 3691 continue; 3692 3693 v = (entry & 0x000000f0) >> 4; 3694 if (v != dcbent->location) 3695 continue; 3696 3697 v = (entry & 0x0000000f); 3698 if (v != dcbent->type) 3699 continue; 3700 3701 return &bios->data[table]; 3702 } 3703 3704 return NULL; 3705} 3706 3707void * 3708nouveau_bios_dp_table(struct drm_device *dev, struct dcb_entry *dcbent, 3709 int *length) 3710{ 3711 struct drm_nouveau_private *dev_priv = dev->dev_private; 3712 struct nvbios *bios = &dev_priv->vbios; 3713 uint8_t *table; 3714 3715 if (!bios->display.dp_table_ptr) { 3716 NV_ERROR(dev, "No pointer to DisplayPort table\n"); 3717 return NULL; 3718 } 3719 table = &bios->data[bios->display.dp_table_ptr]; 3720 3721 if (table[0] != 0x20 && table[0] != 0x21) { 3722 NV_ERROR(dev, "DisplayPort table version 0x%02x unknown\n", 3723 table[0]); 3724 return NULL; 3725 } 3726 3727 *length = table[4]; 3728 return bios_output_config_match(dev, dcbent, 3729 bios->display.dp_table_ptr + table[1], 3730 table[2], table[3]); 3731} 3732 3733int 3734nouveau_bios_run_display_table(struct drm_device *dev, struct dcb_entry *dcbent, 3735 uint32_t sub, int pxclk) 3736{ 3737 /* 3738 * The display script table is located by the BIT 'U' table. 3739 * 3740 * It contains an array of pointers to various tables describing 3741 * a particular output type. The first 32-bits of the output 3742 * tables contains similar information to a DCB entry, and is 3743 * used to decide whether that particular table is suitable for 3744 * the output you want to access. 3745 * 3746 * The "record header length" field here seems to indicate the 3747 * offset of the first configuration entry in the output tables. 3748 * This is 10 on most cards I've seen, but 12 has been witnessed 3749 * on DP cards, and there's another script pointer within the 3750 * header. 3751 * 3752 * offset + 0 ( 8 bits): version 3753 * offset + 1 ( 8 bits): header length 3754 * offset + 2 ( 8 bits): record length 3755 * offset + 3 ( 8 bits): number of records 3756 * offset + 4 ( 8 bits): record header length 3757 * offset + 5 (16 bits): pointer to first output script table 3758 */ 3759 3760 struct drm_nouveau_private *dev_priv = dev->dev_private; 3761 struct nvbios *bios = &dev_priv->vbios; 3762 uint8_t *table = &bios->data[bios->display.script_table_ptr]; 3763 uint8_t *otable = NULL; 3764 uint16_t script; 3765 int i = 0; 3766 3767 if (!bios->display.script_table_ptr) { 3768 NV_ERROR(dev, "No pointer to output script table\n"); 3769 return 1; 3770 } 3771 3772 /* 3773 * Nothing useful has been in any of the pre-2.0 tables I've seen, 3774 * so until they are, we really don't need to care. 3775 */ 3776 if (table[0] < 0x20) 3777 return 1; 3778 3779 if (table[0] != 0x20 && table[0] != 0x21) { 3780 NV_ERROR(dev, "Output script table version 0x%02x unknown\n", 3781 table[0]); 3782 return 1; 3783 } 3784 3785 /* 3786 * The output script tables describing a particular output type 3787 * look as follows: 3788 * 3789 * offset + 0 (32 bits): output this table matches (hash of DCB) 3790 * offset + 4 ( 8 bits): unknown 3791 * offset + 5 ( 8 bits): number of configurations 3792 * offset + 6 (16 bits): pointer to some script 3793 * offset + 8 (16 bits): pointer to some script 3794 * 3795 * headerlen == 10 3796 * offset + 10 : configuration 0 3797 * 3798 * headerlen == 12 3799 * offset + 10 : pointer to some script 3800 * offset + 12 : configuration 0 3801 * 3802 * Each config entry is as follows: 3803 * 3804 * offset + 0 (16 bits): unknown, assumed to be a match value 3805 * offset + 2 (16 bits): pointer to script table (clock set?) 3806 * offset + 4 (16 bits): pointer to script table (reset?) 3807 * 3808 * There doesn't appear to be a count value to say how many 3809 * entries exist in each script table, instead, a 0 value in 3810 * the first 16-bit word seems to indicate both the end of the 3811 * list and the default entry. The second 16-bit word in the 3812 * script tables is a pointer to the script to execute. 3813 */ 3814 3815 NV_DEBUG_KMS(dev, "Searching for output entry for %d %d %d\n", 3816 dcbent->type, dcbent->location, dcbent->or); 3817 otable = bios_output_config_match(dev, dcbent, table[1] + 3818 bios->display.script_table_ptr, 3819 table[2], table[3]); 3820 if (!otable) { 3821 NV_ERROR(dev, "Couldn't find matching output script table\n"); 3822 return 1; 3823 } 3824 3825 if (pxclk < -2 || pxclk > 0) { 3826 /* Try to find matching script table entry */ 3827 for (i = 0; i < otable[5]; i++) { 3828 if (ROM16(otable[table[4] + i*6]) == sub) 3829 break; 3830 } 3831 3832 if (i == otable[5]) { 3833 NV_ERROR(dev, "Table 0x%04x not found for %d/%d, " 3834 "using first\n", 3835 sub, dcbent->type, dcbent->or); 3836 i = 0; 3837 } 3838 } 3839 3840 if (pxclk == 0) { 3841 script = ROM16(otable[6]); 3842 if (!script) { 3843 NV_DEBUG_KMS(dev, "output script 0 not found\n"); 3844 return 1; 3845 } 3846 3847 NV_TRACE(dev, "0x%04X: parsing output script 0\n", script); 3848 nouveau_bios_run_init_table(dev, script, dcbent); 3849 } else 3850 if (pxclk == -1) { 3851 script = ROM16(otable[8]); 3852 if (!script) { 3853 NV_DEBUG_KMS(dev, "output script 1 not found\n"); 3854 return 1; 3855 } 3856 3857 NV_TRACE(dev, "0x%04X: parsing output script 1\n", script); 3858 nouveau_bios_run_init_table(dev, script, dcbent); 3859 } else 3860 if (pxclk == -2) { 3861 if (table[4] >= 12) 3862 script = ROM16(otable[10]); 3863 else 3864 script = 0; 3865 if (!script) { 3866 NV_DEBUG_KMS(dev, "output script 2 not found\n"); 3867 return 1; 3868 } 3869 3870 NV_TRACE(dev, "0x%04X: parsing output script 2\n", script); 3871 nouveau_bios_run_init_table(dev, script, dcbent); 3872 } else 3873 if (pxclk > 0) { 3874 script = ROM16(otable[table[4] + i*6 + 2]); 3875 if (script) 3876 script = clkcmptable(bios, script, pxclk); 3877 if (!script) { 3878 NV_ERROR(dev, "clock script 0 not found\n"); 3879 return 1; 3880 } 3881 3882 NV_TRACE(dev, "0x%04X: parsing clock script 0\n", script); 3883 nouveau_bios_run_init_table(dev, script, dcbent); 3884 } else 3885 if (pxclk < 0) { 3886 script = ROM16(otable[table[4] + i*6 + 4]); 3887 if (script) 3888 script = clkcmptable(bios, script, -pxclk); 3889 if (!script) { 3890 NV_DEBUG_KMS(dev, "clock script 1 not found\n"); 3891 return 1; 3892 } 3893 3894 NV_TRACE(dev, "0x%04X: parsing clock script 1\n", script); 3895 nouveau_bios_run_init_table(dev, script, dcbent); 3896 } 3897 3898 return 0; 3899} 3900 3901 3902int run_tmds_table(struct drm_device *dev, struct dcb_entry *dcbent, int head, int pxclk) 3903{ 3904 /* 3905 * the pxclk parameter is in kHz 3906 * 3907 * This runs the TMDS regs setting code found on BIT bios cards 3908 * 3909 * For ffs(or) == 1 use the first table, for ffs(or) == 2 and 3910 * ffs(or) == 3, use the second. 3911 */ 3912 3913 struct drm_nouveau_private *dev_priv = dev->dev_private; 3914 struct nvbios *bios = &dev_priv->vbios; 3915 int cv = bios->chip_version; 3916 uint16_t clktable = 0, scriptptr; 3917 uint32_t sel_clk_binding, sel_clk; 3918 3919 /* pre-nv17 off-chip tmds uses scripts, post nv17 doesn't */ 3920 if (cv >= 0x17 && cv != 0x1a && cv != 0x20 && 3921 dcbent->location != DCB_LOC_ON_CHIP) 3922 return 0; 3923 3924 switch (ffs(dcbent->or)) { 3925 case 1: 3926 clktable = bios->tmds.output0_script_ptr; 3927 break; 3928 case 2: 3929 case 3: 3930 clktable = bios->tmds.output1_script_ptr; 3931 break; 3932 } 3933 3934 if (!clktable) { 3935 NV_ERROR(dev, "Pixel clock comparison table not found\n"); 3936 return -EINVAL; 3937 } 3938 3939 scriptptr = clkcmptable(bios, clktable, pxclk); 3940 3941 if (!scriptptr) { 3942 NV_ERROR(dev, "TMDS output init script not found\n"); 3943 return -ENOENT; 3944 } 3945 3946 /* don't let script change pll->head binding */ 3947 sel_clk_binding = bios_rd32(bios, NV_PRAMDAC_SEL_CLK) & 0x50000; 3948 run_digital_op_script(dev, scriptptr, dcbent, head, pxclk >= 165000); 3949 sel_clk = NVReadRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK) & ~0x50000; 3950 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, sel_clk | sel_clk_binding); 3951 3952 return 0; 3953} 3954 3955int get_pll_limits(struct drm_device *dev, uint32_t limit_match, struct pll_lims *pll_lim) 3956{ 3957 /* 3958 * PLL limits table 3959 * 3960 * Version 0x10: NV30, NV31 3961 * One byte header (version), one record of 24 bytes 3962 * Version 0x11: NV36 - Not implemented 3963 * Seems to have same record style as 0x10, but 3 records rather than 1 3964 * Version 0x20: Found on Geforce 6 cards 3965 * Trivial 4 byte BIT header. 31 (0x1f) byte record length 3966 * Version 0x21: Found on Geforce 7, 8 and some Geforce 6 cards 3967 * 5 byte header, fifth byte of unknown purpose. 35 (0x23) byte record 3968 * length in general, some (integrated) have an extra configuration byte 3969 * Version 0x30: Found on Geforce 8, separates the register mapping 3970 * from the limits tables. 3971 */ 3972 3973 struct drm_nouveau_private *dev_priv = dev->dev_private; 3974 struct nvbios *bios = &dev_priv->vbios; 3975 int cv = bios->chip_version, pllindex = 0; 3976 uint8_t pll_lim_ver = 0, headerlen = 0, recordlen = 0, entries = 0; 3977 uint32_t crystal_strap_mask, crystal_straps; 3978 3979 if (!bios->pll_limit_tbl_ptr) { 3980 if (cv == 0x30 || cv == 0x31 || cv == 0x35 || cv == 0x36 || 3981 cv >= 0x40) { 3982 NV_ERROR(dev, "Pointer to PLL limits table invalid\n"); 3983 return -EINVAL; 3984 } 3985 } else 3986 pll_lim_ver = bios->data[bios->pll_limit_tbl_ptr]; 3987 3988 crystal_strap_mask = 1 << 6; 3989 /* open coded dev->twoHeads test */ 3990 if (cv > 0x10 && cv != 0x15 && cv != 0x1a && cv != 0x20) 3991 crystal_strap_mask |= 1 << 22; 3992 crystal_straps = nvReadEXTDEV(dev, NV_PEXTDEV_BOOT_0) & 3993 crystal_strap_mask; 3994 3995 switch (pll_lim_ver) { 3996 /* 3997 * We use version 0 to indicate a pre limit table bios (single stage 3998 * pll) and load the hard coded limits instead. 3999 */ 4000 case 0: 4001 break; 4002 case 0x10: 4003 case 0x11: 4004 /* 4005 * Strictly v0x11 has 3 entries, but the last two don't seem 4006 * to get used. 4007 */ 4008 headerlen = 1; 4009 recordlen = 0x18; 4010 entries = 1; 4011 pllindex = 0; 4012 break; 4013 case 0x20: 4014 case 0x21: 4015 case 0x30: 4016 case 0x40: 4017 headerlen = bios->data[bios->pll_limit_tbl_ptr + 1]; 4018 recordlen = bios->data[bios->pll_limit_tbl_ptr + 2]; 4019 entries = bios->data[bios->pll_limit_tbl_ptr + 3]; 4020 break; 4021 default: 4022 NV_ERROR(dev, "PLL limits table revision 0x%X not currently " 4023 "supported\n", pll_lim_ver); 4024 return -ENOSYS; 4025 } 4026 4027 /* initialize all members to zero */ 4028 memset(pll_lim, 0, sizeof(struct pll_lims)); 4029 4030 if (pll_lim_ver == 0x10 || pll_lim_ver == 0x11) { 4031 uint8_t *pll_rec = &bios->data[bios->pll_limit_tbl_ptr + headerlen + recordlen * pllindex]; 4032 4033 pll_lim->vco1.minfreq = ROM32(pll_rec[0]); 4034 pll_lim->vco1.maxfreq = ROM32(pll_rec[4]); 4035 pll_lim->vco2.minfreq = ROM32(pll_rec[8]); 4036 pll_lim->vco2.maxfreq = ROM32(pll_rec[12]); 4037 pll_lim->vco1.min_inputfreq = ROM32(pll_rec[16]); 4038 pll_lim->vco2.min_inputfreq = ROM32(pll_rec[20]); 4039 pll_lim->vco1.max_inputfreq = pll_lim->vco2.max_inputfreq = INT_MAX; 4040 4041 /* these values taken from nv30/31/36 */ 4042 pll_lim->vco1.min_n = 0x1; 4043 if (cv == 0x36) 4044 pll_lim->vco1.min_n = 0x5; 4045 pll_lim->vco1.max_n = 0xff; 4046 pll_lim->vco1.min_m = 0x1; 4047 pll_lim->vco1.max_m = 0xd; 4048 pll_lim->vco2.min_n = 0x4; 4049 /* 4050 * On nv30, 31, 36 (i.e. all cards with two stage PLLs with this 4051 * table version (apart from nv35)), N2 is compared to 4052 * maxN2 (0x46) and 10 * maxM2 (0x4), so set maxN2 to 0x28 and 4053 * save a comparison 4054 */ 4055 pll_lim->vco2.max_n = 0x28; 4056 if (cv == 0x30 || cv == 0x35) 4057 /* only 5 bits available for N2 on nv30/35 */ 4058 pll_lim->vco2.max_n = 0x1f; 4059 pll_lim->vco2.min_m = 0x1; 4060 pll_lim->vco2.max_m = 0x4; 4061 pll_lim->max_log2p = 0x7; 4062 pll_lim->max_usable_log2p = 0x6; 4063 } else if (pll_lim_ver == 0x20 || pll_lim_ver == 0x21) { 4064 uint16_t plloffs = bios->pll_limit_tbl_ptr + headerlen; 4065 uint32_t reg = 0; /* default match */ 4066 uint8_t *pll_rec; 4067 int i; 4068 4069 /* 4070 * First entry is default match, if nothing better. warn if 4071 * reg field nonzero 4072 */ 4073 if (ROM32(bios->data[plloffs])) 4074 NV_WARN(dev, "Default PLL limit entry has non-zero " 4075 "register field\n"); 4076 4077 if (limit_match > MAX_PLL_TYPES) 4078 /* we've been passed a reg as the match */ 4079 reg = limit_match; 4080 else /* limit match is a pll type */ 4081 for (i = 1; i < entries && !reg; i++) { 4082 uint32_t cmpreg = ROM32(bios->data[plloffs + recordlen * i]); 4083 4084 if (limit_match == NVPLL && 4085 (cmpreg == NV_PRAMDAC_NVPLL_COEFF || cmpreg == 0x4000)) 4086 reg = cmpreg; 4087 if (limit_match == MPLL && 4088 (cmpreg == NV_PRAMDAC_MPLL_COEFF || cmpreg == 0x4020)) 4089 reg = cmpreg; 4090 if (limit_match == VPLL1 && 4091 (cmpreg == NV_PRAMDAC_VPLL_COEFF || cmpreg == 0x4010)) 4092 reg = cmpreg; 4093 if (limit_match == VPLL2 && 4094 (cmpreg == NV_RAMDAC_VPLL2 || cmpreg == 0x4018)) 4095 reg = cmpreg; 4096 } 4097 4098 for (i = 1; i < entries; i++) 4099 if (ROM32(bios->data[plloffs + recordlen * i]) == reg) { 4100 pllindex = i; 4101 break; 4102 } 4103 4104 pll_rec = &bios->data[plloffs + recordlen * pllindex]; 4105 4106 BIOSLOG(bios, "Loading PLL limits for reg 0x%08x\n", 4107 pllindex ? reg : 0); 4108 4109 /* 4110 * Frequencies are stored in tables in MHz, kHz are more 4111 * useful, so we convert. 4112 */ 4113 4114 /* What output frequencies can each VCO generate? */ 4115 pll_lim->vco1.minfreq = ROM16(pll_rec[4]) * 1000; 4116 pll_lim->vco1.maxfreq = ROM16(pll_rec[6]) * 1000; 4117 pll_lim->vco2.minfreq = ROM16(pll_rec[8]) * 1000; 4118 pll_lim->vco2.maxfreq = ROM16(pll_rec[10]) * 1000; 4119 4120 /* What input frequencies they accept (past the m-divider)? */ 4121 pll_lim->vco1.min_inputfreq = ROM16(pll_rec[12]) * 1000; 4122 pll_lim->vco2.min_inputfreq = ROM16(pll_rec[14]) * 1000; 4123 pll_lim->vco1.max_inputfreq = ROM16(pll_rec[16]) * 1000; 4124 pll_lim->vco2.max_inputfreq = ROM16(pll_rec[18]) * 1000; 4125 4126 /* What values are accepted as multiplier and divider? */ 4127 pll_lim->vco1.min_n = pll_rec[20]; 4128 pll_lim->vco1.max_n = pll_rec[21]; 4129 pll_lim->vco1.min_m = pll_rec[22]; 4130 pll_lim->vco1.max_m = pll_rec[23]; 4131 pll_lim->vco2.min_n = pll_rec[24]; 4132 pll_lim->vco2.max_n = pll_rec[25]; 4133 pll_lim->vco2.min_m = pll_rec[26]; 4134 pll_lim->vco2.max_m = pll_rec[27]; 4135 4136 pll_lim->max_usable_log2p = pll_lim->max_log2p = pll_rec[29]; 4137 if (pll_lim->max_log2p > 0x7) 4138 /* pll decoding in nv_hw.c assumes never > 7 */ 4139 NV_WARN(dev, "Max log2 P value greater than 7 (%d)\n", 4140 pll_lim->max_log2p); 4141 if (cv < 0x60) 4142 pll_lim->max_usable_log2p = 0x6; 4143 pll_lim->log2p_bias = pll_rec[30]; 4144 4145 if (recordlen > 0x22) 4146 pll_lim->refclk = ROM32(pll_rec[31]); 4147 4148 if (recordlen > 0x23 && pll_rec[35]) 4149 NV_WARN(dev, 4150 "Bits set in PLL configuration byte (%x)\n", 4151 pll_rec[35]); 4152 4153 /* C51 special not seen elsewhere */ 4154 if (cv == 0x51 && !pll_lim->refclk) { 4155 uint32_t sel_clk = bios_rd32(bios, NV_PRAMDAC_SEL_CLK); 4156 4157 if (((limit_match == NV_PRAMDAC_VPLL_COEFF || limit_match == VPLL1) && sel_clk & 0x20) || 4158 ((limit_match == NV_RAMDAC_VPLL2 || limit_match == VPLL2) && sel_clk & 0x80)) { 4159 if (bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, NV_CIO_CRE_CHIP_ID_INDEX) < 0xa3) 4160 pll_lim->refclk = 200000; 4161 else 4162 pll_lim->refclk = 25000; 4163 } 4164 } 4165 } else if (pll_lim_ver == 0x30) { /* ver 0x30 */ 4166 uint8_t *entry = &bios->data[bios->pll_limit_tbl_ptr + headerlen]; 4167 uint8_t *record = NULL; 4168 int i; 4169 4170 BIOSLOG(bios, "Loading PLL limits for register 0x%08x\n", 4171 limit_match); 4172 4173 for (i = 0; i < entries; i++, entry += recordlen) { 4174 if (ROM32(entry[3]) == limit_match) { 4175 record = &bios->data[ROM16(entry[1])]; 4176 break; 4177 } 4178 } 4179 4180 if (!record) { 4181 NV_ERROR(dev, "Register 0x%08x not found in PLL " 4182 "limits table", limit_match); 4183 return -ENOENT; 4184 } 4185 4186 pll_lim->vco1.minfreq = ROM16(record[0]) * 1000; 4187 pll_lim->vco1.maxfreq = ROM16(record[2]) * 1000; 4188 pll_lim->vco2.minfreq = ROM16(record[4]) * 1000; 4189 pll_lim->vco2.maxfreq = ROM16(record[6]) * 1000; 4190 pll_lim->vco1.min_inputfreq = ROM16(record[8]) * 1000; 4191 pll_lim->vco2.min_inputfreq = ROM16(record[10]) * 1000; 4192 pll_lim->vco1.max_inputfreq = ROM16(record[12]) * 1000; 4193 pll_lim->vco2.max_inputfreq = ROM16(record[14]) * 1000; 4194 pll_lim->vco1.min_n = record[16]; 4195 pll_lim->vco1.max_n = record[17]; 4196 pll_lim->vco1.min_m = record[18]; 4197 pll_lim->vco1.max_m = record[19]; 4198 pll_lim->vco2.min_n = record[20]; 4199 pll_lim->vco2.max_n = record[21]; 4200 pll_lim->vco2.min_m = record[22]; 4201 pll_lim->vco2.max_m = record[23]; 4202 pll_lim->max_usable_log2p = pll_lim->max_log2p = record[25]; 4203 pll_lim->log2p_bias = record[27]; 4204 pll_lim->refclk = ROM32(record[28]); 4205 } else if (pll_lim_ver) { /* ver 0x40 */ 4206 uint8_t *entry = &bios->data[bios->pll_limit_tbl_ptr + headerlen]; 4207 uint8_t *record = NULL; 4208 int i; 4209 4210 BIOSLOG(bios, "Loading PLL limits for register 0x%08x\n", 4211 limit_match); 4212 4213 for (i = 0; i < entries; i++, entry += recordlen) { 4214 if (ROM32(entry[3]) == limit_match) { 4215 record = &bios->data[ROM16(entry[1])]; 4216 break; 4217 } 4218 } 4219 4220 if (!record) { 4221 NV_ERROR(dev, "Register 0x%08x not found in PLL " 4222 "limits table", limit_match); 4223 return -ENOENT; 4224 } 4225 4226 pll_lim->vco1.minfreq = ROM16(record[0]) * 1000; 4227 pll_lim->vco1.maxfreq = ROM16(record[2]) * 1000; 4228 pll_lim->vco1.min_inputfreq = ROM16(record[4]) * 1000; 4229 pll_lim->vco1.max_inputfreq = ROM16(record[6]) * 1000; 4230 pll_lim->vco1.min_m = record[8]; 4231 pll_lim->vco1.max_m = record[9]; 4232 pll_lim->vco1.min_n = record[10]; 4233 pll_lim->vco1.max_n = record[11]; 4234 pll_lim->min_p = record[12]; 4235 pll_lim->max_p = record[13]; 4236 /* where did this go to?? */ 4237 if (limit_match == 0x00614100 || limit_match == 0x00614900) 4238 pll_lim->refclk = 27000; 4239 else 4240 pll_lim->refclk = 100000; 4241 } 4242 4243 /* 4244 * By now any valid limit table ought to have set a max frequency for 4245 * vco1, so if it's zero it's either a pre limit table bios, or one 4246 * with an empty limit table (seen on nv18) 4247 */ 4248 if (!pll_lim->vco1.maxfreq) { 4249 pll_lim->vco1.minfreq = bios->fminvco; 4250 pll_lim->vco1.maxfreq = bios->fmaxvco; 4251 pll_lim->vco1.min_inputfreq = 0; 4252 pll_lim->vco1.max_inputfreq = INT_MAX; 4253 pll_lim->vco1.min_n = 0x1; 4254 pll_lim->vco1.max_n = 0xff; 4255 pll_lim->vco1.min_m = 0x1; 4256 if (crystal_straps == 0) { 4257 /* nv05 does this, nv11 doesn't, nv10 unknown */ 4258 if (cv < 0x11) 4259 pll_lim->vco1.min_m = 0x7; 4260 pll_lim->vco1.max_m = 0xd; 4261 } else { 4262 if (cv < 0x11) 4263 pll_lim->vco1.min_m = 0x8; 4264 pll_lim->vco1.max_m = 0xe; 4265 } 4266 if (cv < 0x17 || cv == 0x1a || cv == 0x20) 4267 pll_lim->max_log2p = 4; 4268 else 4269 pll_lim->max_log2p = 5; 4270 pll_lim->max_usable_log2p = pll_lim->max_log2p; 4271 } 4272 4273 if (!pll_lim->refclk) 4274 switch (crystal_straps) { 4275 case 0: 4276 pll_lim->refclk = 13500; 4277 break; 4278 case (1 << 6): 4279 pll_lim->refclk = 14318; 4280 break; 4281 case (1 << 22): 4282 pll_lim->refclk = 27000; 4283 break; 4284 case (1 << 22 | 1 << 6): 4285 pll_lim->refclk = 25000; 4286 break; 4287 } 4288 4289#if 0 /* for easy debugging */ 4290 ErrorF("pll.vco1.minfreq: %d\n", pll_lim->vco1.minfreq); 4291 ErrorF("pll.vco1.maxfreq: %d\n", pll_lim->vco1.maxfreq); 4292 ErrorF("pll.vco2.minfreq: %d\n", pll_lim->vco2.minfreq); 4293 ErrorF("pll.vco2.maxfreq: %d\n", pll_lim->vco2.maxfreq); 4294 4295 ErrorF("pll.vco1.min_inputfreq: %d\n", pll_lim->vco1.min_inputfreq); 4296 ErrorF("pll.vco1.max_inputfreq: %d\n", pll_lim->vco1.max_inputfreq); 4297 ErrorF("pll.vco2.min_inputfreq: %d\n", pll_lim->vco2.min_inputfreq); 4298 ErrorF("pll.vco2.max_inputfreq: %d\n", pll_lim->vco2.max_inputfreq); 4299 4300 ErrorF("pll.vco1.min_n: %d\n", pll_lim->vco1.min_n); 4301 ErrorF("pll.vco1.max_n: %d\n", pll_lim->vco1.max_n); 4302 ErrorF("pll.vco1.min_m: %d\n", pll_lim->vco1.min_m); 4303 ErrorF("pll.vco1.max_m: %d\n", pll_lim->vco1.max_m); 4304 ErrorF("pll.vco2.min_n: %d\n", pll_lim->vco2.min_n); 4305 ErrorF("pll.vco2.max_n: %d\n", pll_lim->vco2.max_n); 4306 ErrorF("pll.vco2.min_m: %d\n", pll_lim->vco2.min_m); 4307 ErrorF("pll.vco2.max_m: %d\n", pll_lim->vco2.max_m); 4308 4309 ErrorF("pll.max_log2p: %d\n", pll_lim->max_log2p); 4310 ErrorF("pll.log2p_bias: %d\n", pll_lim->log2p_bias); 4311 4312 ErrorF("pll.refclk: %d\n", pll_lim->refclk); 4313#endif 4314 4315 return 0; 4316} 4317 4318static void parse_bios_version(struct drm_device *dev, struct nvbios *bios, uint16_t offset) 4319{ 4320 /* 4321 * offset + 0 (8 bits): Micro version 4322 * offset + 1 (8 bits): Minor version 4323 * offset + 2 (8 bits): Chip version 4324 * offset + 3 (8 bits): Major version 4325 */ 4326 4327 bios->major_version = bios->data[offset + 3]; 4328 bios->chip_version = bios->data[offset + 2]; 4329 NV_TRACE(dev, "Bios version %02x.%02x.%02x.%02x\n", 4330 bios->data[offset + 3], bios->data[offset + 2], 4331 bios->data[offset + 1], bios->data[offset]); 4332} 4333 4334static void parse_script_table_pointers(struct nvbios *bios, uint16_t offset) 4335{ 4336 /* 4337 * Parses the init table segment for pointers used in script execution. 4338 * 4339 * offset + 0 (16 bits): init script tables pointer 4340 * offset + 2 (16 bits): macro index table pointer 4341 * offset + 4 (16 bits): macro table pointer 4342 * offset + 6 (16 bits): condition table pointer 4343 * offset + 8 (16 bits): io condition table pointer 4344 * offset + 10 (16 bits): io flag condition table pointer 4345 * offset + 12 (16 bits): init function table pointer 4346 */ 4347 4348 bios->init_script_tbls_ptr = ROM16(bios->data[offset]); 4349 bios->macro_index_tbl_ptr = ROM16(bios->data[offset + 2]); 4350 bios->macro_tbl_ptr = ROM16(bios->data[offset + 4]); 4351 bios->condition_tbl_ptr = ROM16(bios->data[offset + 6]); 4352 bios->io_condition_tbl_ptr = ROM16(bios->data[offset + 8]); 4353 bios->io_flag_condition_tbl_ptr = ROM16(bios->data[offset + 10]); 4354 bios->init_function_tbl_ptr = ROM16(bios->data[offset + 12]); 4355} 4356 4357static int parse_bit_A_tbl_entry(struct drm_device *dev, struct nvbios *bios, struct bit_entry *bitentry) 4358{ 4359 /* 4360 * Parses the load detect values for g80 cards. 4361 * 4362 * offset + 0 (16 bits): loadval table pointer 4363 */ 4364 4365 uint16_t load_table_ptr; 4366 uint8_t version, headerlen, entrylen, num_entries; 4367 4368 if (bitentry->length != 3) { 4369 NV_ERROR(dev, "Do not understand BIT A table\n"); 4370 return -EINVAL; 4371 } 4372 4373 load_table_ptr = ROM16(bios->data[bitentry->offset]); 4374 4375 if (load_table_ptr == 0x0) { 4376 NV_ERROR(dev, "Pointer to BIT loadval table invalid\n"); 4377 return -EINVAL; 4378 } 4379 4380 version = bios->data[load_table_ptr]; 4381 4382 if (version != 0x10) { 4383 NV_ERROR(dev, "BIT loadval table version %d.%d not supported\n", 4384 version >> 4, version & 0xF); 4385 return -ENOSYS; 4386 } 4387 4388 headerlen = bios->data[load_table_ptr + 1]; 4389 entrylen = bios->data[load_table_ptr + 2]; 4390 num_entries = bios->data[load_table_ptr + 3]; 4391 4392 if (headerlen != 4 || entrylen != 4 || num_entries != 2) { 4393 NV_ERROR(dev, "Do not understand BIT loadval table\n"); 4394 return -EINVAL; 4395 } 4396 4397 /* First entry is normal dac, 2nd tv-out perhaps? */ 4398 bios->dactestval = ROM32(bios->data[load_table_ptr + headerlen]) & 0x3ff; 4399 4400 return 0; 4401} 4402 4403static int parse_bit_C_tbl_entry(struct drm_device *dev, struct nvbios *bios, struct bit_entry *bitentry) 4404{ 4405 /* 4406 * offset + 8 (16 bits): PLL limits table pointer 4407 * 4408 * There's more in here, but that's unknown. 4409 */ 4410 4411 if (bitentry->length < 10) { 4412 NV_ERROR(dev, "Do not understand BIT C table\n"); 4413 return -EINVAL; 4414 } 4415 4416 bios->pll_limit_tbl_ptr = ROM16(bios->data[bitentry->offset + 8]); 4417 4418 return 0; 4419} 4420 4421static int parse_bit_display_tbl_entry(struct drm_device *dev, struct nvbios *bios, struct bit_entry *bitentry) 4422{ 4423 /* 4424 * Parses the flat panel table segment that the bit entry points to. 4425 * Starting at bitentry->offset: 4426 * 4427 * offset + 0 (16 bits): ??? table pointer - seems to have 18 byte 4428 * records beginning with a freq. 4429 * offset + 2 (16 bits): mode table pointer 4430 */ 4431 4432 if (bitentry->length != 4) { 4433 NV_ERROR(dev, "Do not understand BIT display table\n"); 4434 return -EINVAL; 4435 } 4436 4437 bios->fp.fptablepointer = ROM16(bios->data[bitentry->offset + 2]); 4438 4439 return 0; 4440} 4441 4442static int parse_bit_init_tbl_entry(struct drm_device *dev, struct nvbios *bios, struct bit_entry *bitentry) 4443{ 4444 /* 4445 * Parses the init table segment that the bit entry points to. 4446 * 4447 * See parse_script_table_pointers for layout 4448 */ 4449 4450 if (bitentry->length < 14) { 4451 NV_ERROR(dev, "Do not understand init table\n"); 4452 return -EINVAL; 4453 } 4454 4455 parse_script_table_pointers(bios, bitentry->offset); 4456 4457 if (bitentry->length >= 16) 4458 bios->some_script_ptr = ROM16(bios->data[bitentry->offset + 14]); 4459 if (bitentry->length >= 18) 4460 bios->init96_tbl_ptr = ROM16(bios->data[bitentry->offset + 16]); 4461 4462 return 0; 4463} 4464 4465static int parse_bit_i_tbl_entry(struct drm_device *dev, struct nvbios *bios, struct bit_entry *bitentry) 4466{ 4467 /* 4468 * BIT 'i' (info?) table 4469 * 4470 * offset + 0 (32 bits): BIOS version dword (as in B table) 4471 * offset + 5 (8 bits): BIOS feature byte (same as for BMP?) 4472 * offset + 13 (16 bits): pointer to table containing DAC load 4473 * detection comparison values 4474 * 4475 * There's other things in the table, purpose unknown 4476 */ 4477 4478 uint16_t daccmpoffset; 4479 uint8_t dacver, dacheaderlen; 4480 4481 if (bitentry->length < 6) { 4482 NV_ERROR(dev, "BIT i table too short for needed information\n"); 4483 return -EINVAL; 4484 } 4485 4486 parse_bios_version(dev, bios, bitentry->offset); 4487 4488 /* 4489 * bit 4 seems to indicate a mobile bios (doesn't suffer from BMP's 4490 * Quadro identity crisis), other bits possibly as for BMP feature byte 4491 */ 4492 bios->feature_byte = bios->data[bitentry->offset + 5]; 4493 bios->is_mobile = bios->feature_byte & FEATURE_MOBILE; 4494 4495 if (bitentry->length < 15) { 4496 NV_WARN(dev, "BIT i table not long enough for DAC load " 4497 "detection comparison table\n"); 4498 return -EINVAL; 4499 } 4500 4501 daccmpoffset = ROM16(bios->data[bitentry->offset + 13]); 4502 4503 /* doesn't exist on g80 */ 4504 if (!daccmpoffset) 4505 return 0; 4506 4507 /* 4508 * The first value in the table, following the header, is the 4509 * comparison value, the second entry is a comparison value for 4510 * TV load detection. 4511 */ 4512 4513 dacver = bios->data[daccmpoffset]; 4514 dacheaderlen = bios->data[daccmpoffset + 1]; 4515 4516 if (dacver != 0x00 && dacver != 0x10) { 4517 NV_WARN(dev, "DAC load detection comparison table version " 4518 "%d.%d not known\n", dacver >> 4, dacver & 0xf); 4519 return -ENOSYS; 4520 } 4521 4522 bios->dactestval = ROM32(bios->data[daccmpoffset + dacheaderlen]); 4523 bios->tvdactestval = ROM32(bios->data[daccmpoffset + dacheaderlen + 4]); 4524 4525 return 0; 4526} 4527 4528static int parse_bit_lvds_tbl_entry(struct drm_device *dev, struct nvbios *bios, struct bit_entry *bitentry) 4529{ 4530 /* 4531 * Parses the LVDS table segment that the bit entry points to. 4532 * Starting at bitentry->offset: 4533 * 4534 * offset + 0 (16 bits): LVDS strap xlate table pointer 4535 */ 4536 4537 if (bitentry->length != 2) { 4538 NV_ERROR(dev, "Do not understand BIT LVDS table\n"); 4539 return -EINVAL; 4540 } 4541 4542 /* 4543 * No idea if it's still called the LVDS manufacturer table, but 4544 * the concept's close enough. 4545 */ 4546 bios->fp.lvdsmanufacturerpointer = ROM16(bios->data[bitentry->offset]); 4547 4548 return 0; 4549} 4550 4551static int 4552parse_bit_M_tbl_entry(struct drm_device *dev, struct nvbios *bios, 4553 struct bit_entry *bitentry) 4554{ 4555 /* 4556 * offset + 2 (8 bits): number of options in an 4557 * INIT_RAM_RESTRICT_ZM_REG_GROUP opcode option set 4558 * offset + 3 (16 bits): pointer to strap xlate table for RAM 4559 * restrict option selection 4560 * 4561 * There's a bunch of bits in this table other than the RAM restrict 4562 * stuff that we don't use - their use currently unknown 4563 */ 4564 4565 /* 4566 * Older bios versions don't have a sufficiently long table for 4567 * what we want 4568 */ 4569 if (bitentry->length < 0x5) 4570 return 0; 4571 4572 if (bitentry->id[1] < 2) { 4573 bios->ram_restrict_group_count = bios->data[bitentry->offset + 2]; 4574 bios->ram_restrict_tbl_ptr = ROM16(bios->data[bitentry->offset + 3]); 4575 } else { 4576 bios->ram_restrict_group_count = bios->data[bitentry->offset + 0]; 4577 bios->ram_restrict_tbl_ptr = ROM16(bios->data[bitentry->offset + 1]); 4578 } 4579 4580 return 0; 4581} 4582 4583static int parse_bit_tmds_tbl_entry(struct drm_device *dev, struct nvbios *bios, struct bit_entry *bitentry) 4584{ 4585 /* 4586 * Parses the pointer to the TMDS table 4587 * 4588 * Starting at bitentry->offset: 4589 * 4590 * offset + 0 (16 bits): TMDS table pointer 4591 * 4592 * The TMDS table is typically found just before the DCB table, with a 4593 * characteristic signature of 0x11,0x13 (1.1 being version, 0x13 being 4594 * length?) 4595 * 4596 * At offset +7 is a pointer to a script, which I don't know how to 4597 * run yet. 4598 * At offset +9 is a pointer to another script, likewise 4599 * Offset +11 has a pointer to a table where the first word is a pxclk 4600 * frequency and the second word a pointer to a script, which should be 4601 * run if the comparison pxclk frequency is less than the pxclk desired. 4602 * This repeats for decreasing comparison frequencies 4603 * Offset +13 has a pointer to a similar table 4604 * The selection of table (and possibly +7/+9 script) is dictated by 4605 * "or" from the DCB. 4606 */ 4607 4608 uint16_t tmdstableptr, script1, script2; 4609 4610 if (bitentry->length != 2) { 4611 NV_ERROR(dev, "Do not understand BIT TMDS table\n"); 4612 return -EINVAL; 4613 } 4614 4615 tmdstableptr = ROM16(bios->data[bitentry->offset]); 4616 4617 if (tmdstableptr == 0x0) { 4618 NV_ERROR(dev, "Pointer to TMDS table invalid\n"); 4619 return -EINVAL; 4620 } 4621 4622 /* nv50+ has v2.0, but we don't parse it atm */ 4623 if (bios->data[tmdstableptr] != 0x11) { 4624 NV_WARN(dev, 4625 "TMDS table revision %d.%d not currently supported\n", 4626 bios->data[tmdstableptr] >> 4, bios->data[tmdstableptr] & 0xf); 4627 return -ENOSYS; 4628 } 4629 4630 /* 4631 * These two scripts are odd: they don't seem to get run even when 4632 * they are not stubbed. 4633 */ 4634 script1 = ROM16(bios->data[tmdstableptr + 7]); 4635 script2 = ROM16(bios->data[tmdstableptr + 9]); 4636 if (bios->data[script1] != 'q' || bios->data[script2] != 'q') 4637 NV_WARN(dev, "TMDS table script pointers not stubbed\n"); 4638 4639 bios->tmds.output0_script_ptr = ROM16(bios->data[tmdstableptr + 11]); 4640 bios->tmds.output1_script_ptr = ROM16(bios->data[tmdstableptr + 13]); 4641 4642 return 0; 4643} 4644 4645static int 4646parse_bit_U_tbl_entry(struct drm_device *dev, struct nvbios *bios, 4647 struct bit_entry *bitentry) 4648{ 4649 /* 4650 * Parses the pointer to the G80 output script tables 4651 * 4652 * Starting at bitentry->offset: 4653 * 4654 * offset + 0 (16 bits): output script table pointer 4655 */ 4656 4657 uint16_t outputscripttableptr; 4658 4659 if (bitentry->length != 3) { 4660 NV_ERROR(dev, "Do not understand BIT U table\n"); 4661 return -EINVAL; 4662 } 4663 4664 outputscripttableptr = ROM16(bios->data[bitentry->offset]); 4665 bios->display.script_table_ptr = outputscripttableptr; 4666 return 0; 4667} 4668 4669static int 4670parse_bit_displayport_tbl_entry(struct drm_device *dev, struct nvbios *bios, 4671 struct bit_entry *bitentry) 4672{ 4673 bios->display.dp_table_ptr = ROM16(bios->data[bitentry->offset]); 4674 return 0; 4675} 4676 4677struct bit_table { 4678 const char id; 4679 int (* const parse_fn)(struct drm_device *, struct nvbios *, struct bit_entry *); 4680}; 4681 4682#define BIT_TABLE(id, funcid) ((struct bit_table){ id, parse_bit_##funcid##_tbl_entry }) 4683 4684static int 4685parse_bit_table(struct nvbios *bios, const uint16_t bitoffset, 4686 struct bit_table *table) 4687{ 4688 struct drm_device *dev = bios->dev; 4689 uint8_t maxentries = bios->data[bitoffset + 4]; 4690 int i, offset; 4691 struct bit_entry bitentry; 4692 4693 for (i = 0, offset = bitoffset + 6; i < maxentries; i++, offset += 6) { 4694 bitentry.id[0] = bios->data[offset]; 4695 4696 if (bitentry.id[0] != table->id) 4697 continue; 4698 4699 bitentry.id[1] = bios->data[offset + 1]; 4700 bitentry.length = ROM16(bios->data[offset + 2]); 4701 bitentry.offset = ROM16(bios->data[offset + 4]); 4702 4703 return table->parse_fn(dev, bios, &bitentry); 4704 } 4705 4706 NV_INFO(dev, "BIT table '%c' not found\n", table->id); 4707 return -ENOSYS; 4708} 4709 4710static int 4711parse_bit_structure(struct nvbios *bios, const uint16_t bitoffset) 4712{ 4713 int ret; 4714 4715 /* 4716 * The only restriction on parsing order currently is having 'i' first 4717 * for use of bios->*_version or bios->feature_byte while parsing; 4718 * functions shouldn't be actually *doing* anything apart from pulling 4719 * data from the image into the bios struct, thus no interdependencies 4720 */ 4721 ret = parse_bit_table(bios, bitoffset, &BIT_TABLE('i', i)); 4722 if (ret) /* info? */ 4723 return ret; 4724 if (bios->major_version >= 0x60) /* g80+ */ 4725 parse_bit_table(bios, bitoffset, &BIT_TABLE('A', A)); 4726 ret = parse_bit_table(bios, bitoffset, &BIT_TABLE('C', C)); 4727 if (ret) 4728 return ret; 4729 parse_bit_table(bios, bitoffset, &BIT_TABLE('D', display)); 4730 ret = parse_bit_table(bios, bitoffset, &BIT_TABLE('I', init)); 4731 if (ret) 4732 return ret; 4733 parse_bit_table(bios, bitoffset, &BIT_TABLE('M', M)); /* memory? */ 4734 parse_bit_table(bios, bitoffset, &BIT_TABLE('L', lvds)); 4735 parse_bit_table(bios, bitoffset, &BIT_TABLE('T', tmds)); 4736 parse_bit_table(bios, bitoffset, &BIT_TABLE('U', U)); 4737 parse_bit_table(bios, bitoffset, &BIT_TABLE('d', displayport)); 4738 4739 return 0; 4740} 4741 4742static int parse_bmp_structure(struct drm_device *dev, struct nvbios *bios, unsigned int offset) 4743{ 4744 /* 4745 * Parses the BMP structure for useful things, but does not act on them 4746 * 4747 * offset + 5: BMP major version 4748 * offset + 6: BMP minor version 4749 * offset + 9: BMP feature byte 4750 * offset + 10: BCD encoded BIOS version 4751 * 4752 * offset + 18: init script table pointer (for bios versions < 5.10h) 4753 * offset + 20: extra init script table pointer (for bios 4754 * versions < 5.10h) 4755 * 4756 * offset + 24: memory init table pointer (used on early bios versions) 4757 * offset + 26: SDR memory sequencing setup data table 4758 * offset + 28: DDR memory sequencing setup data table 4759 * 4760 * offset + 54: index of I2C CRTC pair to use for CRT output 4761 * offset + 55: index of I2C CRTC pair to use for TV output 4762 * offset + 56: index of I2C CRTC pair to use for flat panel output 4763 * offset + 58: write CRTC index for I2C pair 0 4764 * offset + 59: read CRTC index for I2C pair 0 4765 * offset + 60: write CRTC index for I2C pair 1 4766 * offset + 61: read CRTC index for I2C pair 1 4767 * 4768 * offset + 67: maximum internal PLL frequency (single stage PLL) 4769 * offset + 71: minimum internal PLL frequency (single stage PLL) 4770 * 4771 * offset + 75: script table pointers, as described in 4772 * parse_script_table_pointers 4773 * 4774 * offset + 89: TMDS single link output A table pointer 4775 * offset + 91: TMDS single link output B table pointer 4776 * offset + 95: LVDS single link output A table pointer 4777 * offset + 105: flat panel timings table pointer 4778 * offset + 107: flat panel strapping translation table pointer 4779 * offset + 117: LVDS manufacturer panel config table pointer 4780 * offset + 119: LVDS manufacturer strapping translation table pointer 4781 * 4782 * offset + 142: PLL limits table pointer 4783 * 4784 * offset + 156: minimum pixel clock for LVDS dual link 4785 */ 4786 4787 uint8_t *bmp = &bios->data[offset], bmp_version_major, bmp_version_minor; 4788 uint16_t bmplength; 4789 uint16_t legacy_scripts_offset, legacy_i2c_offset; 4790 4791 /* load needed defaults in case we can't parse this info */ 4792 bios->dcb.i2c[0].write = NV_CIO_CRE_DDC_WR__INDEX; 4793 bios->dcb.i2c[0].read = NV_CIO_CRE_DDC_STATUS__INDEX; 4794 bios->dcb.i2c[1].write = NV_CIO_CRE_DDC0_WR__INDEX; 4795 bios->dcb.i2c[1].read = NV_CIO_CRE_DDC0_STATUS__INDEX; 4796 bios->digital_min_front_porch = 0x4b; 4797 bios->fmaxvco = 256000; 4798 bios->fminvco = 128000; 4799 bios->fp.duallink_transition_clk = 90000; 4800 4801 bmp_version_major = bmp[5]; 4802 bmp_version_minor = bmp[6]; 4803 4804 NV_TRACE(dev, "BMP version %d.%d\n", 4805 bmp_version_major, bmp_version_minor); 4806 4807 /* 4808 * Make sure that 0x36 is blank and can't be mistaken for a DCB 4809 * pointer on early versions 4810 */ 4811 if (bmp_version_major < 5) 4812 *(uint16_t *)&bios->data[0x36] = 0; 4813 4814 /* 4815 * Seems that the minor version was 1 for all major versions prior 4816 * to 5. Version 6 could theoretically exist, but I suspect BIT 4817 * happened instead. 4818 */ 4819 if ((bmp_version_major < 5 && bmp_version_minor != 1) || bmp_version_major > 5) { 4820 NV_ERROR(dev, "You have an unsupported BMP version. " 4821 "Please send in your bios\n"); 4822 return -ENOSYS; 4823 } 4824 4825 if (bmp_version_major == 0) 4826 /* nothing that's currently useful in this version */ 4827 return 0; 4828 else if (bmp_version_major == 1) 4829 bmplength = 44; /* exact for 1.01 */ 4830 else if (bmp_version_major == 2) 4831 bmplength = 48; /* exact for 2.01 */ 4832 else if (bmp_version_major == 3) 4833 bmplength = 54; 4834 /* guessed - mem init tables added in this version */ 4835 else if (bmp_version_major == 4 || bmp_version_minor < 0x1) 4836 /* don't know if 5.0 exists... */ 4837 bmplength = 62; 4838 /* guessed - BMP I2C indices added in version 4*/ 4839 else if (bmp_version_minor < 0x6) 4840 bmplength = 67; /* exact for 5.01 */ 4841 else if (bmp_version_minor < 0x10) 4842 bmplength = 75; /* exact for 5.06 */ 4843 else if (bmp_version_minor == 0x10) 4844 bmplength = 89; /* exact for 5.10h */ 4845 else if (bmp_version_minor < 0x14) 4846 bmplength = 118; /* exact for 5.11h */ 4847 else if (bmp_version_minor < 0x24) 4848 /* 4849 * Not sure of version where pll limits came in; 4850 * certainly exist by 0x24 though. 4851 */ 4852 /* length not exact: this is long enough to get lvds members */ 4853 bmplength = 123; 4854 else if (bmp_version_minor < 0x27) 4855 /* 4856 * Length not exact: this is long enough to get pll limit 4857 * member 4858 */ 4859 bmplength = 144; 4860 else 4861 /* 4862 * Length not exact: this is long enough to get dual link 4863 * transition clock. 4864 */ 4865 bmplength = 158; 4866 4867 /* checksum */ 4868 if (nv_cksum(bmp, 8)) { 4869 NV_ERROR(dev, "Bad BMP checksum\n"); 4870 return -EINVAL; 4871 } 4872 4873 /* 4874 * Bit 4 seems to indicate either a mobile bios or a quadro card -- 4875 * mobile behaviour consistent (nv11+), quadro only seen nv18gl-nv36gl 4876 * (not nv10gl), bit 5 that the flat panel tables are present, and 4877 * bit 6 a tv bios. 4878 */ 4879 bios->feature_byte = bmp[9]; 4880 4881 parse_bios_version(dev, bios, offset + 10); 4882 4883 if (bmp_version_major < 5 || bmp_version_minor < 0x10) 4884 bios->old_style_init = true; 4885 legacy_scripts_offset = 18; 4886 if (bmp_version_major < 2) 4887 legacy_scripts_offset -= 4; 4888 bios->init_script_tbls_ptr = ROM16(bmp[legacy_scripts_offset]); 4889 bios->extra_init_script_tbl_ptr = ROM16(bmp[legacy_scripts_offset + 2]); 4890 4891 if (bmp_version_major > 2) { /* appears in BMP 3 */ 4892 bios->legacy.mem_init_tbl_ptr = ROM16(bmp[24]); 4893 bios->legacy.sdr_seq_tbl_ptr = ROM16(bmp[26]); 4894 bios->legacy.ddr_seq_tbl_ptr = ROM16(bmp[28]); 4895 } 4896 4897 legacy_i2c_offset = 0x48; /* BMP version 2 & 3 */ 4898 if (bmplength > 61) 4899 legacy_i2c_offset = offset + 54; 4900 bios->legacy.i2c_indices.crt = bios->data[legacy_i2c_offset]; 4901 bios->legacy.i2c_indices.tv = bios->data[legacy_i2c_offset + 1]; 4902 bios->legacy.i2c_indices.panel = bios->data[legacy_i2c_offset + 2]; 4903 bios->dcb.i2c[0].write = bios->data[legacy_i2c_offset + 4]; 4904 bios->dcb.i2c[0].read = bios->data[legacy_i2c_offset + 5]; 4905 bios->dcb.i2c[1].write = bios->data[legacy_i2c_offset + 6]; 4906 bios->dcb.i2c[1].read = bios->data[legacy_i2c_offset + 7]; 4907 4908 if (bmplength > 74) { 4909 bios->fmaxvco = ROM32(bmp[67]); 4910 bios->fminvco = ROM32(bmp[71]); 4911 } 4912 if (bmplength > 88) 4913 parse_script_table_pointers(bios, offset + 75); 4914 if (bmplength > 94) { 4915 bios->tmds.output0_script_ptr = ROM16(bmp[89]); 4916 bios->tmds.output1_script_ptr = ROM16(bmp[91]); 4917 /* 4918 * Never observed in use with lvds scripts, but is reused for 4919 * 18/24 bit panel interface default for EDID equipped panels 4920 * (if_is_24bit not set directly to avoid any oscillation). 4921 */ 4922 bios->legacy.lvds_single_a_script_ptr = ROM16(bmp[95]); 4923 } 4924 if (bmplength > 108) { 4925 bios->fp.fptablepointer = ROM16(bmp[105]); 4926 bios->fp.fpxlatetableptr = ROM16(bmp[107]); 4927 bios->fp.xlatwidth = 1; 4928 } 4929 if (bmplength > 120) { 4930 bios->fp.lvdsmanufacturerpointer = ROM16(bmp[117]); 4931 bios->fp.fpxlatemanufacturertableptr = ROM16(bmp[119]); 4932 } 4933 if (bmplength > 143) 4934 bios->pll_limit_tbl_ptr = ROM16(bmp[142]); 4935 4936 if (bmplength > 157) 4937 bios->fp.duallink_transition_clk = ROM16(bmp[156]) * 10; 4938 4939 return 0; 4940} 4941 4942static uint16_t findstr(uint8_t *data, int n, const uint8_t *str, int len) 4943{ 4944 int i, j; 4945 4946 for (i = 0; i <= (n - len); i++) { 4947 for (j = 0; j < len; j++) 4948 if (data[i + j] != str[j]) 4949 break; 4950 if (j == len) 4951 return i; 4952 } 4953 4954 return 0; 4955} 4956 4957static int 4958read_dcb_i2c_entry(struct drm_device *dev, int dcb_version, uint8_t *i2ctable, int index, struct dcb_i2c_entry *i2c) 4959{ 4960 uint8_t dcb_i2c_ver = dcb_version, headerlen = 0, entry_len = 4; 4961 int i2c_entries = DCB_MAX_NUM_I2C_ENTRIES; 4962 int recordoffset = 0, rdofs = 1, wrofs = 0; 4963 uint8_t port_type = 0; 4964 4965 if (!i2ctable) 4966 return -EINVAL; 4967 4968 if (dcb_version >= 0x30) { 4969 if (i2ctable[0] != dcb_version) /* necessary? */ 4970 NV_WARN(dev, 4971 "DCB I2C table version mismatch (%02X vs %02X)\n", 4972 i2ctable[0], dcb_version); 4973 dcb_i2c_ver = i2ctable[0]; 4974 headerlen = i2ctable[1]; 4975 if (i2ctable[2] <= DCB_MAX_NUM_I2C_ENTRIES) 4976 i2c_entries = i2ctable[2]; 4977 else 4978 NV_WARN(dev, 4979 "DCB I2C table has more entries than indexable " 4980 "(%d entries, max %d)\n", i2ctable[2], 4981 DCB_MAX_NUM_I2C_ENTRIES); 4982 entry_len = i2ctable[3]; 4983 /* [4] is i2c_default_indices, read in parse_dcb_table() */ 4984 } 4985 /* 4986 * It's your own fault if you call this function on a DCB 1.1 BIOS -- 4987 * the test below is for DCB 1.2 4988 */ 4989 if (dcb_version < 0x14) { 4990 recordoffset = 2; 4991 rdofs = 0; 4992 wrofs = 1; 4993 } 4994 4995 if (index == 0xf) 4996 return 0; 4997 if (index >= i2c_entries) { 4998 NV_ERROR(dev, "DCB I2C index too big (%d >= %d)\n", 4999 index, i2ctable[2]); 5000 return -ENOENT; 5001 } 5002 if (i2ctable[headerlen + entry_len * index + 3] == 0xff) { 5003 NV_ERROR(dev, "DCB I2C entry invalid\n"); 5004 return -EINVAL; 5005 } 5006 5007 if (dcb_i2c_ver >= 0x30) { 5008 port_type = i2ctable[headerlen + recordoffset + 3 + entry_len * index]; 5009 5010 /* 5011 * Fixup for chips using same address offset for read and 5012 * write. 5013 */ 5014 if (port_type == 4) /* seen on C51 */ 5015 rdofs = wrofs = 1; 5016 if (port_type >= 5) /* G80+ */ 5017 rdofs = wrofs = 0; 5018 } 5019 5020 if (dcb_i2c_ver >= 0x40 && port_type != 5 && port_type != 6) 5021 NV_WARN(dev, "DCB I2C table has port type %d\n", port_type); 5022 5023 i2c->port_type = port_type; 5024 i2c->read = i2ctable[headerlen + recordoffset + rdofs + entry_len * index]; 5025 i2c->write = i2ctable[headerlen + recordoffset + wrofs + entry_len * index]; 5026 5027 return 0; 5028} 5029 5030static struct dcb_gpio_entry * 5031new_gpio_entry(struct nvbios *bios) 5032{ 5033 struct dcb_gpio_table *gpio = &bios->dcb.gpio; 5034 5035 return &gpio->entry[gpio->entries++]; 5036} 5037 5038struct dcb_gpio_entry * 5039nouveau_bios_gpio_entry(struct drm_device *dev, enum dcb_gpio_tag tag) 5040{ 5041 struct drm_nouveau_private *dev_priv = dev->dev_private; 5042 struct nvbios *bios = &dev_priv->vbios; 5043 int i; 5044 5045 for (i = 0; i < bios->dcb.gpio.entries; i++) { 5046 if (bios->dcb.gpio.entry[i].tag != tag) 5047 continue; 5048 5049 return &bios->dcb.gpio.entry[i]; 5050 } 5051 5052 return NULL; 5053} 5054 5055static void 5056parse_dcb30_gpio_entry(struct nvbios *bios, uint16_t offset) 5057{ 5058 struct dcb_gpio_entry *gpio; 5059 uint16_t ent = ROM16(bios->data[offset]); 5060 uint8_t line = ent & 0x1f, 5061 tag = ent >> 5 & 0x3f, 5062 flags = ent >> 11 & 0x1f; 5063 5064 if (tag == 0x3f) 5065 return; 5066 5067 gpio = new_gpio_entry(bios); 5068 5069 gpio->tag = tag; 5070 gpio->line = line; 5071 gpio->invert = flags != 4; 5072 gpio->entry = ent; 5073} 5074 5075static void 5076parse_dcb40_gpio_entry(struct nvbios *bios, uint16_t offset) 5077{ 5078 uint32_t entry = ROM32(bios->data[offset]); 5079 struct dcb_gpio_entry *gpio; 5080 5081 if ((entry & 0x0000ff00) == 0x0000ff00) 5082 return; 5083 5084 gpio = new_gpio_entry(bios); 5085 gpio->tag = (entry & 0x0000ff00) >> 8; 5086 gpio->line = (entry & 0x0000001f) >> 0; 5087 gpio->state_default = (entry & 0x01000000) >> 24; 5088 gpio->state[0] = (entry & 0x18000000) >> 27; 5089 gpio->state[1] = (entry & 0x60000000) >> 29; 5090 gpio->entry = entry; 5091} 5092 5093static void 5094parse_dcb_gpio_table(struct nvbios *bios) 5095{ 5096 struct drm_device *dev = bios->dev; 5097 uint16_t gpio_table_ptr = bios->dcb.gpio_table_ptr; 5098 uint8_t *gpio_table = &bios->data[gpio_table_ptr]; 5099 int header_len = gpio_table[1], 5100 entries = gpio_table[2], 5101 entry_len = gpio_table[3]; 5102 void (*parse_entry)(struct nvbios *, uint16_t) = NULL; 5103 int i; 5104 5105 if (bios->dcb.version >= 0x40) { 5106 if (gpio_table_ptr && entry_len != 4) { 5107 NV_WARN(dev, "Invalid DCB GPIO table entry length.\n"); 5108 return; 5109 } 5110 5111 parse_entry = parse_dcb40_gpio_entry; 5112 5113 } else if (bios->dcb.version >= 0x30) { 5114 if (gpio_table_ptr && entry_len != 2) { 5115 NV_WARN(dev, "Invalid DCB GPIO table entry length.\n"); 5116 return; 5117 } 5118 5119 parse_entry = parse_dcb30_gpio_entry; 5120 5121 } else if (bios->dcb.version >= 0x22) { 5122 /* 5123 * DCBs older than v3.0 don't really have a GPIO 5124 * table, instead they keep some GPIO info at fixed 5125 * locations. 5126 */ 5127 uint16_t dcbptr = ROM16(bios->data[0x36]); 5128 uint8_t *tvdac_gpio = &bios->data[dcbptr - 5]; 5129 5130 if (tvdac_gpio[0] & 1) { 5131 struct dcb_gpio_entry *gpio = new_gpio_entry(bios); 5132 5133 gpio->tag = DCB_GPIO_TVDAC0; 5134 gpio->line = tvdac_gpio[1] >> 4; 5135 gpio->invert = tvdac_gpio[0] & 2; 5136 } 5137 } 5138 5139 if (!gpio_table_ptr) 5140 return; 5141 5142 if (entries > DCB_MAX_NUM_GPIO_ENTRIES) { 5143 NV_WARN(dev, "Too many entries in the DCB GPIO table.\n"); 5144 entries = DCB_MAX_NUM_GPIO_ENTRIES; 5145 } 5146 5147 for (i = 0; i < entries; i++) 5148 parse_entry(bios, gpio_table_ptr + header_len + entry_len * i); 5149} 5150 5151struct dcb_connector_table_entry * 5152nouveau_bios_connector_entry(struct drm_device *dev, int index) 5153{ 5154 struct drm_nouveau_private *dev_priv = dev->dev_private; 5155 struct nvbios *bios = &dev_priv->vbios; 5156 struct dcb_connector_table_entry *cte; 5157 5158 if (index >= bios->dcb.connector.entries) 5159 return NULL; 5160 5161 cte = &bios->dcb.connector.entry[index]; 5162 if (cte->type == 0xff) 5163 return NULL; 5164 5165 return cte; 5166} 5167 5168static enum dcb_connector_type 5169divine_connector_type(struct nvbios *bios, int index) 5170{ 5171 struct dcb_table *dcb = &bios->dcb; 5172 unsigned encoders = 0, type = DCB_CONNECTOR_NONE; 5173 int i; 5174 5175 for (i = 0; i < dcb->entries; i++) { 5176 if (dcb->entry[i].connector == index) 5177 encoders |= (1 << dcb->entry[i].type); 5178 } 5179 5180 if (encoders & (1 << OUTPUT_DP)) { 5181 if (encoders & (1 << OUTPUT_TMDS)) 5182 type = DCB_CONNECTOR_DP; 5183 else 5184 type = DCB_CONNECTOR_eDP; 5185 } else 5186 if (encoders & (1 << OUTPUT_TMDS)) { 5187 if (encoders & (1 << OUTPUT_ANALOG)) 5188 type = DCB_CONNECTOR_DVI_I; 5189 else 5190 type = DCB_CONNECTOR_DVI_D; 5191 } else 5192 if (encoders & (1 << OUTPUT_ANALOG)) { 5193 type = DCB_CONNECTOR_VGA; 5194 } else 5195 if (encoders & (1 << OUTPUT_LVDS)) { 5196 type = DCB_CONNECTOR_LVDS; 5197 } else 5198 if (encoders & (1 << OUTPUT_TV)) { 5199 type = DCB_CONNECTOR_TV_0; 5200 } 5201 5202 return type; 5203} 5204 5205static void 5206apply_dcb_connector_quirks(struct nvbios *bios, int idx) 5207{ 5208 struct dcb_connector_table_entry *cte = &bios->dcb.connector.entry[idx]; 5209 struct drm_device *dev = bios->dev; 5210 5211 /* Gigabyte NX85T */ 5212 if ((dev->pdev->device == 0x0421) && 5213 (dev->pdev->subsystem_vendor == 0x1458) && 5214 (dev->pdev->subsystem_device == 0x344c)) { 5215 if (cte->type == DCB_CONNECTOR_HDMI_1) 5216 cte->type = DCB_CONNECTOR_DVI_I; 5217 } 5218} 5219 5220static void 5221parse_dcb_connector_table(struct nvbios *bios) 5222{ 5223 struct drm_device *dev = bios->dev; 5224 struct dcb_connector_table *ct = &bios->dcb.connector; 5225 struct dcb_connector_table_entry *cte; 5226 uint8_t *conntab = &bios->data[bios->dcb.connector_table_ptr]; 5227 uint8_t *entry; 5228 int i; 5229 5230 if (!bios->dcb.connector_table_ptr) { 5231 NV_DEBUG_KMS(dev, "No DCB connector table present\n"); 5232 return; 5233 } 5234 5235 NV_INFO(dev, "DCB connector table: VHER 0x%02x %d %d %d\n", 5236 conntab[0], conntab[1], conntab[2], conntab[3]); 5237 if ((conntab[0] != 0x30 && conntab[0] != 0x40) || 5238 (conntab[3] != 2 && conntab[3] != 4)) { 5239 NV_ERROR(dev, " Unknown! Please report.\n"); 5240 return; 5241 } 5242 5243 ct->entries = conntab[2]; 5244 5245 entry = conntab + conntab[1]; 5246 cte = &ct->entry[0]; 5247 for (i = 0; i < conntab[2]; i++, entry += conntab[3], cte++) { 5248 cte->index = i; 5249 if (conntab[3] == 2) 5250 cte->entry = ROM16(entry[0]); 5251 else 5252 cte->entry = ROM32(entry[0]); 5253 5254 cte->type = (cte->entry & 0x000000ff) >> 0; 5255 cte->index2 = (cte->entry & 0x00000f00) >> 8; 5256 switch (cte->entry & 0x00033000) { 5257 case 0x00001000: 5258 cte->gpio_tag = 0x07; 5259 break; 5260 case 0x00002000: 5261 cte->gpio_tag = 0x08; 5262 break; 5263 case 0x00010000: 5264 cte->gpio_tag = 0x51; 5265 break; 5266 case 0x00020000: 5267 cte->gpio_tag = 0x52; 5268 break; 5269 default: 5270 cte->gpio_tag = 0xff; 5271 break; 5272 } 5273 5274 if (cte->type == 0xff) 5275 continue; 5276 5277 apply_dcb_connector_quirks(bios, i); 5278 5279 NV_INFO(dev, " %d: 0x%08x: type 0x%02x idx %d tag 0x%02x\n", 5280 i, cte->entry, cte->type, cte->index, cte->gpio_tag); 5281 5282 /* check for known types, fallback to guessing the type 5283 * from attached encoders if we hit an unknown. 5284 */ 5285 switch (cte->type) { 5286 case DCB_CONNECTOR_VGA: 5287 case DCB_CONNECTOR_TV_0: 5288 case DCB_CONNECTOR_TV_1: 5289 case DCB_CONNECTOR_TV_3: 5290 case DCB_CONNECTOR_DVI_I: 5291 case DCB_CONNECTOR_DVI_D: 5292 case DCB_CONNECTOR_LVDS: 5293 case DCB_CONNECTOR_DP: 5294 case DCB_CONNECTOR_eDP: 5295 case DCB_CONNECTOR_HDMI_0: 5296 case DCB_CONNECTOR_HDMI_1: 5297 break; 5298 default: 5299 cte->type = divine_connector_type(bios, cte->index); 5300 NV_WARN(dev, "unknown type, using 0x%02x\n", cte->type); 5301 break; 5302 } 5303 5304 if (nouveau_override_conntype) { 5305 int type = divine_connector_type(bios, cte->index); 5306 if (type != cte->type) 5307 NV_WARN(dev, " -> type 0x%02x\n", cte->type); 5308 } 5309 5310 } 5311} 5312 5313static struct dcb_entry *new_dcb_entry(struct dcb_table *dcb) 5314{ 5315 struct dcb_entry *entry = &dcb->entry[dcb->entries]; 5316 5317 memset(entry, 0, sizeof(struct dcb_entry)); 5318 entry->index = dcb->entries++; 5319 5320 return entry; 5321} 5322 5323static void fabricate_vga_output(struct dcb_table *dcb, int i2c, int heads) 5324{ 5325 struct dcb_entry *entry = new_dcb_entry(dcb); 5326 5327 entry->type = 0; 5328 entry->i2c_index = i2c; 5329 entry->heads = heads; 5330 entry->location = DCB_LOC_ON_CHIP; 5331 /* "or" mostly unused in early gen crt modesetting, 0 is fine */ 5332} 5333 5334static void fabricate_dvi_i_output(struct dcb_table *dcb, bool twoHeads) 5335{ 5336 struct dcb_entry *entry = new_dcb_entry(dcb); 5337 5338 entry->type = 2; 5339 entry->i2c_index = LEGACY_I2C_PANEL; 5340 entry->heads = twoHeads ? 3 : 1; 5341 entry->location = !DCB_LOC_ON_CHIP; /* ie OFF CHIP */ 5342 entry->or = 1; /* means |0x10 gets set on CRE_LCD__INDEX */ 5343 entry->duallink_possible = false; /* SiI164 and co. are single link */ 5344 5345#if 0 5346 /* 5347 * For dvi-a either crtc probably works, but my card appears to only 5348 * support dvi-d. "nvidia" still attempts to program it for dvi-a, 5349 * doing the full fp output setup (program 0x6808.. fp dimension regs, 5350 * setting 0x680848 to 0x10000111 to enable, maybe setting 0x680880); 5351 * the monitor picks up the mode res ok and lights up, but no pixel 5352 * data appears, so the board manufacturer probably connected up the 5353 * sync lines, but missed the video traces / components 5354 * 5355 * with this introduction, dvi-a left as an exercise for the reader. 5356 */ 5357 fabricate_vga_output(dcb, LEGACY_I2C_PANEL, entry->heads); 5358#endif 5359} 5360 5361static void fabricate_tv_output(struct dcb_table *dcb, bool twoHeads) 5362{ 5363 struct dcb_entry *entry = new_dcb_entry(dcb); 5364 5365 entry->type = 1; 5366 entry->i2c_index = LEGACY_I2C_TV; 5367 entry->heads = twoHeads ? 3 : 1; 5368 entry->location = !DCB_LOC_ON_CHIP; /* ie OFF CHIP */ 5369} 5370 5371static bool 5372parse_dcb20_entry(struct drm_device *dev, struct dcb_table *dcb, 5373 uint32_t conn, uint32_t conf, struct dcb_entry *entry) 5374{ 5375 entry->type = conn & 0xf; 5376 entry->i2c_index = (conn >> 4) & 0xf; 5377 entry->heads = (conn >> 8) & 0xf; 5378 if (dcb->version >= 0x40) 5379 entry->connector = (conn >> 12) & 0xf; 5380 entry->bus = (conn >> 16) & 0xf; 5381 entry->location = (conn >> 20) & 0x3; 5382 entry->or = (conn >> 24) & 0xf; 5383 /* 5384 * Normal entries consist of a single bit, but dual link has the 5385 * next most significant bit set too 5386 */ 5387 entry->duallink_possible = 5388 ((1 << (ffs(entry->or) - 1)) * 3 == entry->or); 5389 5390 switch (entry->type) { 5391 case OUTPUT_ANALOG: 5392 /* 5393 * Although the rest of a CRT conf dword is usually 5394 * zeros, mac biosen have stuff there so we must mask 5395 */ 5396 entry->crtconf.maxfreq = (dcb->version < 0x30) ? 5397 (conf & 0xffff) * 10 : 5398 (conf & 0xff) * 10000; 5399 break; 5400 case OUTPUT_LVDS: 5401 { 5402 uint32_t mask; 5403 if (conf & 0x1) 5404 entry->lvdsconf.use_straps_for_mode = true; 5405 if (dcb->version < 0x22) { 5406 mask = ~0xd; 5407 /* 5408 * The laptop in bug 14567 lies and claims to not use 5409 * straps when it does, so assume all DCB 2.0 laptops 5410 * use straps, until a broken EDID using one is produced 5411 */ 5412 entry->lvdsconf.use_straps_for_mode = true; 5413 /* 5414 * Both 0x4 and 0x8 show up in v2.0 tables; assume they 5415 * mean the same thing (probably wrong, but might work) 5416 */ 5417 if (conf & 0x4 || conf & 0x8) 5418 entry->lvdsconf.use_power_scripts = true; 5419 } else { 5420 mask = ~0x5; 5421 if (conf & 0x4) 5422 entry->lvdsconf.use_power_scripts = true; 5423 } 5424 if (conf & mask) { 5425 /* 5426 * Until we even try to use these on G8x, it's 5427 * useless reporting unknown bits. They all are. 5428 */ 5429 if (dcb->version >= 0x40) 5430 break; 5431 5432 NV_ERROR(dev, "Unknown LVDS configuration bits, " 5433 "please report\n"); 5434 } 5435 break; 5436 } 5437 case OUTPUT_TV: 5438 { 5439 if (dcb->version >= 0x30) 5440 entry->tvconf.has_component_output = conf & (0x8 << 4); 5441 else 5442 entry->tvconf.has_component_output = false; 5443 5444 break; 5445 } 5446 case OUTPUT_DP: 5447 entry->dpconf.sor.link = (conf & 0x00000030) >> 4; 5448 entry->dpconf.link_bw = (conf & 0x00e00000) >> 21; 5449 switch ((conf & 0x0f000000) >> 24) { 5450 case 0xf: 5451 entry->dpconf.link_nr = 4; 5452 break; 5453 case 0x3: 5454 entry->dpconf.link_nr = 2; 5455 break; 5456 default: 5457 entry->dpconf.link_nr = 1; 5458 break; 5459 } 5460 break; 5461 case OUTPUT_TMDS: 5462 entry->tmdsconf.sor.link = (conf & 0x00000030) >> 4; 5463 break; 5464 case 0xe: 5465 /* weird g80 mobile type that "nv" treats as a terminator */ 5466 dcb->entries--; 5467 return false; 5468 default: 5469 break; 5470 } 5471 5472 /* unsure what DCB version introduces this, 3.0? */ 5473 if (conf & 0x100000) 5474 entry->i2c_upper_default = true; 5475 5476 return true; 5477} 5478 5479static bool 5480parse_dcb15_entry(struct drm_device *dev, struct dcb_table *dcb, 5481 uint32_t conn, uint32_t conf, struct dcb_entry *entry) 5482{ 5483 switch (conn & 0x0000000f) { 5484 case 0: 5485 entry->type = OUTPUT_ANALOG; 5486 break; 5487 case 1: 5488 entry->type = OUTPUT_TV; 5489 break; 5490 case 2: 5491 case 3: 5492 entry->type = OUTPUT_LVDS; 5493 break; 5494 case 4: 5495 switch ((conn & 0x000000f0) >> 4) { 5496 case 0: 5497 entry->type = OUTPUT_TMDS; 5498 break; 5499 case 1: 5500 entry->type = OUTPUT_LVDS; 5501 break; 5502 default: 5503 NV_ERROR(dev, "Unknown DCB subtype 4/%d\n", 5504 (conn & 0x000000f0) >> 4); 5505 return false; 5506 } 5507 break; 5508 default: 5509 NV_ERROR(dev, "Unknown DCB type %d\n", conn & 0x0000000f); 5510 return false; 5511 } 5512 5513 entry->i2c_index = (conn & 0x0003c000) >> 14; 5514 entry->heads = ((conn & 0x001c0000) >> 18) + 1; 5515 entry->or = entry->heads; /* same as heads, hopefully safe enough */ 5516 entry->location = (conn & 0x01e00000) >> 21; 5517 entry->bus = (conn & 0x0e000000) >> 25; 5518 entry->duallink_possible = false; 5519 5520 switch (entry->type) { 5521 case OUTPUT_ANALOG: 5522 entry->crtconf.maxfreq = (conf & 0xffff) * 10; 5523 break; 5524 case OUTPUT_TV: 5525 entry->tvconf.has_component_output = false; 5526 break; 5527 case OUTPUT_TMDS: 5528 /* 5529 * Invent a DVI-A output, by copying the fields of the DVI-D 5530 * output; reported to work by math_b on an NV20(!). 5531 */ 5532 fabricate_vga_output(dcb, entry->i2c_index, entry->heads); 5533 break; 5534 case OUTPUT_LVDS: 5535 if ((conn & 0x00003f00) != 0x10) 5536 entry->lvdsconf.use_straps_for_mode = true; 5537 entry->lvdsconf.use_power_scripts = true; 5538 break; 5539 default: 5540 break; 5541 } 5542 5543 return true; 5544} 5545 5546static bool parse_dcb_entry(struct drm_device *dev, struct dcb_table *dcb, 5547 uint32_t conn, uint32_t conf) 5548{ 5549 struct dcb_entry *entry = new_dcb_entry(dcb); 5550 bool ret; 5551 5552 if (dcb->version >= 0x20) 5553 ret = parse_dcb20_entry(dev, dcb, conn, conf, entry); 5554 else 5555 ret = parse_dcb15_entry(dev, dcb, conn, conf, entry); 5556 if (!ret) 5557 return ret; 5558 5559 read_dcb_i2c_entry(dev, dcb->version, dcb->i2c_table, 5560 entry->i2c_index, &dcb->i2c[entry->i2c_index]); 5561 5562 return true; 5563} 5564 5565static 5566void merge_like_dcb_entries(struct drm_device *dev, struct dcb_table *dcb) 5567{ 5568 /* 5569 * DCB v2.0 lists each output combination separately. 5570 * Here we merge compatible entries to have fewer outputs, with 5571 * more options 5572 */ 5573 5574 int i, newentries = 0; 5575 5576 for (i = 0; i < dcb->entries; i++) { 5577 struct dcb_entry *ient = &dcb->entry[i]; 5578 int j; 5579 5580 for (j = i + 1; j < dcb->entries; j++) { 5581 struct dcb_entry *jent = &dcb->entry[j]; 5582 5583 if (jent->type == 100) /* already merged entry */ 5584 continue; 5585 5586 /* merge heads field when all other fields the same */ 5587 if (jent->i2c_index == ient->i2c_index && 5588 jent->type == ient->type && 5589 jent->location == ient->location && 5590 jent->or == ient->or) { 5591 NV_TRACE(dev, "Merging DCB entries %d and %d\n", 5592 i, j); 5593 ient->heads |= jent->heads; 5594 jent->type = 100; /* dummy value */ 5595 } 5596 } 5597 } 5598 5599 /* Compact entries merged into others out of dcb */ 5600 for (i = 0; i < dcb->entries; i++) { 5601 if (dcb->entry[i].type == 100) 5602 continue; 5603 5604 if (newentries != i) { 5605 dcb->entry[newentries] = dcb->entry[i]; 5606 dcb->entry[newentries].index = newentries; 5607 } 5608 newentries++; 5609 } 5610 5611 dcb->entries = newentries; 5612} 5613 5614static int 5615parse_dcb_table(struct drm_device *dev, struct nvbios *bios, bool twoHeads) 5616{ 5617 struct drm_nouveau_private *dev_priv = dev->dev_private; 5618 struct dcb_table *dcb = &bios->dcb; 5619 uint16_t dcbptr = 0, i2ctabptr = 0; 5620 uint8_t *dcbtable; 5621 uint8_t headerlen = 0x4, entries = DCB_MAX_NUM_ENTRIES; 5622 bool configblock = true; 5623 int recordlength = 8, confofs = 4; 5624 int i; 5625 5626 /* get the offset from 0x36 */ 5627 if (dev_priv->card_type > NV_04) { 5628 dcbptr = ROM16(bios->data[0x36]); 5629 if (dcbptr == 0x0000) 5630 NV_WARN(dev, "No output data (DCB) found in BIOS\n"); 5631 } 5632 5633 /* this situation likely means a really old card, pre DCB */ 5634 if (dcbptr == 0x0) { 5635 NV_INFO(dev, "Assuming a CRT output exists\n"); 5636 fabricate_vga_output(dcb, LEGACY_I2C_CRT, 1); 5637 5638 if (nv04_tv_identify(dev, bios->legacy.i2c_indices.tv) >= 0) 5639 fabricate_tv_output(dcb, twoHeads); 5640 5641 return 0; 5642 } 5643 5644 dcbtable = &bios->data[dcbptr]; 5645 5646 /* get DCB version */ 5647 dcb->version = dcbtable[0]; 5648 NV_TRACE(dev, "Found Display Configuration Block version %d.%d\n", 5649 dcb->version >> 4, dcb->version & 0xf); 5650 5651 if (dcb->version >= 0x20) { /* NV17+ */ 5652 uint32_t sig; 5653 5654 if (dcb->version >= 0x30) { /* NV40+ */ 5655 headerlen = dcbtable[1]; 5656 entries = dcbtable[2]; 5657 recordlength = dcbtable[3]; 5658 i2ctabptr = ROM16(dcbtable[4]); 5659 sig = ROM32(dcbtable[6]); 5660 dcb->gpio_table_ptr = ROM16(dcbtable[10]); 5661 dcb->connector_table_ptr = ROM16(dcbtable[20]); 5662 } else { 5663 i2ctabptr = ROM16(dcbtable[2]); 5664 sig = ROM32(dcbtable[4]); 5665 headerlen = 8; 5666 } 5667 5668 if (sig != 0x4edcbdcb) { 5669 NV_ERROR(dev, "Bad Display Configuration Block " 5670 "signature (%08X)\n", sig); 5671 return -EINVAL; 5672 } 5673 } else if (dcb->version >= 0x15) { /* some NV11 and NV20 */ 5674 char sig[8] = { 0 }; 5675 5676 strncpy(sig, (char *)&dcbtable[-7], 7); 5677 i2ctabptr = ROM16(dcbtable[2]); 5678 recordlength = 10; 5679 confofs = 6; 5680 5681 if (strcmp(sig, "DEV_REC")) { 5682 NV_ERROR(dev, "Bad Display Configuration Block " 5683 "signature (%s)\n", sig); 5684 return -EINVAL; 5685 } 5686 } else { 5687 /* 5688 * v1.4 (some NV15/16, NV11+) seems the same as v1.5, but always 5689 * has the same single (crt) entry, even when tv-out present, so 5690 * the conclusion is this version cannot really be used. 5691 * v1.2 tables (some NV6/10, and NV15+) normally have the same 5692 * 5 entries, which are not specific to the card and so no use. 5693 * v1.2 does have an I2C table that read_dcb_i2c_table can 5694 * handle, but cards exist (nv11 in #14821) with a bad i2c table 5695 * pointer, so use the indices parsed in parse_bmp_structure. 5696 * v1.1 (NV5+, maybe some NV4) is entirely unhelpful 5697 */ 5698 NV_TRACEWARN(dev, "No useful information in BIOS output table; " 5699 "adding all possible outputs\n"); 5700 fabricate_vga_output(dcb, LEGACY_I2C_CRT, 1); 5701 5702 /* 5703 * Attempt to detect TV before DVI because the test 5704 * for the former is more accurate and it rules the 5705 * latter out. 5706 */ 5707 if (nv04_tv_identify(dev, 5708 bios->legacy.i2c_indices.tv) >= 0) 5709 fabricate_tv_output(dcb, twoHeads); 5710 5711 else if (bios->tmds.output0_script_ptr || 5712 bios->tmds.output1_script_ptr) 5713 fabricate_dvi_i_output(dcb, twoHeads); 5714 5715 return 0; 5716 } 5717 5718 if (!i2ctabptr) 5719 NV_WARN(dev, "No pointer to DCB I2C port table\n"); 5720 else { 5721 dcb->i2c_table = &bios->data[i2ctabptr]; 5722 if (dcb->version >= 0x30) 5723 dcb->i2c_default_indices = dcb->i2c_table[4]; 5724 } 5725 5726 if (entries > DCB_MAX_NUM_ENTRIES) 5727 entries = DCB_MAX_NUM_ENTRIES; 5728 5729 for (i = 0; i < entries; i++) { 5730 uint32_t connection, config = 0; 5731 5732 connection = ROM32(dcbtable[headerlen + recordlength * i]); 5733 if (configblock) 5734 config = ROM32(dcbtable[headerlen + confofs + recordlength * i]); 5735 5736 /* seen on an NV11 with DCB v1.5 */ 5737 if (connection == 0x00000000) 5738 break; 5739 5740 /* seen on an NV17 with DCB v2.0 */ 5741 if (connection == 0xffffffff) 5742 break; 5743 5744 if ((connection & 0x0000000f) == 0x0000000f) 5745 continue; 5746 5747 NV_TRACEWARN(dev, "Raw DCB entry %d: %08x %08x\n", 5748 dcb->entries, connection, config); 5749 5750 if (!parse_dcb_entry(dev, dcb, connection, config)) 5751 break; 5752 } 5753 5754 /* 5755 * apart for v2.1+ not being known for requiring merging, this 5756 * guarantees dcbent->index is the index of the entry in the rom image 5757 */ 5758 if (dcb->version < 0x21) 5759 merge_like_dcb_entries(dev, dcb); 5760 5761 if (!dcb->entries) 5762 return -ENXIO; 5763 5764 parse_dcb_gpio_table(bios); 5765 parse_dcb_connector_table(bios); 5766 return 0; 5767} 5768 5769static void 5770fixup_legacy_connector(struct nvbios *bios) 5771{ 5772 struct dcb_table *dcb = &bios->dcb; 5773 int i, i2c, i2c_conn[DCB_MAX_NUM_I2C_ENTRIES] = { }; 5774 5775 /* 5776 * DCB 3.0 also has the table in most cases, but there are some cards 5777 * where the table is filled with stub entries, and the DCB entriy 5778 * indices are all 0. We don't need the connector indices on pre-G80 5779 * chips (yet?) so limit the use to DCB 4.0 and above. 5780 */ 5781 if (dcb->version >= 0x40) 5782 return; 5783 5784 dcb->connector.entries = 0; 5785 5786 /* 5787 * No known connector info before v3.0, so make it up. the rule here 5788 * is: anything on the same i2c bus is considered to be on the same 5789 * connector. any output without an associated i2c bus is assigned 5790 * its own unique connector index. 5791 */ 5792 for (i = 0; i < dcb->entries; i++) { 5793 /* 5794 * Ignore the I2C index for on-chip TV-out, as there 5795 * are cards with bogus values (nv31m in bug 23212), 5796 * and it's otherwise useless. 5797 */ 5798 if (dcb->entry[i].type == OUTPUT_TV && 5799 dcb->entry[i].location == DCB_LOC_ON_CHIP) 5800 dcb->entry[i].i2c_index = 0xf; 5801 i2c = dcb->entry[i].i2c_index; 5802 5803 if (i2c_conn[i2c]) { 5804 dcb->entry[i].connector = i2c_conn[i2c] - 1; 5805 continue; 5806 } 5807 5808 dcb->entry[i].connector = dcb->connector.entries++; 5809 if (i2c != 0xf) 5810 i2c_conn[i2c] = dcb->connector.entries; 5811 } 5812 5813 /* Fake the connector table as well as just connector indices */ 5814 for (i = 0; i < dcb->connector.entries; i++) { 5815 dcb->connector.entry[i].index = i; 5816 dcb->connector.entry[i].type = divine_connector_type(bios, i); 5817 dcb->connector.entry[i].gpio_tag = 0xff; 5818 } 5819} 5820 5821static void 5822fixup_legacy_i2c(struct nvbios *bios) 5823{ 5824 struct dcb_table *dcb = &bios->dcb; 5825 int i; 5826 5827 for (i = 0; i < dcb->entries; i++) { 5828 if (dcb->entry[i].i2c_index == LEGACY_I2C_CRT) 5829 dcb->entry[i].i2c_index = bios->legacy.i2c_indices.crt; 5830 if (dcb->entry[i].i2c_index == LEGACY_I2C_PANEL) 5831 dcb->entry[i].i2c_index = bios->legacy.i2c_indices.panel; 5832 if (dcb->entry[i].i2c_index == LEGACY_I2C_TV) 5833 dcb->entry[i].i2c_index = bios->legacy.i2c_indices.tv; 5834 } 5835} 5836 5837static int load_nv17_hwsq_ucode_entry(struct drm_device *dev, struct nvbios *bios, uint16_t hwsq_offset, int entry) 5838{ 5839 /* 5840 * The header following the "HWSQ" signature has the number of entries, 5841 * and the entry size 5842 * 5843 * An entry consists of a dword to write to the sequencer control reg 5844 * (0x00001304), followed by the ucode bytes, written sequentially, 5845 * starting at reg 0x00001400 5846 */ 5847 5848 uint8_t bytes_to_write; 5849 uint16_t hwsq_entry_offset; 5850 int i; 5851 5852 if (bios->data[hwsq_offset] <= entry) { 5853 NV_ERROR(dev, "Too few entries in HW sequencer table for " 5854 "requested entry\n"); 5855 return -ENOENT; 5856 } 5857 5858 bytes_to_write = bios->data[hwsq_offset + 1]; 5859 5860 if (bytes_to_write != 36) { 5861 NV_ERROR(dev, "Unknown HW sequencer entry size\n"); 5862 return -EINVAL; 5863 } 5864 5865 NV_TRACE(dev, "Loading NV17 power sequencing microcode\n"); 5866 5867 hwsq_entry_offset = hwsq_offset + 2 + entry * bytes_to_write; 5868 5869 /* set sequencer control */ 5870 bios_wr32(bios, 0x00001304, ROM32(bios->data[hwsq_entry_offset])); 5871 bytes_to_write -= 4; 5872 5873 /* write ucode */ 5874 for (i = 0; i < bytes_to_write; i += 4) 5875 bios_wr32(bios, 0x00001400 + i, ROM32(bios->data[hwsq_entry_offset + i + 4])); 5876 5877 /* twiddle NV_PBUS_DEBUG_4 */ 5878 bios_wr32(bios, NV_PBUS_DEBUG_4, bios_rd32(bios, NV_PBUS_DEBUG_4) | 0x18); 5879 5880 return 0; 5881} 5882 5883static int load_nv17_hw_sequencer_ucode(struct drm_device *dev, 5884 struct nvbios *bios) 5885{ 5886 /* 5887 * BMP based cards, from NV17, need a microcode loading to correctly 5888 * control the GPIO etc for LVDS panels 5889 * 5890 * BIT based cards seem to do this directly in the init scripts 5891 * 5892 * The microcode entries are found by the "HWSQ" signature. 5893 */ 5894 5895 const uint8_t hwsq_signature[] = { 'H', 'W', 'S', 'Q' }; 5896 const int sz = sizeof(hwsq_signature); 5897 int hwsq_offset; 5898 5899 hwsq_offset = findstr(bios->data, bios->length, hwsq_signature, sz); 5900 if (!hwsq_offset) 5901 return 0; 5902 5903 /* always use entry 0? */ 5904 return load_nv17_hwsq_ucode_entry(dev, bios, hwsq_offset + sz, 0); 5905} 5906 5907uint8_t *nouveau_bios_embedded_edid(struct drm_device *dev) 5908{ 5909 struct drm_nouveau_private *dev_priv = dev->dev_private; 5910 struct nvbios *bios = &dev_priv->vbios; 5911 const uint8_t edid_sig[] = { 5912 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 }; 5913 uint16_t offset = 0; 5914 uint16_t newoffset; 5915 int searchlen = NV_PROM_SIZE; 5916 5917 if (bios->fp.edid) 5918 return bios->fp.edid; 5919 5920 while (searchlen) { 5921 newoffset = findstr(&bios->data[offset], searchlen, 5922 edid_sig, 8); 5923 if (!newoffset) 5924 return NULL; 5925 offset += newoffset; 5926 if (!nv_cksum(&bios->data[offset], EDID1_LEN)) 5927 break; 5928 5929 searchlen -= offset; 5930 offset++; 5931 } 5932 5933 NV_TRACE(dev, "Found EDID in BIOS\n"); 5934 5935 return bios->fp.edid = &bios->data[offset]; 5936} 5937 5938void 5939nouveau_bios_run_init_table(struct drm_device *dev, uint16_t table, 5940 struct dcb_entry *dcbent) 5941{ 5942 struct drm_nouveau_private *dev_priv = dev->dev_private; 5943 struct nvbios *bios = &dev_priv->vbios; 5944 struct init_exec iexec = { true, false }; 5945 5946 mutex_lock(&bios->lock); 5947 bios->display.output = dcbent; 5948 parse_init_table(bios, table, &iexec); 5949 bios->display.output = NULL; 5950 mutex_unlock(&bios->lock); 5951} 5952 5953static bool NVInitVBIOS(struct drm_device *dev) 5954{ 5955 struct drm_nouveau_private *dev_priv = dev->dev_private; 5956 struct nvbios *bios = &dev_priv->vbios; 5957 5958 memset(bios, 0, sizeof(struct nvbios)); 5959 mutex_init(&bios->lock); 5960 bios->dev = dev; 5961 5962 if (!NVShadowVBIOS(dev, bios->data)) 5963 return false; 5964 5965 bios->length = NV_PROM_SIZE; 5966 return true; 5967} 5968 5969static int nouveau_parse_vbios_struct(struct drm_device *dev) 5970{ 5971 struct drm_nouveau_private *dev_priv = dev->dev_private; 5972 struct nvbios *bios = &dev_priv->vbios; 5973 const uint8_t bit_signature[] = { 0xff, 0xb8, 'B', 'I', 'T' }; 5974 const uint8_t bmp_signature[] = { 0xff, 0x7f, 'N', 'V', 0x0 }; 5975 int offset; 5976 5977 offset = findstr(bios->data, bios->length, 5978 bit_signature, sizeof(bit_signature)); 5979 if (offset) { 5980 NV_TRACE(dev, "BIT BIOS found\n"); 5981 return parse_bit_structure(bios, offset + 6); 5982 } 5983 5984 offset = findstr(bios->data, bios->length, 5985 bmp_signature, sizeof(bmp_signature)); 5986 if (offset) { 5987 NV_TRACE(dev, "BMP BIOS found\n"); 5988 return parse_bmp_structure(dev, bios, offset); 5989 } 5990 5991 NV_ERROR(dev, "No known BIOS signature found\n"); 5992 return -ENODEV; 5993} 5994 5995int 5996nouveau_run_vbios_init(struct drm_device *dev) 5997{ 5998 struct drm_nouveau_private *dev_priv = dev->dev_private; 5999 struct nvbios *bios = &dev_priv->vbios; 6000 int i, ret = 0; 6001 6002 NVLockVgaCrtcs(dev, false); 6003 if (nv_two_heads(dev)) 6004 NVSetOwner(dev, bios->state.crtchead); 6005 6006 if (bios->major_version < 5) /* BMP only */ 6007 load_nv17_hw_sequencer_ucode(dev, bios); 6008 6009 if (bios->execute) { 6010 bios->fp.last_script_invoc = 0; 6011 bios->fp.lvds_init_run = false; 6012 } 6013 6014 parse_init_tables(bios); 6015 6016 /* 6017 * Runs some additional script seen on G8x VBIOSen. The VBIOS' 6018 * parser will run this right after the init tables, the binary 6019 * driver appears to run it at some point later. 6020 */ 6021 if (bios->some_script_ptr) { 6022 struct init_exec iexec = {true, false}; 6023 6024 NV_INFO(dev, "Parsing VBIOS init table at offset 0x%04X\n", 6025 bios->some_script_ptr); 6026 parse_init_table(bios, bios->some_script_ptr, &iexec); 6027 } 6028 6029 if (dev_priv->card_type >= NV_50) { 6030 for (i = 0; i < bios->dcb.entries; i++) { 6031 nouveau_bios_run_display_table(dev, 6032 &bios->dcb.entry[i], 6033 0, 0); 6034 } 6035 } 6036 6037 NVLockVgaCrtcs(dev, true); 6038 6039 return ret; 6040} 6041 6042static void 6043nouveau_bios_i2c_devices_takedown(struct drm_device *dev) 6044{ 6045 struct drm_nouveau_private *dev_priv = dev->dev_private; 6046 struct nvbios *bios = &dev_priv->vbios; 6047 struct dcb_i2c_entry *entry; 6048 int i; 6049 6050 entry = &bios->dcb.i2c[0]; 6051 for (i = 0; i < DCB_MAX_NUM_I2C_ENTRIES; i++, entry++) 6052 nouveau_i2c_fini(dev, entry); 6053} 6054 6055int 6056nouveau_bios_init(struct drm_device *dev) 6057{ 6058 struct drm_nouveau_private *dev_priv = dev->dev_private; 6059 struct nvbios *bios = &dev_priv->vbios; 6060 uint32_t saved_nv_pextdev_boot_0; 6061 bool was_locked; 6062 int ret; 6063 6064 if (!NVInitVBIOS(dev)) 6065 return -ENODEV; 6066 6067 ret = nouveau_parse_vbios_struct(dev); 6068 if (ret) 6069 return ret; 6070 6071 ret = parse_dcb_table(dev, bios, nv_two_heads(dev)); 6072 if (ret) 6073 return ret; 6074 6075 fixup_legacy_i2c(bios); 6076 fixup_legacy_connector(bios); 6077 6078 if (!bios->major_version) /* we don't run version 0 bios */ 6079 return 0; 6080 6081 /* these will need remembering across a suspend */ 6082 saved_nv_pextdev_boot_0 = bios_rd32(bios, NV_PEXTDEV_BOOT_0); 6083 bios->state.saved_nv_pfb_cfg0 = bios_rd32(bios, NV_PFB_CFG0); 6084 6085 /* init script execution disabled */ 6086 bios->execute = false; 6087 6088 /* ... unless card isn't POSTed already */ 6089 if (dev_priv->card_type >= NV_10 && 6090 NVReadVgaCrtc(dev, 0, 0x00) == 0 && 6091 NVReadVgaCrtc(dev, 0, 0x1a) == 0) { 6092 NV_INFO(dev, "Adaptor not initialised\n"); 6093 if (dev_priv->card_type < NV_50) { 6094 NV_ERROR(dev, "Unable to POST this chipset\n"); 6095 return -ENODEV; 6096 } 6097 6098 NV_INFO(dev, "Running VBIOS init tables\n"); 6099 bios->execute = true; 6100 } 6101 6102 bios_wr32(bios, NV_PEXTDEV_BOOT_0, saved_nv_pextdev_boot_0); 6103 6104 ret = nouveau_run_vbios_init(dev); 6105 if (ret) 6106 return ret; 6107 6108 /* feature_byte on BMP is poor, but init always sets CR4B */ 6109 was_locked = NVLockVgaCrtcs(dev, false); 6110 if (bios->major_version < 5) 6111 bios->is_mobile = NVReadVgaCrtc(dev, 0, NV_CIO_CRE_4B) & 0x40; 6112 6113 /* all BIT systems need p_f_m_t for digital_min_front_porch */ 6114 if (bios->is_mobile || bios->major_version >= 5) 6115 ret = parse_fp_mode_table(dev, bios); 6116 NVLockVgaCrtcs(dev, was_locked); 6117 6118 /* allow subsequent scripts to execute */ 6119 bios->execute = true; 6120 6121 return 0; 6122} 6123 6124void 6125nouveau_bios_takedown(struct drm_device *dev) 6126{ 6127 nouveau_bios_i2c_devices_takedown(dev); 6128} 6129