Merge remote branch 'korg/drm-core-next' into drm-next-stage
[linux-2.6.git] / drivers / gpu / drm / nouveau / nouveau_bios.c
1 /*
2  * Copyright 2005-2006 Erik Waling
3  * Copyright 2006 Stephane Marchesin
4  * Copyright 2007-2009 Stuart Bennett
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the "Software"),
8  * to deal in the Software without restriction, including without limitation
9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10  * and/or sell copies of the Software, and to permit persons to whom the
11  * Software is furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
19  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
21  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
24
25 #include "drmP.h"
26 #define NV_DEBUG_NOTRACE
27 #include "nouveau_drv.h"
28 #include "nouveau_hw.h"
29
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
46 struct init_exec {
47         bool execute;
48         bool repeat;
49 };
50
51 static bool nv_cksum(const uint8_t *data, unsigned int length)
52 {
53         /*
54          * There's a few checksums in the BIOS, so here's a generic checking
55          * function.
56          */
57         int i;
58         uint8_t sum = 0;
59
60         for (i = 0; i < length; i++)
61                 sum += data[i];
62
63         if (sum)
64                 return true;
65
66         return false;
67 }
68
69 static int
70 score_vbios(struct drm_device *dev, const uint8_t *data, const bool writeable)
71 {
72         if (!(data[0] == 0x55 && data[1] == 0xAA)) {
73                 NV_TRACEWARN(dev, "... BIOS signature not found\n");
74                 return 0;
75         }
76
77         if (nv_cksum(data, data[2] * 512)) {
78                 NV_TRACEWARN(dev, "... BIOS checksum invalid\n");
79                 /* if a ro image is somewhat bad, it's probably all rubbish */
80                 return writeable ? 2 : 1;
81         } else
82                 NV_TRACE(dev, "... appears to be valid\n");
83
84         return 3;
85 }
86
87 static void load_vbios_prom(struct drm_device *dev, uint8_t *data)
88 {
89         struct drm_nouveau_private *dev_priv = dev->dev_private;
90         uint32_t pci_nv_20, save_pci_nv_20;
91         int pcir_ptr;
92         int i;
93
94         if (dev_priv->card_type >= NV_50)
95                 pci_nv_20 = 0x88050;
96         else
97                 pci_nv_20 = NV_PBUS_PCI_NV_20;
98
99         /* enable ROM access */
100         save_pci_nv_20 = nvReadMC(dev, pci_nv_20);
101         nvWriteMC(dev, pci_nv_20,
102                   save_pci_nv_20 & ~NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED);
103
104         /* bail if no rom signature */
105         if (nv_rd08(dev, NV_PROM_OFFSET) != 0x55 ||
106             nv_rd08(dev, NV_PROM_OFFSET + 1) != 0xaa)
107                 goto out;
108
109         /* additional check (see note below) - read PCI record header */
110         pcir_ptr = nv_rd08(dev, NV_PROM_OFFSET + 0x18) |
111                    nv_rd08(dev, NV_PROM_OFFSET + 0x19) << 8;
112         if (nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr) != 'P' ||
113             nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr + 1) != 'C' ||
114             nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr + 2) != 'I' ||
115             nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr + 3) != 'R')
116                 goto out;
117
118         /* on some 6600GT/6800LE prom reads are messed up.  nvclock alleges a
119          * a good read may be obtained by waiting or re-reading (cargocult: 5x)
120          * each byte.  we'll hope pramin has something usable instead
121          */
122         for (i = 0; i < NV_PROM_SIZE; i++)
123                 data[i] = nv_rd08(dev, NV_PROM_OFFSET + i);
124
125 out:
126         /* disable ROM access */
127         nvWriteMC(dev, pci_nv_20,
128                   save_pci_nv_20 | NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED);
129 }
130
131 static void load_vbios_pramin(struct drm_device *dev, uint8_t *data)
132 {
133         struct drm_nouveau_private *dev_priv = dev->dev_private;
134         uint32_t old_bar0_pramin = 0;
135         int i;
136
137         if (dev_priv->card_type >= NV_50) {
138                 uint32_t vbios_vram = (nv_rd32(dev, 0x619f04) & ~0xff) << 8;
139
140                 if (!vbios_vram)
141                         vbios_vram = (nv_rd32(dev, 0x1700) << 16) + 0xf0000;
142
143                 old_bar0_pramin = nv_rd32(dev, 0x1700);
144                 nv_wr32(dev, 0x1700, vbios_vram >> 16);
145         }
146
147         /* bail if no rom signature */
148         if (nv_rd08(dev, NV_PRAMIN_OFFSET) != 0x55 ||
149             nv_rd08(dev, NV_PRAMIN_OFFSET + 1) != 0xaa)
150                 goto out;
151
152         for (i = 0; i < NV_PROM_SIZE; i++)
153                 data[i] = nv_rd08(dev, NV_PRAMIN_OFFSET + i);
154
155 out:
156         if (dev_priv->card_type >= NV_50)
157                 nv_wr32(dev, 0x1700, old_bar0_pramin);
158 }
159
160 static void load_vbios_pci(struct drm_device *dev, uint8_t *data)
161 {
162         void __iomem *rom = NULL;
163         size_t rom_len;
164         int ret;
165
166         ret = pci_enable_rom(dev->pdev);
167         if (ret)
168                 return;
169
170         rom = pci_map_rom(dev->pdev, &rom_len);
171         if (!rom)
172                 goto out;
173         memcpy_fromio(data, rom, rom_len);
174         pci_unmap_rom(dev->pdev, rom);
175
176 out:
177         pci_disable_rom(dev->pdev);
178 }
179
180 struct methods {
181         const char desc[8];
182         void (*loadbios)(struct drm_device *, uint8_t *);
183         const bool rw;
184 };
185
186 static struct methods nv04_methods[] = {
187         { "PROM", load_vbios_prom, false },
188         { "PRAMIN", load_vbios_pramin, true },
189         { "PCIROM", load_vbios_pci, true },
190 };
191
192 static 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
200 static 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
256 struct init_tbl_entry {
257         char *name;
258         uint8_t id;
259         int (*handler)(struct nvbios *, uint16_t, struct init_exec *);
260 };
261
262 struct bit_entry {
263         uint8_t id[2];
264         uint16_t length;
265         uint16_t offset;
266 };
267
268 static 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
277 static void still_alive(void)
278 {
279 #if 0
280         sync();
281         msleep(2);
282 #endif
283 }
284
285 static uint32_t
286 munge_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
306 static int
307 valid_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.pub.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.pub.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
331 static bool
332 valid_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
358 static bool
359 valid_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
376 static uint32_t
377 bios_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
407 static void
408 bios_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
429 static uint8_t
430 bios_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
457 static void
458 bios_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
505 static uint8_t
506 bios_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
521 static void
522 bios_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
540 static bool
541 io_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
579 static bool
580 bios_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
605 static bool
606 io_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
629 static int
630 nv50_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
659 static int
660 setPLL(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
689 static 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->bdcb.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
712 static struct nouveau_i2c_chan *
713 init_i2c_device_find(struct drm_device *dev, int i2c_index)
714 {
715         struct drm_nouveau_private *dev_priv = dev->dev_private;
716         struct bios_parsed_dcb *bdcb = &dev_priv->VBIOS.bdcb;
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 = bdcb->i2c_default_indices;
722
723                 if (idx != 0x7f && bdcb->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 = bdcb->i2c_default_indices & 0xf;
730
731         return nouveau_i2c_find(dev, i2c_index);
732 }
733
734 static uint32_t get_tmds_index_reg(struct drm_device *dev, uint8_t mlv)
735 {
736         /*
737          * For mlv < 0x80, it is an index into a table of TMDS base addresses.
738          * For mlv == 0x80 use the "or" value of the dcb_entry indexed by
739          * CR58 for CR57 = 0 to index a table of offsets to the basic
740          * 0x6808b0 address.
741          * For mlv == 0x81 use the "or" value of the dcb_entry indexed by
742          * CR58 for CR57 = 0 to index a table of offsets to the basic
743          * 0x6808b0 address, and then flip the offset by 8.
744          */
745
746         struct drm_nouveau_private *dev_priv = dev->dev_private;
747         const int pramdac_offset[13] = {
748                 0, 0, 0x8, 0, 0x2000, 0, 0, 0, 0x2008, 0, 0, 0, 0x2000 };
749         const uint32_t pramdac_table[4] = {
750                 0x6808b0, 0x6808b8, 0x6828b0, 0x6828b8 };
751
752         if (mlv >= 0x80) {
753                 int dcb_entry, dacoffset;
754
755                 /* note: dcb_entry_idx_from_crtchead needs pre-script set-up */
756                 dcb_entry = dcb_entry_idx_from_crtchead(dev);
757                 if (dcb_entry == 0x7f)
758                         return 0;
759                 dacoffset = pramdac_offset[
760                                 dev_priv->VBIOS.bdcb.dcb.entry[dcb_entry].or];
761                 if (mlv == 0x81)
762                         dacoffset ^= 8;
763                 return 0x6808b0 + dacoffset;
764         } else {
765                 if (mlv > ARRAY_SIZE(pramdac_table)) {
766                         NV_ERROR(dev, "Magic Lookup Value too big (%02X)\n",
767                                                                         mlv);
768                         return 0;
769                 }
770                 return pramdac_table[mlv];
771         }
772 }
773
774 static int
775 init_io_restrict_prog(struct nvbios *bios, uint16_t offset,
776                       struct init_exec *iexec)
777 {
778         /*
779          * INIT_IO_RESTRICT_PROG   opcode: 0x32 ('2')
780          *
781          * offset      (8  bit): opcode
782          * offset + 1  (16 bit): CRTC port
783          * offset + 3  (8  bit): CRTC index
784          * offset + 4  (8  bit): mask
785          * offset + 5  (8  bit): shift
786          * offset + 6  (8  bit): count
787          * offset + 7  (32 bit): register
788          * offset + 11 (32 bit): configuration 1
789          * ...
790          *
791          * Starting at offset + 11 there are "count" 32 bit values.
792          * To find out which value to use read index "CRTC index" on "CRTC
793          * port", AND this value with "mask" and then bit shift right "shift"
794          * bits.  Read the appropriate value using this index and write to
795          * "register"
796          */
797
798         uint16_t crtcport = ROM16(bios->data[offset + 1]);
799         uint8_t crtcindex = bios->data[offset + 3];
800         uint8_t mask = bios->data[offset + 4];
801         uint8_t shift = bios->data[offset + 5];
802         uint8_t count = bios->data[offset + 6];
803         uint32_t reg = ROM32(bios->data[offset + 7]);
804         uint8_t config;
805         uint32_t configval;
806         int len = 11 + count * 4;
807
808         if (!iexec->execute)
809                 return len;
810
811         BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
812                       "Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
813                 offset, crtcport, crtcindex, mask, shift, count, reg);
814
815         config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift;
816         if (config > count) {
817                 NV_ERROR(bios->dev,
818                          "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
819                          offset, config, count);
820                 return 0;
821         }
822
823         configval = ROM32(bios->data[offset + 11 + config * 4]);
824
825         BIOSLOG(bios, "0x%04X: Writing config %02X\n", offset, config);
826
827         bios_wr32(bios, reg, configval);
828
829         return len;
830 }
831
832 static int
833 init_repeat(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
834 {
835         /*
836          * INIT_REPEAT   opcode: 0x33 ('3')
837          *
838          * offset      (8 bit): opcode
839          * offset + 1  (8 bit): count
840          *
841          * Execute script following this opcode up to INIT_REPEAT_END
842          * "count" times
843          */
844
845         uint8_t count = bios->data[offset + 1];
846         uint8_t i;
847
848         /* no iexec->execute check by design */
849
850         BIOSLOG(bios, "0x%04X: Repeating following segment %d times\n",
851                 offset, count);
852
853         iexec->repeat = true;
854
855         /*
856          * count - 1, as the script block will execute once when we leave this
857          * opcode -- this is compatible with bios behaviour as:
858          * a) the block is always executed at least once, even if count == 0
859          * b) the bios interpreter skips to the op following INIT_END_REPEAT,
860          * while we don't
861          */
862         for (i = 0; i < count - 1; i++)
863                 parse_init_table(bios, offset + 2, iexec);
864
865         iexec->repeat = false;
866
867         return 2;
868 }
869
870 static int
871 init_io_restrict_pll(struct nvbios *bios, uint16_t offset,
872                      struct init_exec *iexec)
873 {
874         /*
875          * INIT_IO_RESTRICT_PLL   opcode: 0x34 ('4')
876          *
877          * offset      (8  bit): opcode
878          * offset + 1  (16 bit): CRTC port
879          * offset + 3  (8  bit): CRTC index
880          * offset + 4  (8  bit): mask
881          * offset + 5  (8  bit): shift
882          * offset + 6  (8  bit): IO flag condition index
883          * offset + 7  (8  bit): count
884          * offset + 8  (32 bit): register
885          * offset + 12 (16 bit): frequency 1
886          * ...
887          *
888          * Starting at offset + 12 there are "count" 16 bit frequencies (10kHz).
889          * Set PLL register "register" to coefficients for frequency n,
890          * selected by reading index "CRTC index" of "CRTC port" ANDed with
891          * "mask" and shifted right by "shift".
892          *
893          * If "IO flag condition index" > 0, and condition met, double
894          * frequency before setting it.
895          */
896
897         uint16_t crtcport = ROM16(bios->data[offset + 1]);
898         uint8_t crtcindex = bios->data[offset + 3];
899         uint8_t mask = bios->data[offset + 4];
900         uint8_t shift = bios->data[offset + 5];
901         int8_t io_flag_condition_idx = bios->data[offset + 6];
902         uint8_t count = bios->data[offset + 7];
903         uint32_t reg = ROM32(bios->data[offset + 8]);
904         uint8_t config;
905         uint16_t freq;
906         int len = 12 + count * 2;
907
908         if (!iexec->execute)
909                 return len;
910
911         BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
912                       "Shift: 0x%02X, IO Flag Condition: 0x%02X, "
913                       "Count: 0x%02X, Reg: 0x%08X\n",
914                 offset, crtcport, crtcindex, mask, shift,
915                 io_flag_condition_idx, count, reg);
916
917         config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift;
918         if (config > count) {
919                 NV_ERROR(bios->dev,
920                          "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
921                          offset, config, count);
922                 return 0;
923         }
924
925         freq = ROM16(bios->data[offset + 12 + config * 2]);
926
927         if (io_flag_condition_idx > 0) {
928                 if (io_flag_condition_met(bios, offset, io_flag_condition_idx)) {
929                         BIOSLOG(bios, "0x%04X: Condition fulfilled -- "
930                                       "frequency doubled\n", offset);
931                         freq *= 2;
932                 } else
933                         BIOSLOG(bios, "0x%04X: Condition not fulfilled -- "
934                                       "frequency unchanged\n", offset);
935         }
936
937         BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %d0kHz\n",
938                 offset, reg, config, freq);
939
940         setPLL(bios, reg, freq * 10);
941
942         return len;
943 }
944
945 static int
946 init_end_repeat(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
947 {
948         /*
949          * INIT_END_REPEAT   opcode: 0x36 ('6')
950          *
951          * offset      (8 bit): opcode
952          *
953          * Marks the end of the block for INIT_REPEAT to repeat
954          */
955
956         /* no iexec->execute check by design */
957
958         /*
959          * iexec->repeat flag necessary to go past INIT_END_REPEAT opcode when
960          * we're not in repeat mode
961          */
962         if (iexec->repeat)
963                 return 0;
964
965         return 1;
966 }
967
968 static int
969 init_copy(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
970 {
971         /*
972          * INIT_COPY   opcode: 0x37 ('7')
973          *
974          * offset      (8  bit): opcode
975          * offset + 1  (32 bit): register
976          * offset + 5  (8  bit): shift
977          * offset + 6  (8  bit): srcmask
978          * offset + 7  (16 bit): CRTC port
979          * offset + 9  (8 bit): CRTC index
980          * offset + 10  (8 bit): mask
981          *
982          * Read index "CRTC index" on "CRTC port", AND with "mask", OR with
983          * (REGVAL("register") >> "shift" & "srcmask") and write-back to CRTC
984          * port
985          */
986
987         uint32_t reg = ROM32(bios->data[offset + 1]);
988         uint8_t shift = bios->data[offset + 5];
989         uint8_t srcmask = bios->data[offset + 6];
990         uint16_t crtcport = ROM16(bios->data[offset + 7]);
991         uint8_t crtcindex = bios->data[offset + 9];
992         uint8_t mask = bios->data[offset + 10];
993         uint32_t data;
994         uint8_t crtcdata;
995
996         if (!iexec->execute)
997                 return 11;
998
999         BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Shift: 0x%02X, SrcMask: 0x%02X, "
1000                       "Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X\n",
1001                 offset, reg, shift, srcmask, crtcport, crtcindex, mask);
1002
1003         data = bios_rd32(bios, reg);
1004
1005         if (shift < 0x80)
1006                 data >>= shift;
1007         else
1008                 data <<= (0x100 - shift);
1009
1010         data &= srcmask;
1011
1012         crtcdata  = bios_idxprt_rd(bios, crtcport, crtcindex) & mask;
1013         crtcdata |= (uint8_t)data;
1014         bios_idxprt_wr(bios, crtcport, crtcindex, crtcdata);
1015
1016         return 11;
1017 }
1018
1019 static int
1020 init_not(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1021 {
1022         /*
1023          * INIT_NOT   opcode: 0x38 ('8')
1024          *
1025          * offset      (8  bit): opcode
1026          *
1027          * Invert the current execute / no-execute condition (i.e. "else")
1028          */
1029         if (iexec->execute)
1030                 BIOSLOG(bios, "0x%04X: ------ Skipping following commands  ------\n", offset);
1031         else
1032                 BIOSLOG(bios, "0x%04X: ------ Executing following commands ------\n", offset);
1033
1034         iexec->execute = !iexec->execute;
1035         return 1;
1036 }
1037
1038 static int
1039 init_io_flag_condition(struct nvbios *bios, uint16_t offset,
1040                        struct init_exec *iexec)
1041 {
1042         /*
1043          * INIT_IO_FLAG_CONDITION   opcode: 0x39 ('9')
1044          *
1045          * offset      (8 bit): opcode
1046          * offset + 1  (8 bit): condition number
1047          *
1048          * Check condition "condition number" in the IO flag condition table.
1049          * If condition not met skip subsequent opcodes until condition is
1050          * inverted (INIT_NOT), or we hit INIT_RESUME
1051          */
1052
1053         uint8_t cond = bios->data[offset + 1];
1054
1055         if (!iexec->execute)
1056                 return 2;
1057
1058         if (io_flag_condition_met(bios, offset, cond))
1059                 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
1060         else {
1061                 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
1062                 iexec->execute = false;
1063         }
1064
1065         return 2;
1066 }
1067
1068 static int
1069 init_idx_addr_latched(struct nvbios *bios, uint16_t offset,
1070                       struct init_exec *iexec)
1071 {
1072         /*
1073          * INIT_INDEX_ADDRESS_LATCHED   opcode: 0x49 ('I')
1074          *
1075          * offset      (8  bit): opcode
1076          * offset + 1  (32 bit): control register
1077          * offset + 5  (32 bit): data register
1078          * offset + 9  (32 bit): mask
1079          * offset + 13 (32 bit): data
1080          * offset + 17 (8  bit): count
1081          * offset + 18 (8  bit): address 1
1082          * offset + 19 (8  bit): data 1
1083          * ...
1084          *
1085          * For each of "count" address and data pairs, write "data n" to
1086          * "data register", read the current value of "control register",
1087          * and write it back once ANDed with "mask", ORed with "data",
1088          * and ORed with "address n"
1089          */
1090
1091         uint32_t controlreg = ROM32(bios->data[offset + 1]);
1092         uint32_t datareg = ROM32(bios->data[offset + 5]);
1093         uint32_t mask = ROM32(bios->data[offset + 9]);
1094         uint32_t data = ROM32(bios->data[offset + 13]);
1095         uint8_t count = bios->data[offset + 17];
1096         int len = 18 + count * 2;
1097         uint32_t value;
1098         int i;
1099
1100         if (!iexec->execute)
1101                 return len;
1102
1103         BIOSLOG(bios, "0x%04X: ControlReg: 0x%08X, DataReg: 0x%08X, "
1104                       "Mask: 0x%08X, Data: 0x%08X, Count: 0x%02X\n",
1105                 offset, controlreg, datareg, mask, data, count);
1106
1107         for (i = 0; i < count; i++) {
1108                 uint8_t instaddress = bios->data[offset + 18 + i * 2];
1109                 uint8_t instdata = bios->data[offset + 19 + i * 2];
1110
1111                 BIOSLOG(bios, "0x%04X: Address: 0x%02X, Data: 0x%02X\n",
1112                         offset, instaddress, instdata);
1113
1114                 bios_wr32(bios, datareg, instdata);
1115                 value  = bios_rd32(bios, controlreg) & mask;
1116                 value |= data;
1117                 value |= instaddress;
1118                 bios_wr32(bios, controlreg, value);
1119         }
1120
1121         return len;
1122 }
1123
1124 static int
1125 init_io_restrict_pll2(struct nvbios *bios, uint16_t offset,
1126                       struct init_exec *iexec)
1127 {
1128         /*
1129          * INIT_IO_RESTRICT_PLL2   opcode: 0x4A ('J')
1130          *
1131          * offset      (8  bit): opcode
1132          * offset + 1  (16 bit): CRTC port
1133          * offset + 3  (8  bit): CRTC index
1134          * offset + 4  (8  bit): mask
1135          * offset + 5  (8  bit): shift
1136          * offset + 6  (8  bit): count
1137          * offset + 7  (32 bit): register
1138          * offset + 11 (32 bit): frequency 1
1139          * ...
1140          *
1141          * Starting at offset + 11 there are "count" 32 bit frequencies (kHz).
1142          * Set PLL register "register" to coefficients for frequency n,
1143          * selected by reading index "CRTC index" of "CRTC port" ANDed with
1144          * "mask" and shifted right by "shift".
1145          */
1146
1147         uint16_t crtcport = ROM16(bios->data[offset + 1]);
1148         uint8_t crtcindex = bios->data[offset + 3];
1149         uint8_t mask = bios->data[offset + 4];
1150         uint8_t shift = bios->data[offset + 5];
1151         uint8_t count = bios->data[offset + 6];
1152         uint32_t reg = ROM32(bios->data[offset + 7]);
1153         int len = 11 + count * 4;
1154         uint8_t config;
1155         uint32_t freq;
1156
1157         if (!iexec->execute)
1158                 return len;
1159
1160         BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
1161                       "Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
1162                 offset, crtcport, crtcindex, mask, shift, count, reg);
1163
1164         if (!reg)
1165                 return len;
1166
1167         config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift;
1168         if (config > count) {
1169                 NV_ERROR(bios->dev,
1170                          "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
1171                          offset, config, count);
1172                 return 0;
1173         }
1174
1175         freq = ROM32(bios->data[offset + 11 + config * 4]);
1176
1177         BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %dkHz\n",
1178                 offset, reg, config, freq);
1179
1180         setPLL(bios, reg, freq);
1181
1182         return len;
1183 }
1184
1185 static int
1186 init_pll2(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1187 {
1188         /*
1189          * INIT_PLL2   opcode: 0x4B ('K')
1190          *
1191          * offset      (8  bit): opcode
1192          * offset + 1  (32 bit): register
1193          * offset + 5  (32 bit): freq
1194          *
1195          * Set PLL register "register" to coefficients for frequency "freq"
1196          */
1197
1198         uint32_t reg = ROM32(bios->data[offset + 1]);
1199         uint32_t freq = ROM32(bios->data[offset + 5]);
1200
1201         if (!iexec->execute)
1202                 return 9;
1203
1204         BIOSLOG(bios, "0x%04X: Reg: 0x%04X, Freq: %dkHz\n",
1205                 offset, reg, freq);
1206
1207         setPLL(bios, reg, freq);
1208         return 9;
1209 }
1210
1211 static int
1212 init_i2c_byte(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1213 {
1214         /*
1215          * INIT_I2C_BYTE   opcode: 0x4C ('L')
1216          *
1217          * offset      (8 bit): opcode
1218          * offset + 1  (8 bit): DCB I2C table entry index
1219          * offset + 2  (8 bit): I2C slave address
1220          * offset + 3  (8 bit): count
1221          * offset + 4  (8 bit): I2C register 1
1222          * offset + 5  (8 bit): mask 1
1223          * offset + 6  (8 bit): data 1
1224          * ...
1225          *
1226          * For each of "count" registers given by "I2C register n" on the device
1227          * addressed by "I2C slave address" on the I2C bus given by
1228          * "DCB I2C table entry index", read the register, AND the result with
1229          * "mask n" and OR it with "data n" before writing it back to the device
1230          */
1231
1232         uint8_t i2c_index = bios->data[offset + 1];
1233         uint8_t i2c_address = bios->data[offset + 2];
1234         uint8_t count = bios->data[offset + 3];
1235         int len = 4 + count * 3;
1236         struct nouveau_i2c_chan *chan;
1237         struct i2c_msg msg;
1238         int i;
1239
1240         if (!iexec->execute)
1241                 return len;
1242
1243         BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, "
1244                       "Count: 0x%02X\n",
1245                 offset, i2c_index, i2c_address, count);
1246
1247         chan = init_i2c_device_find(bios->dev, i2c_index);
1248         if (!chan)
1249                 return 0;
1250
1251         for (i = 0; i < count; i++) {
1252                 uint8_t i2c_reg = bios->data[offset + 4 + i * 3];
1253                 uint8_t mask = bios->data[offset + 5 + i * 3];
1254                 uint8_t data = bios->data[offset + 6 + i * 3];
1255                 uint8_t value;
1256
1257                 msg.addr = i2c_address;
1258                 msg.flags = I2C_M_RD;
1259                 msg.len = 1;
1260                 msg.buf = &value;
1261                 if (i2c_transfer(&chan->adapter, &msg, 1) != 1)
1262                         return 0;
1263
1264                 BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Value: 0x%02X, "
1265                               "Mask: 0x%02X, Data: 0x%02X\n",
1266                         offset, i2c_reg, value, mask, data);
1267
1268                 value = (value & mask) | data;
1269
1270                 if (bios->execute) {
1271                         msg.addr = i2c_address;
1272                         msg.flags = 0;
1273                         msg.len = 1;
1274                         msg.buf = &value;
1275                         if (i2c_transfer(&chan->adapter, &msg, 1) != 1)
1276                                 return 0;
1277                 }
1278         }
1279
1280         return len;
1281 }
1282
1283 static int
1284 init_zm_i2c_byte(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1285 {
1286         /*
1287          * INIT_ZM_I2C_BYTE   opcode: 0x4D ('M')
1288          *
1289          * offset      (8 bit): opcode
1290          * offset + 1  (8 bit): DCB I2C table entry index
1291          * offset + 2  (8 bit): I2C slave address
1292          * offset + 3  (8 bit): count
1293          * offset + 4  (8 bit): I2C register 1
1294          * offset + 5  (8 bit): data 1
1295          * ...
1296          *
1297          * For each of "count" registers given by "I2C register n" on the device
1298          * addressed by "I2C slave address" on the I2C bus given by
1299          * "DCB I2C table entry index", set the register to "data n"
1300          */
1301
1302         uint8_t i2c_index = bios->data[offset + 1];
1303         uint8_t i2c_address = bios->data[offset + 2];
1304         uint8_t count = bios->data[offset + 3];
1305         int len = 4 + count * 2;
1306         struct nouveau_i2c_chan *chan;
1307         struct i2c_msg msg;
1308         int i;
1309
1310         if (!iexec->execute)
1311                 return len;
1312
1313         BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, "
1314                       "Count: 0x%02X\n",
1315                 offset, i2c_index, i2c_address, count);
1316
1317         chan = init_i2c_device_find(bios->dev, i2c_index);
1318         if (!chan)
1319                 return 0;
1320
1321         for (i = 0; i < count; i++) {
1322                 uint8_t i2c_reg = bios->data[offset + 4 + i * 2];
1323                 uint8_t data = bios->data[offset + 5 + i * 2];
1324
1325                 BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Data: 0x%02X\n",
1326                         offset, i2c_reg, data);
1327
1328                 if (bios->execute) {
1329                         msg.addr = i2c_address;
1330                         msg.flags = 0;
1331                         msg.len = 1;
1332                         msg.buf = &data;
1333                         if (i2c_transfer(&chan->adapter, &msg, 1) != 1)
1334                                 return 0;
1335                 }
1336         }
1337
1338         return len;
1339 }
1340
1341 static int
1342 init_zm_i2c(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1343 {
1344         /*
1345          * INIT_ZM_I2C   opcode: 0x4E ('N')
1346          *
1347          * offset      (8 bit): opcode
1348          * offset + 1  (8 bit): DCB I2C table entry index
1349          * offset + 2  (8 bit): I2C slave address
1350          * offset + 3  (8 bit): count
1351          * offset + 4  (8 bit): data 1
1352          * ...
1353          *
1354          * Send "count" bytes ("data n") to the device addressed by "I2C slave
1355          * address" on the I2C bus given by "DCB I2C table entry index"
1356          */
1357
1358         uint8_t i2c_index = bios->data[offset + 1];
1359         uint8_t i2c_address = bios->data[offset + 2];
1360         uint8_t count = bios->data[offset + 3];
1361         int len = 4 + count;
1362         struct nouveau_i2c_chan *chan;
1363         struct i2c_msg msg;
1364         uint8_t data[256];
1365         int i;
1366
1367         if (!iexec->execute)
1368                 return len;
1369
1370         BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, "
1371                       "Count: 0x%02X\n",
1372                 offset, i2c_index, i2c_address, count);
1373
1374         chan = init_i2c_device_find(bios->dev, i2c_index);
1375         if (!chan)
1376                 return 0;
1377
1378         for (i = 0; i < count; i++) {
1379                 data[i] = bios->data[offset + 4 + i];
1380
1381                 BIOSLOG(bios, "0x%04X: Data: 0x%02X\n", offset, data[i]);
1382         }
1383
1384         if (bios->execute) {
1385                 msg.addr = i2c_address;
1386                 msg.flags = 0;
1387                 msg.len = count;
1388                 msg.buf = data;
1389                 if (i2c_transfer(&chan->adapter, &msg, 1) != 1)
1390                         return 0;
1391         }
1392
1393         return len;
1394 }
1395
1396 static int
1397 init_tmds(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1398 {
1399         /*
1400          * INIT_TMDS   opcode: 0x4F ('O')       (non-canon name)
1401          *
1402          * offset      (8 bit): opcode
1403          * offset + 1  (8 bit): magic lookup value
1404          * offset + 2  (8 bit): TMDS address
1405          * offset + 3  (8 bit): mask
1406          * offset + 4  (8 bit): data
1407          *
1408          * Read the data reg for TMDS address "TMDS address", AND it with mask
1409          * and OR it with data, then write it back
1410          * "magic lookup value" determines which TMDS base address register is
1411          * used -- see get_tmds_index_reg()
1412          */
1413
1414         uint8_t mlv = bios->data[offset + 1];
1415         uint32_t tmdsaddr = bios->data[offset + 2];
1416         uint8_t mask = bios->data[offset + 3];
1417         uint8_t data = bios->data[offset + 4];
1418         uint32_t reg, value;
1419
1420         if (!iexec->execute)
1421                 return 5;
1422
1423         BIOSLOG(bios, "0x%04X: MagicLookupValue: 0x%02X, TMDSAddr: 0x%02X, "
1424                       "Mask: 0x%02X, Data: 0x%02X\n",
1425                 offset, mlv, tmdsaddr, mask, data);
1426
1427         reg = get_tmds_index_reg(bios->dev, mlv);
1428         if (!reg)
1429                 return 0;
1430
1431         bios_wr32(bios, reg,
1432                   tmdsaddr | NV_PRAMDAC_FP_TMDS_CONTROL_WRITE_DISABLE);
1433         value = (bios_rd32(bios, reg + 4) & mask) | data;
1434         bios_wr32(bios, reg + 4, value);
1435         bios_wr32(bios, reg, tmdsaddr);
1436
1437         return 5;
1438 }
1439
1440 static int
1441 init_zm_tmds_group(struct nvbios *bios, uint16_t offset,
1442                    struct init_exec *iexec)
1443 {
1444         /*
1445          * INIT_ZM_TMDS_GROUP   opcode: 0x50 ('P')      (non-canon name)
1446          *
1447          * offset      (8 bit): opcode
1448          * offset + 1  (8 bit): magic lookup value
1449          * offset + 2  (8 bit): count
1450          * offset + 3  (8 bit): addr 1
1451          * offset + 4  (8 bit): data 1
1452          * ...
1453          *
1454          * For each of "count" TMDS address and data pairs write "data n" to
1455          * "addr n".  "magic lookup value" determines which TMDS base address
1456          * register is used -- see get_tmds_index_reg()
1457          */
1458
1459         uint8_t mlv = bios->data[offset + 1];
1460         uint8_t count = bios->data[offset + 2];
1461         int len = 3 + count * 2;
1462         uint32_t reg;
1463         int i;
1464
1465         if (!iexec->execute)
1466                 return len;
1467
1468         BIOSLOG(bios, "0x%04X: MagicLookupValue: 0x%02X, Count: 0x%02X\n",
1469                 offset, mlv, count);
1470
1471         reg = get_tmds_index_reg(bios->dev, mlv);
1472         if (!reg)
1473                 return 0;
1474
1475         for (i = 0; i < count; i++) {
1476                 uint8_t tmdsaddr = bios->data[offset + 3 + i * 2];
1477                 uint8_t tmdsdata = bios->data[offset + 4 + i * 2];
1478
1479                 bios_wr32(bios, reg + 4, tmdsdata);
1480                 bios_wr32(bios, reg, tmdsaddr);
1481         }
1482
1483         return len;
1484 }
1485
1486 static int
1487 init_cr_idx_adr_latch(struct nvbios *bios, uint16_t offset,
1488                       struct init_exec *iexec)
1489 {
1490         /*
1491          * INIT_CR_INDEX_ADDRESS_LATCHED   opcode: 0x51 ('Q')
1492          *
1493          * offset      (8 bit): opcode
1494          * offset + 1  (8 bit): CRTC index1
1495          * offset + 2  (8 bit): CRTC index2
1496          * offset + 3  (8 bit): baseaddr
1497          * offset + 4  (8 bit): count
1498          * offset + 5  (8 bit): data 1
1499          * ...
1500          *
1501          * For each of "count" address and data pairs, write "baseaddr + n" to
1502          * "CRTC index1" and "data n" to "CRTC index2"
1503          * Once complete, restore initial value read from "CRTC index1"
1504          */
1505         uint8_t crtcindex1 = bios->data[offset + 1];
1506         uint8_t crtcindex2 = bios->data[offset + 2];
1507         uint8_t baseaddr = bios->data[offset + 3];
1508         uint8_t count = bios->data[offset + 4];
1509         int len = 5 + count;
1510         uint8_t oldaddr, data;
1511         int i;
1512
1513         if (!iexec->execute)
1514                 return len;
1515
1516         BIOSLOG(bios, "0x%04X: Index1: 0x%02X, Index2: 0x%02X, "
1517                       "BaseAddr: 0x%02X, Count: 0x%02X\n",
1518                 offset, crtcindex1, crtcindex2, baseaddr, count);
1519
1520         oldaddr = bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, crtcindex1);
1521
1522         for (i = 0; i < count; i++) {
1523                 bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex1,
1524                                      baseaddr + i);
1525                 data = bios->data[offset + 5 + i];
1526                 bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex2, data);
1527         }
1528
1529         bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex1, oldaddr);
1530
1531         return len;
1532 }
1533
1534 static int
1535 init_cr(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1536 {
1537         /*
1538          * INIT_CR   opcode: 0x52 ('R')
1539          *
1540          * offset      (8  bit): opcode
1541          * offset + 1  (8  bit): CRTC index
1542          * offset + 2  (8  bit): mask
1543          * offset + 3  (8  bit): data
1544          *
1545          * Assign the value of at "CRTC index" ANDed with mask and ORed with
1546          * data back to "CRTC index"
1547          */
1548
1549         uint8_t crtcindex = bios->data[offset + 1];
1550         uint8_t mask = bios->data[offset + 2];
1551         uint8_t data = bios->data[offset + 3];
1552         uint8_t value;
1553
1554         if (!iexec->execute)
1555                 return 4;
1556
1557         BIOSLOG(bios, "0x%04X: Index: 0x%02X, Mask: 0x%02X, Data: 0x%02X\n",
1558                 offset, crtcindex, mask, data);
1559
1560         value  = bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, crtcindex) & mask;
1561         value |= data;
1562         bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex, value);
1563
1564         return 4;
1565 }
1566
1567 static int
1568 init_zm_cr(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1569 {
1570         /*
1571          * INIT_ZM_CR   opcode: 0x53 ('S')
1572          *
1573          * offset      (8 bit): opcode
1574          * offset + 1  (8 bit): CRTC index
1575          * offset + 2  (8 bit): value
1576          *
1577          * Assign "value" to CRTC register with index "CRTC index".
1578          */
1579
1580         uint8_t crtcindex = ROM32(bios->data[offset + 1]);
1581         uint8_t data = bios->data[offset + 2];
1582
1583         if (!iexec->execute)
1584                 return 3;
1585
1586         bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex, data);
1587
1588         return 3;
1589 }
1590
1591 static int
1592 init_zm_cr_group(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1593 {
1594         /*
1595          * INIT_ZM_CR_GROUP   opcode: 0x54 ('T')
1596          *
1597          * offset      (8 bit): opcode
1598          * offset + 1  (8 bit): count
1599          * offset + 2  (8 bit): CRTC index 1
1600          * offset + 3  (8 bit): value 1
1601          * ...
1602          *
1603          * For "count", assign "value n" to CRTC register with index
1604          * "CRTC index n".
1605          */
1606
1607         uint8_t count = bios->data[offset + 1];
1608         int len = 2 + count * 2;
1609         int i;
1610
1611         if (!iexec->execute)
1612                 return len;
1613
1614         for (i = 0; i < count; i++)
1615                 init_zm_cr(bios, offset + 2 + 2 * i - 1, iexec);
1616
1617         return len;
1618 }
1619
1620 static int
1621 init_condition_time(struct nvbios *bios, uint16_t offset,
1622                     struct init_exec *iexec)
1623 {
1624         /*
1625          * INIT_CONDITION_TIME   opcode: 0x56 ('V')
1626          *
1627          * offset      (8 bit): opcode
1628          * offset + 1  (8 bit): condition number
1629          * offset + 2  (8 bit): retries / 50
1630          *
1631          * Check condition "condition number" in the condition table.
1632          * Bios code then sleeps for 2ms if the condition is not met, and
1633          * repeats up to "retries" times, but on one C51 this has proved
1634          * insufficient.  In mmiotraces the driver sleeps for 20ms, so we do
1635          * this, and bail after "retries" times, or 2s, whichever is less.
1636          * If still not met after retries, clear execution flag for this table.
1637          */
1638
1639         uint8_t cond = bios->data[offset + 1];
1640         uint16_t retries = bios->data[offset + 2] * 50;
1641         unsigned cnt;
1642
1643         if (!iexec->execute)
1644                 return 3;
1645
1646         if (retries > 100)
1647                 retries = 100;
1648
1649         BIOSLOG(bios, "0x%04X: Condition: 0x%02X, Retries: 0x%02X\n",
1650                 offset, cond, retries);
1651
1652         if (!bios->execute) /* avoid 2s delays when "faking" execution */
1653                 retries = 1;
1654
1655         for (cnt = 0; cnt < retries; cnt++) {
1656                 if (bios_condition_met(bios, offset, cond)) {
1657                         BIOSLOG(bios, "0x%04X: Condition met, continuing\n",
1658                                                                 offset);
1659                         break;
1660                 } else {
1661                         BIOSLOG(bios, "0x%04X: "
1662                                 "Condition not met, sleeping for 20ms\n",
1663                                                                 offset);
1664                         msleep(20);
1665                 }
1666         }
1667
1668         if (!bios_condition_met(bios, offset, cond)) {
1669                 NV_WARN(bios->dev,
1670                         "0x%04X: Condition still not met after %dms, "
1671                         "skipping following opcodes\n", offset, 20 * retries);
1672                 iexec->execute = false;
1673         }
1674
1675         return 3;
1676 }
1677
1678 static int
1679 init_zm_reg_sequence(struct nvbios *bios, uint16_t offset,
1680                      struct init_exec *iexec)
1681 {
1682         /*
1683          * INIT_ZM_REG_SEQUENCE   opcode: 0x58 ('X')
1684          *
1685          * offset      (8  bit): opcode
1686          * offset + 1  (32 bit): base register
1687          * offset + 5  (8  bit): count
1688          * offset + 6  (32 bit): value 1
1689          * ...
1690          *
1691          * Starting at offset + 6 there are "count" 32 bit values.
1692          * For "count" iterations set "base register" + 4 * current_iteration
1693          * to "value current_iteration"
1694          */
1695
1696         uint32_t basereg = ROM32(bios->data[offset + 1]);
1697         uint32_t count = bios->data[offset + 5];
1698         int len = 6 + count * 4;
1699         int i;
1700
1701         if (!iexec->execute)
1702                 return len;
1703
1704         BIOSLOG(bios, "0x%04X: BaseReg: 0x%08X, Count: 0x%02X\n",
1705                 offset, basereg, count);
1706
1707         for (i = 0; i < count; i++) {
1708                 uint32_t reg = basereg + i * 4;
1709                 uint32_t data = ROM32(bios->data[offset + 6 + i * 4]);
1710
1711                 bios_wr32(bios, reg, data);
1712         }
1713
1714         return len;
1715 }
1716
1717 static int
1718 init_sub_direct(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1719 {
1720         /*
1721          * INIT_SUB_DIRECT   opcode: 0x5B ('[')
1722          *
1723          * offset      (8  bit): opcode
1724          * offset + 1  (16 bit): subroutine offset (in bios)
1725          *
1726          * Calls a subroutine that will execute commands until INIT_DONE
1727          * is found.
1728          */
1729
1730         uint16_t sub_offset = ROM16(bios->data[offset + 1]);
1731
1732         if (!iexec->execute)
1733                 return 3;
1734
1735         BIOSLOG(bios, "0x%04X: Executing subroutine at 0x%04X\n",
1736                 offset, sub_offset);
1737
1738         parse_init_table(bios, sub_offset, iexec);
1739
1740         BIOSLOG(bios, "0x%04X: End of 0x%04X subroutine\n", offset, sub_offset);
1741
1742         return 3;
1743 }
1744
1745 static int
1746 init_copy_nv_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1747 {
1748         /*
1749          * INIT_COPY_NV_REG   opcode: 0x5F ('_')
1750          *
1751          * offset      (8  bit): opcode
1752          * offset + 1  (32 bit): src reg
1753          * offset + 5  (8  bit): shift
1754          * offset + 6  (32 bit): src mask
1755          * offset + 10 (32 bit): xor
1756          * offset + 14 (32 bit): dst reg
1757          * offset + 18 (32 bit): dst mask
1758          *
1759          * Shift REGVAL("src reg") right by (signed) "shift", AND result with
1760          * "src mask", then XOR with "xor". Write this OR'd with
1761          * (REGVAL("dst reg") AND'd with "dst mask") to "dst reg"
1762          */
1763
1764         uint32_t srcreg = *((uint32_t *)(&bios->data[offset + 1]));
1765         uint8_t shift = bios->data[offset + 5];
1766         uint32_t srcmask = *((uint32_t *)(&bios->data[offset + 6]));
1767         uint32_t xor = *((uint32_t *)(&bios->data[offset + 10]));
1768         uint32_t dstreg = *((uint32_t *)(&bios->data[offset + 14]));
1769         uint32_t dstmask = *((uint32_t *)(&bios->data[offset + 18]));
1770         uint32_t srcvalue, dstvalue;
1771
1772         if (!iexec->execute)
1773                 return 22;
1774
1775         BIOSLOG(bios, "0x%04X: SrcReg: 0x%08X, Shift: 0x%02X, SrcMask: 0x%08X, "
1776                       "Xor: 0x%08X, DstReg: 0x%08X, DstMask: 0x%08X\n",
1777                 offset, srcreg, shift, srcmask, xor, dstreg, dstmask);
1778
1779         srcvalue = bios_rd32(bios, srcreg);
1780
1781         if (shift < 0x80)
1782                 srcvalue >>= shift;
1783         else
1784                 srcvalue <<= (0x100 - shift);
1785
1786         srcvalue = (srcvalue & srcmask) ^ xor;
1787
1788         dstvalue = bios_rd32(bios, dstreg) & dstmask;
1789
1790         bios_wr32(bios, dstreg, dstvalue | srcvalue);
1791
1792         return 22;
1793 }
1794
1795 static int
1796 init_zm_index_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1797 {
1798         /*
1799          * INIT_ZM_INDEX_IO   opcode: 0x62 ('b')
1800          *
1801          * offset      (8  bit): opcode
1802          * offset + 1  (16 bit): CRTC port
1803          * offset + 3  (8  bit): CRTC index
1804          * offset + 4  (8  bit): data
1805          *
1806          * Write "data" to index "CRTC index" of "CRTC port"
1807          */
1808         uint16_t crtcport = ROM16(bios->data[offset + 1]);
1809         uint8_t crtcindex = bios->data[offset + 3];
1810         uint8_t data = bios->data[offset + 4];
1811
1812         if (!iexec->execute)
1813                 return 5;
1814
1815         bios_idxprt_wr(bios, crtcport, crtcindex, data);
1816
1817         return 5;
1818 }
1819
1820 static int
1821 init_compute_mem(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1822 {
1823         /*
1824          * INIT_COMPUTE_MEM   opcode: 0x63 ('c')
1825          *
1826          * offset      (8 bit): opcode
1827          *
1828          * This opcode is meant to set NV_PFB_CFG0 (0x100200) appropriately so
1829          * that the hardware can correctly calculate how much VRAM it has
1830          * (and subsequently report that value in NV_PFB_CSTATUS (0x10020C))
1831          *
1832          * The implementation of this opcode in general consists of two parts:
1833          * 1) determination of the memory bus width
1834          * 2) determination of how many of the card's RAM pads have ICs attached
1835          *
1836          * 1) is done by a cunning combination of writes to offsets 0x1c and
1837          * 0x3c in the framebuffer, and seeing whether the written values are
1838          * read back correctly. This then affects bits 4-7 of NV_PFB_CFG0
1839          *
1840          * 2) is done by a cunning combination of writes to an offset slightly
1841          * less than the maximum memory reported by NV_PFB_CSTATUS, then seeing
1842          * if the test pattern can be read back. This then affects bits 12-15 of
1843          * NV_PFB_CFG0
1844          *
1845          * In this context a "cunning combination" may include multiple reads
1846          * and writes to varying locations, often alternating the test pattern
1847          * and 0, doubtless to make sure buffers are filled, residual charges
1848          * on tracks are removed etc.
1849          *
1850          * Unfortunately, the "cunning combination"s mentioned above, and the
1851          * changes to the bits in NV_PFB_CFG0 differ with nearly every bios
1852          * trace I have.
1853          *
1854          * Therefore, we cheat and assume the value of NV_PFB_CFG0 with which
1855          * we started was correct, and use that instead
1856          */
1857
1858         /* no iexec->execute check by design */
1859
1860         /*
1861          * This appears to be a NOP on G8x chipsets, both io logs of the VBIOS
1862          * and kmmio traces of the binary driver POSTing the card show nothing
1863          * being done for this opcode.  why is it still listed in the table?!
1864          */
1865
1866         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
1867
1868         if (dev_priv->card_type >= NV_40)
1869                 return 1;
1870
1871         /*
1872          * On every card I've seen, this step gets done for us earlier in
1873          * the init scripts
1874         uint8_t crdata = bios_idxprt_rd(dev, NV_VIO_SRX, 0x01);
1875         bios_idxprt_wr(dev, NV_VIO_SRX, 0x01, crdata | 0x20);
1876          */
1877
1878         /*
1879          * This also has probably been done in the scripts, but an mmio trace of
1880          * s3 resume shows nvidia doing it anyway (unlike the NV_VIO_SRX write)
1881          */
1882         bios_wr32(bios, NV_PFB_REFCTRL, NV_PFB_REFCTRL_VALID_1);
1883
1884         /* write back the saved configuration value */
1885         bios_wr32(bios, NV_PFB_CFG0, bios->state.saved_nv_pfb_cfg0);
1886
1887         return 1;
1888 }
1889
1890 static int
1891 init_reset(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
1892 {
1893         /*
1894          * INIT_RESET   opcode: 0x65 ('e')
1895          *
1896          * offset      (8  bit): opcode
1897          * offset + 1  (32 bit): register
1898          * offset + 5  (32 bit): value1
1899          * offset + 9  (32 bit): value2
1900          *
1901          * Assign "value1" to "register", then assign "value2" to "register"
1902          */
1903
1904         uint32_t reg = ROM32(bios->data[offset + 1]);
1905         uint32_t value1 = ROM32(bios->data[offset + 5]);
1906         uint32_t value2 = ROM32(bios->data[offset + 9]);
1907         uint32_t pci_nv_19, pci_nv_20;
1908
1909         /* no iexec->execute check by design */
1910
1911         pci_nv_19 = bios_rd32(bios, NV_PBUS_PCI_NV_19);
1912         bios_wr32(bios, NV_PBUS_PCI_NV_19, 0);
1913         bios_wr32(bios, reg, value1);
1914
1915         udelay(10);
1916
1917         bios_wr32(bios, reg, value2);
1918         bios_wr32(bios, NV_PBUS_PCI_NV_19, pci_nv_19);
1919
1920         pci_nv_20 = bios_rd32(bios, NV_PBUS_PCI_NV_20);
1921         pci_nv_20 &= ~NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED;     /* 0xfffffffe */
1922         bios_wr32(bios, NV_PBUS_PCI_NV_20, pci_nv_20);
1923
1924         return 13;
1925 }
1926
1927 static int
1928 init_configure_mem(struct nvbios *bios, uint16_t offset,
1929                    struct init_exec *iexec)
1930 {
1931         /*
1932          * INIT_CONFIGURE_MEM   opcode: 0x66 ('f')
1933          *
1934          * offset      (8 bit): opcode
1935          *
1936          * Equivalent to INIT_DONE on bios version 3 or greater.
1937          * For early bios versions, sets up the memory registers, using values
1938          * taken from the memory init table
1939          */
1940
1941         /* no iexec->execute check by design */
1942
1943         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);
1944         uint16_t seqtbloffs = bios->legacy.sdr_seq_tbl_ptr, meminitdata = meminitoffs + 6;
1945         uint32_t reg, data;
1946
1947         if (bios->major_version > 2)
1948                 return 0;
1949
1950         bios_idxprt_wr(bios, NV_VIO_SRX, NV_VIO_SR_CLOCK_INDEX, bios_idxprt_rd(
1951                        bios, NV_VIO_SRX, NV_VIO_SR_CLOCK_INDEX) | 0x20);
1952
1953         if (bios->data[meminitoffs] & 1)
1954                 seqtbloffs = bios->legacy.ddr_seq_tbl_ptr;
1955
1956         for (reg = ROM32(bios->data[seqtbloffs]);
1957              reg != 0xffffffff;
1958              reg = ROM32(bios->data[seqtbloffs += 4])) {
1959
1960                 switch (reg) {
1961                 case NV_PFB_PRE:
1962                         data = NV_PFB_PRE_CMD_PRECHARGE;
1963                         break;
1964                 case NV_PFB_PAD:
1965                         data = NV_PFB_PAD_CKE_NORMAL;
1966                         break;
1967                 case NV_PFB_REF:
1968                         data = NV_PFB_REF_CMD_REFRESH;
1969                         break;
1970                 default:
1971                         data = ROM32(bios->data[meminitdata]);
1972                         meminitdata += 4;
1973                         if (data == 0xffffffff)
1974                                 continue;
1975                 }
1976
1977                 bios_wr32(bios, reg, data);
1978         }
1979
1980         return 1;
1981 }
1982
1983 static int
1984 init_configure_clk(struct nvbios *bios, uint16_t offset,
1985                    struct init_exec *iexec)
1986 {
1987         /*
1988          * INIT_CONFIGURE_CLK   opcode: 0x67 ('g')
1989          *
1990          * offset      (8 bit): opcode
1991          *
1992          * Equivalent to INIT_DONE on bios version 3 or greater.
1993          * For early bios versions, sets up the NVClk and MClk PLLs, using
1994          * values taken from the memory init table
1995          */
1996
1997         /* no iexec->execute check by design */
1998
1999         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);
2000         int clock;
2001
2002         if (bios->major_version > 2)
2003                 return 0;
2004
2005         clock = ROM16(bios->data[meminitoffs + 4]) * 10;
2006         setPLL(bios, NV_PRAMDAC_NVPLL_COEFF, clock);
2007
2008         clock = ROM16(bios->data[meminitoffs + 2]) * 10;
2009         if (bios->data[meminitoffs] & 1) /* DDR */
2010                 clock *= 2;
2011         setPLL(bios, NV_PRAMDAC_MPLL_COEFF, clock);
2012
2013         return 1;
2014 }
2015
2016 static int
2017 init_configure_preinit(struct nvbios *bios, uint16_t offset,
2018                        struct init_exec *iexec)
2019 {
2020         /*
2021          * INIT_CONFIGURE_PREINIT   opcode: 0x68 ('h')
2022          *
2023          * offset      (8 bit): opcode
2024          *
2025          * Equivalent to INIT_DONE on bios version 3 or greater.
2026          * For early bios versions, does early init, loading ram and crystal
2027          * configuration from straps into CR3C
2028          */
2029
2030         /* no iexec->execute check by design */
2031
2032         uint32_t straps = bios_rd32(bios, NV_PEXTDEV_BOOT_0);
2033         uint8_t cr3c = ((straps << 2) & 0xf0) | (straps & (1 << 6));
2034
2035         if (bios->major_version > 2)
2036                 return 0;
2037
2038         bios_idxprt_wr(bios, NV_CIO_CRX__COLOR,
2039                              NV_CIO_CRE_SCRATCH4__INDEX, cr3c);
2040
2041         return 1;
2042 }
2043
2044 static int
2045 init_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2046 {
2047         /*
2048          * INIT_IO   opcode: 0x69 ('i')
2049          *
2050          * offset      (8  bit): opcode
2051          * offset + 1  (16 bit): CRTC port
2052          * offset + 3  (8  bit): mask
2053          * offset + 4  (8  bit): data
2054          *
2055          * Assign ((IOVAL("crtc port") & "mask") | "data") to "crtc port"
2056          */
2057
2058         struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
2059         uint16_t crtcport = ROM16(bios->data[offset + 1]);
2060         uint8_t mask = bios->data[offset + 3];
2061         uint8_t data = bios->data[offset + 4];
2062
2063         if (!iexec->execute)
2064                 return 5;
2065
2066         BIOSLOG(bios, "0x%04X: Port: 0x%04X, Mask: 0x%02X, Data: 0x%02X\n",
2067                 offset, crtcport, mask, data);
2068
2069         /*
2070          * I have no idea what this does, but NVIDIA do this magic sequence
2071          * in the places where this INIT_IO happens..
2072          */
2073         if (dev_priv->card_type >= NV_50 && crtcport == 0x3c3 && data == 1) {
2074                 int i;
2075
2076                 bios_wr32(bios, 0x614100, (bios_rd32(
2077                           bios, 0x614100) & 0x0fffffff) | 0x00800000);
2078
2079                 bios_wr32(bios, 0x00e18c, bios_rd32(
2080                           bios, 0x00e18c) | 0x00020000);
2081
2082                 bios_wr32(bios, 0x614900, (bios_rd32(
2083                           bios, 0x614900) & 0x0fffffff) | 0x00800000);
2084
2085                 bios_wr32(bios, 0x000200, bios_rd32(
2086                           bios, 0x000200) & ~0x40000000);
2087
2088                 mdelay(10);
2089
2090                 bios_wr32(bios, 0x00e18c, bios_rd32(
2091                           bios, 0x00e18c) & ~0x00020000);
2092
2093                 bios_wr32(bios, 0x000200, bios_rd32(
2094                           bios, 0x000200) | 0x40000000);
2095
2096                 bios_wr32(bios, 0x614100, 0x00800018);
2097                 bios_wr32(bios, 0x614900, 0x00800018);
2098
2099                 mdelay(10);
2100
2101                 bios_wr32(bios, 0x614100, 0x10000018);
2102                 bios_wr32(bios, 0x614900, 0x10000018);
2103
2104                 for (i = 0; i < 3; i++)
2105                         bios_wr32(bios, 0x614280 + (i*0x800), bios_rd32(
2106                                   bios, 0x614280 + (i*0x800)) & 0xf0f0f0f0);
2107
2108                 for (i = 0; i < 2; i++)
2109                         bios_wr32(bios, 0x614300 + (i*0x800), bios_rd32(
2110                                   bios, 0x614300 + (i*0x800)) & 0xfffff0f0);
2111
2112                 for (i = 0; i < 3; i++)
2113                         bios_wr32(bios, 0x614380 + (i*0x800), bios_rd32(
2114                                   bios, 0x614380 + (i*0x800)) & 0xfffff0f0);
2115
2116                 for (i = 0; i < 2; i++)
2117                         bios_wr32(bios, 0x614200 + (i*0x800), bios_rd32(
2118                                   bios, 0x614200 + (i*0x800)) & 0xfffffff0);
2119
2120                 for (i = 0; i < 2; i++)
2121                         bios_wr32(bios, 0x614108 + (i*0x800), bios_rd32(
2122                                   bios, 0x614108 + (i*0x800)) & 0x0fffffff);
2123                 return 5;
2124         }
2125
2126         bios_port_wr(bios, crtcport, (bios_port_rd(bios, crtcport) & mask) |
2127                                                                         data);
2128         return 5;
2129 }
2130
2131 static int
2132 init_sub(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2133 {
2134         /*
2135          * INIT_SUB   opcode: 0x6B ('k')
2136          *
2137          * offset      (8 bit): opcode
2138          * offset + 1  (8 bit): script number
2139          *
2140          * Execute script number "script number", as a subroutine
2141          */
2142
2143         uint8_t sub = bios->data[offset + 1];
2144
2145         if (!iexec->execute)
2146                 return 2;
2147
2148         BIOSLOG(bios, "0x%04X: Calling script %d\n", offset, sub);
2149
2150         parse_init_table(bios,
2151                          ROM16(bios->data[bios->init_script_tbls_ptr + sub * 2]),
2152                          iexec);
2153
2154         BIOSLOG(bios, "0x%04X: End of script %d\n", offset, sub);
2155
2156         return 2;
2157 }
2158
2159 static int
2160 init_ram_condition(struct nvbios *bios, uint16_t offset,
2161                    struct init_exec *iexec)
2162 {
2163         /*
2164          * INIT_RAM_CONDITION   opcode: 0x6D ('m')
2165          *
2166          * offset      (8 bit): opcode
2167          * offset + 1  (8 bit): mask
2168          * offset + 2  (8 bit): cmpval
2169          *
2170          * Test if (NV_PFB_BOOT_0 & "mask") equals "cmpval".
2171          * If condition not met skip subsequent opcodes until condition is
2172          * inverted (INIT_NOT), or we hit INIT_RESUME
2173          */
2174
2175         uint8_t mask = bios->data[offset + 1];
2176         uint8_t cmpval = bios->data[offset + 2];
2177         uint8_t data;
2178
2179         if (!iexec->execute)
2180                 return 3;
2181
2182         data = bios_rd32(bios, NV_PFB_BOOT_0) & mask;
2183
2184         BIOSLOG(bios, "0x%04X: Checking if 0x%08X equals 0x%08X\n",
2185                 offset, data, cmpval);
2186
2187         if (data == cmpval)
2188                 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
2189         else {
2190                 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
2191                 iexec->execute = false;
2192         }
2193
2194         return 3;
2195 }
2196
2197 static int
2198 init_nv_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2199 {
2200         /*
2201          * INIT_NV_REG   opcode: 0x6E ('n')
2202          *
2203          * offset      (8  bit): opcode
2204          * offset + 1  (32 bit): register
2205          * offset + 5  (32 bit): mask
2206          * offset + 9  (32 bit): data
2207          *
2208          * Assign ((REGVAL("register") & "mask") | "data") to "register"
2209          */
2210
2211         uint32_t reg = ROM32(bios->data[offset + 1]);
2212         uint32_t mask = ROM32(bios->data[offset + 5]);
2213         uint32_t data = ROM32(bios->data[offset + 9]);
2214
2215         if (!iexec->execute)
2216                 return 13;
2217
2218         BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Mask: 0x%08X, Data: 0x%08X\n",
2219                 offset, reg, mask, data);
2220
2221         bios_wr32(bios, reg, (bios_rd32(bios, reg) & mask) | data);
2222
2223         return 13;
2224 }
2225
2226 static int
2227 init_macro(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2228 {
2229         /*
2230          * INIT_MACRO   opcode: 0x6F ('o')
2231          *
2232          * offset      (8 bit): opcode
2233          * offset + 1  (8 bit): macro number
2234          *
2235          * Look up macro index "macro number" in the macro index table.
2236          * The macro index table entry has 1 byte for the index in the macro
2237          * table, and 1 byte for the number of times to repeat the macro.
2238          * The macro table entry has 4 bytes for the register address and
2239          * 4 bytes for the value to write to that register
2240          */
2241
2242         uint8_t macro_index_tbl_idx = bios->data[offset + 1];
2243         uint16_t tmp = bios->macro_index_tbl_ptr + (macro_index_tbl_idx * MACRO_INDEX_SIZE);
2244         uint8_t macro_tbl_idx = bios->data[tmp];
2245         uint8_t count = bios->data[tmp + 1];
2246         uint32_t reg, data;
2247         int i;
2248
2249         if (!iexec->execute)
2250                 return 2;
2251
2252         BIOSLOG(bios, "0x%04X: Macro: 0x%02X, MacroTableIndex: 0x%02X, "
2253                       "Count: 0x%02X\n",
2254                 offset, macro_index_tbl_idx, macro_tbl_idx, count);
2255
2256         for (i = 0; i < count; i++) {
2257                 uint16_t macroentryptr = bios->macro_tbl_ptr + (macro_tbl_idx + i) * MACRO_SIZE;
2258
2259                 reg = ROM32(bios->data[macroentryptr]);
2260                 data = ROM32(bios->data[macroentryptr + 4]);
2261
2262                 bios_wr32(bios, reg, data);
2263         }
2264
2265         return 2;
2266 }
2267
2268 static int
2269 init_done(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2270 {
2271         /*
2272          * INIT_DONE   opcode: 0x71 ('q')
2273          *
2274          * offset      (8  bit): opcode
2275          *
2276          * End the current script
2277          */
2278
2279         /* mild retval abuse to stop parsing this table */
2280         return 0;
2281 }
2282
2283 static int
2284 init_resume(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2285 {
2286         /*
2287          * INIT_RESUME   opcode: 0x72 ('r')
2288          *
2289          * offset      (8  bit): opcode
2290          *
2291          * End the current execute / no-execute condition
2292          */
2293
2294         if (iexec->execute)
2295                 return 1;
2296
2297         iexec->execute = true;
2298         BIOSLOG(bios, "0x%04X: ---- Executing following commands ----\n", offset);
2299
2300         return 1;
2301 }
2302
2303 static int
2304 init_time(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2305 {
2306         /*
2307          * INIT_TIME   opcode: 0x74 ('t')
2308          *
2309          * offset      (8  bit): opcode
2310          * offset + 1  (16 bit): time
2311          *
2312          * Sleep for "time" microseconds.
2313          */
2314
2315         unsigned time = ROM16(bios->data[offset + 1]);
2316
2317         if (!iexec->execute)
2318                 return 3;
2319
2320         BIOSLOG(bios, "0x%04X: Sleeping for 0x%04X microseconds\n",
2321                 offset, time);
2322
2323         if (time < 1000)
2324                 udelay(time);
2325         else
2326                 msleep((time + 900) / 1000);
2327
2328         return 3;
2329 }
2330
2331 static int
2332 init_condition(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2333 {
2334         /*
2335          * INIT_CONDITION   opcode: 0x75 ('u')
2336          *
2337          * offset      (8 bit): opcode
2338          * offset + 1  (8 bit): condition number
2339          *
2340          * Check condition "condition number" in the condition table.
2341          * If condition not met skip subsequent opcodes until condition is
2342          * inverted (INIT_NOT), or we hit INIT_RESUME
2343          */
2344
2345         uint8_t cond = bios->data[offset + 1];
2346
2347         if (!iexec->execute)
2348                 return 2;
2349
2350         BIOSLOG(bios, "0x%04X: Condition: 0x%02X\n", offset, cond);
2351
2352         if (bios_condition_met(bios, offset, cond))
2353                 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
2354         else {
2355                 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
2356                 iexec->execute = false;
2357         }
2358
2359         return 2;
2360 }
2361
2362 static int
2363 init_io_condition(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2364 {
2365         /*
2366          * INIT_IO_CONDITION  opcode: 0x76
2367          *
2368          * offset      (8 bit): opcode
2369          * offset + 1  (8 bit): condition number
2370          *
2371          * Check condition "condition number" in the io condition table.
2372          * If condition not met skip subsequent opcodes until condition is
2373          * inverted (INIT_NOT), or we hit INIT_RESUME
2374          */
2375
2376         uint8_t cond = bios->data[offset + 1];
2377
2378         if (!iexec->execute)
2379                 return 2;
2380
2381         BIOSLOG(bios, "0x%04X: IO condition: 0x%02X\n", offset, cond);
2382
2383         if (io_condition_met(bios, offset, cond))
2384                 BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
2385         else {
2386                 BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
2387                 iexec->execute = false;
2388         }
2389
2390         return 2;
2391 }
2392
2393 static int
2394 init_index_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2395 {
2396         /*
2397          * INIT_INDEX_IO   opcode: 0x78 ('x')
2398          *
2399          * offset      (8  bit): opcode
2400          * offset + 1  (16 bit): CRTC port
2401          * offset + 3  (8  bit): CRTC index
2402          * offset + 4  (8  bit): mask
2403          * offset + 5  (8  bit): data
2404          *
2405          * Read value at index "CRTC index" on "CRTC port", AND with "mask",
2406          * OR with "data", write-back
2407          */
2408
2409         uint16_t crtcport = ROM16(bios->data[offset + 1]);
2410         uint8_t crtcindex = bios->data[offset + 3];
2411         uint8_t mask = bios->data[offset + 4];
2412         uint8_t data = bios->data[offset + 5];
2413         uint8_t value;
2414
2415         if (!iexec->execute)
2416                 return 6;
2417
2418         BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
2419                       "Data: 0x%02X\n",
2420                 offset, crtcport, crtcindex, mask, data);
2421
2422         value = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) | data;
2423         bios_idxprt_wr(bios, crtcport, crtcindex, value);
2424
2425         return 6;
2426 }
2427
2428 static int
2429 init_pll(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2430 {
2431         /*
2432          * INIT_PLL   opcode: 0x79 ('y')
2433          *
2434          * offset      (8  bit): opcode
2435          * offset + 1  (32 bit): register
2436          * offset + 5  (16 bit): freq
2437          *
2438          * Set PLL register "register" to coefficients for frequency (10kHz)
2439          * "freq"
2440          */
2441
2442         uint32_t reg = ROM32(bios->data[offset + 1]);
2443         uint16_t freq = ROM16(bios->data[offset + 5]);
2444
2445         if (!iexec->execute)
2446                 return 7;
2447
2448         BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Freq: %d0kHz\n", offset, reg, freq);
2449
2450         setPLL(bios, reg, freq * 10);
2451
2452         return 7;
2453 }
2454
2455 static int
2456 init_zm_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2457 {
2458         /*
2459          * INIT_ZM_REG   opcode: 0x7A ('z')
2460          *
2461          * offset      (8  bit): opcode
2462          * offset + 1  (32 bit): register
2463          * offset + 5  (32 bit): value
2464          *
2465          * Assign "value" to "register"
2466          */
2467
2468         uint32_t reg = ROM32(bios->data[offset + 1]);
2469         uint32_t value = ROM32(bios->data[offset + 5]);
2470
2471         if (!iexec->execute)
2472                 return 9;
2473
2474         if (reg == 0x000200)
2475                 value |= 1;
2476
2477         bios_wr32(bios, reg, value);
2478
2479         return 9;
2480 }
2481
2482 static int
2483 init_ram_restrict_pll(struct nvbios *bios, uint16_t offset,
2484                       struct init_exec *iexec)
2485 {
2486         /*
2487          * INIT_RAM_RESTRICT_PLL   opcode: 0x87 ('')
2488          *
2489          * offset      (8 bit): opcode
2490          * offset + 1  (8 bit): PLL type
2491          * offset + 2 (32 bit): frequency 0
2492          *
2493          * Uses the RAMCFG strap of PEXTDEV_BOOT as an index into the table at
2494          * ram_restrict_table_ptr.  The value read from there is used to select
2495          * a frequency from the table starting at 'frequency 0' to be
2496          * programmed into the PLL corresponding to 'type'.
2497          *
2498          * The PLL limits table on cards using this opcode has a mapping of
2499          * 'type' to the relevant registers.
2500          */
2501
2502         struct drm_device *dev = bios->dev;
2503         uint32_t strap = (bios_rd32(bios, NV_PEXTDEV_BOOT_0) & 0x0000003c) >> 2;
2504         uint8_t index = bios->data[bios->ram_restrict_tbl_ptr + strap];
2505         uint8_t type = bios->data[offset + 1];
2506         uint32_t freq = ROM32(bios->data[offset + 2 + (index * 4)]);
2507         uint8_t *pll_limits = &bios->data[bios->pll_limit_tbl_ptr], *entry;
2508         int len = 2 + bios->ram_restrict_group_count * 4;
2509         int i;
2510
2511         if (!iexec->execute)
2512                 return len;
2513
2514         if (!bios->pll_limit_tbl_ptr || (pll_limits[0] & 0xf0) != 0x30) {
2515                 NV_ERROR(dev, "PLL limits table not version 3.x\n");
2516                 return len; /* deliberate, allow default clocks to remain */
2517         }
2518
2519         entry = pll_limits + pll_limits[1];
2520         for (i = 0; i < pll_limits[3]; i++, entry += pll_limits[2]) {
2521                 if (entry[0] == type) {
2522                         uint32_t reg = ROM32(entry[3]);
2523
2524                         BIOSLOG(bios, "0x%04X: "
2525                                       "Type %02x Reg 0x%08x Freq %dKHz\n",
2526                                 offset, type, reg, freq);
2527
2528                         setPLL(bios, reg, freq);
2529                         return len;
2530                 }
2531         }
2532
2533         NV_ERROR(dev, "PLL type 0x%02x not found in PLL limits table", type);
2534         return len;
2535 }
2536
2537 static int
2538 init_8c(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2539 {
2540         /*
2541          * INIT_8C   opcode: 0x8C ('')
2542          *
2543          * NOP so far....
2544          *
2545          */
2546
2547         return 1;
2548 }
2549
2550 static int
2551 init_8d(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2552 {
2553         /*
2554          * INIT_8D   opcode: 0x8D ('')
2555          *
2556          * NOP so far....
2557          *
2558          */
2559
2560         return 1;
2561 }
2562
2563 static int
2564 init_gpio(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2565 {
2566         /*
2567          * INIT_GPIO   opcode: 0x8E ('')
2568          *
2569          * offset      (8 bit): opcode
2570          *
2571          * Loop over all entries in the DCB GPIO table, and initialise
2572          * each GPIO according to various values listed in each entry
2573          */
2574
2575         const uint32_t nv50_gpio_reg[4] = { 0xe104, 0xe108, 0xe280, 0xe284 };
2576         const uint32_t nv50_gpio_ctl[2] = { 0xe100, 0xe28c };
2577         const uint8_t *gpio_table = &bios->data[bios->bdcb.gpio_table_ptr];
2578         const uint8_t *gpio_entry;
2579         int i;
2580
2581         if (!iexec->execute)
2582                 return 1;
2583
2584         if (bios->bdcb.version != 0x40) {
2585                 NV_ERROR(bios->dev, "DCB table not version 4.0\n");
2586                 return 0;
2587         }
2588
2589         if (!bios->bdcb.gpio_table_ptr) {
2590                 NV_WARN(bios->dev, "Invalid pointer to INIT_8E table\n");
2591                 return 0;
2592         }
2593
2594         gpio_entry = gpio_table + gpio_table[1];
2595         for (i = 0; i < gpio_table[2]; i++, gpio_entry += gpio_table[3]) {
2596                 uint32_t entry = ROM32(gpio_entry[0]), r, s, v;
2597                 int line = (entry & 0x0000001f);
2598
2599                 BIOSLOG(bios, "0x%04X: Entry: 0x%08X\n", offset, entry);
2600
2601                 if ((entry & 0x0000ff00) == 0x0000ff00)
2602                         continue;
2603
2604                 r = nv50_gpio_reg[line >> 3];
2605                 s = (line & 0x07) << 2;
2606                 v = bios_rd32(bios, r) & ~(0x00000003 << s);
2607                 if (entry & 0x01000000)
2608                         v |= (((entry & 0x60000000) >> 29) ^ 2) << s;
2609                 else
2610                         v |= (((entry & 0x18000000) >> 27) ^ 2) << s;
2611                 bios_wr32(bios, r, v);
2612
2613                 r = nv50_gpio_ctl[line >> 4];
2614                 s = (line & 0x0f);
2615                 v = bios_rd32(bios, r) & ~(0x00010001 << s);
2616                 switch ((entry & 0x06000000) >> 25) {
2617                 case 1:
2618                         v |= (0x00000001 << s);
2619                         break;
2620                 case 2:
2621                         v |= (0x00010000 << s);
2622                         break;
2623                 default:
2624                         break;
2625                 }
2626                 bios_wr32(bios, r, v);
2627         }
2628
2629         return 1;
2630 }
2631
2632 static int
2633 init_ram_restrict_zm_reg_group(struct nvbios *bios, uint16_t offset,
2634                                struct init_exec *iexec)
2635 {
2636         /*
2637          * INIT_RAM_RESTRICT_ZM_REG_GROUP   opcode: 0x8F ('')
2638          *
2639          * offset      (8  bit): opcode
2640          * offset + 1  (32 bit): reg
2641          * offset + 5  (8  bit): regincrement
2642          * offset + 6  (8  bit): count
2643          * offset + 7  (32 bit): value 1,1
2644          * ...
2645          *
2646          * Use the RAMCFG strap of PEXTDEV_BOOT as an index into the table at
2647          * ram_restrict_table_ptr. The value read from here is 'n', and
2648          * "value 1,n" gets written to "reg". This repeats "count" times and on
2649          * each iteration 'm', "reg" increases by "regincrement" and
2650          * "value m,n" is used. The extent of n is limited by a number read
2651          * from the 'M' BIT table, herein called "blocklen"
2652          */
2653
2654         uint32_t reg = ROM32(bios->data[offset + 1]);
2655         uint8_t regincrement = bios->data[offset + 5];
2656         uint8_t count = bios->data[offset + 6];
2657         uint32_t strap_ramcfg, data;
2658         /* previously set by 'M' BIT table */
2659         uint16_t blocklen = bios->ram_restrict_group_count * 4;
2660         int len = 7 + count * blocklen;
2661         uint8_t index;
2662         int i;
2663
2664
2665         if (!iexec->execute)
2666                 return len;
2667
2668         if (!blocklen) {
2669                 NV_ERROR(bios->dev,
2670                          "0x%04X: Zero block length - has the M table "
2671                          "been parsed?\n", offset);
2672                 return 0;
2673         }
2674
2675         strap_ramcfg = (bios_rd32(bios, NV_PEXTDEV_BOOT_0) >> 2) & 0xf;
2676         index = bios->data[bios->ram_restrict_tbl_ptr + strap_ramcfg];
2677
2678         BIOSLOG(bios, "0x%04X: Reg: 0x%08X, RegIncrement: 0x%02X, "
2679                       "Count: 0x%02X, StrapRamCfg: 0x%02X, Index: 0x%02X\n",
2680                 offset, reg, regincrement, count, strap_ramcfg, index);
2681
2682         for (i = 0; i < count; i++) {
2683                 data = ROM32(bios->data[offset + 7 + index * 4 + blocklen * i]);
2684
2685                 bios_wr32(bios, reg, data);
2686
2687                 reg += regincrement;
2688         }
2689
2690         return len;
2691 }
2692
2693 static int
2694 init_copy_zm_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2695 {
2696         /*
2697          * INIT_COPY_ZM_REG   opcode: 0x90 ('')
2698          *
2699          * offset      (8  bit): opcode
2700          * offset + 1  (32 bit): src reg
2701          * offset + 5  (32 bit): dst reg
2702          *
2703          * Put contents of "src reg" into "dst reg"
2704          */
2705
2706         uint32_t srcreg = ROM32(bios->data[offset + 1]);
2707         uint32_t dstreg = ROM32(bios->data[offset + 5]);
2708
2709         if (!iexec->execute)
2710                 return 9;
2711
2712         bios_wr32(bios, dstreg, bios_rd32(bios, srcreg));
2713
2714         return 9;
2715 }
2716
2717 static int
2718 init_zm_reg_group_addr_latched(struct nvbios *bios, uint16_t offset,
2719                                struct init_exec *iexec)
2720 {
2721         /*
2722          * INIT_ZM_REG_GROUP_ADDRESS_LATCHED   opcode: 0x91 ('')
2723          *
2724          * offset      (8  bit): opcode
2725          * offset + 1  (32 bit): dst reg
2726          * offset + 5  (8  bit): count
2727          * offset + 6  (32 bit): data 1
2728          * ...
2729          *
2730          * For each of "count" values write "data n" to "dst reg"
2731          */
2732
2733         uint32_t reg = ROM32(bios->data[offset + 1]);
2734         uint8_t count = bios->data[offset + 5];
2735         int len = 6 + count * 4;
2736         int i;
2737
2738         if (!iexec->execute)
2739                 return len;
2740
2741         for (i = 0; i < count; i++) {
2742                 uint32_t data = ROM32(bios->data[offset + 6 + 4 * i]);
2743                 bios_wr32(bios, reg, data);
2744         }
2745
2746         return len;
2747 }
2748
2749 static int
2750 init_reserved(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2751 {
2752         /*
2753          * INIT_RESERVED   opcode: 0x92 ('')
2754          *
2755          * offset      (8 bit): opcode
2756          *
2757          * Seemingly does nothing
2758          */
2759
2760         return 1;
2761 }
2762
2763 static int
2764 init_96(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2765 {
2766         /*
2767          * INIT_96   opcode: 0x96 ('')
2768          *
2769          * offset      (8  bit): opcode
2770          * offset + 1  (32 bit): sreg
2771          * offset + 5  (8  bit): sshift
2772          * offset + 6  (8  bit): smask
2773          * offset + 7  (8  bit): index
2774          * offset + 8  (32 bit): reg
2775          * offset + 12 (32 bit): mask
2776          * offset + 16 (8  bit): shift
2777          *
2778          */
2779
2780         uint16_t xlatptr = bios->init96_tbl_ptr + (bios->data[offset + 7] * 2);
2781         uint32_t reg = ROM32(bios->data[offset + 8]);
2782         uint32_t mask = ROM32(bios->data[offset + 12]);
2783         uint32_t val;
2784
2785         val = bios_rd32(bios, ROM32(bios->data[offset + 1]));
2786         if (bios->data[offset + 5] < 0x80)
2787                 val >>= bios->data[offset + 5];
2788         else
2789                 val <<= (0x100 - bios->data[offset + 5]);
2790         val &= bios->data[offset + 6];
2791
2792         val   = bios->data[ROM16(bios->data[xlatptr]) + val];
2793         val <<= bios->data[offset + 16];
2794
2795         if (!iexec->execute)
2796                 return 17;
2797
2798         bios_wr32(bios, reg, (bios_rd32(bios, reg) & mask) | val);
2799         return 17;
2800 }
2801
2802 static int
2803 init_97(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2804 {
2805         /*
2806          * INIT_97   opcode: 0x97 ('')
2807          *
2808          * offset      (8  bit): opcode
2809          * offset + 1  (32 bit): register
2810          * offset + 5  (32 bit): mask
2811          * offset + 9  (32 bit): value
2812          *
2813          * Adds "value" to "register" preserving the fields specified
2814          * by "mask"
2815          */
2816
2817         uint32_t reg = ROM32(bios->data[offset + 1]);
2818         uint32_t mask = ROM32(bios->data[offset + 5]);
2819         uint32_t add = ROM32(bios->data[offset + 9]);
2820         uint32_t val;
2821
2822         val = bios_rd32(bios, reg);
2823         val = (val & mask) | ((val + add) & ~mask);
2824
2825         if (!iexec->execute)
2826                 return 13;
2827
2828         bios_wr32(bios, reg, val);
2829         return 13;
2830 }
2831
2832 static int
2833 init_auxch(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2834 {
2835         /*
2836          * INIT_AUXCH   opcode: 0x98 ('')
2837          *
2838          * offset      (8  bit): opcode
2839          * offset + 1  (32 bit): address
2840          * offset + 5  (8  bit): count
2841          * offset + 6  (8  bit): mask 0
2842          * offset + 7  (8  bit): data 0
2843          *  ...
2844          *
2845          */
2846
2847         struct drm_device *dev = bios->dev;
2848         struct nouveau_i2c_chan *auxch;
2849         uint32_t addr = ROM32(bios->data[offset + 1]);
2850         uint8_t count = bios->data[offset + 5];
2851         int len = 6 + count * 2;
2852         int ret, i;
2853
2854         if (!bios->display.output) {
2855                 NV_ERROR(dev, "INIT_AUXCH: no active output\n");
2856                 return 0;
2857         }
2858
2859         auxch = init_i2c_device_find(dev, bios->display.output->i2c_index);
2860         if (!auxch) {
2861                 NV_ERROR(dev, "INIT_AUXCH: couldn't get auxch %d\n",
2862                          bios->display.output->i2c_index);
2863                 return 0;
2864         }
2865
2866         if (!iexec->execute)
2867                 return len;
2868
2869         offset += 6;
2870         for (i = 0; i < count; i++, offset += 2) {
2871                 uint8_t data;
2872
2873                 ret = nouveau_dp_auxch(auxch, 9, addr, &data, 1);
2874                 if (ret) {
2875                         NV_ERROR(dev, "INIT_AUXCH: rd auxch fail %d\n", ret);
2876                         return 0;
2877                 }
2878
2879                 data &= bios->data[offset + 0];
2880                 data |= bios->data[offset + 1];
2881
2882                 ret = nouveau_dp_auxch(auxch, 8, addr, &data, 1);
2883                 if (ret) {
2884                         NV_ERROR(dev, "INIT_AUXCH: wr auxch fail %d\n", ret);
2885                         return 0;
2886                 }
2887         }
2888
2889         return len;
2890 }
2891
2892 static int
2893 init_zm_auxch(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
2894 {
2895         /*
2896          * INIT_ZM_AUXCH   opcode: 0x99 ('')
2897          *
2898          * offset      (8  bit): opcode
2899          * offset + 1  (32 bit): address
2900          * offset + 5  (8  bit): count
2901          * offset + 6  (8  bit): data 0
2902          *  ...
2903          *
2904          */
2905
2906         struct drm_device *dev = bios->dev;
2907         struct nouveau_i2c_chan *auxch;
2908         uint32_t addr = ROM32(bios->data[offset + 1]);
2909         uint8_t count = bios->data[offset + 5];
2910         int len = 6 + count;
2911         int ret, i;
2912
2913         if (!bios->display.output) {
2914                 NV_ERROR(dev, "INIT_ZM_AUXCH: no active output\n");
2915                 return 0;
2916         }
2917
2918         auxch = init_i2c_device_find(dev, bios->display.output->i2c_index);
2919         if (!auxch) {
2920                 NV_ERROR(dev, "INIT_ZM_AUXCH: couldn't get auxch %d\n",
2921                          bios->display.output->i2c_index);
2922                 return 0;
2923         }
2924
2925         if (!iexec->execute)
2926                 return len;
2927
2928         offset += 6;
2929         for (i = 0; i < count; i++, offset++) {
2930                 ret = nouveau_dp_auxch(auxch, 8, addr, &bios->data[offset], 1);
2931                 if (ret) {
2932                         NV_ERROR(dev, "INIT_ZM_AUXCH: wr auxch fail %d\n", ret);
2933                         return 0;
2934                 }
2935         }
2936
2937         return len;
2938 }
2939
2940 static struct init_tbl_entry itbl_entry[] = {
2941         /* command name                       , id  , length  , offset  , mult    , command handler                 */
2942         /* INIT_PROG (0x31, 15, 10, 4) removed due to no example of use */
2943         { "INIT_IO_RESTRICT_PROG"             , 0x32, init_io_restrict_prog           },
2944         { "INIT_REPEAT"                       , 0x33, init_repeat                     },
2945         { "INIT_IO_RESTRICT_PLL"              , 0x34, init_io_restrict_pll            },
2946         { "INIT_END_REPEAT"                   , 0x36, init_end_repeat                 },
2947         { "INIT_COPY"                         , 0x37, init_copy                       },
2948         { "INIT_NOT"                          , 0x38, init_not                        },
2949         { "INIT_IO_FLAG_CONDITION"            , 0x39, init_io_flag_condition          },
2950         { "INIT_INDEX_ADDRESS_LATCHED"        , 0x49, init_idx_addr_latched           },
2951         { "INIT_IO_RESTRICT_PLL2"             , 0x4A, init_io_restrict_pll2           },
2952         { "INIT_PLL2"                         , 0x4B, init_pll2                       },
2953         { "INIT_I2C_BYTE"                     , 0x4C, init_i2c_byte                   },
2954         { "INIT_ZM_I2C_BYTE"                  , 0x4D, init_zm_i2c_byte                },
2955         { "INIT_ZM_I2C"                       , 0x4E, init_zm_i2c                     },
2956         { "INIT_TMDS"                         , 0x4F, init_tmds                       },
2957         { "INIT_ZM_TMDS_GROUP"                , 0x50, init_zm_tmds_group              },
2958         { "INIT_CR_INDEX_ADDRESS_LATCHED"     , 0x51, init_cr_idx_adr_latch           },
2959         { "INIT_CR"                           , 0x52, init_cr                         },
2960         { "INIT_ZM_CR"                        , 0x53, init_zm_cr                      },
2961         { "INIT_ZM_CR_GROUP"                  , 0x54, init_zm_cr_group                },
2962         { "INIT_CONDITION_TIME"               , 0x56, init_condition_time             },
2963         { "INIT_ZM_REG_SEQUENCE"              , 0x58, init_zm_reg_sequence            },
2964         /* INIT_INDIRECT_REG (0x5A, 7, 0, 0) removed due to no example of use */
2965         { "INIT_SUB_DIRECT"                   , 0x5B, init_sub_direct                 },
2966         { "INIT_COPY_NV_REG"                  , 0x5F, init_copy_nv_reg                },
2967         { "INIT_ZM_INDEX_IO"                  , 0x62, init_zm_index_io                },
2968         { "INIT_COMPUTE_MEM"                  , 0x63, init_compute_mem                },
2969         { "INIT_RESET"                        , 0x65, init_reset                      },
2970         { "INIT_CONFIGURE_MEM"                , 0x66, init_configure_mem              },
2971         { "INIT_CONFIGURE_CLK"                , 0x67, init_configure_clk              },
2972         { "INIT_CONFIGURE_PREINIT"            , 0x68, init_configure_preinit          },
2973         { "INIT_IO"                           , 0x69, init_io                         },
2974         { "INIT_SUB"                          , 0x6B, init_sub                        },
2975         { "INIT_RAM_CONDITION"                , 0x6D, init_ram_condition              },
2976         { "INIT_NV_REG"                       , 0x6E, init_nv_reg                     },
2977         { "INIT_MACRO"                        , 0x6F, init_macro                      },
2978         { "INIT_DONE"                         , 0x71, init_done                       },
2979         { "INIT_RESUME"                       , 0x72, init_resume                     },
2980         /* INIT_RAM_CONDITION2 (0x73, 9, 0, 0) removed due to no example of use */
2981         { "INIT_TIME"                         , 0x74, init_time                       },
2982         { "INIT_CONDITION"                    , 0x75, init_condition                  },
2983         { "INIT_IO_CONDITION"                 , 0x76, init_io_condition               },
2984         { "INIT_INDEX_IO"                     , 0x78, init_index_io                   },
2985         { "INIT_PLL"                          , 0x79, init_pll                        },
2986         { "INIT_ZM_REG"                       , 0x7A, init_zm_reg                     },
2987         { "INIT_RAM_RESTRICT_PLL"             , 0x87, init_ram_restrict_pll           },
2988         { "INIT_8C"                           , 0x8C, init_8c                         },
2989         { "INIT_8D"                           , 0x8D, init_8d                         },
2990         { "INIT_GPIO"                         , 0x8E, init_gpio                       },
2991         { "INIT_RAM_RESTRICT_ZM_REG_GROUP"    , 0x8F, init_ram_restrict_zm_reg_group  },
2992         { "INIT_COPY_ZM_REG"                  , 0x90, init_copy_zm_reg                },
2993         { "INIT_ZM_REG_GROUP_ADDRESS_LATCHED" , 0x91, init_zm_reg_group_addr_latched  },
2994         { "INIT_RESERVED"                     , 0x92, init_reserved                   },
2995         { "INIT_96"                           , 0x96, init_96                         },
2996         { "INIT_97"                           , 0x97, init_97                         },
2997         { "INIT_AUXCH"                        , 0x98, init_auxch                      },
2998         { "INIT_ZM_AUXCH"                     , 0x99, init_zm_auxch                   },
2999         { NULL                                , 0   , NULL                            }
3000 };
3001
3002 #define MAX_TABLE_OPS 1000
3003
3004 static int
3005 parse_init_table(struct nvbios *bios, unsigned int offset,
3006                  struct init_exec *iexec)
3007 {
3008         /*
3009          * Parses all commands in an init table.
3010          *
3011          * We start out executing all commands found in the init table. Some
3012          * opcodes may change the status of iexec->execute to SKIP, which will
3013          * cause the following opcodes to perform no operation until the value
3014          * is changed back to EXECUTE.
3015          */
3016
3017         int count = 0, i, res;
3018         uint8_t id;
3019
3020         /*
3021          * Loop until INIT_DONE causes us to break out of the loop
3022          * (or until offset > bios length just in case... )
3023          * (and no more than MAX_TABLE_OPS iterations, just in case... )
3024          */
3025         while ((offset < bios->length) && (count++ < MAX_TABLE_OPS)) {
3026                 id = bios->data[offset];
3027
3028                 /* Find matching id in itbl_entry */
3029                 for (i = 0; itbl_entry[i].name && (itbl_entry[i].id != id); i++)
3030                         ;
3031
3032                 if (itbl_entry[i].name) {
3033                         BIOSLOG(bios, "0x%04X: [ (0x%02X) - %s ]\n",
3034                                 offset, itbl_entry[i].id, itbl_entry[i].name);
3035
3036                         /* execute eventual command handler */
3037                         res = (*itbl_entry[i].handler)(bios, offset, iexec);
3038                         if (!res)
3039                                 break;
3040                         /*
3041                          * Add the offset of the current command including all data
3042                          * of that command. The offset will then be pointing on the
3043                          * next op code.
3044                          */
3045                         offset += res;
3046                 } else {
3047                         NV_ERROR(bios->dev,
3048                                  "0x%04X: Init table command not found: "
3049                                  "0x%02X\n", offset, id);
3050                         return -ENOENT;
3051                 }
3052         }
3053
3054         if (offset >= bios->length)
3055                 NV_WARN(bios->dev,
3056                         "Offset 0x%04X greater than known bios image length.  "
3057                         "Corrupt image?\n", offset);
3058         if (count >= MAX_TABLE_OPS)
3059                 NV_WARN(bios->dev,
3060                         "More than %d opcodes to a table is unlikely, "
3061                         "is the bios image corrupt?\n", MAX_TABLE_OPS);
3062
3063         return 0;
3064 }
3065
3066 static void
3067 parse_init_tables(struct nvbios *bios)
3068 {
3069         /* Loops and calls parse_init_table() for each present table. */
3070
3071         int i = 0;
3072         uint16_t table;
3073         struct init_exec iexec = {true, false};
3074
3075         if (bios->old_style_init) {
3076                 if (bios->init_script_tbls_ptr)
3077                         parse_init_table(bios, bios->init_script_tbls_ptr, &iexec);
3078                 if (bios->extra_init_script_tbl_ptr)
3079                         parse_init_table(bios, bios->extra_init_script_tbl_ptr, &iexec);
3080
3081                 return;
3082         }
3083
3084         while ((table = ROM16(bios->data[bios->init_script_tbls_ptr + i]))) {
3085                 NV_INFO(bios->dev,
3086                         "Parsing VBIOS init table %d at offset 0x%04X\n",
3087                         i / 2, table);
3088                 BIOSLOG(bios, "0x%04X: ------ Executing following commands ------\n", table);
3089
3090                 parse_init_table(bios, table, &iexec);
3091                 i += 2;
3092         }
3093 }
3094
3095 static uint16_t clkcmptable(struct nvbios *bios, uint16_t clktable, int pxclk)
3096 {
3097         int compare_record_len, i = 0;
3098         uint16_t compareclk, scriptptr = 0;
3099
3100         if (bios->major_version < 5) /* pre BIT */
3101                 compare_record_len = 3;
3102         else
3103                 compare_record_len = 4;
3104
3105         do {
3106                 compareclk = ROM16(bios->data[clktable + compare_record_len * i]);
3107                 if (pxclk >= compareclk * 10) {
3108                         if (bios->major_version < 5) {
3109                                 uint8_t tmdssub = bios->data[clktable + 2 + compare_record_len * i];
3110                                 scriptptr = ROM16(bios->data[bios->init_script_tbls_ptr + tmdssub * 2]);
3111                         } else
3112                                 scriptptr = ROM16(bios->data[clktable + 2 + compare_record_len * i]);
3113                         break;
3114                 }
3115                 i++;
3116         } while (compareclk);
3117
3118         return scriptptr;
3119 }
3120
3121 static void
3122 run_digital_op_script(struct drm_device *dev, uint16_t scriptptr,
3123                       struct dcb_entry *dcbent, int head, bool dl)
3124 {
3125         struct drm_nouveau_private *dev_priv = dev->dev_private;
3126         struct nvbios *bios = &dev_priv->VBIOS;
3127         struct init_exec iexec = {true, false};
3128
3129         NV_TRACE(dev, "0x%04X: Parsing digital output script table\n",
3130                  scriptptr);
3131         bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, NV_CIO_CRE_44,
3132                        head ? NV_CIO_CRE_44_HEADB : NV_CIO_CRE_44_HEADA);
3133         /* note: if dcb entries have been merged, index may be misleading */
3134         NVWriteVgaCrtc5758(dev, head, 0, dcbent->index);
3135         parse_init_table(bios, scriptptr, &iexec);
3136
3137         nv04_dfp_bind_head(dev, dcbent, head, dl);
3138 }
3139
3140 static int call_lvds_manufacturer_script(struct drm_device *dev, struct dcb_entry *dcbent, int head, enum LVDS_script script)
3141 {
3142         struct drm_nouveau_private *dev_priv = dev->dev_private;
3143         struct nvbios *bios = &dev_priv->VBIOS;
3144         uint8_t sub = bios->data[bios->fp.xlated_entry + script] + (bios->fp.link_c_increment && dcbent->or & OUTPUT_C ? 1 : 0);
3145         uint16_t scriptofs = ROM16(bios->data[bios->init_script_tbls_ptr + sub * 2]);
3146
3147         if (!bios->fp.xlated_entry || !sub || !scriptofs)
3148                 return -EINVAL;
3149
3150         run_digital_op_script(dev, scriptofs, dcbent, head, bios->fp.dual_link);
3151
3152         if (script == LVDS_PANEL_OFF) {
3153                 /* off-on delay in ms */
3154                 msleep(ROM16(bios->data[bios->fp.xlated_entry + 7]));
3155         }
3156 #ifdef __powerpc__
3157         /* Powerbook specific quirks */
3158         if ((dev->pci_device & 0xffff) == 0x0179 ||
3159             (dev->pci_device & 0xffff) == 0x0189 ||
3160             (dev->pci_device & 0xffff) == 0x0329) {
3161                 if (script == LVDS_RESET) {
3162                         nv_write_tmds(dev, dcbent->or, 0, 0x02, 0x72);
3163
3164                 } else if (script == LVDS_PANEL_ON) {
3165                         bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL,
3166                                   bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL)
3167                                   | (1 << 31));
3168                         bios_wr32(bios, NV_PCRTC_GPIO_EXT,
3169                                   bios_rd32(bios, NV_PCRTC_GPIO_EXT) | 1);
3170
3171                 } else if (script == LVDS_PANEL_OFF) {
3172             &n