INIT_CONDITION_TIME opcode
[nouveau] / src / nv_bios.c
1 /*
2  * Copyright 2005-2006 Erik Waling
3  * Copyright 2006 Stephane Marchesin
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
19  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
20  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21  * SOFTWARE.
22  */
23
24 #include "nv_include.h"
25 #include "nvreg.h"
26 #include <byteswap.h>
27
28 /* FIXME: put these somewhere */
29 #define CRTC_INDEX_COLOR VGA_IOBASE_COLOR + VGA_CRTC_INDEX_OFFSET
30 #define NV_VGA_CRTCX_OWNER_HEADA 0x0
31 #define NV_VGA_CRTCX_OWNER_HEADB 0x3
32 #define NV_PBUS_PCI_NV_19 0x0000184C
33 #define NV_PBUS_PCI_NV_20 0x00001850
34 #define NV_PBUS_PCI_NV_20_ROM_SHADOW_DISABLED 0x00000000
35 #define NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED 0x00000001
36 #define NV_PRAMIN_ROM_OFFSET 0x00700000
37
38 #define DEBUGLEVEL 6
39
40 /* TODO: 
41  *       * PLL algorithms.
42  */
43
44 static int crtchead = 0;
45
46 typedef struct {
47         Bool execute;
48         Bool repeat;
49 } init_exec_t;
50
51 static uint16_t le16_to_cpu(const uint16_t x)
52 {
53 #if X_BYTE_ORDER == X_BIG_ENDIAN
54         return bswap_16(x);
55 #else
56         return x;
57 #endif
58 }
59
60 static uint32_t le32_to_cpu(const uint32_t x)
61 {
62 #if X_BYTE_ORDER == X_BIG_ENDIAN
63         return bswap_32(x);
64 #else
65         return x;
66 #endif
67 }
68
69 static Bool nv_cksum(const uint8_t *data, unsigned int length)
70 {
71         /* there's a few checksums in the BIOS, so here's a generic checking function */
72         int i;
73         uint8_t sum = 0;
74
75         for (i = 0; i < length; i++)
76                 sum += data[i];
77
78         if (sum)
79                 return TRUE;
80
81         return FALSE;
82 }
83
84 static int NVValidVBIOS(ScrnInfoPtr pScrn, const uint8_t *data)
85 {
86         /* check for BIOS signature */
87         if (!(data[0] == 0x55 && data[1] == 0xAA)) {
88                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
89                            "... BIOS signature not found\n");
90                 return 0;
91         }
92
93         if (nv_cksum(data, data[2] * 512)) {
94                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
95                            "... BIOS checksum invalid\n");
96                 /* probably ought to set a do_not_execute flag for table parsing here,
97                  * assuming most BIOSen are valid */
98                 return 1;
99         } else
100                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "... appears to be valid\n");
101
102         return 2;
103 }
104
105 static void NVShadowVBIOS_PROM(ScrnInfoPtr pScrn, uint8_t *data)
106 {
107         NVPtr pNv = NVPTR(pScrn);
108         int i;
109
110         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
111                    "Attempting to locate BIOS image in PROM\n");
112
113         /* enable ROM access */
114         nvWriteMC(pNv, NV_PBUS_PCI_NV_20, NV_PBUS_PCI_NV_20_ROM_SHADOW_DISABLED);
115         for (i = 0; i < NV_PROM_SIZE; i++) {
116                 /* according to nvclock, we need that to work around a 6600GT/6800LE bug */
117                 data[i] = pNv->PROM[i];
118                 data[i] = pNv->PROM[i];
119                 data[i] = pNv->PROM[i];
120                 data[i] = pNv->PROM[i];
121                 data[i] = pNv->PROM[i];
122         }
123         /* disable ROM access */
124         nvWriteMC(pNv, NV_PBUS_PCI_NV_20, NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED);
125 }
126
127 static void NVShadowVBIOS_PRAMIN(ScrnInfoPtr pScrn, uint32_t *data)
128 {
129         NVPtr pNv = NVPTR(pScrn);
130         const uint32_t *pramin = (uint32_t *)&pNv->REGS[NV_PRAMIN_ROM_OFFSET/4];
131         uint32_t old_bar0_pramin = 0;
132
133         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
134                    "Attempting to locate BIOS image in PRAMIN\n");
135
136         if (pNv->Architecture >= NV_ARCH_50) {
137                 uint32_t vbios_vram;
138
139                 vbios_vram = (pNv->REGS[0x619f04/4] & ~0xff) << 8;
140                 if (!vbios_vram) {
141                         vbios_vram = pNv->REGS[0x1700/4] << 16;
142                         vbios_vram += 0xf0000;
143                 }
144
145                 old_bar0_pramin = pNv->REGS[0x1700/4];
146                 pNv->REGS[0x1700/4] = vbios_vram >> 16;
147         }
148
149         memcpy(data, pramin, NV_PROM_SIZE);
150
151         if (pNv->Architecture >= NV_ARCH_50) {
152                 pNv->REGS[0x1700/4] = old_bar0_pramin;
153         }
154 }
155
156 static Bool NVShadowVBIOS(ScrnInfoPtr pScrn, uint8_t *data)
157 {
158         NVShadowVBIOS_PROM(pScrn, data);
159         if (NVValidVBIOS(pScrn, data) == 2)
160                 return TRUE;
161
162         NVShadowVBIOS_PRAMIN(pScrn, (uint32_t *)data);
163         if (NVValidVBIOS(pScrn, data))
164                 return TRUE;
165
166         return FALSE;
167 }
168
169 typedef struct {
170         char* name;
171         uint8_t id;
172         int length;
173         int length_offset;
174         int length_multiplier;
175         Bool (*handler)(ScrnInfoPtr pScrn, bios_t *, uint16_t, init_exec_t *);
176 } init_tbl_entry_t;
177
178 typedef struct {
179         uint8_t id[2];
180         uint16_t length;
181         uint16_t offset;
182 } bit_entry_t;
183
184 static void parse_init_table(ScrnInfoPtr pScrn, bios_t *bios, unsigned int offset, init_exec_t *iexec);
185
186 #define MACRO_INDEX_SIZE        2
187 #define MACRO_SIZE              8
188 #define CONDITION_SIZE          12
189 #define IO_FLAG_CONDITION_SIZE  9 
190
191 void still_alive()
192 {
193         sync();
194 //      usleep(200000);
195 }
196
197 static int nv_valid_reg(uint32_t reg)
198 {
199         #define WITHIN(x,y,z) ((x>=y)&&(x<y+z))
200         if (WITHIN(reg,NV_PRAMIN_OFFSET,NV_PRAMIN_SIZE))
201                 return 1;
202         if (WITHIN(reg,NV_PCRTC0_OFFSET,NV_PCRTC0_SIZE))
203                 return 1;
204         if (WITHIN(reg,NV_PRAMDAC0_OFFSET,NV_PRAMDAC0_SIZE))
205                 return 1;
206         if (WITHIN(reg,NV_PFB_OFFSET,NV_PFB_SIZE))
207                 return 1;
208         if (WITHIN(reg,NV_PFIFO_OFFSET,NV_PFIFO_SIZE))
209                 return 1;
210         if (WITHIN(reg,NV_PGRAPH_OFFSET,NV_PGRAPH_SIZE))
211                 return 1;
212         if (WITHIN(reg,NV_PEXTDEV_OFFSET,NV_PEXTDEV_SIZE))
213                 return 1;
214         if (WITHIN(reg,NV_PTIMER_OFFSET,NV_PTIMER_SIZE))
215                 return 1;
216         if (WITHIN(reg,NV_PVIDEO_OFFSET,NV_PVIDEO_SIZE))
217                 return 1;
218         if (WITHIN(reg,NV_PMC_OFFSET,NV_PMC_SIZE))
219                 return 1;
220         if (WITHIN(reg,NV_FIFO_OFFSET,NV_FIFO_SIZE))
221                 return 1;
222         if (WITHIN(reg,NV_PCIO0_OFFSET,NV_PCIO0_SIZE))
223                 return 1;
224         if (WITHIN(reg,NV_PDIO0_OFFSET,NV_PDIO0_SIZE))
225                 return 1;
226         if (WITHIN(reg,NV_PVIO_OFFSET,NV_PVIO_SIZE))
227                 return 1;
228         if (WITHIN(reg,NV_PROM_OFFSET,NV_PROM_SIZE))
229                 return 1;
230         if (WITHIN(reg,NV_PRAMIN_ROM_OFFSET,NV_PROM_SIZE))
231                 return 1;
232         /* A new PBUS? */
233         if (WITHIN(reg,0x88000,0x1000))
234                 return 1;
235         #undef WITHIN
236         return 0;
237 }
238
239 static void nv32_rd(ScrnInfoPtr pScrn, uint32_t reg, uint32_t *data)
240 {
241         NVPtr pNv = NVPTR(pScrn);
242
243         if (!nv_valid_reg(reg)) {
244                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
245                            "========= unknown reg 0x%08X ==========\n", reg);
246                 return;
247         }
248         *data = pNv->REGS[reg/4];
249         if (DEBUGLEVEL >= 6)
250                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
251                            "    Read:  Reg: 0x%08X, Data: 0x%08X\n", reg, *data);
252 }
253
254 static int nv32_wr(ScrnInfoPtr pScrn, uint32_t reg, uint32_t data)
255 {
256         NVPtr pNv = NVPTR(pScrn);
257         int specialcase = 0;
258         uint8_t saved1 = 0, saved2 = 0;
259         volatile uint8_t *crtcptr = crtchead ? pNv->PCIO1 : pNv->PCIO0;
260
261         if (DEBUGLEVEL >= 8) {
262                 uint32_t tmp;
263                 nv32_rd(pScrn, reg, &tmp);
264         }
265         if (DEBUGLEVEL >= 6)
266                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
267                            "    Write: Reg: 0x%08X, Data: 0x%08X\n", reg, data);
268         if (!nv_valid_reg(reg)) {
269                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
270                            "========= unknown reg 0x%08X ==========\n", reg);
271                 return 0;
272         }
273
274         if (pNv->VBIOS.execute) {
275                 still_alive();
276
277                 if ((reg & 0xffc) == 0x3c0) {
278                         specialcase = 1;
279                         saved1 = VGA_RD08(crtcptr, VGA_MISC_OUT_R);
280                         saved2 = VGA_RD08(crtcptr, VGA_ENABLE);
281                 }
282                 if ((reg & 0xffc) == 0x3cc) {
283                         specialcase = 2;
284                         saved1 = VGA_RD08(crtcptr, VGA_GRAPH_INDEX);
285                         VGA_WR08(crtcptr, VGA_GRAPH_INDEX, 0x06);
286                         saved2 = VGA_RD08(crtcptr, VGA_GRAPH_DATA);
287                 }
288
289                 pNv->REGS[reg/4] = data;
290
291                 if (specialcase == 1) {
292                         VGA_WR08(crtcptr, VGA_ENABLE, saved2);
293                         VGA_WR08(crtcptr, VGA_MISC_OUT_W, saved1);
294                 }
295                 if (specialcase == 2) {
296                         VGA_WR08(crtcptr, VGA_GRAPH_INDEX, 0x06);
297                         VGA_WR08(crtcptr, VGA_GRAPH_DATA, saved2);
298                         VGA_WR08(crtcptr, VGA_GRAPH_INDEX, saved1);
299                 }
300         }
301
302         return 1;
303 }
304
305 static void nv_idx_port_rd(ScrnInfoPtr pScrn, uint16_t port, uint8_t index, uint8_t *data)
306 {
307         NVPtr pNv = NVPTR(pScrn);
308         volatile uint8_t *ptr = crtchead ? pNv->PCIO1 : pNv->PCIO0;
309
310         VGA_WR08(ptr, port, index);
311         *data = VGA_RD08(ptr, port + 1);
312
313         if (DEBUGLEVEL >= 6)
314                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
315                            "    Indexed read:  Port: 0x%04X, Index: 0x%02X, Head: 0x%02X, Data: 0x%02X\n",
316                            port, index, crtchead, *data);
317 }
318
319 static void nv_idx_port_wr(ScrnInfoPtr pScrn, uint16_t port, uint8_t index, uint8_t data)
320 {
321         NVPtr pNv = NVPTR(pScrn);
322         volatile uint8_t *ptr;
323
324         /* The current head is maintained in a file scope variable crtchead.
325          * We trap changes to CRTCX_OWNER and update the head variable
326          * and hence the register set written.
327          * As CRTCX_OWNER only exists on CRTC0, we update crtchead to head0
328          * in advance of the write, and to head1 after the write
329          */
330         if (port == CRTC_INDEX_COLOR && index == NV_VGA_CRTCX_OWNER && data != NV_VGA_CRTCX_OWNER_HEADB)
331                 crtchead = 0;
332         ptr = crtchead ? pNv->PCIO1 : pNv->PCIO0;
333
334         if (DEBUGLEVEL >= 8) {
335                 uint8_t tmp;
336                 nv_idx_port_rd(pScrn, port, index, &tmp);
337         }
338         if (DEBUGLEVEL >= 6)
339                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
340                            "    Indexed write: Port: 0x%04X, Index: 0x%02X, Head: 0x%02X, Data: 0x%02X\n",
341                            port, index, crtchead, data);
342
343         if (pNv->VBIOS.execute) {
344                 still_alive();
345                 VGA_WR08(ptr, port, index);
346                 VGA_WR08(ptr, port + 1, data);
347         }
348
349         if (port == CRTC_INDEX_COLOR && index == NV_VGA_CRTCX_OWNER && data == NV_VGA_CRTCX_OWNER_HEADB)
350                 crtchead = 1;
351 }
352
353 static Bool io_flag_condition(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, uint8_t cond)
354 {
355         /* The IO flag condition entry has 2 bytes for the CRTC port; 1 byte
356          * for the CRTC index; 1 byte for the mask to apply to the value
357          * retrieved from the CRTC; 1 byte for the shift right to apply to the
358          * masked CRTC value; 2 bytes for the offset to the flag array, to
359          * which the shifted value is added; 1 byte for the mask applied to the
360          * value read from the flag array; and 1 byte for the value to compare
361          * against the masked byte from the flag table.
362          */
363
364         uint16_t condptr = bios->io_flag_condition_tbl_ptr + cond * IO_FLAG_CONDITION_SIZE;
365         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[condptr])));
366         uint8_t crtcindex = bios->data[condptr + 2];
367         uint8_t mask = bios->data[condptr + 3];
368         uint8_t shift = bios->data[condptr + 4];
369         uint16_t flagarray = le16_to_cpu(*((uint16_t *)(&bios->data[condptr + 5])));
370         uint8_t flagarraymask = bios->data[condptr + 7];
371         uint8_t cmpval = bios->data[condptr + 8];
372         uint8_t data;
373
374         if (DEBUGLEVEL >= 6)
375                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
376                            "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, Shift: 0x%02X, FlagArray: 0x%04X, FAMask: 0x%02X, Cmpval: 0x%02X\n",
377                            offset, crtcport, crtcindex, mask, shift, flagarray, flagarraymask, cmpval);
378
379         nv_idx_port_rd(pScrn, crtcport, crtcindex, &data);
380
381         data = bios->data[flagarray + ((data & mask) >> shift)];
382         data &= flagarraymask;
383
384         if (DEBUGLEVEL >= 6)
385                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
386                            "0x%04X: Checking if 0x%02X equals 0x%02X\n",
387                            offset, data, cmpval);
388
389         if (data == cmpval)
390                 return TRUE;
391
392         return FALSE;
393 }
394
395 static Bool init_prog(ScrnInfoPtr pScrn, bios_t *bios, CARD16 offset, init_exec_t *iexec)
396 {
397         /* INIT_PROG   opcode: 0x31
398          * 
399          * offset      (8  bit): opcode
400          * offset + 1  (32 bit): reg
401          * offset + 5  (32 bit): and mask
402          * offset + 9  (8  bit): shift right
403          * offset + 10 (8  bit): number of configurations
404          * offset + 11 (32 bit): register
405          * offset + 15 (32 bit): configuration 1
406          * ...
407          * 
408          * Starting at offset + 15 there are "number of configurations"
409          * 32 bit values. To find out which configuration value to use
410          * read "CRTC reg" on the CRTC controller with index "CRTC index"
411          * and bitwise AND this value with "and mask" and then bit shift the
412          * result "shift right" bits to the right.
413          * Assign "register" with appropriate configuration value.
414          */
415
416         CARD32 reg = *((CARD32 *) (&bios->data[offset + 1]));
417         CARD32 and = *((CARD32 *) (&bios->data[offset + 5]));
418         CARD8 shiftr = *((CARD8 *) (&bios->data[offset + 9]));
419         CARD8 nr = *((CARD8 *) (&bios->data[offset + 10]));
420         CARD32 reg2 = *((CARD32 *) (&bios->data[offset + 11]));
421         CARD8 configuration;
422         CARD32 configval, tmp;
423
424         if (iexec->execute) {
425                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: REG: 0x%04X\n", offset, 
426                                 reg);
427
428                 nv32_rd(pScrn, reg, &tmp);
429                 configuration = (tmp & and) >> shiftr;
430
431                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CONFIGURATION TO USE: 0x%02X\n", 
432                                 offset, configuration);
433
434                 if (configuration <= nr) {
435
436                         configval = 
437                                 *((CARD32 *) (&bios->data[offset + 15 + configuration * 4]));
438
439                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: REG: 0x%08X, VALUE: 0x%08X\n", offset, 
440                                         reg2, configval);
441                         
442                         nv32_rd(pScrn, reg2, &tmp);
443                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CURRENT VALUE IS: 0x%08X\n",
444                                 offset, tmp);
445                         nv32_wr(pScrn, reg2, configval);
446                 }
447         }
448         return TRUE;
449 }
450
451 static Bool init_io_restrict_prog(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
452 {
453         /* INIT_IO_RESTRICT_PROG   opcode: 0x32 ('2')
454          * 
455          * offset      (8  bit): opcode
456          * offset + 1  (16 bit): CRTC port
457          * offset + 3  (8  bit): CRTC index
458          * offset + 4  (8  bit): mask
459          * offset + 5  (8  bit): shift
460          * offset + 6  (8  bit): count
461          * offset + 7  (32 bit): register
462          * offset + 11 (32 bit): configuration 1
463          * ...
464          * 
465          * Starting at offset + 11 there are "count" 32 bit values.
466          * To find out which value to use read index "CRTC index" on "CRTC port",
467          * AND this value with "mask" and then bit shift right "shift" bits.
468          * Read the appropriate value using this index and write to "register"
469          */
470
471         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
472         uint8_t crtcindex = bios->data[offset + 3];
473         uint8_t mask = bios->data[offset + 4];
474         uint8_t shift = bios->data[offset + 5];
475         uint8_t count = bios->data[offset + 6];
476         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 7])));
477         uint8_t config;
478         uint32_t configval;
479
480         if (!iexec->execute)
481                 return TRUE;
482
483         if (DEBUGLEVEL >= 6)
484                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
485                            "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
486                            offset, crtcport, crtcindex, mask, shift, count, reg);
487
488         nv_idx_port_rd(pScrn, crtcport, crtcindex, &config);
489         config = (config & mask) >> shift;
490         if (config > count) {
491                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
492                            "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
493                            offset, config, count);
494                 return FALSE;
495         }
496
497         configval = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 11 + config * 4])));
498
499         if (DEBUGLEVEL >= 6)
500                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
501                            "0x%04X: Writing config %02X\n", offset, config);
502
503         nv32_wr(pScrn, reg, configval);
504
505         return TRUE;
506 }
507
508 static Bool init_repeat(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
509 {
510         /* INIT_REPEAT   opcode: 0x33 ('3')
511          *
512          * offset      (8 bit): opcode
513          * offset + 1  (8 bit): count
514          *
515          * Execute script following this opcode up to INIT_REPEAT_END
516          * "count" times
517          */
518
519         uint8_t count = bios->data[offset + 1];
520         uint8_t i;
521
522         /* no iexec->execute check by design */
523
524         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
525                    "0x%04X: REPEATING FOLLOWING SEGMENT %d TIMES.\n",
526                    offset, count);
527
528         iexec->repeat = TRUE;
529
530         /* count - 1, as the script block will execute once when we leave this
531          * opcode -- this is compatible with bios behaviour as:
532          * a) the block is always executed at least once, even if count == 0
533          * b) the bios interpreter skips to the op following INIT_END_REPEAT,
534          * while we don't
535          */
536         for (i = 0; i < count - 1; i++)
537                 parse_init_table(pScrn, bios, offset + 2, iexec);
538
539         iexec->repeat = FALSE;
540
541         return TRUE;
542 }
543
544 static Bool init_io_restrict_pll(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
545 {
546         /* INIT_IO_RESTRICT_PLL   opcode: 0x34 ('4')
547          *
548          * offset      (8  bit): opcode
549          * offset + 1  (16 bit): CRTC port
550          * offset + 3  (8  bit): CRTC index
551          * offset + 4  (8  bit): mask
552          * offset + 5  (8  bit): shift
553          * offset + 6  (8  bit): IO flag condition index
554          * offset + 7  (8  bit): count
555          * offset + 8  (32 bit): register
556          * offset + 12 (16 bit): frequency 1
557          * ...
558          *
559          * Starting at offset + 12 there are "count" 16 bit frequencies (10kHz).
560          * Set PLL register "register" to coefficients for frequency n,
561          * selected by reading index "CRTC index" of "CRTC port" ANDed with
562          * "mask" and shifted right by "shift". If "IO flag condition index" > 0,
563          * and condition met, double frequency before setting it.
564          */
565
566         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
567         uint8_t crtcindex = bios->data[offset + 3];
568         uint8_t mask = bios->data[offset + 4];
569         uint8_t shift = bios->data[offset + 5];
570         int8_t io_flag_condition_idx = bios->data[offset + 6];
571         uint8_t count = bios->data[offset + 7];
572         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 8])));
573         uint8_t config;
574         uint16_t freq;
575
576         if (!iexec->execute)
577                 return TRUE;
578
579         if (DEBUGLEVEL >= 6)
580                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
581                            "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, Shift: 0x%02X, IO Flag Condition: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
582                            offset, crtcport, crtcindex, mask, shift, io_flag_condition_idx, count, reg);
583
584         nv_idx_port_rd(pScrn, crtcport, crtcindex, &config);
585         config = (config & mask) >> shift;
586         if (config > count) {
587                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
588                            "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
589                            offset, config, count);
590                 return FALSE;
591         }
592
593         freq = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 12 + config * 2])));
594
595         if (io_flag_condition_idx > 0) {
596                 if (io_flag_condition(pScrn, bios, offset, io_flag_condition_idx)) {
597                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
598                                    "0x%04X: CONDITION FULFILLED - FREQ DOUBLED\n", offset);
599                         freq *= 2;
600                 } else
601                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
602                                    "0x%04X: CONDITION IS NOT FULFILLED. FREQ UNCHANGED\n", offset);
603         }
604
605         if (DEBUGLEVEL >= 6)
606                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
607                            "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %d0kHz\n",
608                            offset, reg, config, freq);
609
610         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%04X: [ NOT YET IMPLEMENTED ]\n", offset);
611
612 #if 0
613         switch (reg) {
614         case 0x00004004:
615                 configval = 0x01014E07;
616                 break;
617         case 0x00004024:
618                 configval = 0x13030E02;
619                 break;
620         }
621 #endif
622         return TRUE;
623 }
624
625 static Bool init_end_repeat(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
626 {
627         /* INIT_END_REPEAT   opcode: 0x36 ('6')
628          *
629          * offset      (8 bit): opcode
630          *
631          * Marks the end of the block for INIT_REPEAT to repeat
632          */
633
634         /* no iexec->execute check by design */
635
636         /* iexec->repeat flag necessary to go past INIT_END_REPEAT opcode when
637          * we're not in repeat mode
638          */
639         if (iexec->repeat)
640                 return FALSE;
641
642         return TRUE;
643 }
644
645 static Bool init_copy(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
646 {
647         /* INIT_COPY   opcode: 0x37 ('7')
648          *
649          * offset      (8  bit): opcode
650          * offset + 1  (32 bit): register
651          * offset + 5  (8  bit): shift
652          * offset + 6  (8  bit): srcmask
653          * offset + 7  (16 bit): CRTC port
654          * offset + 9  (8 bit): CRTC index
655          * offset + 10  (8 bit): mask
656          *
657          * Read index "CRTC index" on "CRTC port", AND with "mask", OR with
658          * (REGVAL("register") >> "shift" & "srcmask") and write-back to CRTC port
659          */
660
661         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
662         uint8_t shift = bios->data[offset + 5];
663         uint8_t srcmask = bios->data[offset + 6];
664         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 7])));
665         uint8_t crtcindex = bios->data[offset + 9];
666         uint8_t mask = bios->data[offset + 10];
667         uint32_t data;
668         uint8_t crtcdata;
669
670         if (!iexec->execute)
671                 return TRUE;
672
673         if (DEBUGLEVEL >= 6)
674                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
675                            "0x%04X: Reg: 0x%08X, Shift: 0x%02X, SrcMask: 0x%02X, Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X\n",
676                            offset, reg, shift, srcmask, crtcport, crtcindex, mask);
677
678         nv32_rd(pScrn, reg, &data);
679
680         if (shift < 0x80)
681                 data >>= shift;
682         else
683                 data <<= (0x100 - shift);
684
685         data &= srcmask;
686
687         nv_idx_port_rd(pScrn, crtcport, crtcindex, &crtcdata);
688         crtcdata = (crtcdata & mask) | (uint8_t)data;
689         nv_idx_port_wr(pScrn, crtcport, crtcindex, crtcdata);
690
691         return TRUE;
692 }
693
694 static Bool init_not(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
695 {
696         /* INIT_NOT   opcode: 0x38 ('8')
697          *
698          * offset      (8  bit): opcode
699          *
700          * Invert the current execute / no-execute condition (i.e. "else")
701          */
702         if (iexec->execute)
703                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
704                            "0x%04X: ------ SKIPPING FOLLOWING COMMANDS  ------\n", offset);
705         else
706                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
707                            "0x%04X: ------ EXECUTING FOLLOWING COMMANDS ------\n", offset);
708
709         iexec->execute = !iexec->execute;
710         return TRUE;
711 }
712
713 static Bool init_io_flag_condition(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
714 {
715         /* INIT_IO_FLAG_CONDITION   opcode: 0x39 ('9')
716          *
717          * offset      (8 bit): opcode
718          * offset + 1  (8 bit): condition number
719          *
720          * Check condition "condition number" in the IO flag condition table.
721          * If condition not met skip subsequent opcodes until condition
722          * is inverted (INIT_NOT), or we hit INIT_RESUME
723          */
724
725         uint8_t cond = bios->data[offset + 1];
726
727         if (!iexec->execute)
728                 return TRUE;
729
730         if (io_flag_condition(pScrn, bios, offset, cond))
731                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
732                            "0x%04X: CONDITION FULFILLED - CONTINUING TO EXECUTE\n", offset);
733         else {
734                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
735                            "0x%04X: CONDITION IS NOT FULFILLED.\n", offset);
736                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
737                            "0x%04X: ------ SKIPPING FOLLOWING COMMANDS  ------\n", offset);
738                 iexec->execute = FALSE;
739         }
740
741         return TRUE;
742 }
743
744 Bool init_idx_addr_latched(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
745 {
746         /* INIT_INDEX_ADDRESS_LATCHED   opcode: 0x49 ('I')
747          *
748          * offset      (8  bit): opcode
749          * offset + 1  (32 bit): control register
750          * offset + 5  (32 bit): data register
751          * offset + 9  (32 bit): mask
752          * offset + 13 (32 bit): data
753          * offset + 17 (8  bit): count
754          * offset + 18 (8  bit): address 1
755          * offset + 19 (8  bit): data 1
756          * ...
757          *
758          * For each of "count" address and data pairs, write "data n" to "data register",
759          * read the current value of "control register", and write it back once ANDed
760          * with "mask", ORed with "data", and ORed with "address n"
761          */
762
763         uint32_t controlreg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
764         uint32_t datareg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
765         uint32_t mask = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 9])));
766         uint32_t data = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 13])));
767         uint8_t count = bios->data[offset + 17];
768         uint32_t value;
769         int i;
770
771         if (!iexec->execute)
772                 return TRUE;
773
774         if (DEBUGLEVEL >= 6)
775                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
776                            "0x%04X: ControlReg: 0x%08X, DataReg: 0x%08X, Mask: 0x%08X, Data: 0x%08X, Count: 0x%02X\n",
777                            offset, controlreg, datareg, mask, data, count);
778
779         for (i = 0; i < count; i++) {
780                 uint8_t instaddress = bios->data[offset + 18 + i * 2];
781                 uint8_t instdata = bios->data[offset + 19 + i * 2];
782
783                 if (DEBUGLEVEL >= 6)
784                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
785                                    "0x%04X: Address: 0x%02X, Data: 0x%02X\n", offset, instaddress, instdata);
786
787                 nv32_wr(pScrn, datareg, instdata);
788
789                 nv32_rd(pScrn, controlreg, &value);
790                 value = (value & mask) | data | instaddress;
791
792                 nv32_wr(pScrn, controlreg, value);
793         }
794
795         return TRUE;
796 }
797
798 static Bool init_io_restrict_pll2(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
799 {
800         /* INIT_IO_RESTRICT_PLL2   opcode: 0x4A ('J')
801          *
802          * offset      (8  bit): opcode
803          * offset + 1  (16 bit): CRTC port
804          * offset + 3  (8  bit): CRTC index
805          * offset + 4  (8  bit): mask
806          * offset + 5  (8  bit): shift
807          * offset + 6  (8  bit): count
808          * offset + 7  (32 bit): register
809          * offset + 11 (32 bit): frequency 1
810          * ...
811          *
812          * Starting at offset + 11 there are "count" 32 bit frequencies (kHz).
813          * Set PLL register "register" to coefficients for frequency n,
814          * selected by reading index "CRTC index" of "CRTC port" ANDed with
815          * "mask" and shifted right by "shift".
816          */
817
818         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
819         uint8_t crtcindex = bios->data[offset + 3];
820         uint8_t mask = bios->data[offset + 4];
821         uint8_t shift = bios->data[offset + 5];
822         uint8_t count = bios->data[offset + 6];
823         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 7])));
824         uint8_t config;
825         uint32_t freq;
826
827         if (!iexec->execute)
828                 return TRUE;
829
830         if (DEBUGLEVEL >= 6)
831                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
832                            "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
833                            offset, crtcport, crtcindex, mask, shift, count, reg);
834
835         if (!reg)
836                 return TRUE;
837
838         nv_idx_port_rd(pScrn, crtcport, crtcindex, &config);
839         config = (config & mask) >> shift;
840         if (config > count) {
841                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
842                            "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
843                            offset, config, count);
844                 return FALSE;
845         }
846
847         freq = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 11 + config * 4])));
848
849         if (DEBUGLEVEL >= 6)
850                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
851                            "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %dkHz\n",
852                            offset, reg, config, freq);
853
854         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%04X: [ NOT YET IMPLEMENTED ]\n", offset);
855
856         return TRUE;
857 }
858
859 static Bool init_pll2(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
860 {
861         /* INIT_PLL2   opcode: 0x4B ('K')
862          *
863          * offset      (8  bit): opcode
864          * offset + 1  (32 bit): register
865          * offset + 5  (32 bit): freq
866          *
867          * Set PLL register "register" to coefficients for frequency "freq"
868          */
869
870         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
871         uint32_t freq = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
872
873         if (!iexec->execute)
874                 return TRUE;
875
876         if (DEBUGLEVEL >= 6)
877                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
878                            "0x%04X: Reg: 0x%04X, Freq: %dkHz\n",
879                            offset, reg, freq);
880
881         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%04X: [ NOT YET IMPLEMENTED ]\n", offset);
882
883         return TRUE;
884 }
885
886 static uint32_t get_tmds_index_reg(ScrnInfoPtr pScrn, uint8_t mlv)
887 {
888         /* For mlv < 0x80, it is an index into a table of TMDS base addresses
889          * For mlv == 0x80 use the "or" value of the dcb_entry indexed by CR58 for CR57 = 0
890          * to index a table of offsets to the basic 0x6808b0 address
891          * For mlv == 0x81 use the "or" value of the dcb_entry indexed by CR58 for CR57 = 0
892          * to index a table of offsets to the basic 0x6808b0 address, and then flip the offset by 8
893          */
894
895         NVPtr pNv = NVPTR(pScrn);
896         int pramdac_offset[13] = {0, 0, 0x8, 0, 0x2000, 0, 0, 0, 0x2008, 0, 0, 0, 0x2000};
897         uint32_t pramdac_table[4] = {0x6808b0, 0x6808b8, 0x6828b0, 0x6828b8};
898
899         if (mlv >= 0x80) {
900                 /* here we assume that the DCB table has already been parsed */
901                 uint8_t dcb_entry;
902                 int dacoffset;
903                 /* This register needs to be written to set index for reading CR58 */
904                 nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, 0x57, 0);
905                 nv_idx_port_rd(pScrn, CRTC_INDEX_COLOR, 0x58, &dcb_entry);
906                 if (dcb_entry > pNv->dcb_table.entries) {
907                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
908                                    "CR58 doesn't have a valid DCB entry currently (%02X)\n", dcb_entry);
909                         return FALSE;
910                 }
911                 dacoffset = pramdac_offset[pNv->dcb_table.entry[dcb_entry].or];
912                 if (mlv == 0x81)
913                         dacoffset ^= 8;
914                 return (0x6808b0 + dacoffset);
915         } else {
916                 if (mlv > (sizeof(pramdac_table) / sizeof(uint32_t))) {
917                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
918                                    "Magic Lookup Value too big (%02X)\n", mlv);
919                         return FALSE;
920                 }
921                 return pramdac_table[mlv];
922         }
923 }
924
925 static Bool init_4f(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
926 {
927         /* INIT_4F   opcode: 0x4F ('O')
928          *
929          * offset      (8 bit): opcode
930          * offset + 1  (8 bit): magic lookup value
931          * offset + 2  (8 bit): TMDS address
932          * offset + 3  (8 bit): mask
933          * offset + 4  (8 bit): data
934          *
935          * Read the data reg for TMDS address "TMDS address", AND it with mask
936          * and OR it with data, then write it back
937          * "magic lookup value" determines which TMDS base address register is used --
938          * see get_tmds_index_reg()
939          */
940
941         uint8_t mlv = bios->data[offset + 1];
942         uint32_t tmdsaddr = bios->data[offset + 2];
943         uint8_t mask = bios->data[offset + 3];
944         uint8_t data = bios->data[offset + 4];
945         uint32_t reg, value;
946
947         if (!iexec->execute)
948                 return TRUE;
949
950         if (DEBUGLEVEL >= 6)
951                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
952                            "0x%04X: MagicLookupValue: 0x%02X, TMDSAddr: 0x%02X, Mask: 0x%02X, Data: 0x%02X\n",
953                            offset, mlv, tmdsaddr, mask, data);
954
955         reg = get_tmds_index_reg(pScrn, mlv);
956
957         nv32_wr(pScrn, reg, tmdsaddr | 0x10000);
958         nv32_rd(pScrn, reg + 4, &value);
959         value = (value & mask) | data;
960         nv32_wr(pScrn, reg + 4, value);
961         nv32_wr(pScrn, reg, tmdsaddr);
962
963         return TRUE;
964 }
965
966 Bool init_50(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
967 {
968         /* INIT_50   opcode: 0x50 ('P')
969          *
970          * offset      (8 bit): opcode
971          * offset + 1  (8 bit): magic lookup value
972          * offset + 2  (8 bit): count
973          * offset + 3  (8 bit): addr 1
974          * offset + 4  (8 bit): data 1
975          * ...
976          *
977          * For each of "count" TMDS address and data pairs write "data n" to "addr n"
978          * "magic lookup value" determines which TMDS base address register is used --
979          * see get_tmds_index_reg()
980          */
981
982         uint8_t mlv = bios->data[offset + 1];
983         uint8_t count = bios->data[offset + 2];
984         uint32_t reg;
985         int i;
986
987         if (!iexec->execute)
988                 return TRUE;
989
990         if (DEBUGLEVEL >= 6)
991                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
992                            "0x%04X: MagicLookupValue: 0x%02X, Count: 0x%02X\n",
993                            offset, mlv, count);
994
995         reg = get_tmds_index_reg(pScrn, mlv);
996
997         for (i = 0; i < count; i++) {
998                 uint8_t tmdsaddr = bios->data[offset + 3 + i * 2];
999                 uint8_t tmdsdata = bios->data[offset + 4 + i * 2];
1000
1001                 nv32_wr(pScrn, reg + 4, tmdsdata);
1002                 nv32_wr(pScrn, reg, tmdsaddr);
1003         }
1004
1005         return TRUE;
1006 }
1007         
1008 Bool init_cr_idx_adr_latch(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1009 {
1010         /* INIT_CR_INDEX_ADDRESS_LATCHED   opcode: 0x51 ('Q')
1011          *
1012          * offset      (8 bit): opcode
1013          * offset + 1  (8 bit): CRTC index1
1014          * offset + 2  (8 bit): CRTC index2
1015          * offset + 3  (8 bit): baseaddr
1016          * offset + 4  (8 bit): count
1017          * offset + 5  (8 bit): data 1
1018          * ...
1019          *
1020          * For each of "count" address and data pairs, write "baseaddr + n" to
1021          * "CRTC index1" and "data n" to "CRTC index2"
1022          * Once complete, restore initial value read from "CRTC index1"
1023          */
1024         uint8_t crtcindex1 = bios->data[offset + 1];
1025         uint8_t crtcindex2 = bios->data[offset + 2];
1026         uint8_t baseaddr = bios->data[offset + 3];
1027         uint8_t count = bios->data[offset + 4];
1028         uint8_t oldaddr, data;
1029         int i;
1030
1031         if (!iexec->execute)
1032                 return TRUE;
1033
1034         if (DEBUGLEVEL >= 6)
1035                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1036                            "0x%04X: Index1: 0x%02X, Index2: 0x%02X, BaseAddr: 0x%02X, Count: 0x%02X\n",
1037                            offset, crtcindex1, crtcindex2, baseaddr, count);
1038
1039         nv_idx_port_rd(pScrn, CRTC_INDEX_COLOR, crtcindex1, &oldaddr);
1040
1041         for (i = 0; i < count; i++) {
1042                 nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, crtcindex1, baseaddr + i);
1043
1044                 data = bios->data[offset + 5 + i];
1045                 nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, crtcindex2, data);
1046         }
1047
1048         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, crtcindex1, oldaddr);
1049
1050         return TRUE;
1051 }
1052
1053 Bool init_cr(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1054 {
1055         /* INIT_CR   opcode: 0x52 ('R')
1056          *
1057          * offset      (8  bit): opcode
1058          * offset + 1  (8  bit): CRTC index
1059          * offset + 2  (8  bit): mask
1060          * offset + 3  (8  bit): data
1061          *
1062          * Assign the value of at "CRTC index" ANDed with mask and ORed with data
1063          * back to "CRTC index"
1064          */
1065
1066         uint8_t crtcindex = bios->data[offset + 1];
1067         uint8_t mask = bios->data[offset + 2];
1068         uint8_t data = bios->data[offset + 3];
1069         uint8_t value;
1070
1071         if (!iexec->execute)
1072                 return TRUE;
1073
1074         if (DEBUGLEVEL >= 6)
1075                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1076                            "0x%04X: Index: 0x%02X, Mask: 0x%02X, Data: 0x%02X\n",
1077                            offset, crtcindex, mask, data);
1078
1079         nv_idx_port_rd(pScrn, CRTC_INDEX_COLOR, crtcindex, &value);
1080
1081         value = (value & mask) | data;
1082
1083         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, crtcindex, value);
1084
1085         return TRUE;
1086 }
1087
1088 static Bool init_zm_cr(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1089 {
1090         /* INIT_ZM_CR   opcode: 0x53 ('S')
1091          *
1092          * offset      (8 bit): opcode
1093          * offset + 1  (8 bit): CRTC index
1094          * offset + 2  (8 bit): value
1095          *
1096          * Assign "value" to CRTC register with index "CRTC index".
1097          */
1098
1099         uint8_t crtcindex = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1100         uint8_t data = bios->data[offset + 2];
1101
1102         if (!iexec->execute)
1103                 return TRUE;
1104
1105         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, crtcindex, data);
1106
1107         return TRUE;
1108 }
1109
1110 static Bool init_zm_cr_group(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1111 {
1112         /* INIT_ZM_CR   opcode: 0x54 ('T')
1113          * 
1114          * offset      (8 bit): opcode
1115          * offset + 1  (8 bit): count
1116          * offset + 2  (8 bit): CRTC index 1
1117          * offset + 3  (8 bit): value 1
1118          * ...
1119          * 
1120          * For "count", assign "value n" to CRTC register with index "CRTC index n".
1121          */
1122     
1123         uint8_t count = bios->data[offset + 1];
1124         int i;
1125         
1126         if (!iexec->execute)
1127                 return TRUE;
1128
1129         for (i = 0; i < count; i++)
1130                 init_zm_cr(pScrn, bios, offset + 2 + 2 * i - 1, iexec);
1131
1132         return TRUE;
1133 }
1134
1135 static Bool init_condition_time(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1136 {
1137         /* INIT_CONDITION_TIME   opcode: 0x56 ('V')
1138          *
1139          * offset      (8 bit): opcode
1140          * offset + 1  (8 bit): condition number
1141          *
1142          * Check condition "condition number" in the condition table.
1143          * The condition table entry has 4 bytes for the address of the
1144          * register to check, 4 bytes for a mask and 4 for a test value.
1145          * If condition not met sleep for 2ms
1146          */
1147
1148         // this opcode makes no sense. it seems to do some competely useless things
1149         uint8_t cond = bios->data[offset + 1];
1150 //      uint16_t b = bios->data[offset + 2];    // this needs printing
1151         uint16_t condptr = bios->condition_tbl_ptr + cond * CONDITION_SIZE;
1152         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[condptr])));
1153         uint32_t mask = le32_to_cpu(*((uint32_t *)(&bios->data[condptr + 4])));
1154         uint32_t cmpval = le32_to_cpu(*((uint32_t *)(&bios->data[condptr + 8])));
1155         uint32_t data;
1156
1157         if (!iexec->execute)
1158                 return TRUE;
1159
1160         if (DEBUGLEVEL >= 6)
1161                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1162                            "0x%04X: Cond: 0x%02X, Reg: 0x%08X, Mask: 0x%08X, Cmpval: 0x%08X\n",
1163                            offset, cond, reg, mask, cmpval);
1164
1165 //      b *= 50;
1166         reg &= 0xfffffffc;      // FIXME: this not in init_condition() - should it be?
1167
1168         nv32_rd(pScrn, reg, &data);
1169         data &= mask;
1170
1171         if (DEBUGLEVEL >= 6)
1172                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1173                            "0x%04X: Checking if 0x%08X equals 0x%08X\n",
1174                            offset, data, cmpval);
1175
1176         if (data != cmpval) {
1177                 if (DEBUGLEVEL >= 6)
1178                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1179                                    "0x%04X: Condition not met, sleeping for 2ms\n", offset);
1180 //              reg--;
1181                 usleep(2000);
1182         } else
1183                 if (DEBUGLEVEL >= 6)
1184                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1185                                    "0x%04X: Condition met, continuing\n", offset);
1186
1187         return TRUE;
1188 }
1189
1190 static Bool init_zm_reg_sequence(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1191 {
1192         /* INIT_ZM_REG_SEQUENCE   opcode: 0x58 ('X')
1193          * 
1194          * offset      (8  bit): opcode
1195          * offset + 1  (32 bit): base register
1196          * offset + 5  (8  bit): count
1197          * offset + 6  (32 bit): value 1
1198          * ...
1199          * 
1200          * Starting at offset + 6 there are "count" 32 bit values.
1201          * For "count" iterations set "base register" + 4 * current_iteration
1202          * to "value current_iteration"
1203          */
1204
1205         uint32_t basereg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1206         uint32_t count = bios->data[offset + 5];
1207         int i;
1208
1209         if (!iexec->execute)
1210                 return TRUE;
1211
1212         if (DEBUGLEVEL >= 6)
1213                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1214                            "0x%04X: BaseReg: 0x%08X, Count: 0x%02X\n",
1215                            offset, basereg, count);
1216
1217         for (i = 0; i < count; i++) {
1218                 uint32_t reg = basereg + i * 4;
1219                 uint32_t data = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 6 + i * 4])));
1220
1221                 nv32_wr(pScrn, reg, data);
1222         }
1223
1224         return TRUE;
1225 }
1226
1227 static Bool init_indirect_reg(ScrnInfoPtr pScrn, bios_t *bios, CARD16 offset, init_exec_t *iexec)
1228 {
1229         /* INIT_INDIRECT_REG opcode: 0x5A
1230          * 
1231          * offset      (8  bit): opcode
1232          * offset + 1  (32 bit): register
1233          * offset + 5  (16 bit): adress offset (in bios)
1234          *
1235          * Lookup value at offset data in the bios and write it to reg
1236          */
1237         CARD32 reg = *((CARD32 *) (&bios->data[offset + 1]));
1238         CARD16 data = le16_to_cpu(*((CARD16 *) (&bios->data[offset + 5])));
1239         CARD32 data2 = bios->data[data];
1240
1241         if (iexec->execute) {
1242                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  
1243                                 "0x%04X: REG: 0x%04X, DATA AT: 0x%04X, VALUE IS: 0x%08X\n", 
1244                                 offset, reg, data, data2);
1245
1246                 if (DEBUGLEVEL >= 6) {
1247                         CARD32 tmpval;
1248                         nv32_rd(pScrn, reg, &tmpval);
1249                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CURRENT VALUE IS: 0x%08X\n", offset, tmpval);
1250                 }
1251
1252                 nv32_wr(pScrn, reg, data2);
1253         }
1254         return TRUE;
1255 }
1256
1257 static Bool init_sub_direct(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1258 {
1259         /* INIT_SUB_DIRECT   opcode: 0x5B ('[')
1260          * 
1261          * offset      (8  bit): opcode
1262          * offset + 1  (16 bit): subroutine offset (in bios)
1263          *
1264          * Calls a subroutine that will execute commands until INIT_DONE
1265          * is found. 
1266          */
1267
1268         uint16_t sub_offset = le16_to_cpu(*((uint16_t *) (&bios->data[offset + 1])));
1269
1270         if (!iexec->execute)
1271                 return TRUE;
1272
1273         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: EXECUTING SUB-ROUTINE AT 0x%04X\n",
1274                         offset, sub_offset);
1275
1276         parse_init_table(pScrn, bios, sub_offset, iexec);
1277
1278         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: END OF SUB-ROUTINE AT 0x%04X\n",
1279                         offset, sub_offset);
1280
1281         return TRUE;
1282 }
1283
1284 static Bool init_copy_nv_reg(ScrnInfoPtr pScrn, bios_t *bios, CARD16 offset, init_exec_t *iexec)
1285 {   
1286         CARD32 srcreg = *((CARD32 *) (&bios->data[offset + 1]));
1287         CARD8 shift = *((CARD8 *) (&bios->data[offset + 5]));
1288         CARD32 and1 = *((CARD32 *) (&bios->data[offset + 6]));
1289         CARD32 xor = *((CARD32 *) (&bios->data[offset + 10]));
1290         CARD32 dstreg = *((CARD32 *) (&bios->data[offset + 14]));
1291         CARD32 and2 = *((CARD32 *) (&bios->data[offset + 18]));
1292         CARD32 srcdata;
1293         CARD32 dstdata;
1294         
1295         if (iexec->execute) {
1296                 nv32_rd(pScrn, srcreg, &srcdata);
1297                 
1298                 if (shift > 0)
1299                         srcdata >>= shift;
1300                 else
1301                         srcdata <<= shift;
1302
1303                 srcdata = (srcdata & and1) ^ xor;
1304
1305                 nv32_rd(pScrn, dstreg, &dstdata);
1306                 dstdata &= and2;
1307
1308                 dstdata |= srcdata;
1309
1310                 CARD32 tmp;             
1311                 nv32_rd(pScrn, dstreg, &tmp);
1312
1313                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: REG: 0x%08X, VALUE: 0x%08X\n", offset, dstreg, 
1314                                 dstdata);
1315
1316                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CURRENT VALUE IS: 0x%08X\n", offset, tmp);
1317
1318                 nv32_wr(pScrn, dstreg, dstdata);
1319         }
1320         return TRUE;
1321 }
1322
1323 static Bool init_zm_index_io(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1324 {
1325         /* INIT_ZM_INDEX_IO   opcode: 0x62 ('b')
1326          *
1327          * offset      (8  bit): opcode
1328          * offset + 1  (16 bit): CRTC port
1329          * offset + 3  (8  bit): CRTC index
1330          * offset + 4  (8  bit): data
1331          *
1332          * Write "data" to index "CRTC index" of "CRTC port"
1333          */
1334         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
1335         uint8_t crtcindex = bios->data[offset + 3];
1336         uint8_t data = bios->data[offset + 4];
1337
1338         if (!iexec->execute)
1339                 return TRUE;
1340
1341         nv_idx_port_wr(pScrn, crtcport, crtcindex, data);
1342
1343         return TRUE;
1344 }
1345
1346 static Bool init_compute_mem(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1347 {
1348         /* INIT_COMPUTE_MEM   opcode: 0x63 ('c')
1349          *
1350          * offset      (8 bit): opcode
1351          *
1352          * FIXME
1353          */
1354
1355         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%04X: [ NOT YET IMPLEMENTED ]\n", offset);
1356 #if 0
1357         uint16_t ramcfg = le16_to_cpu(*((uint16_t *)(&bios->data[bios->ram_table_offset])));
1358         uint32_t pfb_debug;
1359         uint32_t strapinfo;
1360         uint32_t ramcfg2;
1361
1362         if (!iexec->execute)
1363                 return TRUE;
1364
1365         nv32_rd(pScrn, 0x00101000, &strapinfo);
1366         nv32_rd(pScrn, 0x00100080, &pfb_debug);
1367
1368         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "STRAPINFO: 0x%08X\n", strapinfo);
1369         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "PFB_DEBUG: 0x%08X\n", pfb_debug);
1370         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "RAM CFG: 0x%04X\n", ramcfg);
1371
1372         pfb_debug &= 0xffffffef;
1373         strapinfo >>= 2;
1374         strapinfo &= 0x0000000f;
1375         ramcfg2 = le16_to_cpu(*((uint16_t *)
1376                         (&bios->data[bios->ram_table_offset + (2 * strapinfo)])));
1377
1378         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "AFTER MANIPULATION\n");
1379         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "STRAPINFO: 0x%08X\n", strapinfo);
1380         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "PFB_DEBUG: 0x%08X\n", pfb_debug);
1381         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "RAM CFG2: 0x%08X\n", ramcfg2);
1382
1383
1384         uint32_t reg1;
1385         uint32_t reg2;
1386
1387         nv32_rd(pScrn, 0x00100200, &reg1);
1388         nv32_rd(pScrn, 0x0010020C, &reg2);
1389
1390         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x00100200: 0x%08X\n", reg1);
1391         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x0010020C: 0x%08X\n", reg2);
1392 #endif
1393
1394         return TRUE;
1395 }
1396
1397 static Bool init_reset(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1398 {
1399         /* INIT_RESET   opcode: 0x65 ('e')
1400          *
1401          * offset      (8  bit): opcode
1402          * offset + 1  (32 bit): register
1403          * offset + 5  (32 bit): value1
1404          * offset + 9  (32 bit): value2
1405          *
1406          * Assign "value1" to "register", then assign "value2" to "register"
1407          */
1408
1409         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1410         uint32_t value1 = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
1411         uint32_t value2 = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 9])));
1412         uint32_t pci_nv_19, pci_nv_20;
1413
1414         /* no iexec->execute check by design */
1415
1416         nv32_rd(pScrn, NV_PBUS_PCI_NV_19, &pci_nv_19);
1417         nv32_wr(pScrn, NV_PBUS_PCI_NV_19, 0);
1418         nv32_wr(pScrn, reg, value1);
1419
1420         usleep(10);
1421
1422         nv32_wr(pScrn, reg, value2);
1423         nv32_wr(pScrn, NV_PBUS_PCI_NV_19, pci_nv_19);
1424
1425         nv32_rd(pScrn, NV_PBUS_PCI_NV_20, &pci_nv_20);
1426         pci_nv_20 &= !NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED;     /* 0xfffffffe */
1427         nv32_wr(pScrn, NV_PBUS_PCI_NV_20, pci_nv_20);
1428
1429         return TRUE;
1430 }
1431
1432 static Bool init_index_io8(ScrnInfoPtr pScrn, bios_t *bios, CARD16 offset, init_exec_t *iexec)
1433 {
1434         /* INIT_INDEX_IO8   opcode: 0x69
1435          * 
1436          * offset      (8  bit): opcode
1437          * offset + 1  (16 bit): CRTC reg
1438          * offset + 3  (8  bit): and mask
1439          * offset + 4  (8  bit): or with
1440          * 
1441          * 
1442          */
1443
1444         NVPtr pNv = NVPTR(pScrn);
1445         volatile CARD8 *ptr = crtchead ? pNv->PCIO1 : pNv->PCIO0;
1446         CARD16 reg = le16_to_cpu(*((CARD16 *)(&bios->data[offset + 1])));
1447         CARD8 and  = *((CARD8 *)(&bios->data[offset + 3]));
1448         CARD8 or = *((CARD8 *)(&bios->data[offset + 4]));
1449         CARD8 data;
1450
1451         if (iexec->execute) {
1452                 data = (VGA_RD08(ptr, reg) & and) | or;
1453
1454                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  
1455                                 "0x%04X: CRTC REG: 0x%04X, VALUE: 0x%02X\n", 
1456                                 offset, reg, data);
1457                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CURRENT VALUE IS: 0x%02X\n", offset, 
1458                                 VGA_RD08(ptr, reg));
1459
1460 #ifdef PERFORM_WRITE
1461                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "init_index_io8 crtcreg 0x%X value 0x%X\n",reg,data);
1462                 still_alive();
1463                 VGA_WR08(ptr, reg, data);
1464 #endif
1465         }
1466         return TRUE;
1467 }
1468
1469 static Bool init_sub(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1470 {
1471         /* INIT_SUB   opcode: 0x6B ('k')
1472          *
1473          * offset      (8 bit): opcode
1474          * offset + 1  (8 bit): script number
1475          *
1476          * Execute script number "script number", as a subroutine
1477          */
1478
1479         uint8_t sub = bios->data[offset + 1];
1480
1481         if (!iexec->execute)
1482                 return TRUE;
1483
1484         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1485                    "0x%04X: EXECUTING SUB-SCRIPT %d\n", offset, sub);
1486
1487         parse_init_table(pScrn, bios,
1488                          le16_to_cpu(*((uint16_t *)(&bios->data[bios->init_script_tbls_ptr + sub * 2]))),
1489                          iexec);
1490
1491         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1492                    "0x%04X: END OF SUB-SCRIPT %d\n", offset, sub);
1493
1494         return TRUE;
1495 }
1496
1497 static Bool init_ram_condition(ScrnInfoPtr pScrn, bios_t *bios, CARD16 offset, init_exec_t *iexec)
1498 {
1499         /* INIT_RAM_CONDITION   opcode: 0x6D
1500          * 
1501          * offset      (8  bit): opcode
1502          * offset + 1  (8  bit): and mask
1503          * offset + 2  (8  bit): cmpval
1504          *
1505          * Test if (NV_PFB_BOOT & and mask) matches cmpval
1506          */
1507         NVPtr pNv = NVPTR(pScrn);
1508         CARD8 and = *((CARD8 *) (&bios->data[offset + 1]));
1509         CARD8 cmpval = *((CARD8 *) (&bios->data[offset + 2]));
1510         CARD32 data;
1511
1512         if (iexec->execute) {
1513                 data=(pNv->PFB[NV_PFB_BOOT/4])&and;
1514
1515                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  
1516                                 "0x%04X: CHECKING IF REGVAL: 0x%08X equals COND: 0x%08X\n",
1517                                 offset, data, cmpval);
1518
1519                 if (data == cmpval) {
1520                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  
1521                                         "0x%04X: CONDITION FULFILLED - CONTINUING TO EXECUTE\n",
1522                                         offset);
1523                 } else {
1524                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CONDITION IS NOT FULFILLED.\n", offset);
1525                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  
1526                                         "0x%04X: ------ SKIPPING FOLLOWING COMMANDS  ------\n", offset);
1527                         iexec->execute = FALSE;     
1528                 }
1529         }
1530         return TRUE;
1531 }
1532
1533 static Bool init_nv_reg(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1534 {
1535         /* INIT_NV_REG   opcode: 0x6E ('n')
1536          * 
1537          * offset      (8  bit): opcode
1538          * offset + 1  (32 bit): register
1539          * offset + 5  (32 bit): mask
1540          * offset + 9  (32 bit): data
1541          *
1542          * Assign ((REGVAL("register") & "mask") | "data") to "register"
1543          */
1544
1545         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1546         uint32_t mask = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
1547         uint32_t data = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 9])));
1548         uint32_t value;
1549
1550         if (!iexec->execute)
1551                 return TRUE;
1552
1553         if (DEBUGLEVEL >= 6)
1554                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1555                            "0x%04X: Reg: 0x%08X, Mask: 0x%08X, Data: 0x%08X\n",
1556                            offset, reg, mask, data);
1557
1558         nv32_rd(pScrn, reg, &value);
1559
1560         value = (value & mask) | data;
1561
1562         nv32_wr(pScrn, reg, value);
1563
1564         return TRUE;
1565 }
1566
1567 static Bool init_macro(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1568 {
1569         /* INIT_MACRO   opcode: 0x6F ('o')
1570          *
1571          * offset      (8 bit): opcode
1572          * offset + 1  (8 bit): macro number
1573          *
1574          * Look up macro index "macro number" in the macro index table.
1575          * The macro index table entry has 1 byte for the index in the macro table,
1576          * and 1 byte for the number of times to repeat the macro.
1577          * The macro table entry has 4 bytes for the register address and
1578          * 4 bytes for the value to write to that register
1579          */
1580
1581         uint8_t macro_index_tbl_idx = bios->data[offset + 1];
1582         uint16_t tmp = bios->macro_index_tbl_ptr + (macro_index_tbl_idx * MACRO_INDEX_SIZE);
1583         uint8_t macro_tbl_idx = bios->data[tmp];
1584         uint8_t count = bios->data[tmp + 1];
1585         uint32_t reg, data;
1586         int i;
1587
1588         if (!iexec->execute)
1589                 return TRUE;
1590
1591         if (DEBUGLEVEL >= 6)
1592                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1593                            "0x%04X: Macro: 0x%02X, MacroTableIndex: 0x%02X, Count: 0x%02X\n",
1594                            offset, macro_index_tbl_idx, macro_tbl_idx, count);
1595
1596         for (i = 0; i < count; i++) {
1597                 uint16_t macroentryptr = bios->macro_tbl_ptr + (macro_tbl_idx + i) * MACRO_SIZE;
1598
1599                 reg = le32_to_cpu(*((uint32_t *)(&bios->data[macroentryptr])));
1600                 data = le32_to_cpu(*((uint32_t *)(&bios->data[macroentryptr + 4])));
1601
1602                 nv32_wr(pScrn, reg, data);
1603         }
1604
1605         return TRUE;
1606 }
1607
1608 static Bool init_done(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1609 {
1610         /* INIT_DONE   opcode: 0x71 ('q')
1611          *
1612          * offset      (8  bit): opcode
1613          *
1614          * End the current script
1615          */
1616
1617         /* mild retval abuse to stop parsing this table */
1618         return FALSE;
1619 }
1620
1621 static Bool init_resume(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1622 {
1623         /* INIT_RESUME   opcode: 0x72 ('r')
1624          *
1625          * offset      (8  bit): opcode
1626          *
1627          * End the current execute / no-execute condition
1628          */
1629
1630         if (iexec->execute)
1631                 return TRUE;
1632
1633         iexec->execute = TRUE;;
1634         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1635                    "0x%04X: ---- EXECUTING FOLLOWING COMMANDS ----\n", offset);
1636
1637         return TRUE;
1638 }
1639
1640 static Bool init_ram_condition2(ScrnInfoPtr pScrn, bios_t *bios, CARD16 offset, init_exec_t *iexec)
1641 {
1642         /* INIT_RAM_CONDITION2   opcode: 0x73
1643          * 
1644          * offset      (8  bit): opcode
1645          * offset + 1  (8  bit): and mask
1646          * offset + 2  (8  bit): cmpval
1647          *
1648          * Test if (NV_EXTDEV_BOOT & and mask) matches cmpval
1649          */
1650         NVPtr pNv = NVPTR(pScrn);
1651         CARD32 and = *((CARD32 *) (&bios->data[offset + 1]));
1652         CARD32 cmpval = *((CARD32 *) (&bios->data[offset + 5]));
1653         CARD32 data;
1654
1655         if (iexec->execute) {
1656                 data=(nvReadEXTDEV(pNv, NV_PEXTDEV_BOOT))&and;
1657                 
1658                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,  
1659                                 "0x%04X: CHECKING IF REGVAL: 0x%08X equals COND: 0x%08X\n",
1660                                 offset, data, cmpval);
1661
1662                 if (data == cmpval) {
1663                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  
1664                                         "0x%04X: CONDITION FULFILLED - CONTINUING TO EXECUTE\n",
1665                                         offset);
1666                 } else {
1667                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  "0x%04X: CONDITION IS NOT FULFILLED.\n", offset);
1668                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,  
1669                                         "0x%04X: ------ SKIPPING FOLLOWING COMMANDS  ------\n", offset);
1670                         iexec->execute = FALSE;     
1671                 }
1672         }
1673         return TRUE;
1674 }
1675
1676 static Bool init_time(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1677 {
1678         /* INIT_TIME   opcode: 0x74 ('t')
1679          * 
1680          * offset      (8  bit): opcode
1681          * offset + 1  (16 bit): time
1682          * 
1683          * Sleep for "time" microseconds.
1684          */
1685
1686         uint16_t time = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
1687
1688         if (!iexec->execute)
1689                 return TRUE;
1690
1691         if (DEBUGLEVEL >= 6)
1692                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1693                            "0x%04X: Sleeping for 0x%04X microseconds.\n", offset, time);
1694
1695         usleep(time);
1696
1697         return TRUE;
1698 }
1699
1700 static Bool init_condition(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1701 {
1702         /* INIT_CONDITION   opcode: 0x75 ('u')
1703          *
1704          * offset      (8 bit): opcode
1705          * offset + 1  (8 bit): condition number
1706          *
1707          * Check condition "condition number" in the condition table.
1708          * The condition table entry has 4 bytes for the address of the
1709          * register to check, 4 bytes for a mask and 4 for a test value.
1710          * If condition not met skip subsequent opcodes until condition
1711          * is inverted (INIT_NOT), or we hit INIT_RESUME
1712          */
1713
1714         uint8_t cond = bios->data[offset + 1];
1715         uint16_t condptr = bios->condition_tbl_ptr + cond * CONDITION_SIZE;
1716         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[condptr])));
1717         uint32_t mask = le32_to_cpu(*((uint32_t *)(&bios->data[condptr + 4])));
1718         uint32_t cmpval = le32_to_cpu(*((uint32_t *)(&bios->data[condptr + 8])));
1719         uint32_t data;
1720
1721         if (!iexec->execute)
1722                 return TRUE;
1723
1724         if (DEBUGLEVEL >= 6)
1725                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1726                            "0x%04X: Cond: 0x%02X, Reg: 0x%08X, Mask: 0x%08X, Cmpval: 0x%08X\n",
1727                            offset, cond, reg, mask, cmpval);
1728
1729         nv32_rd(pScrn, reg, &data);
1730         data &= mask;
1731
1732         if (DEBUGLEVEL >= 6)
1733                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1734                            "0x%04X: Checking if 0x%08X equals 0x%08X\n",
1735                            offset, data, cmpval);
1736
1737         if (data == cmpval) {
1738                 if (DEBUGLEVEL >= 6)
1739                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1740                                    "0x%04X: CONDITION FULFILLED - CONTINUING TO EXECUTE\n", offset);
1741         } else {
1742                 if (DEBUGLEVEL >= 6)
1743                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1744                                    "0x%04X: CONDITION IS NOT FULFILLED.\n", offset);
1745                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1746                            "0x%04X: ------ SKIPPING FOLLOWING COMMANDS  ------\n", offset);
1747                 iexec->execute = FALSE;
1748         }
1749
1750         return TRUE;
1751 }
1752
1753 static Bool init_index_io(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1754 {
1755         /* INIT_INDEX_IO   opcode: 0x78 ('x')
1756          * 
1757          * offset      (8  bit): opcode
1758          * offset + 1  (16 bit): CRTC port
1759          * offset + 3  (8  bit): CRTC index
1760          * offset + 4  (8  bit): mask
1761          * offset + 5  (8  bit): data
1762          * 
1763          * Read value at index "CRTC index" on "CRTC port", AND with "mask", OR with "data", write-back
1764          */
1765
1766         uint16_t crtcport = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 1])));
1767         uint8_t crtcindex = bios->data[offset + 3];
1768         uint8_t mask = bios->data[offset + 4];
1769         uint8_t data = bios->data[offset + 5];
1770         uint8_t value;
1771         
1772         if (!iexec->execute)
1773                 return TRUE;
1774
1775         if (DEBUGLEVEL >= 6)
1776                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1777                            "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, Data: 0x%02X\n",
1778                            offset, crtcport, crtcindex, mask, data);
1779
1780         nv_idx_port_rd(pScrn, crtcport, crtcindex, &value);
1781         value = (value & mask) | data;
1782         nv_idx_port_wr(pScrn, crtcport, crtcindex, value);
1783
1784         return TRUE;
1785 }
1786
1787 static Bool init_pll(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1788 {
1789         /* INIT_PLL   opcode: 0x79 ('y')
1790          *
1791          * offset      (8  bit): opcode
1792          * offset + 1  (32 bit): register
1793          * offset + 5  (16 bit): freq
1794          *
1795          * Set PLL register "register" to coefficients for frequency (10kHz) "freq"
1796          */
1797
1798         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1799         uint16_t freq = le16_to_cpu(*((uint16_t *)(&bios->data[offset + 5])));
1800
1801         if (!iexec->execute)
1802                 return TRUE;
1803
1804         if (DEBUGLEVEL >= 6)
1805                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1806                            "0x%04X: Reg: 0x%08X, Freq: %d0kHz\n",
1807                            offset, reg, freq);
1808
1809         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%04X: [ NOT YET IMPLEMENTED ]\n", offset);
1810
1811 #if 0
1812         switch (reg) {
1813                 case 0x00680508:
1814                 configval = 0x00011F05;
1815                 break;
1816         }
1817 #endif
1818         return TRUE;
1819 }
1820
1821 static Bool init_zm_reg(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1822 {
1823         /* INIT_ZM_REG   opcode: 0x7A ('z')
1824          * 
1825          * offset      (8  bit): opcode
1826          * offset + 1  (32 bit): register
1827          * offset + 5  (32 bit): value
1828          * 
1829          * Assign "value" to "register"
1830          */
1831
1832         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1833         uint32_t value = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
1834
1835         if (!iexec->execute)
1836                 return TRUE;
1837
1838         nv32_wr(pScrn, reg, value);
1839
1840         return TRUE;
1841 }
1842
1843 /* hack to avoid moving the itbl_entry array before this function */
1844 int init_ram_restrict_zm_reg_group_blocklen = 0;
1845
1846 static Bool init_ram_restrict_zm_reg_group(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1847 {
1848         /* INIT_RAM_RESTRICT_ZM_REG_GROUP   opcode: 0x8F ('')
1849          *
1850          * offset      (8  bit): opcode
1851          * offset + 1  (32 bit): reg
1852          * offset + 5  (8  bit): regincrement
1853          * offset + 6  (8  bit): count
1854          * offset + 7  (32 bit): value 1,1
1855          * ...
1856          *
1857          * Use the RAMCFG strap of PEXTDEV_BOOT as an index into the table at
1858          * ram_restrict_table_ptr. The value read from here is 'n', and
1859          * "value 1,n" gets written to "reg". This repeats "count" times and on
1860          * each iteration 'm', "reg" increases by "regincrement" and
1861          * "value m,n" is used. The extent of n is limited by a number read
1862          * from the 'M' BIT table, herein called "blocklen"
1863          */
1864
1865         NVPtr pNv = NVPTR(pScrn);
1866         uint32_t reg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1867         uint8_t regincrement = bios->data[offset + 5];
1868         uint8_t count = bios->data[offset + 6];
1869         uint32_t strap_ramcfg, data;
1870         uint16_t blocklen;
1871         uint8_t index;
1872         int i;
1873
1874         /* previously set by 'M' BIT table */
1875         blocklen = init_ram_restrict_zm_reg_group_blocklen;
1876
1877         if (!iexec->execute)
1878                 return TRUE;
1879
1880         if (!blocklen) {
1881                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1882                            "0x%04X: Zero block length - has the M table been parsed?\n", offset);
1883                 return FALSE;
1884         }
1885
1886         strap_ramcfg = (nvReadEXTDEV(pNv, NV_PEXTDEV_BOOT) >> 2) & 0xf;
1887         index = bios->data[bios->ram_restrict_tbl_ptr + strap_ramcfg];
1888
1889         if (DEBUGLEVEL >= 6)
1890                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
1891                            "0x%04X: Reg: 0x%08X, RegIncrement: 0x%02X, Count: 0x%02X, StrapRamCfg: 0x%02X, Index: 0x%02X\n",
1892                            offset, reg, regincrement, count, strap_ramcfg, index);
1893
1894         for (i = 0; i < count; i++) {
1895                 data = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 7 + index * 4 + blocklen * i])));
1896
1897                 nv32_wr(pScrn, reg, data);
1898
1899                 reg += regincrement;
1900         }
1901
1902         return TRUE;
1903 }
1904
1905 static Bool init_copy_zm_reg(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1906 {
1907         /* INIT_COPY_ZM_REG   opcode: 0x90 ('')
1908          *
1909          * offset      (8  bit): opcode
1910          * offset + 1  (32 bit): src reg
1911          * offset + 5  (32 bit): dst reg
1912          *
1913          * Put contents of "src reg" into "dst reg"
1914          */
1915
1916         uint32_t srcreg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 1])));
1917         uint32_t dstreg = le32_to_cpu(*((uint32_t *)(&bios->data[offset + 5])));
1918         uint32_t data;
1919
1920         if (!iexec->execute)
1921                 return TRUE;
1922
1923         nv32_rd(pScrn, srcreg, &data);
1924         nv32_wr(pScrn, dstreg, data);
1925
1926         return TRUE;
1927 }
1928
1929 static Bool init_reserved(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset, init_exec_t *iexec)
1930 {
1931         /* INIT_RESERVED   opcode: 0x92 ('')
1932          *
1933          * offset      (8 bit): opcode
1934          *
1935          * Seemingly does nothing
1936          */
1937
1938         return TRUE;
1939 }
1940
1941 static init_tbl_entry_t itbl_entry[] = {
1942         /* command name                       , id  , length  , offset  , mult    , command handler                 */
1943 //      { "INIT_PROG"                         , 0x31, 15      , 10      , 4       , init_prog                       },
1944         { "INIT_IO_RESTRICT_PROG"             , 0x32, 11      , 6       , 4       , init_io_restrict_prog           },
1945         { "INIT_REPEAT"                       , 0x33, 2       , 0       , 0       , init_repeat                     },
1946         { "INIT_IO_RESTRICT_PLL"              , 0x34, 12      , 7       , 2       , init_io_restrict_pll            },
1947         { "INIT_END_REPEAT"                   , 0x36, 1       , 0       , 0       , init_end_repeat                 },
1948         { "INIT_COPY"                         , 0x37, 11      , 0       , 0       , init_copy                       },
1949         { "INIT_NOT"                          , 0x38, 1       , 0       , 0       , init_not                        },
1950         { "INIT_IO_FLAG_CONDITION"            , 0x39, 2       , 0       , 0       , init_io_flag_condition          },
1951         { "INIT_INDEX_ADDRESS_LATCHED"        , 0x49, 18      , 17      , 2       , init_idx_addr_latched           },
1952         { "INIT_IO_RESTRICT_PLL2"             , 0x4A, 11      , 6       , 4       , init_io_restrict_pll2           },
1953         { "INIT_PLL2"                         , 0x4B, 9       , 0       , 0       , init_pll2                       },
1954 /*      { "INIT_I2C_BYTE"                     , 0x4C, x       , x       , x       , init_i2c_byte                   }, */
1955 /*      { "INIT_ZM_I2C_BYTE"                  , 0x4D, x       , x       , x       , init_zm_i2c_byte                }, */
1956 /*      { "INIT_ZM_I2C"                       , 0x4E, x       , x       , x       , init_zm_i2c                     }, */
1957         { "INIT_4F"                           , 0x4F, 5       , 0       , 0       , init_4f                         },
1958         { "INIT_50"                           , 0x50, 3       , 2       , 2       , init_50                         },
1959         { "INIT_CR_INDEX_ADDRESS_LATCHED"     , 0x51, 5       , 4       , 1       , init_cr_idx_adr_latch           },
1960         { "INIT_CR"                           , 0x52, 4       , 0       , 0       , init_cr                         },
1961         { "INIT_ZM_CR"                        , 0x53, 3       , 0       , 0       , init_zm_cr                      },
1962         { "INIT_ZM_CR_GROUP"                  , 0x54, 2       , 1       , 2       , init_zm_cr_group                },
1963         { "INIT_CONDITION_TIME"               , 0x56, 3       , 0       , 0       , init_condition_time             },
1964         { "INIT_ZM_REG_SEQUENCE"              , 0x58, 6       , 5       , 4       , init_zm_reg_sequence            },
1965 //      { "INIT_INDIRECT_REG"                 , 0x5A, 7       , 0       , 0       , init_indirect_reg               },
1966         { "INIT_SUB_DIRECT"                   , 0x5B, 3       , 0       , 0       , init_sub_direct                 },
1967 //      { "INIT_COPY_NV_REG"                  , 0x5F, 22      , 0       , 0       , init_copy_nv_reg                },
1968         { "INIT_ZM_INDEX_IO"                  , 0x62, 5       , 0       , 0       , init_zm_index_io                },
1969         { "INIT_COMPUTE_MEM"                  , 0x63, 1       , 0       , 0       , init_compute_mem                },
1970         { "INIT_RESET"                        , 0x65, 13      , 0       , 0       , init_reset                      },
1971 /*      { "INIT_NEXT"                         , 0x66, x       , x       , x       , init_next                       }, */       
1972 /*      { "INIT_NEXT"                         , 0x67, x       , x       , x       , init_next                       }, */       
1973 /*      { "INIT_NEXT"                         , 0x68, x       , x       , x       , init_next                       }, */       
1974 //      { "INIT_INDEX_IO8"                    , 0x69, 5       , 0       , 0       , init_index_io8                  },
1975         { "INIT_SUB"                          , 0x6B, 2       , 0       , 0       , init_sub                        },
1976 //      { "INIT_RAM_CONDITION"                , 0x6D, 3       , 0       , 0       , init_ram_condition              },
1977         { "INIT_NV_REG"                       , 0x6E, 13      , 0       , 0       , init_nv_reg                     },
1978         { "INIT_MACRO"                        , 0x6F, 2       , 0       , 0       , init_macro                      },
1979         { "INIT_DONE"                         , 0x71, 1       , 0       , 0       , init_done                       },
1980         { "INIT_RESUME"                       , 0x72, 1       , 0       , 0       , init_resume                     },
1981 //      { "INIT_RAM_CONDITION2"               , 0x73, 9       , 0       , 0       , init_ram_condition2             },
1982         { "INIT_TIME"                         , 0x74, 3       , 0       , 0       , init_time                       },
1983         { "INIT_CONDITION"                    , 0x75, 2       , 0       , 0       , init_condition                  },
1984 /*      { "INIT_IO_CONDITION"                 , 0x76, x       , x       , x       , init_io_condition               }, */
1985         { "INIT_INDEX_IO"                     , 0x78, 6       , 0       , 0       , init_index_io                   },
1986         { "INIT_PLL"                          , 0x79, 7       , 0       , 0       , init_pll                        },
1987         { "INIT_ZM_REG"                       , 0x7A, 9       , 0       , 0       , init_zm_reg                     },
1988         /* INIT_RAM_RESTRICT_ZM_REG_GROUP's mult is loaded by M table in BIT */
1989         { "INIT_RAM_RESTRICT_ZM_REG_GROUP"    , 0x8F, 7       , 6       , 0       , init_ram_restrict_zm_reg_group  },
1990         { "INIT_COPY_ZM_REG"                  , 0x90, 9       , 0       , 0       , init_copy_zm_reg                },
1991 /*      { "INIT_ZM_REG_GROUP_ADDRESS_LATCHED" , 0x91, x       , x       , x       , init_zm_reg_group_addr_latched  }, */
1992         { "INIT_RESERVED"                     , 0x92, 1       , 0       , 0       , init_reserved                   },
1993         { 0                                   , 0   , 0       , 0       , 0       , 0                               }
1994 };
1995
1996 static unsigned int get_init_table_entry_length(bios_t *bios, unsigned int offset, int i)
1997 {
1998         /* Calculates the length of a given init table entry. */
1999         return itbl_entry[i].length + bios->data[offset + itbl_entry[i].length_offset]*itbl_entry[i].length_multiplier;
2000 }
2001
2002 static void parse_init_table(ScrnInfoPtr pScrn, bios_t *bios, unsigned int offset, init_exec_t *iexec)
2003 {
2004         /* Parses all commands in a init table. */
2005
2006         /* We start out executing all commands found in the
2007          * init table. Some op codes may change the status
2008          * of this variable to SKIP, which will cause
2009          * the following op codes to perform no operation until
2010          * the value is changed back to EXECUTE.
2011          */
2012         unsigned char id;
2013         int i;
2014
2015         int count=0;
2016         /* Loop until INIT_DONE causes us to break out of the loop
2017          * (or until offset > bios length just in case... )
2018          * (and no more than 10000 iterations just in case... ) */
2019         while ((offset < bios->length) && (count++ < 10000)) {
2020                 id = bios->data[offset];
2021
2022                 /* Find matching id in itbl_entry */
2023                 for (i = 0; itbl_entry[i].name && (itbl_entry[i].id != id); i++)
2024                         ;
2025
2026                 if (itbl_entry[i].name) {
2027                         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%04X: [ (0x%02X) - %s ]\n",
2028                                    offset, itbl_entry[i].id, itbl_entry[i].name);
2029
2030                         /* execute eventual command handler */
2031                         if (itbl_entry[i].handler)
2032                                 if (!(*itbl_entry[i].handler)(pScrn, bios, offset, iexec))
2033                                         break;
2034                 } else {
2035                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2036                                    "0x%04X: Init table command not found: 0x%02X\n", offset, id);
2037                         break;
2038                 }
2039
2040                 /* Add the offset of the current command including all data
2041                  * of that command. The offset will then be pointing on the
2042                  * next op code.
2043                  */
2044                 offset += get_init_table_entry_length(bios, offset, i);
2045         }
2046 }
2047
2048 void parse_init_tables(ScrnInfoPtr pScrn, bios_t *bios)
2049 {
2050         /* Loops and calls parse_init_table() for each present table. */
2051
2052         int i = 0;
2053         uint16_t table;
2054         init_exec_t iexec = {TRUE, FALSE};
2055
2056         while ((table = le16_to_cpu(*((uint16_t *)(&bios->data[bios->init_script_tbls_ptr + i]))))) {
2057
2058                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%04X: Parsing init table %d\n",
2059                         table, i / 2);
2060
2061                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2062                            "0x%04X: ------ EXECUTING FOLLOWING COMMANDS ------\n", table);
2063                 still_alive();
2064                 parse_init_table(pScrn, bios, table, &iexec);
2065                 i += 2;
2066         }
2067 }
2068
2069 void link_head_and_output(ScrnInfoPtr pScrn, int head, int dcb_entry, Bool overrideval)
2070 {
2071         /* The BIOS scripts don't do this for us, sadly
2072          * Luckily we do know the values ;-)
2073          *
2074          * head < 0 indicates we wish to force a setting with the overrideval
2075          * (for VT restore etc.)
2076          */
2077
2078         NVPtr pNv = NVPTR(pScrn);
2079
2080         Bool crosswired = FALSE;
2081         uint8_t possible_outputs = ffs(pNv->dcb_table.entry[dcb_entry].or);
2082         uint8_t bus = pNv->dcb_table.entry[dcb_entry].bus;
2083
2084         uint8_t output;
2085
2086         /* We need to check if crosswiring is needed. */
2087         switch(possible_outputs) {
2088                 case (OUTPUT_0 | OUTPUT_1):
2089                 case OUTPUT_1:
2090                         output = 1;
2091                         break;
2092                 case OUTPUT_0:
2093                 default:
2094                         output = 0;
2095                         break;
2096         }
2097
2098         /* This is based on the mmio-traces of:
2099          * A strange 6800GT.
2100          * A 6600GO with DVI.
2101          */
2102         /* I need more dumps to get a good picture of the situation */
2103         if (bus > 1) { /* usually mobile cards with dvi */
2104                 if (head == 1)
2105                         crosswired = TRUE;
2106         } else {
2107                 if (head != output)
2108                         crosswired = TRUE;
2109         }
2110
2111         /* Is this also valid on earlier cards? */
2112
2113         /* 6800GT: */
2114         /* This card has it's dvi output on bus = 1 and or = 1.
2115          * I was wrong, it gets 0x80 on crtc0 (i guess) and 0x88 on crtc1.
2116          * Conclusion: It behaves according to "or", despite earlier ideas.
2117          */
2118
2119         /* 6600GO: */
2120         /* This card has dvi output on bus = 3 and or = 3.
2121          * On crtc1 it gets value 0x88.
2122          * Conclusion: It behaves as if it were on output 0?
2123          */
2124
2125         uint8_t preferred_output = possible_outputs >> 1;
2126
2127         uint8_t tmds04 = 0x80;
2128         uint32_t tmds_ctrl, tmds_ctrl2;
2129
2130         /* Bit 3 crosswires output and bus. */
2131         if (head >= 0 && crosswired)
2132                 tmds04 = 0x88;
2133         if (head < 0 && overrideval)
2134                 tmds04 = 0x88;
2135
2136         if (pNv->dcb_table.entry[dcb_entry].type == OUTPUT_LVDS)
2137                 tmds04 |= 0x01;
2138
2139         tmds_ctrl = NV_PRAMDAC0_OFFSET + (preferred_output ? NV_PRAMDAC0_SIZE : 0) + NV_RAMDAC_FP_TMDS_CONTROL;
2140         tmds_ctrl2 = NV_PRAMDAC0_OFFSET + (preferred_output ? NV_PRAMDAC0_SIZE : 0) + NV_RAMDAC_FP_TMDS_CONTROL_2;
2141
2142         Bool oldexecute = pNv->VBIOS.execute;
2143         pNv->VBIOS.execute = TRUE;
2144         nv32_wr(pScrn, tmds_ctrl + 4, tmds04);
2145         nv32_wr(pScrn, tmds_ctrl, 0x04);
2146         if (pNv->dcb_table.entry[dcb_entry].type == OUTPUT_LVDS && pNv->VBIOS.fp.dual_link)
2147                 nv32_wr(pScrn, tmds_ctrl2 + 4, tmds04 ^ 0x08);
2148         else {
2149                 /* I have encountered no dvi (dual-link or not) that sets to anything else. */
2150                 /* Does this change beyond the 165 MHz boundary? */
2151                 nv32_wr(pScrn, tmds_ctrl2 + 4, 0x0);
2152         }
2153         nv32_wr(pScrn, tmds_ctrl2, 0x04);
2154         pNv->VBIOS.execute = oldexecute;
2155 }
2156
2157 void call_lvds_script(ScrnInfoPtr pScrn, int head, int dcb_entry, enum LVDS_script script)
2158 {
2159         NVPtr pNv = NVPTR(pScrn);
2160         bios_t *bios = &pNv->VBIOS;
2161         init_exec_t iexec = {TRUE, FALSE};
2162
2163         uint8_t sub = bios->data[bios->fp.script_table + script];
2164         uint16_t scriptofs = le16_to_cpu(*((CARD16 *)(&bios->data[bios->init_script_tbls_ptr + sub * 2])));
2165
2166         if (!bios->fp.script_table || !sub || !scriptofs)
2167                 return;
2168
2169         if (script == LVDS_INIT && bios->data[scriptofs] != 'q') {
2170                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "LVDS init script not stubbed\n");
2171                 return;
2172         }
2173
2174         if (script == LVDS_PANEL_ON && bios->fp.reset_after_pclk_change)
2175                 call_lvds_script(pScrn, head, dcb_entry, LVDS_RESET);
2176         if (script == LVDS_RESET && bios->fp.power_off_for_reset)
2177                 call_lvds_script(pScrn, head, dcb_entry, LVDS_PANEL_OFF);
2178
2179         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Calling LVDS script %d:\n", script);
2180         pNv->VBIOS.execute = TRUE;
2181         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_OWNER,
2182                    head ? NV_VGA_CRTCX_OWNER_HEADB : NV_VGA_CRTCX_OWNER_HEADA);
2183         parse_init_table(pScrn, bios, scriptofs, &iexec);
2184         pNv->VBIOS.execute = FALSE;
2185
2186         if (script == LVDS_PANEL_OFF)
2187                 usleep(bios->fp.off_on_delay * 1000);
2188         if (script == LVDS_RESET)
2189                 link_head_and_output(pScrn, head, dcb_entry, FALSE);
2190 }
2191
2192 struct fppointers {
2193         uint16_t fptablepointer;
2194         uint16_t fpxlatetableptr;
2195         uint16_t lvdsmanufacturerpointer;
2196         uint16_t fpxlatemanufacturertableptr;
2197         int xlatwidth;
2198 };
2199
2200 static void parse_fp_mode_table(ScrnInfoPtr pScrn, bios_t *bios, struct fppointers *fpp)
2201 {
2202         NVPtr pNv = NVPTR(pScrn);
2203         unsigned int fpstrapping;
2204         uint8_t *fptable;
2205         uint8_t fptable_ver, headerlen = 0, recordlen, fpentries = 0xf, fpindex;
2206         int ofs;
2207         DisplayModePtr mode;
2208
2209         fpstrapping = (nvReadEXTDEV(pNv, NV_PEXTDEV_BOOT) >> 16) & 0xf;
2210
2211         if (fpp->fptablepointer == 0x0 || fpp->fpxlatetableptr == 0x0) {
2212                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2213                            "Pointers to flat panel table invalid\n");
2214                 return;
2215         }
2216
2217         fptable = &bios->data[fpp->fptablepointer];
2218
2219         fptable_ver = fptable[0];
2220
2221         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2222                    "Found flat panel mode table revision %d.%d\n",
2223                    fptable_ver >> 4, fptable_ver & 0xf);
2224
2225         switch (fptable_ver) {
2226         /* PINS version 0x5.0x11 BIOSen have version 1 like tables, but no version field,
2227          * and miss one of the spread spectrum/PWM bytes.
2228          * This could affect early GF2Go parts (not seen any appropriate ROMs though).
2229          * Here we assume that a version of 0x05 matches this case (combining with a
2230          * PINS version check would be better), as the common case for the panel type
2231          * field is 0x0005, and that is in fact what we are reading the first byte of. */
2232         case 0x05:      /* some NV10, 11, 15, 16 */
2233                 recordlen = 42;
2234                 ofs = 6;
2235                 break;
2236         case 0x10:      /* some NV15/16, and NV11+ */
2237                 recordlen = 44;
2238                 ofs = 7;
2239                 break;
2240         case 0x20:      /* NV40+ */
2241                 headerlen = fptable[1];
2242                 recordlen = fptable[2];
2243                 fpentries = fptable[3];
2244                 ofs = 0;
2245                 break;
2246         default:
2247                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2248                            "FP Table revision not currently supported\n");
2249                 return;
2250         }
2251
2252         fpindex = bios->data[fpp->fpxlatetableptr + fpstrapping * fpp->xlatwidth];
2253         if (fpindex > fpentries) {
2254                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2255                            "Bad flat panel table index\n");
2256                 return;
2257         }
2258
2259         if (!(mode = xcalloc(1, sizeof(DisplayModeRec))))
2260                 return;
2261
2262         int modeofs = headerlen + recordlen * fpindex + ofs;
2263         mode->Clock = le16_to_cpu(*(uint16_t *)&fptable[modeofs]) * 10;
2264         mode->HDisplay = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 2]);
2265         mode->HSyncStart = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 10] + 1);
2266         mode->HSyncEnd = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 12] + 1);
2267         mode->HTotal = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 14] + 1);
2268         mode->VDisplay = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 16]);
2269         mode->VSyncStart = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 24] + 1);
2270         mode->VSyncEnd = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 26] + 1);
2271         mode->VTotal = le16_to_cpu(*(uint16_t *)&fptable[modeofs + 28] + 1);
2272         mode->Flags |= (fptable[modeofs + 30] & 0x10) ? V_PHSYNC : V_NHSYNC;
2273         mode->Flags |= (fptable[modeofs + 30] & 0x1) ? V_PVSYNC : V_NVSYNC;
2274
2275         /* for version 1.0:
2276          * bytes 1-2 are "panel type", including bits on whether Colour/mono, single/dual link, and type (TFT etc.)
2277          * bytes 3-6 are bits per colour in RGBX
2278          * 11-12 is HDispEnd
2279          * 13-14 is HValid Start
2280          * 15-16 is HValid End
2281          * bytes 38-39 relate to spread spectrum settings
2282          * bytes 40-43 are something to do with PWM */
2283
2284         mode->prev = mode->next = NULL;
2285         mode->status = MODE_OK;
2286         mode->type = M_T_DRIVER | M_T_PREFERRED;
2287         xf86SetModeDefaultName(mode);
2288
2289 //      if (pNv->debug_modes) { this should exist
2290                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2291                            "Found flat panel mode in BIOS tables:\n");
2292                 xf86PrintModeline(pScrn->scrnIndex, mode);
2293 //      }
2294
2295         bios->fp.native_mode = mode;
2296 }
2297
2298 static void parse_lvds_manufacturer_table(ScrnInfoPtr pScrn, bios_t *bios, struct fppointers *fpp)
2299 {
2300         NVPtr pNv = NVPTR(pScrn);
2301         unsigned int fpstrapping;
2302         uint8_t *lvdsmanufacturertable, *fpxlatemanufacturertable;
2303         int lvdsmanufacturerindex = 0;
2304         uint8_t lvds_ver, headerlen, recordlen;
2305
2306         fpstrapping = (nvReadEXTDEV(pNv, NV_PEXTDEV_BOOT) >> 16) & 0xf;
2307
2308         if (fpp->lvdsmanufacturerpointer == 0x0) {
2309                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2310                            "Pointer to LVDS manufacturer table invalid\n");
2311                 return;
2312         }
2313
2314         lvdsmanufacturertable = &bios->data[fpp->lvdsmanufacturerpointer];
2315         lvds_ver = lvdsmanufacturertable[0];
2316
2317         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2318                    "Found LVDS manufacturer table revision %d\n",
2319                    lvds_ver);
2320
2321         switch (lvds_ver) {
2322         case 0x0a:      /* pre NV40 */
2323                 fpxlatemanufacturertable = &bios->data[fpp->fpxlatemanufacturertableptr];
2324                 lvdsmanufacturerindex = fpxlatemanufacturertable[fpstrapping];
2325
2326                 headerlen = 2;
2327                 recordlen = lvdsmanufacturertable[1];
2328
2329                 break;
2330 //      case 0x:        /* NV40+ */
2331         default:
2332                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2333                            "LVDS manufacturer table revision not currently supported\n");
2334                 return;
2335         }
2336
2337         uint16_t lvdsofs = bios->fp.script_table = fpp->lvdsmanufacturerpointer + headerlen + recordlen * lvdsmanufacturerindex;
2338         bios->fp.power_off_for_reset = bios->data[lvdsofs] & 1;
2339         bios->fp.reset_after_pclk_change = bios->data[lvdsofs] & 2;
2340         bios->fp.dual_link = bios->data[lvdsofs] & 4;
2341         bios->fp.if_is_24bit = bios->data[lvdsofs] & 16;
2342         bios->fp.off_on_delay = le16_to_cpu(*(uint16_t *)&bios->data[lvdsofs + 7]);
2343 }
2344
2345 void run_tmds_table(ScrnInfoPtr pScrn, bios_t *bios, uint8_t dcb_entry, uint8_t head, uint16_t pxclk)
2346 {
2347         /* the dcb_entry parameter is the index of the appropriate DCB entry
2348          * the pxclk parameter is in 10s of kHz (eg. 108Mhz is 10800, or 0x2a30)
2349          *
2350          * This runs the TMDS regs setting code found on BIT bios cards
2351          *
2352          * For ffs(or) == 1 use the first table, for ffs(or) == 2 and
2353          * ffs(or) == 3, use the second.
2354          */
2355
2356         NVPtr pNv = NVPTR(pScrn);
2357         uint16_t clktable = 0, tmdsscript = 0;
2358         int i = 0;
2359         uint16_t compareclk;
2360         uint8_t compare_record_len, tmdssub;
2361         init_exec_t iexec = {TRUE, FALSE};
2362
2363         if (pNv->dcb_table.entry[dcb_entry].location) /* off chip */
2364                 return;
2365
2366         if (bios->major_version < 5) /* pre BIT */
2367                 compare_record_len = 3;
2368         else
2369                 compare_record_len = 4;
2370
2371         switch (ffs(pNv->dcb_table.entry[dcb_entry].or)) {
2372         case 1:
2373                 clktable = bios->tmds.output0_script_ptr;
2374                 break;
2375         case 2:
2376         case 3:
2377                 clktable = bios->tmds.output1_script_ptr;
2378                 break;
2379         }
2380
2381         if (!clktable) {
2382                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Pixel clock comparison table not found\n");
2383                 return;
2384         }
2385
2386         do {
2387                 compareclk = le16_to_cpu(*((uint16_t *)&bios->data[clktable + compare_record_len * i]));
2388                 if (pxclk >= compareclk) {
2389                         if (bios->major_version < 5) {
2390                                 tmdssub = bios->data[clktable + 2 + compare_record_len * i];
2391                                 tmdsscript = le16_to_cpu(*((uint16_t *)(&bios->data[bios->init_script_tbls_ptr + tmdssub * 2])));
2392                         } else
2393                                 tmdsscript = le16_to_cpu(*((uint16_t *)&bios->data[clktable + 2 + compare_record_len * i]));
2394                         break;
2395                 }
2396                 i++;
2397         } while (compareclk);
2398
2399         if (!tmdsscript) {
2400                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "TMDS script not found\n");
2401                 return;
2402         }
2403
2404         /* This code has to be executed */
2405         bios->execute = TRUE;
2406         /* We must set the owner register appropriately */ 
2407         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, NV_VGA_CRTCX_OWNER, head * 3);
2408
2409         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%04X: Parsing TMDS table\n", tmdsscript);
2410         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, 0x57, 0);
2411         nv_idx_port_wr(pScrn, CRTC_INDEX_COLOR, 0x58, dcb_entry);
2412         parse_init_table(pScrn, bios, tmdsscript, &iexec);
2413         bios->execute = FALSE;
2414
2415         link_head_and_output(pScrn, head, dcb_entry, FALSE);
2416 }
2417
2418 static void parse_bios_version(ScrnInfoPtr pScrn, bios_t *bios, uint16_t offset)
2419 {
2420         /* offset + 0  (8 bits): Micro version
2421          * offset + 1  (8 bits): Minor version
2422          * offset + 2  (8 bits): Chip version
2423          * offset + 3  (8 bits): Major version
2424          */
2425
2426         bios->major_version = bios->data[offset + 3];
2427         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Bios version %02x.%02x.%02x.%02x\n",
2428                    bios->data[offset+3], bios->data[offset+2],
2429                    bios->data[offset+1], bios->data[offset]);
2430 }
2431
2432 static int parse_bit_b_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry)
2433 {
2434         /* offset + 0  (32 bits): BIOS version dword
2435          *
2436          * There's a bunch of bits in this table other than the bios version
2437          * that we don't use - their use currently unknown
2438          */
2439
2440         if (bitentry->length < 0x4) {
2441                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2442                            "Do not understand B table entry.\n");
2443                 return 0;
2444         }
2445
2446         parse_bios_version(pScrn, bios, bitentry->offset);
2447
2448         return 1;
2449 }
2450
2451 static int parse_bit_display_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry, struct fppointers *fpp)
2452 {
2453         /* Parses the flat panel table segment that the bit entry points to.
2454          * Starting at bitentry->offset:
2455          *
2456          * offset + 0  (16 bits): FIXME table pointer
2457          * offset + 2  (16 bits): mode table pointer
2458          */
2459
2460         if (bitentry->length != 4) {
2461                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2462                            "Do not understand BIT display table entry.\n");
2463                 return 0;
2464         }
2465
2466         fpp->fptablepointer = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 2])));
2467
2468         return 1;
2469 }
2470
2471 static unsigned int parse_bit_init_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry)
2472 {
2473         /* Parses the init table segment that the bit entry points to.
2474          * Starting at bitentry->offset: 
2475          * 
2476          * offset + 0  (16 bits): init script tables pointer
2477          * offset + 2  (16 bits): macro index table pointer
2478          * offset + 4  (16 bits): macro table pointer
2479          * offset + 6  (16 bits): condition table pointer
2480          * offset + 8  (16 bits): io condition table pointer
2481          * offset + 10 (16 bits): io flag condition table pointer
2482          * offset + 12 (16 bits): init function table pointer
2483          *
2484          * TODO:
2485          * * Are 'I' bit entries always of length 0xE?
2486          * 
2487          */
2488
2489         if (bitentry->length < 12) {
2490                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2491                            "Unable to recognize BIT init table entry.\n");
2492                 return 0;
2493         }
2494
2495         bios->init_script_tbls_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset])));
2496         bios->macro_index_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 2])));
2497         bios->macro_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 4])));
2498         bios->condition_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 6])));
2499         bios->io_condition_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 8])));
2500         bios->io_flag_condition_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 10])));
2501         bios->init_function_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 12])));
2502
2503         parse_init_tables(pScrn, bios);
2504
2505         return 1;
2506 }
2507
2508 static int parse_bit_lvds_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry, struct fppointers *fpp)
2509 {
2510         /* Parses the LVDS table segment that the bit entry points to.
2511          * Starting at bitentry->offset:
2512          *
2513          * offset + 0  (16 bits): LVDS strap xlate table pointer
2514          *
2515          * The LVDS table has the typical BIT table header: version byte,
2516          * header length byte, record length byte, a byte for the maximum
2517          * number of records that can be held in the table, and then some
2518          * other things.
2519          *
2520          * The table serves as a glorified xlat table: the records in the table
2521          * are indexed by the FP strap nibble in EXTDEV_BOOT, and each record
2522          * has two bytes - the first for FIXME, the second for indexing the fp
2523          * mode table pointed to by the BIT 'D' table
2524          */
2525
2526         uint16_t lvdstbl_ptr;
2527         uint8_t lvdstbl_ver, lvdstbl_headerlen, lvdstbl_entrywidth;
2528
2529         if (bitentry->length != 2) {
2530                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2531                            "Do not understand BIT LVDS table entry.\n");
2532                 return 0;
2533         }
2534
2535         lvdstbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset])));
2536
2537         if (lvdstbl_ptr == 0x0) {
2538                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Pointer to LVDS table invalid\n");
2539                 return 0;
2540         }
2541
2542         lvdstbl_ver = bios->data[lvdstbl_ptr];
2543         lvdstbl_headerlen = bios->data[lvdstbl_ptr + 1];
2544         lvdstbl_entrywidth = bios->data[lvdstbl_ptr + 2];
2545         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Found LVDS table revision %d.%d\n",
2546                    lvdstbl_ver >> 4, lvdstbl_ver & 0xf);
2547         if (lvdstbl_ver != 0x30 || lvdstbl_entrywidth != 0x2) {
2548                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2549                            "Do not understand BIT LVDS table.\n");
2550                 return 0;
2551         }
2552
2553         fpp->xlatwidth = lvdstbl_entrywidth;
2554         fpp->fpxlatetableptr = lvdstbl_ptr + lvdstbl_headerlen + 1;
2555
2556         return 1;
2557 }
2558
2559 static int parse_bit_m_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry)
2560 {
2561         /* offset + 2  (8  bits): number of options in an INIT_RAM_RESTRICT_ZM_REG_GROUP opcode option set
2562          * offset + 3  (16 bits): pointer to strap xlate table for RAM restrict option selection
2563          *
2564          * There's a bunch of bits in this table other than the RAM restrict
2565          * stuff that we don't use - their use currently unknown
2566          */
2567
2568         int i;
2569
2570         /* Older bios versions don't have a sufficiently long table for what we want */
2571         if (bitentry->length < 0x5)
2572                 return 1;
2573
2574         /* set up multiplier for INIT_RAM_RESTRICT_ZM_REG_GROUP */
2575         for (i = 0; itbl_entry[i].name && (itbl_entry[i].id != 0x8f); i++)
2576                 ;
2577         itbl_entry[i].length_multiplier = bios->data[bitentry->offset + 2] * 4;
2578         init_ram_restrict_zm_reg_group_blocklen = itbl_entry[i].length_multiplier;
2579
2580         bios->ram_restrict_tbl_ptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 3])));
2581
2582         return 1;
2583 }
2584
2585 static int parse_bit_tmds_tbl_entry(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry)
2586 {
2587         /* Parses the pointer to the TMDS table
2588          *
2589          * Starting at bitentry->offset:
2590          *
2591          * offset + 0  (16 bits): TMDS table pointer
2592          *
2593          * The TMDS table is typically found just before the DCB table, with a
2594          * characteristic signature of 0x11,0x13 (1.1 being version, 0x13 being
2595          * length?)
2596          *
2597          * At offset +7 is a pointer to a script, which I don't know how to run yet
2598          * At offset +9 is a pointer to another script, likewise
2599          * Offset +11 has a pointer to a table where the first word is a pxclk
2600          * frequency and the second word a pointer to a script, which should be
2601          * run if the comparison pxclk frequency is less than the pxclk desired.
2602          * This repeats for decreasing comparison frequencies
2603          * Offset +13 has a pointer to a similar table
2604          * The selection of table (and possibly +7/+9 script) is dictated by
2605          * "or" from the DCB.
2606          */
2607
2608         uint16_t tmdstableptr, script1, script2;
2609
2610         if (bitentry->length != 2) {
2611                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2612                            "Do not understand BIT TMDS table entry.\n");
2613                 return 0;
2614         }
2615
2616         tmdstableptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset])));
2617
2618         if (tmdstableptr == 0x0) {
2619                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Pointer to TMDS table invalid\n");
2620                 return 0;
2621         }
2622
2623         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Found TMDS table revision %d.%d\n",
2624                    bios->data[tmdstableptr] >> 4, bios->data[tmdstableptr] & 0xf);
2625
2626         /* These two scripts are odd: they don't seem to get run even when they are not stubbed */
2627         script1 = le16_to_cpu(*((uint16_t *)&bios->data[tmdstableptr + 7]));
2628         script2 = le16_to_cpu(*((uint16_t *)&bios->data[tmdstableptr + 9]));
2629         if (bios->data[script1] != 'q' || bios->data[script2] != 'q')
2630                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "TMDS table script pointers not stubbed\n");
2631
2632         bios->tmds.output0_script_ptr = le16_to_cpu(*((uint16_t *)&bios->data[tmdstableptr + 11]));
2633         bios->tmds.output1_script_ptr = le16_to_cpu(*((uint16_t *)&bios->data[tmdstableptr + 13]));
2634
2635         return 1;
2636 }
2637
2638 static unsigned int parse_bmp_table_pointers(ScrnInfoPtr pScrn, bios_t *bios, bit_entry_t *bitentry)
2639 {
2640         /* Parse the pointers for useful tables in the BMP structure, starting at
2641          * offset 75 from the ..NV. signature.
2642          *
2643          * First 7 pointers as for parse_bit_init_tbl_entry
2644          *
2645          * offset + 30: flat panel timings table pointer
2646          * offset + 32: flat panel strapping translation table pointer
2647          * offset + 42: LVDS manufacturer panel config table pointer
2648          * offset + 44: LVDS manufacturer strapping translation table pointer
2649          */
2650
2651         NVPtr pNv = NVPTR(pScrn);
2652         struct fppointers fpp;
2653
2654         if (!parse_bit_init_tbl_entry(pScrn, bios, bitentry))
2655                 return 0;
2656
2657         /* If it's not a laptop, you probably don't care about fptables */
2658         /* FIXME: detect mobile BIOS? */
2659         if (!pNv->Mobile)
2660                 return 1;
2661
2662         if (bitentry->length > 17) {
2663                 bios->tmds.output0_script_ptr = le16_to_cpu(*((uint16_t *)&bios->data[bitentry->offset + 14]));
2664                 bios->tmds.output1_script_ptr = le16_to_cpu(*((uint16_t *)&bios->data[bitentry->offset + 16]));
2665         }
2666
2667         memset(&fpp, 0, sizeof(struct fppointers));
2668         if (bitentry->length > 33) {
2669                 fpp.fptablepointer = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 30])));
2670                 fpp.xlatwidth = 1;
2671                 fpp.fpxlatetableptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 32])));
2672                 parse_fp_mode_table(pScrn, bios, &fpp);
2673         }
2674         if (bitentry->length > 45) {
2675                 fpp.lvdsmanufacturerpointer = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 42])));
2676                 fpp.fpxlatemanufacturertableptr = le16_to_cpu(*((uint16_t *)(&bios->data[bitentry->offset + 44])));
2677                 parse_lvds_manufacturer_table(pScrn, bios, &fpp);
2678                 /* I've never seen a valid LVDS_INIT script, so we'll do a test for it here */
2679                 call_lvds_script(pScrn, 0, 0, LVDS_INIT);
2680         }
2681
2682         return 1;
2683 }
2684
2685 static void parse_bit_structure(ScrnInfoPtr pScrn, bios_t *bios, unsigned int offset)
2686 {
2687         bit_entry_t bitentry, storedinitentry = {{ 0 }};
2688         char done = 0;
2689         struct fppointers fpp;
2690         NVPtr pNv = NVPTR(pScrn);
2691
2692         memset(&fpp, 0, sizeof(struct fppointers));
2693
2694         while (!done) {
2695                 bitentry.id[0] = bios->data[offset];
2696                 bitentry.id[1] = bios->data[offset + 1];
2697                 bitentry.length = le16_to_cpu(*((uint16_t *)&bios->data[offset + 2]));
2698                 bitentry.offset = le16_to_cpu(*((uint16_t *)&bios->data[offset + 4]));
2699
2700                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2701                            "0x%04X: Found BIT command with id 0x%02X (%c)\n",
2702                            offset, bitentry.id[0], bitentry.id[0]);
2703
2704                 switch (bitentry.id[0]) {
2705                 case 0:
2706                         /* id[0] = 0 and id[1] = 0 ==> end of BIT struture */
2707                         if (bitentry.id[1] == 0)
2708                                 done = 1;
2709                         break;
2710                 case 'B':
2711                         parse_bit_b_tbl_entry(pScrn, bios, &bitentry);
2712                         break;
2713                 case 'D':
2714                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2715                                    "0x%04X: Found flat panel display table entry in BIT structure.\n", offset);
2716                         parse_bit_display_tbl_entry(pScrn, bios, &bitentry, &fpp);
2717                         break;
2718                 case 'I':
2719                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2720                                    "0x%04X: Found init table entry in BIT structure.\n", offset);
2721                         memcpy(&storedinitentry, &bitentry, sizeof(bit_entry_t));
2722                         break;
2723                 case 'L':
2724                         parse_bit_lvds_tbl_entry(pScrn, bios, &bitentry, &fpp);
2725                         break;
2726                 case 'M': /* memory? */
2727                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2728                                    "0x%04X: Found M table entry in BIT structure.\n", offset);
2729                         parse_bit_m_tbl_entry(pScrn, bios, &bitentry);
2730                         break;
2731                 case 'T':
2732                         parse_bit_tmds_tbl_entry(pScrn, bios, &bitentry);
2733                         break;
2734
2735                         /* TODO: What kind of information does the other BIT entrys point to?
2736                          *       'P' entry is probably performance tables, but there are
2737                          *       quite a few others...
2738                          */
2739                 }
2740
2741                 offset += sizeof(bit_entry_t);
2742         }
2743
2744         /* 'M' table has to be parsed before 'I' can run */
2745         if (storedinitentry.id[0]) {
2746                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2747                            "Parsing previously deferred init table entry.\n");
2748                 parse_bit_init_tbl_entry(pScrn, bios, &storedinitentry);
2749         }
2750
2751         /* If it's not a laptop, you probably don't care about LVDS */
2752         /* FIXME: detect mobile BIOS? */
2753         if (!pNv->Mobile)
2754                 return;
2755
2756         /* Need D and L tables parsed before doing this */
2757         parse_fp_mode_table(pScrn, bios, &fpp);
2758
2759 }
2760
2761 static void parse_pins_structure(ScrnInfoPtr pScrn, bios_t *bios, unsigned int offset)
2762 {
2763         int pins_version_major=bios->data[offset+5];
2764         int pins_version_minor=bios->data[offset+6];
2765         int init1 = bios->data[offset + 18] + (bios->data[offset + 19] * 256);
2766         int init2 = bios->data[offset + 20] + (bios->data[offset + 21] * 256);
2767         int init_size = bios->data[offset + 22] + (bios->data[offset + 23] * 256) + 1;
2768         int ram_tab;
2769
2770         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "PINS version %d.%d\n",
2771                    pins_version_major, pins_version_minor);
2772
2773         /* checksum */
2774         if (nv_cksum(bios->data + offset, 8)) {
2775                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "bad PINS checksum\n");
2776                 return;
2777         }
2778
2779         switch (pins_version_major) {
2780                 case 2:
2781                         ram_tab = init1-0x0010;
2782                         break;
2783                 case 3:
2784                 case 4:
2785                 case 5:
2786                         ram_tab = bios->data[offset + 24] + (bios->data[offset + 25] * 256);
2787                         break;
2788                 default:
2789                         return;
2790         }
2791         
2792         if ((pins_version_major==5)&&(pins_version_minor>=6)) {
2793                 /* VCO range info */
2794         }
2795
2796         if ((pins_version_major==5)&&(pins_version_minor>=16)) {
2797                 bit_entry_t bitentry;
2798
2799                 if (pins_version_minor == 0x10)
2800                         bitentry.length = 12; /* I've not seen this version, so be "long enough" */
2801                 else if (pins_version_minor < 0x14)
2802                         bitentry.length = 34;
2803                 else
2804                         bitentry.length = 48; /* versions after 0x14 are longer,
2805                                                  but extra contents unneeded ATM */
2806
2807                 parse_bios_version(pScrn, bios, offset + 10);
2808                 bitentry.offset = offset + 75;
2809                 parse_bmp_table_pointers(pScrn, bios, &bitentry);
2810         } else {
2811                 /* TODO type1 script */
2812         }
2813 }
2814
2815 static unsigned int findstr(bios_t* bios, unsigned char *str, int len)
2816 {
2817         int i;
2818
2819         for (i = 2; i <= (bios->length - len); i++)
2820                 if (strncmp((char *)&bios->data[i], (char *)str, len) == 0)
2821                         return i;
2822
2823         return 0;
2824 }
2825
2826 static Bool parse_dcb_entry(uint8_t dcb_version, uint32_t conn, uint32_t conf, struct dcb_entry *entry)
2827 {
2828         memset(entry, 0, sizeof (struct dcb_entry));
2829
2830         if (dcb_version >= 0x20) {
2831                 entry->type = conn & 0xf;
2832                 entry->i2c_index = (conn >> 4) & 0xf;
2833                 entry->heads = (conn >> 8) & 0xf;
2834                 entry->bus = (conn >> 16) & 0xf;
2835                 entry->location = (conn >> 20) & 0xf;
2836                 entry->or = (conn >> 24) & 0xf;
2837                 if ((1 << ffs(entry->or)) * 3 == entry->or)
2838                         entry->duallink_possible = TRUE;
2839                 else
2840                         entry->duallink_possible = FALSE;
2841
2842                 switch (entry->type) {
2843                 case OUTPUT_LVDS:
2844                         if (conf & 0xfffffffa)
2845                                 ErrorF("Unknown LVDS configuration bits, please report\n");
2846                         if (conf & 0x1)
2847                                 entry->lvdsconf.use_straps_for_mode = TRUE;
2848                         if (conf & 0x4)
2849                                 entry->lvdsconf.use_power_scripts = TRUE;
2850                         break;
2851                 }
2852         } else if (dcb_version >= 0x14 ) {
2853                 if (conn != 0xf0003f00) {
2854                         ErrorF("Unknown DCB 1.4 entry, please report\n");
2855                         return FALSE;
2856                 }
2857                 /* safe defaults for a crt */
2858                 entry->type = 0;
2859                 entry->i2c_index = 0;
2860                 entry->heads = 1;
2861                 entry->bus = 0;
2862                 entry->location = 0;
2863                 entry->or = 1;
2864                 entry->duallink_possible = FALSE;
2865         } else {
2866                 // 1.2 needs more loving
2867                 return FALSE;
2868                 entry->type = 0;
2869                 entry->i2c_index = 0;
2870                 entry->heads = 0;
2871                 entry->bus = 0;
2872                 entry->location = 0;
2873                 entry->or = 0;
2874                 entry->duallink_possible = FALSE;
2875         }
2876
2877         return TRUE;
2878 }
2879
2880 static void
2881 read_dcb_i2c_table(ScrnInfoPtr pScrn, bios_t *bios, uint8_t dcb_version, uint16_t i2ctabptr)
2882 {
2883         NVPtr pNv = NVPTR(pScrn);
2884         uint8_t *i2ctable;
2885         uint8_t headerlen = 0;
2886         int i2c_entries;
2887         int recordoffset = 0, rdofs = 1, wrofs = 0;
2888         int i;
2889
2890         i2c_entries = MAX_NUM_DCB_ENTRIES;
2891         memset(pNv->dcb_table.i2c_read, 0, sizeof(pNv->dcb_table.i2c_read));
2892         memset(pNv->dcb_table.i2c_write, 0, sizeof(pNv->dcb_table.i2c_write));
2893
2894         i2ctable = &bios->data[i2ctabptr];
2895
2896         if (dcb_version >= 0x30) {
2897                 if (i2ctable[0] != dcb_version) { /* necessary? */
2898                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2899                                    "DCB I2C table version mismatch (%02X vs %02X)\n",
2900                                    i2ctable[0], dcb_version);
2901                         return;
2902                 }
2903                 headerlen = i2ctable[1];
2904                 i2c_entries = i2ctable[2];
2905                 if (i2ctable[0] >= 0x40) {
2906                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2907                                    "G80 DCB I2C table detected, arrgh\n"); /* they're plain weird */
2908                         return;
2909                 }
2910         }
2911         /* it's your own fault if you call this function on a DCB 1.1 BIOS */
2912         if (dcb_version < 0x14) {
2913                 recordoffset = 2;
2914                 rdofs = 0;
2915                 wrofs = 1;
2916         }
2917
2918         for (i = 0; i < i2c_entries; i++) {
2919                 if (i2ctable[headerlen + 4 * i + 3] != 0xff) {
2920                         pNv->dcb_table.i2c_read[i] = i2ctable[headerlen + recordoffset + rdofs + 4 * i];
2921                         pNv->dcb_table.i2c_write[i] = i2ctable[headerlen + recordoffset + wrofs + 4 * i];
2922                 }
2923         }
2924 }
2925
2926 static unsigned int parse_dcb_table(ScrnInfoPtr pScrn, bios_t *bios)
2927 {
2928         NVPtr pNv = NVPTR(pScrn);
2929         uint16_t dcbptr, i2ctabptr = 0;
2930         uint8_t *dcbtable;
2931         uint8_t dcb_version, headerlen = 0x4, entries = MAX_NUM_DCB_ENTRIES;
2932         Bool configblock = TRUE;
2933         int recordlength = 8, confofs = 4;
2934         int i;
2935
2936         pNv->dcb_table.entries = 0;
2937
2938         /* get the offset from 0x36 */
2939         dcbptr = le16_to_cpu(*(uint16_t *)&bios->data[0x36]);
2940
2941         if (dcbptr == 0x0) {
2942                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2943                            "No Display Configuration Block pointer found\n");
2944                 return 0;
2945         }
2946
2947         dcbtable = &bios->data[dcbptr];
2948
2949         /* get DCB version */
2950         dcb_version = dcbtable[0];
2951         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2952                    "Display Configuration Block version %d.%d found\n",
2953                    dcb_version >> 4, dcb_version & 0xf);
2954
2955         if (dcb_version >= 0x20) { /* NV17+ */
2956                 uint32_t sig;
2957
2958                 if (dcb_version >= 0x30) { /* NV40+ */
2959                         headerlen = dcbtable[1];
2960                         entries = dcbtable[2];
2961                         i2ctabptr = le16_to_cpu(*(uint16_t *)&dcbtable[4]);
2962                         sig = le32_to_cpu(*(uint32_t *)&dcbtable[6]);
2963
2964                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2965                                    "DCB header length %02X, with %02X possible entries\n",
2966                                    headerlen, entries);
2967                 } else {
2968                         /* dcb_block_count = *(dcbtable[1]); */
2969                         i2ctabptr = le16_to_cpu(*(uint16_t *)&dcbtable[2]);
2970                         sig = le32_to_cpu(*(uint32_t *)&dcbtable[4]);
2971                         headerlen = 8;
2972                 }
2973
2974                 if (sig != 0x4edcbdcb) {
2975                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2976                                    "Bad Display Configuration Block signature (%08X)\n", sig);
2977                         return 0;
2978                 }
2979         } else if (dcb_version >= 0x14) { /* some NV15/16, and NV11+ */
2980                 char sig[8];
2981
2982                 memset(sig, 0, 8);
2983                 strncpy(sig, (char *)&dcbtable[-7], 7);
2984                 /* dcb_block_count = *(dcbtable[1]); */
2985                 i2ctabptr = le16_to_cpu(*(uint16_t *)&dcbtable[2]);
2986                 recordlength = 10;
2987                 confofs = 6;
2988
2989                 if (strcmp(sig, "DEV_REC")) {
2990                         xf86DrvMsg(pScrn->scrnIndex, X_INFO,
2991                                    "Bad Display Configuration Block signature (%s)\n", sig);
2992                         return 0;
2993                 }
2994         } else if (dcb_version >= 0x12) { /* some NV6/10, and NV15+ */
2995                 /* dcb_block_count = *(dcbtable[1]); */
2996                 i2ctabptr = le16_to_cpu(*(uint16_t *)&dcbtable[2]);
2997                 configblock = FALSE;
2998         } else {        /* NV5+, maybe NV4 */
2999                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3000                            "Structure of Display Configuration Blocks prior to version 1.2 unknown\n");
3001                 return 0;
3002         }
3003
3004         if (entries >= MAX_NUM_DCB_ENTRIES)
3005                 entries = MAX_NUM_DCB_ENTRIES;
3006
3007         for (i = 0; i < entries; i++) {
3008                 uint32_t connection, config = 0;
3009
3010                 connection = le32_to_cpu(*(uint32_t *)&dcbtable[headerlen + recordlength * i]);
3011                 if (configblock)
3012                         config = le32_to_cpu(*(uint32_t *)&dcbtable[headerlen + confofs + recordlength * i]);
3013
3014                 /* Should we allow discontinuous DCBs? Certainly DCB I2C tables
3015                  * can be discontinuous */
3016                 if ((connection & 0x0000000f) == 0x0000000f) /* end of records */
3017                         break;
3018
3019                 ErrorF("Raw DCB entry %d: %08x %08x\n", i, connection, config);
3020                 if (!parse_dcb_entry(dcb_version, connection, config, &pNv->dcb_table.entry[i]))
3021                         break;
3022         }
3023         pNv->dcb_table.entries = i;
3024
3025         read_dcb_i2c_table(pScrn, bios, dcb_version, i2ctabptr);
3026
3027         /* This is needed for DCB version 2.0 */
3028         /* Otherwise you end up with multiple outputs that are trying to be activated */
3029         for ( i = 0; i < pNv->dcb_table.entries; i ++) {
3030                 int j;
3031                 int cur_i2c = pNv->dcb_table.entry[i].i2c_index;
3032                 int cur_type = pNv->dcb_table.entry[i].type;
3033                 for ( j = 0; j < pNv->dcb_table.entries; j ++ ) {
3034                         if ( i == j ) continue;
3035                         if ( pNv->dcb_table.entry[j].type == 100) continue; /* merged entry */
3036                         if (( pNv->dcb_table.entry[j].i2c_index == cur_i2c )  && ( pNv->dcb_table.entry[j].type == cur_type ))  {
3037                                 /* We can only merge entries with the same allowed crtc's. */
3038                                 /* This has not occured so far and needs some logic (to merge dual link properly). */ 
3039                                 /* So this remains TODO for the moment. */
3040
3041                                 /* We also merge entries with the same allowed output routes */
3042                                 if (pNv->dcb_table.entry[i].or == pNv->dcb_table.entry[j].or) {
3043                                         xf86DrvMsg(0, X_INFO, "Merging DCB entries %d and %d!\n", i, j);
3044                                         pNv->dcb_table.entry[i].heads |= pNv->dcb_table.entry[j].heads;
3045
3046                                         pNv->dcb_table.entry[j].type = 100; /* dummy value */
3047                                 }
3048                         }
3049                 }
3050         }
3051
3052         /* Remove "disabled" entries (merged) */
3053         int valid_entries[pNv->dcb_table.entries];
3054         int cent = 0;
3055         for ( i = 0; i < pNv->dcb_table.entries; i ++) valid_entries[i] = -1;
3056         for ( i = 0; i < pNv->dcb_table.entries; i ++)
3057                 if ( pNv->dcb_table.entry[i].type != 100 ) {
3058                         valid_entries[cent] = i;
3059                         cent++;
3060                 }
3061         for ( i = 0; i < cent; i++) {
3062                 memmove(&pNv->dcb_table.entry[i], &pNv->dcb_table.entry[valid_entries[i]], sizeof(pNv->dcb_table.entry[i]));
3063                 memmove(&pNv->dcb_table.i2c_read[i], &pNv->dcb_table.i2c_read[valid_entries[i]], sizeof(pNv->dcb_table.i2c_read[i]));
3064                 memmove(&pNv->dcb_table.i2c_write[i], &pNv->dcb_table.i2c_write[valid_entries[i]], sizeof(pNv->dcb_table.i2c_write[i]));
3065         }
3066
3067         pNv->dcb_table.entries = cent;
3068
3069         return pNv->dcb_table.entries;
3070 }
3071
3072 unsigned int NVParseBios(ScrnInfoPtr pScrn)
3073 {
3074         unsigned int bit_offset;
3075         uint8_t nv_signature[]={0xff,0x7f,'N','V',0x0};
3076         uint8_t bit_signature[]={'B','I','T'};
3077         NVPtr pNv;
3078         pNv = NVPTR(pScrn);
3079
3080         pNv->dcb_table.entries = 0;
3081
3082         memset(&pNv->VBIOS, 0, sizeof(bios_t));
3083         pNv->VBIOS.execute = FALSE;
3084         pNv->VBIOS.data = xalloc(64 * 1024);
3085         if (!NVShadowVBIOS(pScrn, pNv->VBIOS.data)) {
3086                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
3087                            "No valid BIOS image found.\n");
3088                 xfree(pNv->VBIOS.data);
3089                 return 0;
3090         }
3091         pNv->VBIOS.length = pNv->VBIOS.data[2] * 512;
3092         if (pNv->VBIOS.length > NV_PROM_SIZE)
3093                 pNv->VBIOS.length = NV_PROM_SIZE;
3094
3095         /* parse Display Configuration Block (DCB) table */
3096         if (parse_dcb_table(pScrn, &pNv->VBIOS))
3097                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3098                            "Found %d entries in DCB.\n", pNv->dcb_table.entries);
3099
3100         /* check for known signatures */
3101         if ((bit_offset = findstr(&pNv->VBIOS, bit_signature, sizeof(bit_signature)))) {
3102                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "BIT signature found.\n");
3103                 parse_bit_structure(pScrn, &pNv->VBIOS, bit_offset + 4);
3104         } else if ((bit_offset = findstr(&pNv->VBIOS, nv_signature, sizeof(nv_signature)))) {
3105                 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "NV signature found.\n");
3106                 parse_pins_structure(pScrn, &pNv->VBIOS, bit_offset);
3107         } else
3108                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
3109                            "No known script signature found.\n");
3110
3111         return 1;
3112 }