#include <u.h>
#include <libc.h>
#include <bio.h>

#include "pci.h"
#include "vga.h"

/*
* S3 Trio/ViRGE/Savage4
* Requires work.
*/

/* on some cards, savage4mem[1] == 8, but i don't know how to tell. -rsc */
static uchar savage4mem[] = { 2, 4, 8, 12, 16, 32, 0, 32};
static void
snarf(Vga* vga, Ctlr* ctlr)
{
       int i, id;
       char *p;

       /*
        * The Trio/ViRGE variants have some extra sequencer registers
        * which need to be unlocked for access.
        */
       vgaxo(Seqx, 0x08, 0x06);
       s3generic.snarf(vga, ctlr);

       for(i = 0x08; i < 0x4F; i++)
               vga->sequencer[i] = vgaxi(Seqx, i);
       vga->crt[0x2D] = vgaxi(Crtx, 0x2D);
       vga->crt[0x2E] = vgaxi(Crtx, 0x2E);
       vga->crt[0x2F] = vgaxi(Crtx, 0x2F);
       for(i = 0x70; i < 0x99; i++)
               vga->crt[i] = vgaxi(Crtx, i);

       id = (vga->crt[0x2D]<<8)|vga->crt[0x2E];
       switch(id){

       default:
               trace("Unknown ViRGE/Trio64+ - 0x%4.4uX\n",
                       (vga->crt[0x2D]<<8)|vga->crt[0x2E]);
               /*FALLTHROUGH*/

       case 0x8810:                            /* Microsoft Virtual PC 2004 */
       case 0x8811:                            /* Trio64+ */
               vga->r[1] = 3;
               vga->m[1] = 127;
               vga->n[1] = 31;
               vga->f[1] = 135000000;
               trace("Trio64+\n");
               break;

       case 0x8812:                            /* Aurora64V+ */
               vga->r[1] = 3;
               vga->m[1] = 127;
               vga->n[1] = 63;
               vga->f[1] = 135000000;
               trace("Aurora64V+\n");
               break;

       case 0x8901:                            /* Trio64V2 */
               vga->r[1] = 4;
               vga->m[1] = 127;
               vga->n[1] = 31;
               vga->f[1] = 170000000;
               trace("Trio64V2\n");
               break;

       case 0x5631:                            /* ViRGE */
               vga->r[1] = 3;
               vga->m[1] = 127;
               vga->n[1] = 31;
               vga->f[1] = 135000000;
               vga->apz = 64*1024*1024;
               trace("ViRGE\n");
               break;

       case 0x8A01:                            /* ViRGE/[DG]X */
               vga->r[1] = 4;
               vga->m[1] = 127;
               vga->n[1] = 31;
               vga->f[1] = 170000000;
               trace("ViRGE/[DG]X\n");
               break;

       case 0x8A10:                            /* ViRGE/GX2 */
               vga->r[1] = 4;
               vga->m[1] = 127;
               vga->n[1] = 31;
               vga->f[1] = 170000000;
               vga->apz = 64*1024*1024;
               trace("ViRGE/GX2\n");
               /*
                * Memory encoding on the ViRGE/GX2 is different.
                */
               switch((vga->crt[0x36]>>6) & 0x03){

               case 0x01:
                       vga->vmz = 4*1024*1024;
                       break;

               case 0x03:
                       vga->vmz = 2*1024*1024;
                       break;
               }
               break;

       case 0x883D:                            /* ViRGE/VX */
               vga->r[1] = 4;
               vga->m[1] = 127;
               vga->n[1] = 31;
               vga->f[1] = 220000000;
               vga->apz = 64*1024*1024;
               trace("ViRGE/VX\n");
               /*
                * Memory encoding on the ViRGE/VX is different.
                */
               vga->vmz = (2*(((vga->crt[0x36]>>5) & 0x03)+1)) * 1*1024*1024;
               break;

       case 0x8C10:                            /* Savage MX/MV */
       case 0x8C12:                            /* Savage4/IX-MV */
               vga->r[1] = 4;
               vga->m[1] = 127;
               vga->n[1] = 127;
               vga->f[1] = 135000000;          /* without clock-doubling */
               for(i = 0x50; i < 0x70; i++)
                       vga->sequencer[i] = vgaxi(Seqx, i);
               vga->apz = 128*1024*1024;
               vga->vmz = savage4mem[vga->crt[0x36]>>5] * 1024 * 1024;
               trace("Savage4/IX-MV\n");
               break;

       case 0x8C2E:                            /* SuperSavage/IXC16 */
               /*
                * This is all guessed, from the Savage4/IX,
                * inspection of the card (apz), and web pages
                * talking about the chip (f[1]).  It seems to
                * work on the IBM Thinkpad T23.
                *
                * XXX only 1024x768 works, not 1400x1050.
                */
               vga->r[1] = 4;
               vga->m[1] = 127;
               vga->n[1] = 127;
               vga->f[1] = 135000000;          /* 300000000 after doubling? */
               for(i = 0x50; i < 0x70; i++)
                       vga->sequencer[i] = vgaxi(Seqx, i);
               vga->apz = 64*1024*1024;
               vga->vmz = savage4mem[vga->crt[0x36]>>5] * 1024 * 1024;
               trace("SuperSavage/IXC16\n");
               break;

       case 0x8A22:                            /* Savage4 */
       case 0x8A25:                            /* ProSavage PN133 */
       case 0x8A26:                            /* ProSavage KN133 */
       case 0x8D04:                            /* ProSavage DDR, K.Okamoto */
               vga->r[1] = 4;
               vga->m[1] = 511;
               vga->n[1] = 127;
               vga->f[1] = 300000000;

               vga->apz = 128*1024*1024;
               vga->vmz = savage4mem[vga->crt[0x36]>>5] * 1024 * 1024;
               trace("Savage4\n");
               break;
       }

       /*
        * Work out the part speed-grade from name. Name can have,
        * e.g. '-135' on the end for 135MHz part.
        */
       if(p = strrchr(ctlr->name, '-'))
               vga->f[1] = strtoul(p+1, 0, 0) * 1000000;

       ctlr->flag |= Fsnarf;
}

static void
options(Vga *vga, Ctlr* ctlr)
{
       int id;

       id = (vga->crt[0x2D]<<8)|(vga->crt[0x2E]);
       switch(id){
       case 0x8C2E:                            /* SuperSavage/IXC16 */
       case 0x8C10:                            /* Savage MX/MV */
       case 0x8C12:                            /* Savage4/IX-MV */
       case 0x8A22:                            /* Savage4 */
       case 0x8A25:                            /* ProSavage PN133 */
       case 0x8A26:                            /* ProSavage KN133 */
       case 0x8D04:                            /* ProSavabe DDR, K.Okamoto */
               /*
                * Round up so stride is multiple of 16.
                */
               if(vga->virtx%16)
                       vga->virtx = (vga->virtx+15)&~15;
               break;
       }

       ctlr->flag |= Hlinear|Hpclk2x8|Henhanced|Foptions;
}

static void
init(Vga* vga, Ctlr* ctlr)
{
       char *p, *val;
       Mode *mode;
       ulong pclk, x;
       int id, noclockset, width;

       id = (vga->crt[0x2D]<<8)|vga->crt[0x2E];
       mode = vga->mode;

       /*
        * double 16bpp horizontal timings on ViRGE/[DG]X
        * leaves overflow bit-fiddling to s3generic.init
        */
       if((id == 0x8A01) && ((mode->z+7)/8 == 2)){
               resyncinit(vga, ctlr, Uenhanced, 0);
               vga->crt[0x00] = ((mode->ht * 2) >> 3) - 5;
               vga->crt[0x01] = ((mode->x * 2) >> 3) - 1;
               vga->crt[0x02] = ((mode->shb * 2) >> 3) - 1;
               x = (mode->ehb * 2) >> 3;
               vga->crt[0x03] = 0x80 | (x & 0x1F);
               vga->crt[0x04] = (mode->shs * 2) >> 3;
               vga->crt[0x05] = ((mode->ehs * 2) >> 3) & 0x1F;
               if(x & 0x20)
                       vga->crt[0x05] |= 0x80;
       }
       s3generic.init(vga, ctlr);

       /*
        * Work out the part speed-grade from name. Name can have,
        * e.g. '-135' on the end for 135MHz part.
        */
       noclockset = 0;
       if(p = strrchr(ctlr->name, '-'))
               vga->f[1] = strtoul(p+1, 0, 0) * 1000000;
       pclk = vga->f[1];

       if(vga->mode->z > 8)
               width = vga->virtx*(vga->mode->z/8);
       else
               width = vga->virtx*(8/vga->mode->z);

       switch(id){

       case 0x8810:                            /* Microsoft Virtual PC 2004 */
       case 0x8811:                            /* Trio64+ */
               /*
                * Part comes in -135MHz speed grade. In 8-bit mode
                * the maximum DCLK is 80MHz. In 2x8-bit mode the maximum
                * DCLK is 135MHz using the internal clock doubler.
                */
               if((ctlr->flag & Hpclk2x8) && vga->mode->z == 8){
                       if(vga->f[0] > 80000000)
                               ctlr->flag |= Upclk2x8;
               }
               else
                       pclk = 80000000;

               vga->crt[0x67] &= ~0xF2;
               if(ctlr->flag & Upclk2x8){
                       vga->sequencer[0x15] |= 0x10;
                       vga->sequencer[0x18] |= 0x80;
                       /*
                        * There's a little strip of the border
                        * appears on the left in resolutions
                        * 1280 and above if the 0x02 bit isn't
                        * set (when it appears on the right...).
                        */
                       vga->crt[0x67] |= 0x10;
               }

               /*
                * VLB address latch delay.
                */
               if((vga->crt[0x36] & 0x03) == 0x01)
                       vga->crt[0x58] &= ~0x08;

               /*
                * Display memory access control.
                */
               vga->crt[0x60] = 0xFF;

               if(vga->mode->z > 8)
                       error("trio64: depth %d not supported\n", vga->mode->z);
               break;

       case 0x8901:                            /* Trio64V2 */
               vga->crt[0x90] = 0;
               vga->crt[0x91] = 0;
               break;
       case 0x8A10:                            /* ViRGE/GX2 */
               vga->crt[0x90] = 0;

               vga->crt[0x31] |= 0x08;

               vga->crt[0x13] = (width>>3) & 0xFF;
               vga->crt[0x51] &= ~0x30;
               vga->crt[0x51] |= (width>>7) & 0x30;

               /*
                * Increase primary FIFO threshold
                * to reduce flicker and tearing.
                */
               vga->crt[0x85] = 0x0F;

               /*FALLTHROUGH*/
       case 0x5631:                            /* ViRGE */
       case 0x8A01:                            /* ViRGE/[DG]X */
               if(id == 0x8A01){
                       x = mode->x * ((mode->z + 7) / 8);
                       x = (x + 7) / 8;
                       vga->crt[0x91] = x & 0xFF;
                       vga->crt[0x90] = (x >> 8) | 0x80;
               }
       case 0x883D:                            /* ViRGE/VX */
               vga->crt[0x60] &= 0x0F;
               /*FALLTHROUGH*/
       case 0x8812:                            /* Aurora64V+ */
               if(id == 0x8812)                /* Aurora64V+ */
                       noclockset = 1;
               vga->crt[0x65] = 0;
               vga->crt[0x66] = 0x89;
               vga->crt[0x67] = 0;

               if(id == 0x883D){               /* ViRGE/VX */
                       /*
                        * Put the VRAM in 1-cycle EDO mode.
                        * If it is not put in this mode, hardware acceleration
                        * will leave little turds on the screen when hwfill is used.
                        */
                       vga->crt[0x36] &= ~0x0C;

                       if(vga->mode->x > 800 && vga->mode->z == 8)
                               vga->crt[0x67] = 0x10;
                       else
                               vga->crt[0x67] = 0;

                       /*
                        * Adjustments to the generic settings:
                        *      heuristic fiddling.
                        *
                        * We used to set crt[0x66] to 0x89, but setting it
                        * to 0x90 seems to allow us (and more importantly the card)
                        * to access more than 2MB of memory.
                        */
                       vga->crt[0x66] = 0x90;
                       vga->crt[0x58] &= ~0x88;
                       vga->crt[0x58] |= 0x40;
                       if(vga->mode->x > 640 && vga->mode->z >= 8)
                               vga->crt[0x63] |= 0x01;
                       else
                               vga->crt[0x63] &= ~0x01;
               }

               /*
                * The high nibble is the mode; or'ing in 0x02 turns
                * on support for gamma correction via the DACs, but I
                * haven't figured out how to turn on the 8-bit DACs,
                * so gamma correction stays off.
                */
               switch(vga->mode->z){
               case 1:
               case 2:
               case 4:
               case 8:
               default:
                       vga->crt[0x67] |= 0x00;
                       break;
               case 15:
                       vga->crt[0x67] |= 0x30;
                       break;
               case 16:
                       vga->crt[0x67] |= 0x50;
                       break;
               case 24:
                       if(id == 0x8A10)        /* GX2 has to be different */
                               vga->crt[0x67] |= 0x70;
                       else
                               vga->crt[0x67] |= 0xD0;
                       break;
               case 32:
                       /*
                        * The ViRGE and ViRGE/VX manuals make no mention of
                        * 32-bit mode (which the GX/2 calls 24-bit unpacked mode).
                        */
                       if(id != 0x8A10)
                               error("32-bit mode only supported on the GX/2\n");
                       vga->crt[0x67] |= 0xD0;
                       break;
               }

               /*
                * Set new MMIO method
                */
               vga->crt[0x53] &= ~0x18;
               vga->crt[0x53] |= 0x08;

               break;

       case 0x8C2E:                            /* SuperSavage/IXC16 (let's try this -rsc) */
       case 0x8C10:                            /* Savage MX/MV */
       case 0x8C12:                            /* Savage4/IX-MV */
               /*
                * Experience shows the -1 (according to the manual)
                * is incorrect.
                */
               x = width/8 /*-1*/;
               vga->crt[0x91] = x;
               vga->crt[0x90] &= ~0x07;
               vga->crt[0x90] |= (x>>8) & 0x07;

       case 0x8D04:                            /* ProSavage DDR, K.Okamoto */
               x = mode->x * ((mode->z + 7) / 8);
               x = (x + 7) / 8;
               vga->crt[0x91] = x & 0xFF;
               vga->crt[0x90] = (x >> 8) | 0x80;

               /*FALLTHROUGH*/

       case 0x8A22:                            /* Savage4 */
       case 0x8A25:                            /* ProSavage PN133 */
       case 0x8A26:                            /* ProSavage KN133 */
               /*
                * The Savage 4 is frustratingly similar to the
                * ViRGE/GX2, but has enough slight differences
                * to warrant special treatment.  Blog.
                */
               vga->crt[0x66] = 0x89;
               vga->crt[0x67] = 0;
               vga->crt[0x85] = 0x02;
               vga->crt[0x31] |= 0x08;

               vga->crt[0x13] = (width>>3) & 0xFF;
               vga->crt[0x51] &= ~0x30;
               vga->crt[0x51] |= (width>>7) & 0x30;

               /* pull screen width from GBD for graphics engine. */
               vga->crt[0x50] = 0xC1;  /* set color mode */

               /*
                * The high nibble is the mode; or'ing in 0x02 turns
                * on support for gamma correction via the DACs, but I
                * haven't figured out how to turn on the 8-bit DACs,
                * so gamma correction stays off.
                */
               switch(vga->mode->z){
               default:
                       error("%d-bit mode not supported on savage 4\n", vga->mode->z);
               case 8:
                       vga->crt[0x67] |= 0x00;
                       vga->crt[0x50] |= 0<<4;
                       break;
               case 15:
                       vga->crt[0x67] |= 0x20;
                       vga->crt[0x50] |= 1<<4;
                       break;
               case 16:
                       vga->crt[0x67] |= 0x40;
                       vga->crt[0x50] |= 1<<4;
                       /*
                        * Manual says this should be accompanied by setting
                        * the clock-doubled modes but this seems to be the
                        * right answer.
                        * Should check if using doubled modes tidies any of
                        * this up.
                        */
                       if(id == 0x8C12 || id == 0x8C2E || id == 0x8C10)
                               vga->crt[0x67] |= 0x10;
                       break;
               case 32:
                       vga->crt[0x67] |= 0xD0;
                       vga->crt[0x50] |= 3<<4;
                       break;
               }
               break;
       }

       /*
        * Clock bits. If the desired video clock is
        * one of the two standard VGA clocks it can just be
        * set using bits <3:2> of vga->misc, otherwise we
        * need to programme the DCLK PLL.
        */
       if(val = dbattr(vga->mode->attr, "noclockset")){
                if((noclockset = strtol(val, &p, 0)) == 0 && p == val)
                       error("%s: invalid 'noclockset' attr\n", ctlr->name);
       }
       if(vga->f[0] == 0)
               vga->f[0] = vga->mode->frequency;
       vga->misc &= ~0x0C;
       if(vga->f[0] == VgaFreq0){
               /* nothing to do */;
       }
       else if(vga->f[0] == VgaFreq1)
               vga->misc |= 0x04;
       else if(noclockset){
               /*
                * Don't touch the clock on the Aurora64V+
                * and optionally on some others.
                */
               vga->misc |= 0x0C;
       }
       else{
               if(vga->f[0] > pclk)
                       error("%s: invalid pclk - %lud\n",
                               ctlr->name, vga->f[0]);

               trio64clock(vga, ctlr);
               switch(id){

               case 0x8A10:                    /* ViRGE/GX2 */
                       vga->sequencer[0x12] = (vga->r[0]<<6)|vga->n[0];
                       if(vga->r[0] & 0x04)
                               vga->sequencer[0x29] |= 0x01;
                       else
                               vga->sequencer[0x29] &= ~0x01;
                       break;

               case 0x8C2E:                    /* SuperSavage/IXC16 (let's try this -rsc) */
               case 0x8C10:                    /* Savage MX/MV */
               case 0x8C12:                    /* Savage4/IX-MV */
               case 0x8A22:                    /* Savage4 */
               case 0x8A25:                    /* ProSavage PN133 */
               case 0x8A26:                    /* ProSavage KN133 */
               case 0x8D04:                    /* ProSavage DDR, K.Okamoto */
                       vga->sequencer[0x12] = (vga->r[0]<<6)|(vga->n[0] & 0x3F);
                       vga->sequencer[0x39] &= ~0x01;
                       vga->sequencer[0x29] &= ~0x1C;
                       if(vga->r[0] & 0x04)
                               vga->sequencer[0x29] |= (1<<2);
                       if(vga->m[0] & 0x100)
                               vga->sequencer[0x29] |= (1<<3);
                       if(vga->n[0] & 0x40)
                               vga->sequencer[0x29] |= (1<<4);
                       break;

               default:
                       vga->sequencer[0x12] = (vga->r[0]<<5)|vga->n[0];
                       break;
               }
               vga->sequencer[0x13] = vga->m[0];
               vga->misc |= 0x0C;
       }

       /*
        * Internal clock generator.
        */
       vga->sequencer[0x15] &= ~0x31;
       vga->sequencer[0x15] |= 0x02;
       vga->sequencer[0x18] &= ~0x80;

       /*
        * Start display FIFO fetch.
        */
       x = (vga->crt[0]+vga->crt[4]+1)/2;
       vga->crt[0x3B] = x;
       if(x & 0x100)
               vga->crt[0x5D] |= 0x40;

       /*
        * Display memory access control.
        * Calculation of the M-parameter (Crt54) is
        * memory-system and dot-clock dependent, the
        * values below are guesses from dumping
        * registers.
        * The Savage4 does not document 0x54,
        * but we leave this anyway.
        */
       if(vga->mode->x <= 800)
               vga->crt[0x54] = 0xE8;
       else if(vga->mode->x <= 1024 && id != 0x8C12 && id != 0x8C2E)
               vga->crt[0x54] = 0xA8;
       else
               vga->crt[0x54] = 0x00/*0x48*/;

       ctlr->flag |= Finit;
}

static void
load(Vga* vga, Ctlr* ctlr)
{
       int id;
       ushort advfunc;

       s3generic.load(vga, ctlr);

       /*
        * Load the PLL registers if necessary.
        * Not sure if the variable-delay method of setting the
        * PLL will work without a write here to vga->misc,
        * so use the immediate-load method by toggling bit 5
        * of Seq15 if necessary.
        */
       vgaxo(Seqx, 0x12, vga->sequencer[0x12]);
       vgaxo(Seqx, 0x13, vga->sequencer[0x13]);
       id = (vga->crt[0x2D]<<8)|vga->crt[0x2E];
       switch(id){
       case 0x883D:                            /* ViRGE/VX*/
               vgaxo(Crtx, 0x36, vga->crt[0x36]);
               break;
       case 0x8A10:                            /* ViRGE/GX2 */
               vgaxo(Seqx, 0x29, vga->sequencer[0x29]);
               break;
       case 0x8C2E:                            /* SuperSavage/IXC16 (let's try this -rsc) */
       case 0x8C12:                            /* Savage4/IX-MV */
               vgaxo(Crtx, 0x90, vga->crt[0x90]);
               vgaxo(Crtx, 0x91, vga->crt[0x91]);
               /*FALLTHROUGH*/
       case 0x8A22:                            /* Savage4 */
       case 0x8A25:                            /* ProSavage PN133 */
       case 0x8A26:                            /* ProSavage KN133 */
       case 0x8D04:                            /* ProSavage DDR, K.Okamoto */
               vgaxo(Seqx, 0x29, vga->sequencer[0x29]);
               vgaxo(Seqx, 0x39, vga->sequencer[0x39]);
               break;
       }
       if((vga->misc & 0x0C) == 0x0C)
               vgaxo(Seqx, 0x15, vga->sequencer[0x15]|0x20);
       vgaxo(Seqx, 0x15, vga->sequencer[0x15]);
       vgaxo(Seqx, 0x18, vga->sequencer[0x18]);

       vgaxo(Crtx, 0x60, vga->crt[0x60]);
       vgaxo(Crtx, 0x63, vga->crt[0x63]);
       vgaxo(Crtx, 0x65, vga->crt[0x65]);
       vgaxo(Crtx, 0x66, vga->crt[0x66]);
       vgaxo(Crtx, 0x67, vga->crt[0x67]);

       switch(id){

       case 0x8810:                            /* Microsoft Virtual PC 2004 */
       case 0x8811:                            /* Trio64+ */
               advfunc = 0x0000;
               if(ctlr->flag & Uenhanced)
                       advfunc = 0x0001;
               outportw(0x4AE8, advfunc);
               break;
       case 0x8901:                            /* Trio64V2 */
       case 0x8A01:                            /* ViRGE/[DG]X */
               vgaxo(Crtx, 0x90, vga->crt[0x90]);
               vgaxo(Crtx, 0x91, vga->crt[0x91]);
               break;
       case 0x8A10:                            /* ViRGE/GX2 */
               vgaxo(Crtx, 0x90, vga->crt[0x90]);
               vgaxo(Crtx, 0x31, vga->crt[0x31]);
               vgaxo(Crtx, 0x13, vga->crt[0x13]);
               vgaxo(Crtx, 0x51, vga->crt[0x51]);
               vgaxo(Crtx, 0x85, vga->crt[0x85]);
               break;
       case 0x8D04:                            /* ProSavage DDR, K.Okamoto */
               vgaxo(Crtx, 0x90, vga->crt[0x90]);              //K.Okamoto
               vgaxo(Crtx, 0x91, vga->crt[0x91]);              //K.Okamoto
       case 0x8C2E:                            /* SuperSavage/IXC16 (let's try this -rsc) */
       case 0x8C12:                            /* Savage4/IX-MV */
       case 0x8A22:                            /* Savage4 */
       case 0x8A25:                            /* ProSavage PN133 */
       case 0x8A26:                            /* ProSavage KN133 */
               vgaxo(Crtx, 0x31, vga->crt[0x31]);
               vgaxo(Crtx, 0x13, vga->crt[0x13]);
               vgaxo(Crtx, 0x51, vga->crt[0x51]);
               vgaxo(Crtx, 0x85, vga->crt[0x85]);
               vgaxo(Crtx, 0x50, vga->crt[0x50]);
               break;
       }
}

static void
dump(Vga* vga, Ctlr* ctlr)
{
       int i, id;
       ulong dclk, m, n, r;

       s3generic.dump(vga, ctlr);
       printitem(ctlr->name, "Crt70");
       for(i = 0x70; i < 0x99; i++)
               printreg(vga->crt[i]);

       printitem(ctlr->name, "Seq08");
       for(i = 0x08; i < 0x10; i++)
               printreg(vga->sequencer[i]);
       printitem(ctlr->name, "Seq10");
       for(i = 0x10; i < 0x50; i++)
               printreg(vga->sequencer[i]);
       id = (vga->crt[0x2D]<<8)|vga->crt[0x2E];
       switch(id){
       default:
               break;

       case 0x8812:                            /* Aurora64V+ */
       case 0x8C2E:                            /* SuperSavage/IXC16 (let's try this -rsc) */
       case 0x8C12:                            /* Savage4/IX-MV */
               printitem(ctlr->name, "Seq50");
               for(i = 0x50; i < 0x70; i++)
                       printreg(vga->sequencer[i]);
               break;
       }

       printitem(ctlr->name, "Crt2D");
       printreg(vga->crt[0x2D]);
       printreg(vga->crt[0x2E]);
       printreg(vga->crt[0x2F]);

       m = vga->sequencer[0x13] & vga->m[1];
       n = vga->sequencer[0x12] & vga->n[1];
       r = (vga->sequencer[0x12]>>5) & 0x03;

       switch(id){
       case 0x8812:                            /* Aurora64V+ */
               r = (vga->sequencer[0x12]>>6) & 0x03;
               break;
       case 0x8A01:                            /* ViRGE/[DG]X */
               r = (vga->sequencer[0x12]>>5) & 0x07;
               break;
       case 0x8A10:                            /* ViRGE/GX2 */
               r = (vga->sequencer[0x12]>>6) & 0x03;
               r |= (vga->sequencer[0x29] & 0x01)<<2;
               break;
       case 0x8C2E:                            /* SuperSavage/IXC16 (let's try this -rsc) */
       case 0x8C12:                            /* Savage4/IX-MV */
       case 0x8A22:                            /* Savage4 */
       case 0x8A25:                            /* ProSavage PN133 */
       case 0x8A26:                            /* ProSavage KN133 */
       case 0x8D04:                            /* Prosavage DDR, K.Okamoto */
               m = vga->sequencer[0x13] & 0xFF;
               if(vga->sequencer[0x29] & (1<<3))
                       m |= 0x100;
               if(vga->sequencer[0x29] & (1<<4))
                       n |= 0x40;
               r = (vga->sequencer[0x12]>>6) & 0x03;
               r |= (vga->sequencer[0x29] & (1<<2));
               break;
       }

       dclk = (m+2)*RefFreq;
       dclk /= (n+2)*(1<<r);
       printitem(ctlr->name, "dclk m n r");
       Bprint(&stdout, "%9ld %8ld       - %8ld %8ld\n", dclk, m, n, r);

       m = vga->sequencer[0x11] & 0x7F;
       n = vga->sequencer[0x10] & 0x1F;
       r = (vga->sequencer[0x10]>>5) & 0x03;   /* might be GX/2 specific */
       dclk = (m+2)*RefFreq;
       dclk /= (n+2)*(1<<r);
       printitem(ctlr->name, "mclk m n r");
       Bprint(&stdout, "%9ld %8ld       - %8ld %8ld\n", dclk, m, n, r);
}

Ctlr virge = {
       "virge",                        /* name */
       snarf,                          /* snarf */
       options,                        /* options */
       init,                           /* init */
       load,                           /* load */
       dump,                           /* dump */
};

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.