]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/gpu/drm/nouveau/core/subdev/bios/init.c
drm/nouveau/bios: implement opcode 0xa9
[~shefty/rdma-dev.git] / drivers / gpu / drm / nouveau / core / subdev / bios / init.c
1 #include <core/engine.h>
2 #include <core/device.h>
3
4 #include <subdev/bios.h>
5 #include <subdev/bios/bmp.h>
6 #include <subdev/bios/bit.h>
7 #include <subdev/bios/conn.h>
8 #include <subdev/bios/dcb.h>
9 #include <subdev/bios/dp.h>
10 #include <subdev/bios/gpio.h>
11 #include <subdev/bios/init.h>
12 #include <subdev/devinit.h>
13 #include <subdev/clock.h>
14 #include <subdev/i2c.h>
15 #include <subdev/vga.h>
16 #include <subdev/gpio.h>
17
18 #define bioslog(lvl, fmt, args...) do {                                        \
19         nv_printk(init->bios, lvl, "0x%04x[%c]: "fmt, init->offset,            \
20                   init_exec(init) ? '0' + (init->nested - 1) : ' ', ##args);   \
21 } while(0)
22 #define cont(fmt, args...) do {                                                \
23         if (nv_subdev(init->bios)->debug >= NV_DBG_TRACE)                      \
24                 printk(fmt, ##args);                                           \
25 } while(0)
26 #define trace(fmt, args...) bioslog(TRACE, fmt, ##args)
27 #define warn(fmt, args...) bioslog(WARN, fmt, ##args)
28 #define error(fmt, args...) bioslog(ERROR, fmt, ##args)
29
30 /******************************************************************************
31  * init parser control flow helpers
32  *****************************************************************************/
33
34 static inline bool
35 init_exec(struct nvbios_init *init)
36 {
37         return (init->execute == 1) || ((init->execute & 5) == 5);
38 }
39
40 static inline void
41 init_exec_set(struct nvbios_init *init, bool exec)
42 {
43         if (exec) init->execute &= 0xfd;
44         else      init->execute |= 0x02;
45 }
46
47 static inline void
48 init_exec_inv(struct nvbios_init *init)
49 {
50         init->execute ^= 0x02;
51 }
52
53 static inline void
54 init_exec_force(struct nvbios_init *init, bool exec)
55 {
56         if (exec) init->execute |= 0x04;
57         else      init->execute &= 0xfb;
58 }
59
60 /******************************************************************************
61  * init parser wrappers for normal register/i2c/whatever accessors
62  *****************************************************************************/
63
64 static inline int
65 init_or(struct nvbios_init *init)
66 {
67         if (init->outp)
68                 return ffs(init->outp->or) - 1;
69         error("script needs OR!!\n");
70         return 0;
71 }
72
73 static inline int
74 init_link(struct nvbios_init *init)
75 {
76         if (init->outp)
77                 return !(init->outp->sorconf.link & 1);
78         error("script needs OR link\n");
79         return 0;
80 }
81
82 static inline int
83 init_crtc(struct nvbios_init *init)
84 {
85         if (init->crtc >= 0)
86                 return init->crtc;
87         error("script needs crtc\n");
88         return 0;
89 }
90
91 static u8
92 init_conn(struct nvbios_init *init)
93 {
94         struct nouveau_bios *bios = init->bios;
95
96         if (init->outp) {
97                 u8  ver, len;
98                 u16 conn = dcb_conn(bios, init->outp->connector, &ver, &len);
99                 if (conn)
100                         return nv_ro08(bios, conn);
101         }
102
103         error("script needs connector type\n");
104         return 0x00;
105 }
106
107 static inline u32
108 init_nvreg(struct nvbios_init *init, u32 reg)
109 {
110         /* C51 (at least) sometimes has the lower bits set which the VBIOS
111          * interprets to mean that access needs to go through certain IO
112          * ports instead.  The NVIDIA binary driver has been seen to access
113          * these through the NV register address, so lets assume we can
114          * do the same
115          */
116         reg &= ~0x00000003;
117
118         /* GF8+ display scripts need register addresses mangled a bit to
119          * select a specific CRTC/OR
120          */
121         if (nv_device(init->bios)->card_type >= NV_50) {
122                 if (reg & 0x80000000) {
123                         reg += init_crtc(init) * 0x800;
124                         reg &= ~0x80000000;
125                 }
126
127                 if (reg & 0x40000000) {
128                         reg += init_or(init) * 0x800;
129                         reg &= ~0x40000000;
130                         if (reg & 0x20000000) {
131                                 reg += init_link(init) * 0x80;
132                                 reg &= ~0x20000000;
133                         }
134                 }
135         }
136
137         if (reg & ~0x00fffffc)
138                 warn("unknown bits in register 0x%08x\n", reg);
139         return reg;
140 }
141
142 static u32
143 init_rd32(struct nvbios_init *init, u32 reg)
144 {
145         reg = init_nvreg(init, reg);
146         if (init_exec(init))
147                 return nv_rd32(init->subdev, reg);
148         return 0x00000000;
149 }
150
151 static void
152 init_wr32(struct nvbios_init *init, u32 reg, u32 val)
153 {
154         reg = init_nvreg(init, reg);
155         if (init_exec(init))
156                 nv_wr32(init->subdev, reg, val);
157 }
158
159 static u32
160 init_mask(struct nvbios_init *init, u32 reg, u32 mask, u32 val)
161 {
162         reg = init_nvreg(init, reg);
163         if (init_exec(init)) {
164                 u32 tmp = nv_rd32(init->subdev, reg);
165                 nv_wr32(init->subdev, reg, (tmp & ~mask) | val);
166                 return tmp;
167         }
168         return 0x00000000;
169 }
170
171 static u8
172 init_rdport(struct nvbios_init *init, u16 port)
173 {
174         if (init_exec(init))
175                 return nv_rdport(init->subdev, init->crtc, port);
176         return 0x00;
177 }
178
179 static void
180 init_wrport(struct nvbios_init *init, u16 port, u8 value)
181 {
182         if (init_exec(init))
183                 nv_wrport(init->subdev, init->crtc, port, value);
184 }
185
186 static u8
187 init_rdvgai(struct nvbios_init *init, u16 port, u8 index)
188 {
189         struct nouveau_subdev *subdev = init->subdev;
190         if (init_exec(init)) {
191                 int head = init->crtc < 0 ? 0 : init->crtc;
192                 return nv_rdvgai(subdev, head, port, index);
193         }
194         return 0x00;
195 }
196
197 static void
198 init_wrvgai(struct nvbios_init *init, u16 port, u8 index, u8 value)
199 {
200         /* force head 0 for updates to cr44, it only exists on first head */
201         if (nv_device(init->subdev)->card_type < NV_50) {
202                 if (port == 0x03d4 && index == 0x44)
203                         init->crtc = 0;
204         }
205
206         if (init_exec(init)) {
207                 int head = init->crtc < 0 ? 0 : init->crtc;
208                 nv_wrvgai(init->subdev, head, port, index, value);
209         }
210
211         /* select head 1 if cr44 write selected it */
212         if (nv_device(init->subdev)->card_type < NV_50) {
213                 if (port == 0x03d4 && index == 0x44 && value == 3)
214                         init->crtc = 1;
215         }
216 }
217
218 static struct nouveau_i2c_port *
219 init_i2c(struct nvbios_init *init, int index)
220 {
221         struct nouveau_i2c *i2c = nouveau_i2c(init->bios);
222
223         if (index == 0xff) {
224                 index = NV_I2C_DEFAULT(0);
225                 if (init->outp && init->outp->i2c_upper_default)
226                         index = NV_I2C_DEFAULT(1);
227         } else
228         if (index < 0) {
229                 if (!init->outp) {
230                         error("script needs output for i2c\n");
231                         return NULL;
232                 }
233
234                 index = init->outp->i2c_index;
235         }
236
237         return i2c->find(i2c, index);
238 }
239
240 static int
241 init_rdi2cr(struct nvbios_init *init, u8 index, u8 addr, u8 reg)
242 {
243         struct nouveau_i2c_port *port = init_i2c(init, index);
244         if (port && init_exec(init))
245                 return nv_rdi2cr(port, addr, reg);
246         return -ENODEV;
247 }
248
249 static int
250 init_wri2cr(struct nvbios_init *init, u8 index, u8 addr, u8 reg, u8 val)
251 {
252         struct nouveau_i2c_port *port = init_i2c(init, index);
253         if (port && init_exec(init))
254                 return nv_wri2cr(port, addr, reg, val);
255         return -ENODEV;
256 }
257
258 static int
259 init_rdauxr(struct nvbios_init *init, u32 addr)
260 {
261         struct nouveau_i2c_port *port = init_i2c(init, -1);
262         u8 data;
263
264         if (port && init_exec(init)) {
265                 int ret = nv_rdaux(port, addr, &data, 1);
266                 if (ret)
267                         return ret;
268                 return data;
269         }
270
271         return -ENODEV;
272 }
273
274 static int
275 init_wrauxr(struct nvbios_init *init, u32 addr, u8 data)
276 {
277         struct nouveau_i2c_port *port = init_i2c(init, -1);
278         if (port && init_exec(init))
279                 return nv_wraux(port, addr, &data, 1);
280         return -ENODEV;
281 }
282
283 static void
284 init_prog_pll(struct nvbios_init *init, u32 id, u32 freq)
285 {
286         struct nouveau_clock *clk = nouveau_clock(init->bios);
287         if (clk && clk->pll_set && init_exec(init)) {
288                 int ret = clk->pll_set(clk, id, freq);
289                 if (ret)
290                         warn("failed to prog pll 0x%08x to %dkHz\n", id, freq);
291         }
292 }
293
294 /******************************************************************************
295  * parsing of bios structures that are required to execute init tables
296  *****************************************************************************/
297
298 static u16
299 init_table(struct nouveau_bios *bios, u16 *len)
300 {
301         struct bit_entry bit_I;
302
303         if (!bit_entry(bios, 'I', &bit_I)) {
304                 *len = bit_I.length;
305                 return bit_I.offset;
306         }
307
308         if (bmp_version(bios) >= 0x0510) {
309                 *len = 14;
310                 return bios->bmp_offset + 75;
311         }
312
313         return 0x0000;
314 }
315
316 static u16
317 init_table_(struct nvbios_init *init, u16 offset, const char *name)
318 {
319         struct nouveau_bios *bios = init->bios;
320         u16 len, data = init_table(bios, &len);
321         if (data) {
322                 if (len >= offset + 2) {
323                         data = nv_ro16(bios, data + offset);
324                         if (data)
325                                 return data;
326
327                         warn("%s pointer invalid\n", name);
328                         return 0x0000;
329                 }
330
331                 warn("init data too short for %s pointer", name);
332                 return 0x0000;
333         }
334
335         warn("init data not found\n");
336         return 0x0000;
337 }
338
339 #define init_script_table(b) init_table_((b), 0x00, "script table")
340 #define init_macro_index_table(b) init_table_((b), 0x02, "macro index table")
341 #define init_macro_table(b) init_table_((b), 0x04, "macro table")
342 #define init_condition_table(b) init_table_((b), 0x06, "condition table")
343 #define init_io_condition_table(b) init_table_((b), 0x08, "io condition table")
344 #define init_io_flag_condition_table(b) init_table_((b), 0x0a, "io flag conditon table")
345 #define init_function_table(b) init_table_((b), 0x0c, "function table")
346 #define init_xlat_table(b) init_table_((b), 0x10, "xlat table");
347
348 static u16
349 init_script(struct nouveau_bios *bios, int index)
350 {
351         struct nvbios_init init = { .bios = bios };
352         u16 data;
353
354         if (bmp_version(bios) && bmp_version(bios) < 0x0510) {
355                 if (index > 1)
356                         return 0x0000;
357
358                 data = bios->bmp_offset + (bios->version.major < 2 ? 14 : 18);
359                 return nv_ro16(bios, data + (index * 2));
360         }
361
362         data = init_script_table(&init);
363         if (data)
364                 return nv_ro16(bios, data + (index * 2));
365
366         return 0x0000;
367 }
368
369 static u16
370 init_unknown_script(struct nouveau_bios *bios)
371 {
372         u16 len, data = init_table(bios, &len);
373         if (data && len >= 16)
374                 return nv_ro16(bios, data + 14);
375         return 0x0000;
376 }
377
378 static u16
379 init_ram_restrict_table(struct nvbios_init *init)
380 {
381         struct nouveau_bios *bios = init->bios;
382         struct bit_entry bit_M;
383         u16 data = 0x0000;
384
385         if (!bit_entry(bios, 'M', &bit_M)) {
386                 if (bit_M.version == 1 && bit_M.length >= 5)
387                         data = nv_ro16(bios, bit_M.offset + 3);
388                 if (bit_M.version == 2 && bit_M.length >= 3)
389                         data = nv_ro16(bios, bit_M.offset + 1);
390         }
391
392         if (data == 0x0000)
393                 warn("ram restrict table not found\n");
394         return data;
395 }
396
397 static u8
398 init_ram_restrict_group_count(struct nvbios_init *init)
399 {
400         struct nouveau_bios *bios = init->bios;
401         struct bit_entry bit_M;
402
403         if (!bit_entry(bios, 'M', &bit_M)) {
404                 if (bit_M.version == 1 && bit_M.length >= 5)
405                         return nv_ro08(bios, bit_M.offset + 2);
406                 if (bit_M.version == 2 && bit_M.length >= 3)
407                         return nv_ro08(bios, bit_M.offset + 0);
408         }
409
410         return 0x00;
411 }
412
413 static u8
414 init_ram_restrict(struct nvbios_init *init)
415 {
416         u32 strap = (init_rd32(init, 0x101000) & 0x0000003c) >> 2;
417         u16 table = init_ram_restrict_table(init);
418         if (table)
419                 return nv_ro08(init->bios, table + strap);
420         return 0x00;
421 }
422
423 static u8
424 init_xlat_(struct nvbios_init *init, u8 index, u8 offset)
425 {
426         struct nouveau_bios *bios = init->bios;
427         u16 table = init_xlat_table(init);
428         if (table) {
429                 u16 data = nv_ro16(bios, table + (index * 2));
430                 if (data)
431                         return nv_ro08(bios, data + offset);
432                 warn("xlat table pointer %d invalid\n", index);
433         }
434         return 0x00;
435 }
436
437 /******************************************************************************
438  * utility functions used by various init opcode handlers
439  *****************************************************************************/
440
441 static bool
442 init_condition_met(struct nvbios_init *init, u8 cond)
443 {
444         struct nouveau_bios *bios = init->bios;
445         u16 table = init_condition_table(init);
446         if (table) {
447                 u32 reg = nv_ro32(bios, table + (cond * 12) + 0);
448                 u32 msk = nv_ro32(bios, table + (cond * 12) + 4);
449                 u32 val = nv_ro32(bios, table + (cond * 12) + 8);
450                 trace("\t[0x%02x] (R[0x%06x] & 0x%08x) == 0x%08x\n",
451                       cond, reg, msk, val);
452                 return (init_rd32(init, reg) & msk) == val;
453         }
454         return false;
455 }
456
457 static bool
458 init_io_condition_met(struct nvbios_init *init, u8 cond)
459 {
460         struct nouveau_bios *bios = init->bios;
461         u16 table = init_io_condition_table(init);
462         if (table) {
463                 u16 port = nv_ro16(bios, table + (cond * 5) + 0);
464                 u8 index = nv_ro08(bios, table + (cond * 5) + 2);
465                 u8  mask = nv_ro08(bios, table + (cond * 5) + 3);
466                 u8 value = nv_ro08(bios, table + (cond * 5) + 4);
467                 trace("\t[0x%02x] (0x%04x[0x%02x] & 0x%02x) == 0x%02x\n",
468                       cond, port, index, mask, value);
469                 return (init_rdvgai(init, port, index) & mask) == value;
470         }
471         return false;
472 }
473
474 static bool
475 init_io_flag_condition_met(struct nvbios_init *init, u8 cond)
476 {
477         struct nouveau_bios *bios = init->bios;
478         u16 table = init_io_flag_condition_table(init);
479         if (table) {
480                 u16 port = nv_ro16(bios, table + (cond * 9) + 0);
481                 u8 index = nv_ro08(bios, table + (cond * 9) + 2);
482                 u8  mask = nv_ro08(bios, table + (cond * 9) + 3);
483                 u8 shift = nv_ro08(bios, table + (cond * 9) + 4);
484                 u16 data = nv_ro16(bios, table + (cond * 9) + 5);
485                 u8 dmask = nv_ro08(bios, table + (cond * 9) + 7);
486                 u8 value = nv_ro08(bios, table + (cond * 9) + 8);
487                 u8 ioval = (init_rdvgai(init, port, index) & mask) >> shift;
488                 return (nv_ro08(bios, data + ioval) & dmask) == value;
489         }
490         return false;
491 }
492
493 static inline u32
494 init_shift(u32 data, u8 shift)
495 {
496         if (shift < 0x80)
497                 return data >> shift;
498         return data << (0x100 - shift);
499 }
500
501 static u32
502 init_tmds_reg(struct nvbios_init *init, u8 tmds)
503 {
504         /* For mlv < 0x80, it is an index into a table of TMDS base addresses.
505          * For mlv == 0x80 use the "or" value of the dcb_entry indexed by
506          * CR58 for CR57 = 0 to index a table of offsets to the basic
507          * 0x6808b0 address.
508          * For mlv == 0x81 use the "or" value of the dcb_entry indexed by
509          * CR58 for CR57 = 0 to index a table of offsets to the basic
510          * 0x6808b0 address, and then flip the offset by 8.
511          */
512
513         const int pramdac_offset[13] = {
514                 0, 0, 0x8, 0, 0x2000, 0, 0, 0, 0x2008, 0, 0, 0, 0x2000 };
515         const u32 pramdac_table[4] = {
516                 0x6808b0, 0x6808b8, 0x6828b0, 0x6828b8 };
517
518         if (tmds >= 0x80) {
519                 if (init->outp) {
520                         u32 dacoffset = pramdac_offset[init->outp->or];
521                         if (tmds == 0x81)
522                                 dacoffset ^= 8;
523                         return 0x6808b0 + dacoffset;
524                 }
525
526                 error("tmds opcodes need dcb\n");
527         } else {
528                 if (tmds < ARRAY_SIZE(pramdac_table))
529                         return pramdac_table[tmds];
530
531                 error("tmds selector 0x%02x unknown\n", tmds);
532         }
533
534         return 0;
535 }
536
537 /******************************************************************************
538  * init opcode handlers
539  *****************************************************************************/
540
541 /**
542  * init_reserved - stub for various unknown/unused single-byte opcodes
543  *
544  */
545 static void
546 init_reserved(struct nvbios_init *init)
547 {
548         u8 opcode = nv_ro08(init->bios, init->offset);
549         trace("RESERVED\t0x%02x\n", opcode);
550         init->offset += 1;
551 }
552
553 /**
554  * INIT_DONE - opcode 0x71
555  *
556  */
557 static void
558 init_done(struct nvbios_init *init)
559 {
560         trace("DONE\n");
561         init->offset = 0x0000;
562 }
563
564 /**
565  * INIT_IO_RESTRICT_PROG - opcode 0x32
566  *
567  */
568 static void
569 init_io_restrict_prog(struct nvbios_init *init)
570 {
571         struct nouveau_bios *bios = init->bios;
572         u16 port = nv_ro16(bios, init->offset + 1);
573         u8 index = nv_ro08(bios, init->offset + 3);
574         u8  mask = nv_ro08(bios, init->offset + 4);
575         u8 shift = nv_ro08(bios, init->offset + 5);
576         u8 count = nv_ro08(bios, init->offset + 6);
577         u32  reg = nv_ro32(bios, init->offset + 7);
578         u8 conf, i;
579
580         trace("IO_RESTRICT_PROG\tR[0x%06x] = "
581               "((0x%04x[0x%02x] & 0x%02x) >> %d) [{\n",
582               reg, port, index, mask, shift);
583         init->offset += 11;
584
585         conf = (init_rdvgai(init, port, index) & mask) >> shift;
586         for (i = 0; i < count; i++) {
587                 u32 data = nv_ro32(bios, init->offset);
588
589                 if (i == conf) {
590                         trace("\t0x%08x *\n", data);
591                         init_wr32(init, reg, data);
592                 } else {
593                         trace("\t0x%08x\n", data);
594                 }
595
596                 init->offset += 4;
597         }
598         trace("}]\n");
599 }
600
601 /**
602  * INIT_REPEAT - opcode 0x33
603  *
604  */
605 static void
606 init_repeat(struct nvbios_init *init)
607 {
608         struct nouveau_bios *bios = init->bios;
609         u8 count = nv_ro08(bios, init->offset + 1);
610         u16 repeat = init->repeat;
611
612         trace("REPEAT\t0x%02x\n", count);
613         init->offset += 2;
614
615         init->repeat = init->offset;
616         init->repend = init->offset;
617         while (count--) {
618                 init->offset = init->repeat;
619                 nvbios_exec(init);
620                 if (count)
621                         trace("REPEAT\t0x%02x\n", count);
622         }
623         init->offset = init->repend;
624         init->repeat = repeat;
625 }
626
627 /**
628  * INIT_IO_RESTRICT_PLL - opcode 0x34
629  *
630  */
631 static void
632 init_io_restrict_pll(struct nvbios_init *init)
633 {
634         struct nouveau_bios *bios = init->bios;
635         u16 port = nv_ro16(bios, init->offset + 1);
636         u8 index = nv_ro08(bios, init->offset + 3);
637         u8  mask = nv_ro08(bios, init->offset + 4);
638         u8 shift = nv_ro08(bios, init->offset + 5);
639         s8  iofc = nv_ro08(bios, init->offset + 6);
640         u8 count = nv_ro08(bios, init->offset + 7);
641         u32  reg = nv_ro32(bios, init->offset + 8);
642         u8 conf, i;
643
644         trace("IO_RESTRICT_PLL\tR[0x%06x] =PLL= "
645               "((0x%04x[0x%02x] & 0x%02x) >> 0x%02x) IOFCOND 0x%02x [{\n",
646               reg, port, index, mask, shift, iofc);
647         init->offset += 12;
648
649         conf = (init_rdvgai(init, port, index) & mask) >> shift;
650         for (i = 0; i < count; i++) {
651                 u32 freq = nv_ro16(bios, init->offset) * 10;
652
653                 if (i == conf) {
654                         trace("\t%dkHz *\n", freq);
655                         if (iofc > 0 && init_io_flag_condition_met(init, iofc))
656                                 freq *= 2;
657                         init_prog_pll(init, reg, freq);
658                 } else {
659                         trace("\t%dkHz\n", freq);
660                 }
661
662                 init->offset += 2;
663         }
664         trace("}]\n");
665 }
666
667 /**
668  * INIT_END_REPEAT - opcode 0x36
669  *
670  */
671 static void
672 init_end_repeat(struct nvbios_init *init)
673 {
674         trace("END_REPEAT\n");
675         init->offset += 1;
676
677         if (init->repeat) {
678                 init->repend = init->offset;
679                 init->offset = 0;
680         }
681 }
682
683 /**
684  * INIT_COPY - opcode 0x37
685  *
686  */
687 static void
688 init_copy(struct nvbios_init *init)
689 {
690         struct nouveau_bios *bios = init->bios;
691         u32  reg = nv_ro32(bios, init->offset + 1);
692         u8 shift = nv_ro08(bios, init->offset + 5);
693         u8 smask = nv_ro08(bios, init->offset + 6);
694         u16 port = nv_ro16(bios, init->offset + 7);
695         u8 index = nv_ro08(bios, init->offset + 9);
696         u8  mask = nv_ro08(bios, init->offset + 10);
697         u8  data;
698
699         trace("COPY\t0x%04x[0x%02x] &= 0x%02x |= "
700               "((R[0x%06x] %s 0x%02x) & 0x%02x)\n",
701               port, index, mask, reg, (shift & 0x80) ? "<<" : ">>",
702               (shift & 0x80) ? (0x100 - shift) : shift, smask);
703         init->offset += 11;
704
705         data  = init_rdvgai(init, port, index) & mask;
706         data |= init_shift(init_rd32(init, reg), shift) & smask;
707         init_wrvgai(init, port, index, data);
708 }
709
710 /**
711  * INIT_NOT - opcode 0x38
712  *
713  */
714 static void
715 init_not(struct nvbios_init *init)
716 {
717         trace("NOT\n");
718         init->offset += 1;
719         init_exec_inv(init);
720 }
721
722 /**
723  * INIT_IO_FLAG_CONDITION - opcode 0x39
724  *
725  */
726 static void
727 init_io_flag_condition(struct nvbios_init *init)
728 {
729         struct nouveau_bios *bios = init->bios;
730         u8 cond = nv_ro08(bios, init->offset + 1);
731
732         trace("IO_FLAG_CONDITION\t0x%02x\n", cond);
733         init->offset += 2;
734
735         if (!init_io_flag_condition_met(init, cond))
736                 init_exec_set(init, false);
737 }
738
739 /**
740  * INIT_DP_CONDITION - opcode 0x3a
741  *
742  */
743 static void
744 init_dp_condition(struct nvbios_init *init)
745 {
746         struct nouveau_bios *bios = init->bios;
747         struct nvbios_dpout info;
748         u8  cond = nv_ro08(bios, init->offset + 1);
749         u8  unkn = nv_ro08(bios, init->offset + 2);
750         u8  ver, hdr, cnt, len;
751         u16 data;
752
753         trace("DP_CONDITION\t0x%02x 0x%02x\n", cond, unkn);
754         init->offset += 3;
755
756         switch (cond) {
757         case 0:
758                 if (init_conn(init) != DCB_CONNECTOR_eDP)
759                         init_exec_set(init, false);
760                 break;
761         case 1:
762         case 2:
763                 if ( init->outp &&
764                     (data = nvbios_dpout_match(bios, DCB_OUTPUT_DP,
765                                                (init->outp->or << 0) |
766                                                (init->outp->sorconf.link << 6),
767                                                &ver, &hdr, &cnt, &len, &info)))
768                 {
769                         if (!(info.flags & cond))
770                                 init_exec_set(init, false);
771                         break;
772                 }
773
774                 warn("script needs dp output table data\n");
775                 break;
776         case 5:
777                 if (!(init_rdauxr(init, 0x0d) & 1))
778                         init_exec_set(init, false);
779                 break;
780         default:
781                 warn("unknown dp condition 0x%02x\n", cond);
782                 break;
783         }
784 }
785
786 /**
787  * INIT_IO_MASK_OR - opcode 0x3b
788  *
789  */
790 static void
791 init_io_mask_or(struct nvbios_init *init)
792 {
793         struct nouveau_bios *bios = init->bios;
794         u8 index = nv_ro08(bios, init->offset + 1);
795         u8    or = init_or(init);
796         u8  data;
797
798         trace("IO_MASK_OR\t0x03d4[0x%02x] &= ~(1 << 0x%02x)", index, or);
799         init->offset += 2;
800
801         data = init_rdvgai(init, 0x03d4, index);
802         init_wrvgai(init, 0x03d4, index, data &= ~(1 << or));
803 }
804
805 /**
806  * INIT_IO_OR - opcode 0x3c
807  *
808  */
809 static void
810 init_io_or(struct nvbios_init *init)
811 {
812         struct nouveau_bios *bios = init->bios;
813         u8 index = nv_ro08(bios, init->offset + 1);
814         u8    or = init_or(init);
815         u8  data;
816
817         trace("IO_OR\t0x03d4[0x%02x] |= (1 << 0x%02x)", index, or);
818         init->offset += 2;
819
820         data = init_rdvgai(init, 0x03d4, index);
821         init_wrvgai(init, 0x03d4, index, data | (1 << or));
822 }
823
824 /**
825  * INIT_INDEX_ADDRESS_LATCHED - opcode 0x49
826  *
827  */
828 static void
829 init_idx_addr_latched(struct nvbios_init *init)
830 {
831         struct nouveau_bios *bios = init->bios;
832         u32 creg = nv_ro32(bios, init->offset + 1);
833         u32 dreg = nv_ro32(bios, init->offset + 5);
834         u32 mask = nv_ro32(bios, init->offset + 9);
835         u32 data = nv_ro32(bios, init->offset + 13);
836         u8 count = nv_ro08(bios, init->offset + 17);
837
838         trace("INDEX_ADDRESS_LATCHED\t"
839               "R[0x%06x] : R[0x%06x]\n\tCTRL &= 0x%08x |= 0x%08x\n",
840               creg, dreg, mask, data);
841         init->offset += 18;
842
843         while (count--) {
844                 u8 iaddr = nv_ro08(bios, init->offset + 0);
845                 u8 idata = nv_ro08(bios, init->offset + 1);
846
847                 trace("\t[0x%02x] = 0x%02x\n", iaddr, idata);
848                 init->offset += 2;
849
850                 init_wr32(init, dreg, idata);
851                 init_mask(init, creg, ~mask, data | idata);
852         }
853 }
854
855 /**
856  * INIT_IO_RESTRICT_PLL2 - opcode 0x4a
857  *
858  */
859 static void
860 init_io_restrict_pll2(struct nvbios_init *init)
861 {
862         struct nouveau_bios *bios = init->bios;
863         u16 port = nv_ro16(bios, init->offset + 1);
864         u8 index = nv_ro08(bios, init->offset + 3);
865         u8  mask = nv_ro08(bios, init->offset + 4);
866         u8 shift = nv_ro08(bios, init->offset + 5);
867         u8 count = nv_ro08(bios, init->offset + 6);
868         u32  reg = nv_ro32(bios, init->offset + 7);
869         u8  conf, i;
870
871         trace("IO_RESTRICT_PLL2\t"
872               "R[0x%06x] =PLL= ((0x%04x[0x%02x] & 0x%02x) >> 0x%02x) [{\n",
873               reg, port, index, mask, shift);
874         init->offset += 11;
875
876         conf = (init_rdvgai(init, port, index) & mask) >> shift;
877         for (i = 0; i < count; i++) {
878                 u32 freq = nv_ro32(bios, init->offset);
879                 if (i == conf) {
880                         trace("\t%dkHz *\n", freq);
881                         init_prog_pll(init, reg, freq);
882                 } else {
883                         trace("\t%dkHz\n", freq);
884                 }
885                 init->offset += 4;
886         }
887         trace("}]\n");
888 }
889
890 /**
891  * INIT_PLL2 - opcode 0x4b
892  *
893  */
894 static void
895 init_pll2(struct nvbios_init *init)
896 {
897         struct nouveau_bios *bios = init->bios;
898         u32  reg = nv_ro32(bios, init->offset + 1);
899         u32 freq = nv_ro32(bios, init->offset + 5);
900
901         trace("PLL2\tR[0x%06x] =PLL= %dkHz\n", reg, freq);
902         init->offset += 9;
903
904         init_prog_pll(init, reg, freq);
905 }
906
907 /**
908  * INIT_I2C_BYTE - opcode 0x4c
909  *
910  */
911 static void
912 init_i2c_byte(struct nvbios_init *init)
913 {
914         struct nouveau_bios *bios = init->bios;
915         u8 index = nv_ro08(bios, init->offset + 1);
916         u8  addr = nv_ro08(bios, init->offset + 2) >> 1;
917         u8 count = nv_ro08(bios, init->offset + 3);
918
919         trace("I2C_BYTE\tI2C[0x%02x][0x%02x]\n", index, addr);
920         init->offset += 4;
921
922         while (count--) {
923                 u8  reg = nv_ro08(bios, init->offset + 0);
924                 u8 mask = nv_ro08(bios, init->offset + 1);
925                 u8 data = nv_ro08(bios, init->offset + 2);
926                 int val;
927
928                 trace("\t[0x%02x] &= 0x%02x |= 0x%02x\n", reg, mask, data);
929                 init->offset += 3;
930
931                 val = init_rdi2cr(init, index, addr, reg);
932                 if (val < 0)
933                         continue;
934                 init_wri2cr(init, index, addr, reg, (val & mask) | data);
935         }
936 }
937
938 /**
939  * INIT_ZM_I2C_BYTE - opcode 0x4d
940  *
941  */
942 static void
943 init_zm_i2c_byte(struct nvbios_init *init)
944 {
945         struct nouveau_bios *bios = init->bios;
946         u8 index = nv_ro08(bios, init->offset + 1);
947         u8  addr = nv_ro08(bios, init->offset + 2) >> 1;
948         u8 count = nv_ro08(bios, init->offset + 3);
949
950         trace("ZM_I2C_BYTE\tI2C[0x%02x][0x%02x]\n", index, addr);
951         init->offset += 4;
952
953         while (count--) {
954                 u8  reg = nv_ro08(bios, init->offset + 0);
955                 u8 data = nv_ro08(bios, init->offset + 1);
956
957                 trace("\t[0x%02x] = 0x%02x\n", reg, data);
958                 init->offset += 2;
959
960                 init_wri2cr(init, index, addr, reg, data);
961         }
962
963 }
964
965 /**
966  * INIT_ZM_I2C - opcode 0x4e
967  *
968  */
969 static void
970 init_zm_i2c(struct nvbios_init *init)
971 {
972         struct nouveau_bios *bios = init->bios;
973         u8 index = nv_ro08(bios, init->offset + 1);
974         u8  addr = nv_ro08(bios, init->offset + 2) >> 1;
975         u8 count = nv_ro08(bios, init->offset + 3);
976         u8 data[256], i;
977
978         trace("ZM_I2C\tI2C[0x%02x][0x%02x]\n", index, addr);
979         init->offset += 4;
980
981         for (i = 0; i < count; i++) {
982                 data[i] = nv_ro08(bios, init->offset);
983                 trace("\t0x%02x\n", data[i]);
984                 init->offset++;
985         }
986
987         if (init_exec(init)) {
988                 struct nouveau_i2c_port *port = init_i2c(init, index);
989                 struct i2c_msg msg = {
990                         .addr = addr, .flags = 0, .len = count, .buf = data,
991                 };
992                 int ret;
993
994                 if (port && (ret = i2c_transfer(&port->adapter, &msg, 1)) != 1)
995                         warn("i2c wr failed, %d\n", ret);
996         }
997 }
998
999 /**
1000  * INIT_TMDS - opcode 0x4f
1001  *
1002  */
1003 static void
1004 init_tmds(struct nvbios_init *init)
1005 {
1006         struct nouveau_bios *bios = init->bios;
1007         u8 tmds = nv_ro08(bios, init->offset + 1);
1008         u8 addr = nv_ro08(bios, init->offset + 2);
1009         u8 mask = nv_ro08(bios, init->offset + 3);
1010         u8 data = nv_ro08(bios, init->offset + 4);
1011         u32 reg = init_tmds_reg(init, tmds);
1012
1013         trace("TMDS\tT[0x%02x][0x%02x] &= 0x%02x |= 0x%02x\n",
1014               tmds, addr, mask, data);
1015         init->offset += 5;
1016
1017         if (reg == 0)
1018                 return;
1019
1020         init_wr32(init, reg + 0, addr | 0x00010000);
1021         init_wr32(init, reg + 4, data | (init_rd32(init, reg + 4) & mask));
1022         init_wr32(init, reg + 0, addr);
1023 }
1024
1025 /**
1026  * INIT_ZM_TMDS_GROUP - opcode 0x50
1027  *
1028  */
1029 static void
1030 init_zm_tmds_group(struct nvbios_init *init)
1031 {
1032         struct nouveau_bios *bios = init->bios;
1033         u8  tmds = nv_ro08(bios, init->offset + 1);
1034         u8 count = nv_ro08(bios, init->offset + 2);
1035         u32  reg = init_tmds_reg(init, tmds);
1036
1037         trace("TMDS_ZM_GROUP\tT[0x%02x]\n", tmds);
1038         init->offset += 3;
1039
1040         while (count--) {
1041                 u8 addr = nv_ro08(bios, init->offset + 0);
1042                 u8 data = nv_ro08(bios, init->offset + 1);
1043
1044                 trace("\t[0x%02x] = 0x%02x\n", addr, data);
1045                 init->offset += 2;
1046
1047                 init_wr32(init, reg + 4, data);
1048                 init_wr32(init, reg + 0, addr);
1049         }
1050 }
1051
1052 /**
1053  * INIT_CR_INDEX_ADDRESS_LATCHED - opcode 0x51
1054  *
1055  */
1056 static void
1057 init_cr_idx_adr_latch(struct nvbios_init *init)
1058 {
1059         struct nouveau_bios *bios = init->bios;
1060         u8 addr0 = nv_ro08(bios, init->offset + 1);
1061         u8 addr1 = nv_ro08(bios, init->offset + 2);
1062         u8  base = nv_ro08(bios, init->offset + 3);
1063         u8 count = nv_ro08(bios, init->offset + 4);
1064         u8 save0;
1065
1066         trace("CR_INDEX_ADDR C[%02x] C[%02x]\n", addr0, addr1);
1067         init->offset += 5;
1068
1069         save0 = init_rdvgai(init, 0x03d4, addr0);
1070         while (count--) {
1071                 u8 data = nv_ro08(bios, init->offset);
1072
1073                 trace("\t\t[0x%02x] = 0x%02x\n", base, data);
1074                 init->offset += 1;
1075
1076                 init_wrvgai(init, 0x03d4, addr0, base++);
1077                 init_wrvgai(init, 0x03d4, addr1, data);
1078         }
1079         init_wrvgai(init, 0x03d4, addr0, save0);
1080 }
1081
1082 /**
1083  * INIT_CR - opcode 0x52
1084  *
1085  */
1086 static void
1087 init_cr(struct nvbios_init *init)
1088 {
1089         struct nouveau_bios *bios = init->bios;
1090         u8 addr = nv_ro08(bios, init->offset + 1);
1091         u8 mask = nv_ro08(bios, init->offset + 2);
1092         u8 data = nv_ro08(bios, init->offset + 3);
1093         u8 val;
1094
1095         trace("CR\t\tC[0x%02x] &= 0x%02x |= 0x%02x\n", addr, mask, data);
1096         init->offset += 4;
1097
1098         val = init_rdvgai(init, 0x03d4, addr) & mask;
1099         init_wrvgai(init, 0x03d4, addr, val | data);
1100 }
1101
1102 /**
1103  * INIT_ZM_CR - opcode 0x53
1104  *
1105  */
1106 static void
1107 init_zm_cr(struct nvbios_init *init)
1108 {
1109         struct nouveau_bios *bios = init->bios;
1110         u8 addr = nv_ro08(bios, init->offset + 1);
1111         u8 data = nv_ro08(bios, init->offset + 2);
1112
1113         trace("ZM_CR\tC[0x%02x] = 0x%02x\n", addr,  data);
1114         init->offset += 3;
1115
1116         init_wrvgai(init, 0x03d4, addr, data);
1117 }
1118
1119 /**
1120  * INIT_ZM_CR_GROUP - opcode 0x54
1121  *
1122  */
1123 static void
1124 init_zm_cr_group(struct nvbios_init *init)
1125 {
1126         struct nouveau_bios *bios = init->bios;
1127         u8 count = nv_ro08(bios, init->offset + 1);
1128
1129         trace("ZM_CR_GROUP\n");
1130         init->offset += 2;
1131
1132         while (count--) {
1133                 u8 addr = nv_ro08(bios, init->offset + 0);
1134                 u8 data = nv_ro08(bios, init->offset + 1);
1135
1136                 trace("\t\tC[0x%02x] = 0x%02x\n", addr, data);
1137                 init->offset += 2;
1138
1139                 init_wrvgai(init, 0x03d4, addr, data);
1140         }
1141 }
1142
1143 /**
1144  * INIT_CONDITION_TIME - opcode 0x56
1145  *
1146  */
1147 static void
1148 init_condition_time(struct nvbios_init *init)
1149 {
1150         struct nouveau_bios *bios = init->bios;
1151         u8  cond = nv_ro08(bios, init->offset + 1);
1152         u8 retry = nv_ro08(bios, init->offset + 2);
1153         u8  wait = min((u16)retry * 50, 100);
1154
1155         trace("CONDITION_TIME\t0x%02x 0x%02x\n", cond, retry);
1156         init->offset += 3;
1157
1158         if (!init_exec(init))
1159                 return;
1160
1161         while (wait--) {
1162                 if (init_condition_met(init, cond))
1163                         return;
1164                 mdelay(20);
1165         }
1166
1167         init_exec_set(init, false);
1168 }
1169
1170 /**
1171  * INIT_LTIME - opcode 0x57
1172  *
1173  */
1174 static void
1175 init_ltime(struct nvbios_init *init)
1176 {
1177         struct nouveau_bios *bios = init->bios;
1178         u16 msec = nv_ro16(bios, init->offset + 1);
1179
1180         trace("LTIME\t0x%04x\n", msec);
1181         init->offset += 3;
1182
1183         if (init_exec(init))
1184                 mdelay(msec);
1185 }
1186
1187 /**
1188  * INIT_ZM_REG_SEQUENCE - opcode 0x58
1189  *
1190  */
1191 static void
1192 init_zm_reg_sequence(struct nvbios_init *init)
1193 {
1194         struct nouveau_bios *bios = init->bios;
1195         u32 base = nv_ro32(bios, init->offset + 1);
1196         u8 count = nv_ro08(bios, init->offset + 5);
1197
1198         trace("ZM_REG_SEQUENCE\t0x%02x\n", count);
1199         init->offset += 6;
1200
1201         while (count--) {
1202                 u32 data = nv_ro32(bios, init->offset);
1203
1204                 trace("\t\tR[0x%06x] = 0x%08x\n", base, data);
1205                 init->offset += 4;
1206
1207                 init_wr32(init, base, data);
1208                 base += 4;
1209         }
1210 }
1211
1212 /**
1213  * INIT_SUB_DIRECT - opcode 0x5b
1214  *
1215  */
1216 static void
1217 init_sub_direct(struct nvbios_init *init)
1218 {
1219         struct nouveau_bios *bios = init->bios;
1220         u16 addr = nv_ro16(bios, init->offset + 1);
1221         u16 save;
1222
1223         trace("SUB_DIRECT\t0x%04x\n", addr);
1224
1225         if (init_exec(init)) {
1226                 save = init->offset;
1227                 init->offset = addr;
1228                 if (nvbios_exec(init)) {
1229                         error("error parsing sub-table\n");
1230                         return;
1231                 }
1232                 init->offset = save;
1233         }
1234
1235         init->offset += 3;
1236 }
1237
1238 /**
1239  * INIT_JUMP - opcode 0x5c
1240  *
1241  */
1242 static void
1243 init_jump(struct nvbios_init *init)
1244 {
1245         struct nouveau_bios *bios = init->bios;
1246         u16 offset = nv_ro16(bios, init->offset + 1);
1247
1248         trace("JUMP\t0x%04x\n", offset);
1249         init->offset = offset;
1250 }
1251
1252 /**
1253  * INIT_I2C_IF - opcode 0x5e
1254  *
1255  */
1256 static void
1257 init_i2c_if(struct nvbios_init *init)
1258 {
1259         struct nouveau_bios *bios = init->bios;
1260         u8 index = nv_ro08(bios, init->offset + 1);
1261         u8  addr = nv_ro08(bios, init->offset + 2);
1262         u8   reg = nv_ro08(bios, init->offset + 3);
1263         u8  mask = nv_ro08(bios, init->offset + 4);
1264         u8  data = nv_ro08(bios, init->offset + 5);
1265         u8 value;
1266
1267         trace("I2C_IF\tI2C[0x%02x][0x%02x][0x%02x] & 0x%02x == 0x%02x\n",
1268               index, addr, reg, mask, data);
1269         init->offset += 6;
1270         init_exec_force(init, true);
1271
1272         value = init_rdi2cr(init, index, addr, reg);
1273         if ((value & mask) != data)
1274                 init_exec_set(init, false);
1275
1276         init_exec_force(init, false);
1277 }
1278
1279 /**
1280  * INIT_COPY_NV_REG - opcode 0x5f
1281  *
1282  */
1283 static void
1284 init_copy_nv_reg(struct nvbios_init *init)
1285 {
1286         struct nouveau_bios *bios = init->bios;
1287         u32  sreg = nv_ro32(bios, init->offset + 1);
1288         u8  shift = nv_ro08(bios, init->offset + 5);
1289         u32 smask = nv_ro32(bios, init->offset + 6);
1290         u32  sxor = nv_ro32(bios, init->offset + 10);
1291         u32  dreg = nv_ro32(bios, init->offset + 14);
1292         u32 dmask = nv_ro32(bios, init->offset + 18);
1293         u32 data;
1294
1295         trace("COPY_NV_REG\tR[0x%06x] &= 0x%08x |= "
1296               "((R[0x%06x] %s 0x%02x) & 0x%08x ^ 0x%08x)\n",
1297               dreg, dmask, sreg, (shift & 0x80) ? "<<" : ">>",
1298               (shift & 0x80) ? (0x100 - shift) : shift, smask, sxor);
1299         init->offset += 22;
1300
1301         data = init_shift(init_rd32(init, sreg), shift);
1302         init_mask(init, dreg, ~dmask, (data & smask) ^ sxor);
1303 }
1304
1305 /**
1306  * INIT_ZM_INDEX_IO - opcode 0x62
1307  *
1308  */
1309 static void
1310 init_zm_index_io(struct nvbios_init *init)
1311 {
1312         struct nouveau_bios *bios = init->bios;
1313         u16 port = nv_ro16(bios, init->offset + 1);
1314         u8 index = nv_ro08(bios, init->offset + 3);
1315         u8  data = nv_ro08(bios, init->offset + 4);
1316
1317         trace("ZM_INDEX_IO\tI[0x%04x][0x%02x] = 0x%02x\n", port, index, data);
1318         init->offset += 5;
1319
1320         init_wrvgai(init, port, index, data);
1321 }
1322
1323 /**
1324  * INIT_COMPUTE_MEM - opcode 0x63
1325  *
1326  */
1327 static void
1328 init_compute_mem(struct nvbios_init *init)
1329 {
1330         struct nouveau_devinit *devinit = nouveau_devinit(init->bios);
1331
1332         trace("COMPUTE_MEM\n");
1333         init->offset += 1;
1334
1335         init_exec_force(init, true);
1336         if (init_exec(init) && devinit->meminit)
1337                 devinit->meminit(devinit);
1338         init_exec_force(init, false);
1339 }
1340
1341 /**
1342  * INIT_RESET - opcode 0x65
1343  *
1344  */
1345 static void
1346 init_reset(struct nvbios_init *init)
1347 {
1348         struct nouveau_bios *bios = init->bios;
1349         u32   reg = nv_ro32(bios, init->offset + 1);
1350         u32 data1 = nv_ro32(bios, init->offset + 5);
1351         u32 data2 = nv_ro32(bios, init->offset + 9);
1352         u32 savepci19;
1353
1354         trace("RESET\tR[0x%08x] = 0x%08x, 0x%08x", reg, data1, data2);
1355         init->offset += 13;
1356         init_exec_force(init, true);
1357
1358         savepci19 = init_mask(init, 0x00184c, 0x00000f00, 0x00000000);
1359         init_wr32(init, reg, data1);
1360         udelay(10);
1361         init_wr32(init, reg, data2);
1362         init_wr32(init, 0x00184c, savepci19);
1363         init_mask(init, 0x001850, 0x00000001, 0x00000000);
1364
1365         init_exec_force(init, false);
1366 }
1367
1368 /**
1369  * INIT_CONFIGURE_MEM - opcode 0x66
1370  *
1371  */
1372 static u16
1373 init_configure_mem_clk(struct nvbios_init *init)
1374 {
1375         u16 mdata = bmp_mem_init_table(init->bios);
1376         if (mdata)
1377                 mdata += (init_rdvgai(init, 0x03d4, 0x3c) >> 4) * 66;
1378         return mdata;
1379 }
1380
1381 static void
1382 init_configure_mem(struct nvbios_init *init)
1383 {
1384         struct nouveau_bios *bios = init->bios;
1385         u16 mdata, sdata;
1386         u32 addr, data;
1387
1388         trace("CONFIGURE_MEM\n");
1389         init->offset += 1;
1390
1391         if (bios->version.major > 2) {
1392                 init_done(init);
1393                 return;
1394         }
1395         init_exec_force(init, true);
1396
1397         mdata = init_configure_mem_clk(init);
1398         sdata = bmp_sdr_seq_table(bios);
1399         if (nv_ro08(bios, mdata) & 0x01)
1400                 sdata = bmp_ddr_seq_table(bios);
1401         mdata += 6; /* skip to data */
1402
1403         data = init_rdvgai(init, 0x03c4, 0x01);
1404         init_wrvgai(init, 0x03c4, 0x01, data | 0x20);
1405
1406         while ((addr = nv_ro32(bios, sdata)) != 0xffffffff) {
1407                 switch (addr) {
1408                 case 0x10021c: /* CKE_NORMAL */
1409                 case 0x1002d0: /* CMD_REFRESH */
1410                 case 0x1002d4: /* CMD_PRECHARGE */
1411                         data = 0x00000001;
1412                         break;
1413                 default:
1414                         data = nv_ro32(bios, mdata);
1415                         mdata += 4;
1416                         if (data == 0xffffffff)
1417                                 continue;
1418                         break;
1419                 }
1420
1421                 init_wr32(init, addr, data);
1422         }
1423
1424         init_exec_force(init, false);
1425 }
1426
1427 /**
1428  * INIT_CONFIGURE_CLK - opcode 0x67
1429  *
1430  */
1431 static void
1432 init_configure_clk(struct nvbios_init *init)
1433 {
1434         struct nouveau_bios *bios = init->bios;
1435         u16 mdata, clock;
1436
1437         trace("CONFIGURE_CLK\n");
1438         init->offset += 1;
1439
1440         if (bios->version.major > 2) {
1441                 init_done(init);
1442                 return;
1443         }
1444         init_exec_force(init, true);
1445
1446         mdata = init_configure_mem_clk(init);
1447
1448         /* NVPLL */
1449         clock = nv_ro16(bios, mdata + 4) * 10;
1450         init_prog_pll(init, 0x680500, clock);
1451
1452         /* MPLL */
1453         clock = nv_ro16(bios, mdata + 2) * 10;
1454         if (nv_ro08(bios, mdata) & 0x01)
1455                 clock *= 2;
1456         init_prog_pll(init, 0x680504, clock);
1457
1458         init_exec_force(init, false);
1459 }
1460
1461 /**
1462  * INIT_CONFIGURE_PREINIT - opcode 0x68
1463  *
1464  */
1465 static void
1466 init_configure_preinit(struct nvbios_init *init)
1467 {
1468         struct nouveau_bios *bios = init->bios;
1469         u32 strap;
1470
1471         trace("CONFIGURE_PREINIT\n");
1472         init->offset += 1;
1473
1474         if (bios->version.major > 2) {
1475                 init_done(init);
1476                 return;
1477         }
1478         init_exec_force(init, true);
1479
1480         strap = init_rd32(init, 0x101000);
1481         strap = ((strap << 2) & 0xf0) | ((strap & 0x40) >> 6);
1482         init_wrvgai(init, 0x03d4, 0x3c, strap);
1483
1484         init_exec_force(init, false);
1485 }
1486
1487 /**
1488  * INIT_IO - opcode 0x69
1489  *
1490  */
1491 static void
1492 init_io(struct nvbios_init *init)
1493 {
1494         struct nouveau_bios *bios = init->bios;
1495         u16 port = nv_ro16(bios, init->offset + 1);
1496         u8  mask = nv_ro16(bios, init->offset + 3);
1497         u8  data = nv_ro16(bios, init->offset + 4);
1498         u8 value;
1499
1500         trace("IO\t\tI[0x%04x] &= 0x%02x |= 0x%02x\n", port, mask, data);
1501         init->offset += 5;
1502
1503         /* ummm.. yes.. should really figure out wtf this is and why it's
1504          * needed some day..  it's almost certainly wrong, but, it also
1505          * somehow makes things work...
1506          */
1507         if (nv_device(init->bios)->card_type >= NV_50 &&
1508             port == 0x03c3 && data == 0x01) {
1509                 init_mask(init, 0x614100, 0xf0800000, 0x00800000);
1510                 init_mask(init, 0x00e18c, 0x00020000, 0x00020000);
1511                 init_mask(init, 0x614900, 0xf0800000, 0x00800000);
1512                 init_mask(init, 0x000200, 0x40000000, 0x00000000);
1513                 mdelay(10);
1514                 init_mask(init, 0x00e18c, 0x00020000, 0x00000000);
1515                 init_mask(init, 0x000200, 0x40000000, 0x40000000);
1516                 init_wr32(init, 0x614100, 0x00800018);
1517                 init_wr32(init, 0x614900, 0x00800018);
1518                 mdelay(10);
1519                 init_wr32(init, 0x614100, 0x10000018);
1520                 init_wr32(init, 0x614900, 0x10000018);
1521                 return;
1522         }
1523
1524         value = init_rdport(init, port) & mask;
1525         init_wrport(init, port, data | value);
1526 }
1527
1528 /**
1529  * INIT_SUB - opcode 0x6b
1530  *
1531  */
1532 static void
1533 init_sub(struct nvbios_init *init)
1534 {
1535         struct nouveau_bios *bios = init->bios;
1536         u8 index = nv_ro08(bios, init->offset + 1);
1537         u16 addr, save;
1538
1539         trace("SUB\t0x%02x\n", index);
1540
1541         addr = init_script(bios, index);
1542         if (addr && init_exec(init)) {
1543                 save = init->offset;
1544                 init->offset = addr;
1545                 if (nvbios_exec(init)) {
1546                         error("error parsing sub-table\n");
1547                         return;
1548                 }
1549                 init->offset = save;
1550         }
1551
1552         init->offset += 2;
1553 }
1554
1555 /**
1556  * INIT_RAM_CONDITION - opcode 0x6d
1557  *
1558  */
1559 static void
1560 init_ram_condition(struct nvbios_init *init)
1561 {
1562         struct nouveau_bios *bios = init->bios;
1563         u8  mask = nv_ro08(bios, init->offset + 1);
1564         u8 value = nv_ro08(bios, init->offset + 2);
1565
1566         trace("RAM_CONDITION\t"
1567               "(R[0x100000] & 0x%02x) == 0x%02x\n", mask, value);
1568         init->offset += 3;
1569
1570         if ((init_rd32(init, 0x100000) & mask) != value)
1571                 init_exec_set(init, false);
1572 }
1573
1574 /**
1575  * INIT_NV_REG - opcode 0x6e
1576  *
1577  */
1578 static void
1579 init_nv_reg(struct nvbios_init *init)
1580 {
1581         struct nouveau_bios *bios = init->bios;
1582         u32  reg = nv_ro32(bios, init->offset + 1);
1583         u32 mask = nv_ro32(bios, init->offset + 5);
1584         u32 data = nv_ro32(bios, init->offset + 9);
1585
1586         trace("NV_REG\tR[0x%06x] &= 0x%08x |= 0x%08x\n", reg, mask, data);
1587         init->offset += 13;
1588
1589         init_mask(init, reg, ~mask, data);
1590 }
1591
1592 /**
1593  * INIT_MACRO - opcode 0x6f
1594  *
1595  */
1596 static void
1597 init_macro(struct nvbios_init *init)
1598 {
1599         struct nouveau_bios *bios = init->bios;
1600         u8  macro = nv_ro08(bios, init->offset + 1);
1601         u16 table;
1602
1603         trace("MACRO\t0x%02x\n", macro);
1604
1605         table = init_macro_table(init);
1606         if (table) {
1607                 u32 addr = nv_ro32(bios, table + (macro * 8) + 0);
1608                 u32 data = nv_ro32(bios, table + (macro * 8) + 4);
1609                 trace("\t\tR[0x%06x] = 0x%08x\n", addr, data);
1610                 init_wr32(init, addr, data);
1611         }
1612
1613         init->offset += 2;
1614 }
1615
1616 /**
1617  * INIT_RESUME - opcode 0x72
1618  *
1619  */
1620 static void
1621 init_resume(struct nvbios_init *init)
1622 {
1623         trace("RESUME\n");
1624         init->offset += 1;
1625         init_exec_set(init, true);
1626 }
1627
1628 /**
1629  * INIT_TIME - opcode 0x74
1630  *
1631  */
1632 static void
1633 init_time(struct nvbios_init *init)
1634 {
1635         struct nouveau_bios *bios = init->bios;
1636         u16 usec = nv_ro16(bios, init->offset + 1);
1637
1638         trace("TIME\t0x%04x\n", usec);
1639         init->offset += 3;
1640
1641         if (init_exec(init)) {
1642                 if (usec < 1000)
1643                         udelay(usec);
1644                 else
1645                         mdelay((usec + 900) / 1000);
1646         }
1647 }
1648
1649 /**
1650  * INIT_CONDITION - opcode 0x75
1651  *
1652  */
1653 static void
1654 init_condition(struct nvbios_init *init)
1655 {
1656         struct nouveau_bios *bios = init->bios;
1657         u8 cond = nv_ro08(bios, init->offset + 1);
1658
1659         trace("CONDITION\t0x%02x\n", cond);
1660         init->offset += 2;
1661
1662         if (!init_condition_met(init, cond))
1663                 init_exec_set(init, false);
1664 }
1665
1666 /**
1667  * INIT_IO_CONDITION - opcode 0x76
1668  *
1669  */
1670 static void
1671 init_io_condition(struct nvbios_init *init)
1672 {
1673         struct nouveau_bios *bios = init->bios;
1674         u8 cond = nv_ro08(bios, init->offset + 1);
1675
1676         trace("IO_CONDITION\t0x%02x\n", cond);
1677         init->offset += 2;
1678
1679         if (!init_io_condition_met(init, cond))
1680                 init_exec_set(init, false);
1681 }
1682
1683 /**
1684  * INIT_INDEX_IO - opcode 0x78
1685  *
1686  */
1687 static void
1688 init_index_io(struct nvbios_init *init)
1689 {
1690         struct nouveau_bios *bios = init->bios;
1691         u16 port = nv_ro16(bios, init->offset + 1);
1692         u8 index = nv_ro16(bios, init->offset + 3);
1693         u8  mask = nv_ro08(bios, init->offset + 4);
1694         u8  data = nv_ro08(bios, init->offset + 5);
1695         u8 value;
1696
1697         trace("INDEX_IO\tI[0x%04x][0x%02x] &= 0x%02x |= 0x%02x\n",
1698               port, index, mask, data);
1699         init->offset += 6;
1700
1701         value = init_rdvgai(init, port, index) & mask;
1702         init_wrvgai(init, port, index, data | value);
1703 }
1704
1705 /**
1706  * INIT_PLL - opcode 0x79
1707  *
1708  */
1709 static void
1710 init_pll(struct nvbios_init *init)
1711 {
1712         struct nouveau_bios *bios = init->bios;
1713         u32  reg = nv_ro32(bios, init->offset + 1);
1714         u32 freq = nv_ro16(bios, init->offset + 5) * 10;
1715
1716         trace("PLL\tR[0x%06x] =PLL= %dkHz\n", reg, freq);
1717         init->offset += 7;
1718
1719         init_prog_pll(init, reg, freq);
1720 }
1721
1722 /**
1723  * INIT_ZM_REG - opcode 0x7a
1724  *
1725  */
1726 static void
1727 init_zm_reg(struct nvbios_init *init)
1728 {
1729         struct nouveau_bios *bios = init->bios;
1730         u32 addr = nv_ro32(bios, init->offset + 1);
1731         u32 data = nv_ro32(bios, init->offset + 5);
1732
1733         trace("ZM_REG\tR[0x%06x] = 0x%08x\n", addr, data);
1734         init->offset += 9;
1735
1736         if (addr == 0x000200)
1737                 data |= 0x00000001;
1738
1739         init_wr32(init, addr, data);
1740 }
1741
1742 /**
1743  * INIT_RAM_RESTRICT_PLL - opcde 0x87
1744  *
1745  */
1746 static void
1747 init_ram_restrict_pll(struct nvbios_init *init)
1748 {
1749         struct nouveau_bios *bios = init->bios;
1750         u8  type = nv_ro08(bios, init->offset + 1);
1751         u8 count = init_ram_restrict_group_count(init);
1752         u8 strap = init_ram_restrict(init);
1753         u8 cconf;
1754
1755         trace("RAM_RESTRICT_PLL\t0x%02x\n", type);
1756         init->offset += 2;
1757
1758         for (cconf = 0; cconf < count; cconf++) {
1759                 u32 freq = nv_ro32(bios, init->offset);
1760
1761                 if (cconf == strap) {
1762                         trace("%dkHz *\n", freq);
1763                         init_prog_pll(init, type, freq);
1764                 } else {
1765                         trace("%dkHz\n", freq);
1766                 }
1767
1768                 init->offset += 4;
1769         }
1770 }
1771
1772 /**
1773  * INIT_GPIO - opcode 0x8e
1774  *
1775  */
1776 static void
1777 init_gpio(struct nvbios_init *init)
1778 {
1779         struct nouveau_gpio *gpio = nouveau_gpio(init->bios);
1780
1781         trace("GPIO\n");
1782         init->offset += 1;
1783
1784         if (init_exec(init) && gpio && gpio->reset)
1785                 gpio->reset(gpio, DCB_GPIO_UNUSED);
1786 }
1787
1788 /**
1789  * INIT_RAM_RESTRICT_ZM_GROUP - opcode 0x8f
1790  *
1791  */
1792 static void
1793 init_ram_restrict_zm_reg_group(struct nvbios_init *init)
1794 {
1795         struct nouveau_bios *bios = init->bios;
1796         u32 addr = nv_ro32(bios, init->offset + 1);
1797         u8  incr = nv_ro08(bios, init->offset + 5);
1798         u8   num = nv_ro08(bios, init->offset + 6);
1799         u8 count = init_ram_restrict_group_count(init);
1800         u8 index = init_ram_restrict(init);
1801         u8 i, j;
1802
1803         trace("RAM_RESTRICT_ZM_REG_GROUP\t"
1804               "R[%08x] 0x%02x 0x%02x\n", addr, incr, num);
1805         init->offset += 7;
1806
1807         for (i = 0; i < num; i++) {
1808                 trace("\tR[0x%06x] = {\n", addr);
1809                 for (j = 0; j < count; j++) {
1810                         u32 data = nv_ro32(bios, init->offset);
1811
1812                         if (j == index) {
1813                                 trace("\t\t0x%08x *\n", data);
1814                                 init_wr32(init, addr, data);
1815                         } else {
1816                                 trace("\t\t0x%08x\n", data);
1817                         }
1818
1819                         init->offset += 4;
1820                 }
1821                 trace("\t}\n");
1822                 addr += incr;
1823         }
1824 }
1825
1826 /**
1827  * INIT_COPY_ZM_REG - opcode 0x90
1828  *
1829  */
1830 static void
1831 init_copy_zm_reg(struct nvbios_init *init)
1832 {
1833         struct nouveau_bios *bios = init->bios;
1834         u32 sreg = nv_ro32(bios, init->offset + 1);
1835         u32 dreg = nv_ro32(bios, init->offset + 5);
1836
1837         trace("COPY_ZM_REG\tR[0x%06x] = R[0x%06x]\n", sreg, dreg);
1838         init->offset += 9;
1839
1840         init_wr32(init, dreg, init_rd32(init, sreg));
1841 }
1842
1843 /**
1844  * INIT_ZM_REG_GROUP - opcode 0x91
1845  *
1846  */
1847 static void
1848 init_zm_reg_group(struct nvbios_init *init)
1849 {
1850         struct nouveau_bios *bios = init->bios;
1851         u32 addr = nv_ro32(bios, init->offset + 1);
1852         u8 count = nv_ro08(bios, init->offset + 5);
1853
1854         trace("ZM_REG_GROUP\tR[0x%06x] =\n");
1855         init->offset += 6;
1856
1857         while (count--) {
1858                 u32 data = nv_ro32(bios, init->offset);
1859                 trace("\t0x%08x\n", data);
1860                 init_wr32(init, addr, data);
1861                 init->offset += 4;
1862         }
1863 }
1864
1865 /**
1866  * INIT_XLAT - opcode 0x96
1867  *
1868  */
1869 static void
1870 init_xlat(struct nvbios_init *init)
1871 {
1872         struct nouveau_bios *bios = init->bios;
1873         u32 saddr = nv_ro32(bios, init->offset + 1);
1874         u8 sshift = nv_ro08(bios, init->offset + 5);
1875         u8  smask = nv_ro08(bios, init->offset + 6);
1876         u8  index = nv_ro08(bios, init->offset + 7);
1877         u32 daddr = nv_ro32(bios, init->offset + 8);
1878         u32 dmask = nv_ro32(bios, init->offset + 12);
1879         u8  shift = nv_ro08(bios, init->offset + 16);
1880         u32 data;
1881
1882         trace("INIT_XLAT\tR[0x%06x] &= 0x%08x |= "
1883               "(X%02x((R[0x%06x] %s 0x%02x) & 0x%02x) << 0x%02x)\n",
1884               daddr, dmask, index, saddr, (sshift & 0x80) ? "<<" : ">>",
1885               (sshift & 0x80) ? (0x100 - sshift) : sshift, smask, shift);
1886         init->offset += 17;
1887
1888         data = init_shift(init_rd32(init, saddr), sshift) & smask;
1889         data = init_xlat_(init, index, data) << shift;
1890         init_mask(init, daddr, ~dmask, data);
1891 }
1892
1893 /**
1894  * INIT_ZM_MASK_ADD - opcode 0x97
1895  *
1896  */
1897 static void
1898 init_zm_mask_add(struct nvbios_init *init)
1899 {
1900         struct nouveau_bios *bios = init->bios;
1901         u32 addr = nv_ro32(bios, init->offset + 1);
1902         u32 mask = nv_ro32(bios, init->offset + 5);
1903         u32  add = nv_ro32(bios, init->offset + 9);
1904         u32 data;
1905
1906         trace("ZM_MASK_ADD\tR[0x%06x] &= 0x%08x += 0x%08x\n", addr, mask, add);
1907         init->offset += 13;
1908
1909         data  =  init_rd32(init, addr) & mask;
1910         data |= ((data + add) & ~mask);
1911         init_wr32(init, addr, data);
1912 }
1913
1914 /**
1915  * INIT_AUXCH - opcode 0x98
1916  *
1917  */
1918 static void
1919 init_auxch(struct nvbios_init *init)
1920 {
1921         struct nouveau_bios *bios = init->bios;
1922         u32 addr = nv_ro32(bios, init->offset + 1);
1923         u8 count = nv_ro08(bios, init->offset + 5);
1924
1925         trace("AUXCH\tAUX[0x%08x] 0x%02x\n", addr, count);
1926         init->offset += 6;
1927
1928         while (count--) {
1929                 u8 mask = nv_ro08(bios, init->offset + 0);
1930                 u8 data = nv_ro08(bios, init->offset + 1);
1931                 trace("\tAUX[0x%08x] &= 0x%02x |= 0x%02x\n", addr, mask, data);
1932                 mask = init_rdauxr(init, addr) & mask;
1933                 init_wrauxr(init, addr, mask | data);
1934                 init->offset += 2;
1935         }
1936 }
1937
1938 /**
1939  * INIT_AUXCH - opcode 0x99
1940  *
1941  */
1942 static void
1943 init_zm_auxch(struct nvbios_init *init)
1944 {
1945         struct nouveau_bios *bios = init->bios;
1946         u32 addr = nv_ro32(bios, init->offset + 1);
1947         u8 count = nv_ro08(bios, init->offset + 5);
1948
1949         trace("ZM_AUXCH\tAUX[0x%08x] 0x%02x\n", addr, count);
1950         init->offset += 6;
1951
1952         while (count--) {
1953                 u8 data = nv_ro08(bios, init->offset + 0);
1954                 trace("\tAUX[0x%08x] = 0x%02x\n", addr, data);
1955                 init_wrauxr(init, addr, data);
1956                 init->offset += 1;
1957         }
1958 }
1959
1960 /**
1961  * INIT_I2C_LONG_IF - opcode 0x9a
1962  *
1963  */
1964 static void
1965 init_i2c_long_if(struct nvbios_init *init)
1966 {
1967         struct nouveau_bios *bios = init->bios;
1968         u8 index = nv_ro08(bios, init->offset + 1);
1969         u8  addr = nv_ro08(bios, init->offset + 2) >> 1;
1970         u8 reglo = nv_ro08(bios, init->offset + 3);
1971         u8 reghi = nv_ro08(bios, init->offset + 4);
1972         u8  mask = nv_ro08(bios, init->offset + 5);
1973         u8  data = nv_ro08(bios, init->offset + 6);
1974         struct nouveau_i2c_port *port;
1975
1976         trace("I2C_LONG_IF\t"
1977               "I2C[0x%02x][0x%02x][0x%02x%02x] & 0x%02x == 0x%02x\n",
1978               index, addr, reglo, reghi, mask, data);
1979         init->offset += 7;
1980
1981         port = init_i2c(init, index);
1982         if (port) {
1983                 u8 i[2] = { reghi, reglo };
1984                 u8 o[1] = {};
1985                 struct i2c_msg msg[] = {
1986                         { .addr = addr, .flags = 0, .len = 2, .buf = i },
1987                         { .addr = addr, .flags = I2C_M_RD, .len = 1, .buf = o }
1988                 };
1989                 int ret;
1990
1991                 ret = i2c_transfer(&port->adapter, msg, 2);
1992                 if (ret == 2 && ((o[0] & mask) == data))
1993                         return;
1994         }
1995
1996         init_exec_set(init, false);
1997 }
1998
1999 /**
2000  * INIT_GPIO_NE - opcode 0xa9
2001  *
2002  */
2003 static void
2004 init_gpio_ne(struct nvbios_init *init)
2005 {
2006         struct nouveau_bios *bios = init->bios;
2007         struct nouveau_gpio *gpio = nouveau_gpio(bios);
2008         struct dcb_gpio_func func;
2009         u8 count = nv_ro08(bios, init->offset + 1);
2010         u8 idx = 0, ver, len;
2011         u16 data, i;
2012
2013         trace("GPIO_NE\t");
2014         init->offset += 2;
2015
2016         for (i = init->offset; i < init->offset + count; i++)
2017                 cont("0x%02x ", nv_ro08(bios, i));
2018         cont("\n");
2019
2020         while ((data = dcb_gpio_parse(bios, 0, idx++, &ver, &len, &func))) {
2021                 if (func.func != DCB_GPIO_UNUSED) {
2022                         for (i = init->offset; i < init->offset + count; i++) {
2023                                 if (func.func == nv_ro08(bios, i))
2024                                         break;
2025                         }
2026
2027                         trace("\tFUNC[0x%02x]", func.func);
2028                         if (i == (init->offset + count)) {
2029                                 cont(" *");
2030                                 if (init_exec(init) && gpio && gpio->reset)
2031                                         gpio->reset(gpio, func.func);
2032                         }
2033                         cont("\n");
2034                 }
2035         }
2036
2037         init->offset += count;
2038 }
2039
2040 static struct nvbios_init_opcode {
2041         void (*exec)(struct nvbios_init *);
2042 } init_opcode[] = {
2043         [0x32] = { init_io_restrict_prog },
2044         [0x33] = { init_repeat },
2045         [0x34] = { init_io_restrict_pll },
2046         [0x36] = { init_end_repeat },
2047         [0x37] = { init_copy },
2048         [0x38] = { init_not },
2049         [0x39] = { init_io_flag_condition },
2050         [0x3a] = { init_dp_condition },
2051         [0x3b] = { init_io_mask_or },
2052         [0x3c] = { init_io_or },
2053         [0x49] = { init_idx_addr_latched },
2054         [0x4a] = { init_io_restrict_pll2 },
2055         [0x4b] = { init_pll2 },
2056         [0x4c] = { init_i2c_byte },
2057         [0x4d] = { init_zm_i2c_byte },
2058         [0x4e] = { init_zm_i2c },
2059         [0x4f] = { init_tmds },
2060         [0x50] = { init_zm_tmds_group },
2061         [0x51] = { init_cr_idx_adr_latch },
2062         [0x52] = { init_cr },
2063         [0x53] = { init_zm_cr },
2064         [0x54] = { init_zm_cr_group },
2065         [0x56] = { init_condition_time },
2066         [0x57] = { init_ltime },
2067         [0x58] = { init_zm_reg_sequence },
2068         [0x5b] = { init_sub_direct },
2069         [0x5c] = { init_jump },
2070         [0x5e] = { init_i2c_if },
2071         [0x5f] = { init_copy_nv_reg },
2072         [0x62] = { init_zm_index_io },
2073         [0x63] = { init_compute_mem },
2074         [0x65] = { init_reset },
2075         [0x66] = { init_configure_mem },
2076         [0x67] = { init_configure_clk },
2077         [0x68] = { init_configure_preinit },
2078         [0x69] = { init_io },
2079         [0x6b] = { init_sub },
2080         [0x6d] = { init_ram_condition },
2081         [0x6e] = { init_nv_reg },
2082         [0x6f] = { init_macro },
2083         [0x71] = { init_done },
2084         [0x72] = { init_resume },
2085         [0x74] = { init_time },
2086         [0x75] = { init_condition },
2087         [0x76] = { init_io_condition },
2088         [0x78] = { init_index_io },
2089         [0x79] = { init_pll },
2090         [0x7a] = { init_zm_reg },
2091         [0x87] = { init_ram_restrict_pll },
2092         [0x8c] = { init_reserved },
2093         [0x8d] = { init_reserved },
2094         [0x8e] = { init_gpio },
2095         [0x8f] = { init_ram_restrict_zm_reg_group },
2096         [0x90] = { init_copy_zm_reg },
2097         [0x91] = { init_zm_reg_group },
2098         [0x92] = { init_reserved },
2099         [0x96] = { init_xlat },
2100         [0x97] = { init_zm_mask_add },
2101         [0x98] = { init_auxch },
2102         [0x99] = { init_zm_auxch },
2103         [0x9a] = { init_i2c_long_if },
2104         [0xa9] = { init_gpio_ne },
2105 };
2106
2107 #define init_opcode_nr (sizeof(init_opcode) / sizeof(init_opcode[0]))
2108
2109 int
2110 nvbios_exec(struct nvbios_init *init)
2111 {
2112         init->nested++;
2113         while (init->offset) {
2114                 u8 opcode = nv_ro08(init->bios, init->offset);
2115                 if (opcode >= init_opcode_nr || !init_opcode[opcode].exec) {
2116                         error("unknown opcode 0x%02x\n", opcode);
2117                         return -EINVAL;
2118                 }
2119
2120                 init_opcode[opcode].exec(init);
2121         }
2122         init->nested--;
2123         return 0;
2124 }
2125
2126 int
2127 nvbios_init(struct nouveau_subdev *subdev, bool execute)
2128 {
2129         struct nouveau_bios *bios = nouveau_bios(subdev);
2130         int ret = 0;
2131         int i = -1;
2132         u16 data;
2133
2134         if (execute)
2135                 nv_info(bios, "running init tables\n");
2136         while (!ret && (data = (init_script(bios, ++i)))) {
2137                 struct nvbios_init init = {
2138                         .subdev = subdev,
2139                         .bios = bios,
2140                         .offset = data,
2141                         .outp = NULL,
2142                         .crtc = -1,
2143                         .execute = execute ? 1 : 0,
2144                 };
2145
2146                 ret = nvbios_exec(&init);
2147         }
2148
2149         /* the vbios parser will run this right after the normal init
2150          * tables, whereas the binary driver appears to run it later.
2151          */
2152         if (!ret && (data = init_unknown_script(bios))) {
2153                 struct nvbios_init init = {
2154                         .subdev = subdev,
2155                         .bios = bios,
2156                         .offset = data,
2157                         .outp = NULL,
2158                         .crtc = -1,
2159                         .execute = execute ? 1 : 0,
2160                 };
2161
2162                 ret = nvbios_exec(&init);
2163         }
2164
2165         return 0;
2166 }