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