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

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

enum {
       NSeqx           = 0x05,
       NCrtx           = 0x19,
       NGrx            = 0x09,
       NAttrx          = 0x15,
};

uchar
vgai(long port)
{
       uchar data;

       switch(port){

       case MiscR:
       case Status0:
       case Status1:
       case FeatureR:
       case PaddrW:
       case Pdata:
       case Pixmask:
       case Pstatus:
               data = inportb(port);
               break;

       default:
               error("vgai(0x%4.4lX): unknown port\n", port);
               /*NOTREACHED*/
               data = 0xFF;
               break;
       }
       return data;
}

uchar
vgaxi(long port, uchar index)
{
       uchar data;

       switch(port){

       case Seqx:
       case Crtx:
       case Grx:
               outportb(port, index);
               data = inportb(port+1);
               break;

       case Attrx:
               /*
                * Allow processor access to the colour
                * palette registers. Writes to Attrx must
                * be preceded by a read from Status1 to
                * initialise the register to point to the
                * index register and not the data register.
                * Processor access is allowed by turning
                * off bit 0x20.
                */
               inportb(Status1);
               if(index < 0x10){
                       outportb(Attrx, index);
                       data = inportb(Attrx+1);
                       inportb(Status1);
                       outportb(Attrx, 0x20|index);
               }
               else{
                       outportb(Attrx, 0x20|index);
                       data = inportb(Attrx+1);
               }
               break;

       default:
               error("vgaxi(0x%4.4lx, 0x%2.2uX): unknown port\n", port, index);
               /*NOTREACHED*/
               data = 0xFF;
               break;
       }
       return data;
}

void
vgao(long port, uchar data)
{
       switch(port){

       case MiscW:
       case FeatureW:
       case PaddrW:
       case Pdata:
       case Pixmask:
       case PaddrR:
               outportb(port, data);
               break;

       default:
               error("vgao(0x%4.4lX, 0x%2.2uX): unknown port\n", port, data);
               /*NOTREACHED*/
               break;
       }
}

void
vgaxo(long port, uchar index, uchar data)
{
       switch(port){

       case Seqx:
       case Crtx:
       case Grx:
               /*
                * We could use an outport here, but some chips
                * (e.g. 86C928) have trouble with that for some
                * registers.
                */
               outportb(port, index);
               outportb(port+1, data);
               break;

       case Attrx:
               inportb(Status1);
               if(index < 0x10){
                       outportb(Attrx, index);
                       outportb(Attrx, data);
                       inportb(Status1);
                       outportb(Attrx, 0x20|index);
               }
               else{
                       outportb(Attrx, 0x20|index);
                       outportb(Attrx, data);
               }
               break;

       default:
               error("vgaxo(0x%4.4lX, 0x%2.2uX, 0x%2.2uX): unknown port\n",
                       port, index, data);
               break;
       }
}

static void
snarf(Vga* vga, Ctlr* ctlr)
{
       int i;

       /*
        * Generic VGA registers:
        *      misc, feature;
        *      sequencer;
        *      crt;
        *      graphics;
        *      attribute;
        *      palette.
        */
       vga->misc = vgai(MiscR);
       vga->feature = vgai(FeatureR);

       for(i = 0; i < NSeqx; i++)
               vga->sequencer[i] = vgaxi(Seqx, i);

       for(i = 0; i < NCrtx; i++)
               vga->crt[i] = vgaxi(Crtx, i);

       for(i = 0; i < NGrx; i++)
               vga->graphics[i] = vgaxi(Grx, i);

       for(i = 0; i < NAttrx; i++)
               vga->attribute[i] = vgaxi(Attrx, i);

       if(dflag)
               palette.snarf(vga, ctlr);

       ctlr->flag |= Fsnarf;
}

static void
init(Vga* vga, Ctlr* ctlr)
{
       Mode *mode;
       int vt, vde, vrs, vre;
       ulong tmp;

       mode = vga->mode;

       memset(vga->sequencer, 0, NSeqx*sizeof(vga->sequencer[0]));
       memset(vga->crt, 0, NCrtx*sizeof(vga->crt[0]));
       memset(vga->graphics, 0, NGrx*sizeof(vga->graphics[0]));
       memset(vga->attribute, 0, NAttrx*sizeof(vga->attribute[0]));
       if(dflag)
               memset(vga->palette, 0, sizeof(vga->palette));

       /*
        * Misc. If both the horizontal and vertical sync polarity
        * options are set, use them. Otherwise use the defaults for
        * the given vertical size.
        */
       vga->misc = 0x23;
       if(mode->frequency == VgaFreq1)
               vga->misc |= 0x04;
       if(mode->hsync && mode->vsync){
               if(mode->hsync == '-')
                       vga->misc |= 0x40;
               if(mode->vsync == '-')
                       vga->misc |= 0x80;
       }
       else{
               if(mode->y < 480)
                       vga->misc |= 0x40;
               else if(mode->y < 400)
                       vga->misc |= 0x80;
               else if(mode->y < 768)
                       vga->misc |= 0xC0;
       }

       /*
        * Sequencer
        */
       vga->sequencer[0x00] = 0x03;
       vga->sequencer[0x01] = 0x01;
       vga->sequencer[0x02] = 0x0F;
       vga->sequencer[0x03] = 0x00;
       if(mode->z >= 8)
               vga->sequencer[0x04] = 0x0A;
       else
               vga->sequencer[0x04] = 0x06;

       /*
        * Crt. Most of the work here is in dealing
        * with field overflow.
        */
       memset(vga->crt, 0, NCrtx);

       vga->crt[0x00] = (mode->ht>>3)-5;
       vga->crt[0x01] = (mode->x>>3)-1;
       vga->crt[0x02] = (mode->shb>>3)-1;

       /*
        * End Horizontal Blank is a 6-bit field, 5-bits
        * in Crt3, high bit in Crt5.
        */
       tmp = mode->ehb>>3;
       vga->crt[0x03] = 0x80|(tmp & 0x1F);
       if(tmp & 0x20)
               vga->crt[0x05] |= 0x80;

       vga->crt[0x04] = mode->shs>>3;
       vga->crt[0x05] |= ((mode->ehs>>3) & 0x1F);

       /*
        * Vertical Total is 10-bits, 8 in Crt6, the high
        * two bits in Crt7. What if vt is >= 1024? We hope
        * the specific controller has some more overflow
        * bits.
        *
        * Interlace: if 'v',  divide the vertical timing
        * values by 2.
        */
       vt = mode->vt;
       vde = mode->y;
       vrs = mode->vrs;
       vre = mode->vre;

       if(mode->interlace == 'v'){
               vt /= 2;
               vde /= 2;
               vrs /= 2;
               vre /= 2;
       }

       tmp = vt-2;
       vga->crt[0x06] = tmp;
       if(tmp & 0x100)
               vga->crt[0x07] |= 0x01;
       if(tmp & 0x200)
               vga->crt[0x07] |= 0x20;

       tmp = vrs;
       vga->crt[0x10] = tmp;
       if(tmp & 0x100)
               vga->crt[0x07] |= 0x04;
       if(tmp & 0x200)
               vga->crt[0x07] |= 0x80;

       vga->crt[0x11] = 0x20|(vre & 0x0F);

       tmp = vde-1;
       vga->crt[0x12] = tmp;
       if(tmp & 0x100)
               vga->crt[0x07] |= 0x02;
       if(tmp & 0x200)
               vga->crt[0x07] |= 0x40;

       vga->crt[0x15] = vrs;
       if(vrs & 0x100)
               vga->crt[0x07] |= 0x08;
       if(vrs & 0x200)
               vga->crt[0x09] |= 0x20;

       vga->crt[0x16] = (vrs+1);

       vga->crt[0x17] = 0x83;
       tmp = ((vga->virtx*mode->z)/8);
       if(tmp >= 512){
               vga->crt[0x14] |= 0x60;
               tmp /= 8;
       }
       else if(tmp >= 256){
               vga->crt[0x17] |= 0x08;
               tmp /= 4;
       }
       else{
               vga->crt[0x17] |= 0x40;
               tmp /= 2;
       }
       vga->crt[0x13] = tmp;

       if(mode->x*mode->y*mode->z/8 > 64*1024)
               vga->crt[0x17] |= 0x20;

       vga->crt[0x18] = 0x7FF;
       if(vga->crt[0x18] & 0x100)
               vga->crt[0x07] |= 0x10;
       if(vga->crt[0x18] & 0x200)
               vga->crt[0x09] |= 0x40;

       /*
        * Graphics
        */
       memset(vga->graphics, 0, NGrx);
       if((vga->sequencer[0x04] & 0x04) == 0)
               vga->graphics[0x05] |= 0x10;
       if(mode->z >= 8)
               vga->graphics[0x05] |= 0x40;
       vga->graphics[0x06] = 0x05;
       vga->graphics[0x07] = 0x0F;
       vga->graphics[0x08] = 0xFF;

       /*
        * Attribute
        */
       memset(vga->attribute, 0, NAttrx);
       for(tmp = 0; tmp < 0x10; tmp++)
               vga->attribute[tmp] = tmp;
       vga->attribute[0x10] = 0x01;
       if(mode->z >= 8)
               vga->attribute[0x10] |= 0x40;
       vga->attribute[0x11] = 0xFF;
       vga->attribute[0x12] = 0x0F;

       /*
        * Palette
        */
       if(dflag)
               palette.init(vga, ctlr);

       ctlr->flag |= Finit;
}

static void
load(Vga* vga, Ctlr* ctlr)
{
       int i;

       /*
        * Reset the sequencer and leave it off.
        * Load the generic VGA registers:
        *      misc;
        *      sequencer (but not seq01, display enable);
        *      take the sequencer out of reset;
        *      take off write-protect on crt[0x00-0x07];
        *      crt;
        *      graphics;
        *      attribute;
        *      palette.
       vgaxo(Seqx, 0x00, 0x00);
        */

       vgao(MiscW, vga->misc);

       for(i = 2; i < NSeqx; i++)
               vgaxo(Seqx, i, vga->sequencer[i]);
       /*vgaxo(Seqx, 0x00, 0x03);*/

       vgaxo(Crtx, 0x11, vga->crt[0x11] & ~0x80);
       for(i = 0; i < NCrtx; i++)
               vgaxo(Crtx, i, vga->crt[i]);

       for(i = 0; i < NGrx; i++)
               vgaxo(Grx, i, vga->graphics[i]);

       for(i = 0; i < NAttrx; i++)
               vgaxo(Attrx, i, vga->attribute[i]);

       if(dflag)
               palette.load(vga, ctlr);

       ctlr->flag |= Fload;
}

static void
dump(Vga* vga, Ctlr* ctlr)
{
       int i;

       printitem(ctlr->name, "misc");
       printreg(vga->misc);
       printitem(ctlr->name, "feature");
       printreg(vga->feature);

       printitem(ctlr->name, "sequencer");
       for(i = 0; i < NSeqx; i++)
               printreg(vga->sequencer[i]);

       printitem(ctlr->name, "crt");
       for(i = 0; i < NCrtx; i++)
               printreg(vga->crt[i]);

       printitem(ctlr->name, "graphics");
       for(i = 0; i < NGrx; i++)
               printreg(vga->graphics[i]);

       printitem(ctlr->name, "attribute");
       for(i = 0; i < NAttrx; i++)
               printreg(vga->attribute[i]);

       if(dflag)
               palette.dump(vga, ctlr);

       printitem(ctlr->name, "virtual");
       Bprint(&stdout, "%ld %ld\n", vga->virtx, vga->virty);
       printitem(ctlr->name, "panning");
       Bprint(&stdout, "%s\n", vga->panning ? "on" : "off");
       if(vga->f[0]){
               printitem(ctlr->name, "clock[0] f");
               Bprint(&stdout, "%9ld\n", vga->f[0]);
               printitem(ctlr->name, "clock[0] d i m");
               Bprint(&stdout, "%9ld %8ld       - %8ld\n",
                       vga->d[0], vga->i[0], vga->m[0]);
               printitem(ctlr->name, "clock[0] n p q r");
               Bprint(&stdout, "%9ld %8ld       - %8ld %8ld\n",
                       vga->n[0], vga->p[0], vga->q[0], vga->r[0]);
       }
       if(vga->f[1]){
               printitem(ctlr->name, "clock[1] f");
               Bprint(&stdout, "%9ld\n", vga->f[1]);
               printitem(ctlr->name, "clock[1] d i m");
               Bprint(&stdout, "%9ld %8ld       - %8ld\n",
                       vga->d[1], vga->i[1], vga->m[1]);
               printitem(ctlr->name, "clock[1] n p q r");
               Bprint(&stdout, "%9ld %8ld       - %8ld %8ld\n",
                       vga->n[1], vga->p[1], vga->q[1], vga->r[1]);
       }

       if(vga->vma || vga->vmb){
               printitem(ctlr->name, "vm a b");
               Bprint(&stdout, "%9lud %8lud\n", vga->vma, vga->vmb);
       }
       if(vga->vmz){
               printitem(ctlr->name, "vmz");
               Bprint(&stdout, "%9lud\n", vga->vmz);
       }
       printitem(ctlr->name, "apz");
       Bprint(&stdout, "%9lud\n", vga->apz);

       printitem(ctlr->name, "linear");
       Bprint(&stdout, "%9d\n", vga->linear);
}

Ctlr generic = {
       "vga",                          /* name */
       snarf,                          /* snarf */
       0,                              /* 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.