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

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

/*
* Matrox Millenium and Matrox Millenium II.
* Matrox MGA-2064W, MGA-2164W 3D graphics accelerators
* Texas Instruments Tvp3026 RAMDAC.
*/
enum {
       Meg             = 1024*1024,
       /* pci chip manufacturer */
       MATROX          = 0x102B,

       /* pci chip device ids */
       MGA2064         = 0x0519,
       MGA2164         = 0x051B,
       MGA2164AGP      = 0x051F,

       /* i/o ports */
       Crtcext         = 0x03DE,       /* CRTC Extensions */

       /* config space offsets */
       Devctrl         = 0x04,         /* Device Control */
       Option          = 0x40,         /* Option */

       /* control aperture offsets */
       RAMDAC          = 0x3C00,       /* RAMDAC registers */
       CACHEFLUSH      = 0x1FFF,
};

typedef struct {
       Pcidev* pci;
       int     devid;
       uchar*  membase1;
       uchar*  membase2;
       ulong   devctrl;
       ulong   option;
       uchar   crtcext[6];
       uchar   tvp[64];
       uchar   pclk[3];
       uchar   mclk[3];
       uchar   lclk[3];
} Mga;

static uchar
_tvp3026i(Vga* vga, Ctlr* ctlr, uchar reg)
{
       Mga *mga;

       if(reg >= 0x10)
               error("%s: tvp3026io: direct reg 0x%uX out of range\n", ctlr->name, reg);

       if(vga->private == nil)
               error("%s: tvp3026io: no *mga\n", ctlr->name);
       mga = vga->private;

       return *(mga->membase1+RAMDAC+reg);
}

static void
_tvp3026o(Vga* vga, Ctlr* ctlr, uchar reg, uchar data)
{
       Mga *mga;

       if(reg >= 0x10)
               error("%s: tvp3026io: direct reg 0x%uX out of range\n", ctlr->name, reg);

       if(vga->private == nil)
               error("%s: tvp3026io: no *mga\n", ctlr->name);
       mga = vga->private;

       *(mga->membase1+RAMDAC+reg) = data;
}

static uchar
_tvp3026xi(Vga* vga, Ctlr* ctlr, uchar index)
{
       if(index >= 0x40)
               error("%s: tvp3026xi: reg 0x%uX out of range\n", ctlr->name, index);

       _tvp3026o(vga, ctlr, 0x00, index);

       return _tvp3026i(vga, ctlr, 0x0A);
}

void
_tvp3026xo(Vga* vga, Ctlr* ctlr, uchar index, uchar data)
{
       if(index >= 0x40)
               error("%s: tvp3026xo: reg 0x%uX out of range\n", ctlr->name, index);

       _tvp3026o(vga, ctlr, 0x00, index);
       _tvp3026o(vga, ctlr, 0x0A, data);
}

static uchar
crtcexti(uchar index)
{
       uchar data;

       outportb(Crtcext, index);
       data = inportb(Crtcext+1);

       return data;
}

static void
crtcexto(uchar index, uchar data)
{
       outportb(Crtcext, index);
       outportb(Crtcext+1, data);
}

static void
mapmga(Vga* vga, Ctlr* ctlr)
{
       uchar *m;
       Mga *mga;

       if(vga->private == nil)
               error("%s: tvp3026io: no *mga\n", ctlr->name);
       mga = vga->private;

       vgactlpci(vga->pci);
       vgactlw("type", "mga2164w");

       m = segattach(0, "mga2164wmmio", 0, 16*1024);
       if(m == (void*)-1)
               error("%s: can't attach mga2164wmmio segment\n", ctlr->name);
       mga->membase1 = m;

       m = segattach(0, "mga2164wscreen", 0, (mga->devid==MGA2064? 8 : 16)*Meg);
       if(m ==(void*)-1)
               error("%s: can't attach mga2164wscreen segment\n", ctlr->name);

       mga->membase2 = m;
}

static void
clockcalc(Vga* vga, Ctlr* ctlr, int bpp)
{
       ulong m, n, p, q;
       double z, fdiff, fmindiff, fvco, fgoal;
       Mga *mga;

       USED(ctlr);

       mga = vga->private;

       /*
        * Look for values of n, d and p that give
        * the least error for
        *      Fvco = 8*RefFreq*(65-m)/(65-n)
        *      Fpll = Fvco/2**p
        * N and m are 6 bits, p is 2 bits. Constraints:
        *      110MHz <= Fvco <= 250MHz
        *      40 <= n <= 62
        *       1 <= m <= 62
        *       0 <= p <=  3
        */
       fgoal = (double)vga->f[0];
       fmindiff = fgoal;
       vga->m[0] = 0x15;
       vga->n[0] = 0x18;
       vga->p[0] = 3;
       for(m = 62; m > 0; m--){
               for(n = 62; n >= 40; n--){
                       fvco = 8.*((double)RefFreq)*(65.-m)/(65.-n);
                       if(fvco < 110e6 || fvco > 250e6)
                               continue;
                       for(p = 0; p < 4; p++){
                               fdiff = fgoal - fvco/(1<<p);
                               if(fdiff < 0)
                                       fdiff = -fdiff;
                               if(fdiff < fmindiff){
                                       fmindiff = fdiff;
                                       vga->m[0] = m;
                                       vga->n[0] = n;
                                       vga->p[0] = p;
                               }
                       }
               }
       }
       mga->pclk[0] = 0xC0 | (vga->n[0] & 0x3f);
       mga->pclk[1] = (vga->m[0] & 0x3f);
       mga->pclk[2] = 0xB0 | (vga->p[0] & 0x03);

       /*
        * Now the loop clock:
        *      m is fixed;
        *      calculate n;
        *      set z to the lower bound (110MHz) and calculate p and q.
        */
       vga->m[1] = 61;
       n = 65 - 4*(64/(vga->vmz==2*Meg? bpp*2 : bpp));
       fvco = (8*RefFreq*(65-vga->m[0]))/(65-vga->n[0]);
       vga->f[1] = fvco/(1<<vga->p[0]);
       z = 110e6*(65.-n)/(4.*vga->f[1]);
       if(z <= 16){
               for(p = 0; p < 4; p++){
                       if(1<<(p+1) > z)
                               break;
               }
               q = 0;
       }
       else{
               p = 3;
               q = (z - 16)/16 + 1;
       }
       vga->n[1] = n;
       vga->p[1] = p;
       vga->q[1] = q;
       mga->lclk[0] = 0xC0 | (vga->n[1] & 0x3f);
       mga->lclk[1] = (vga->m[1] & 0x3f);
       mga->lclk[2] = 0xF0 | (vga->p[1] & 0x03);
       mga->tvp[0x39] = 0x38 | q;
}

static void
snarf(Vga* vga, Ctlr* ctlr)
{
       int i, k, n;
       uchar *p, x[8];
       Pcidev *pci;
       Mga *mga;

       if(vga->private == nil) {
               pci = pcimatch(nil, MATROX, MGA2164AGP);
               if(pci == nil)
                       pci = pcimatch(nil, MATROX, MGA2164);
               if(pci == nil)
                       pci = pcimatch(nil, MATROX, MGA2064);
               if(pci == nil)
                       error("%s: no Pcidev with Vid=0x102B, Did=0x051[9BF] or 0x521\n", ctlr->name);

               vga->private = alloc(sizeof(Mga));
               mga = (Mga*)vga->private;
               mga->devid = pci->did;
               mga->pci = pci;
               mapmga(vga, ctlr);
       }
       else {
               mga = (Mga*)vga->private;
               pci = mga->pci;
       }

       for(i = 0; i < 0x06; i++)
               mga->crtcext[i] = crtcexti(i);

       mga->devctrl = pcicfgr32(pci, Devctrl);
       mga->option = pcicfgr32(pci, Option);

       for(i = 0; i < 64; i++)
               mga->tvp[i] = _tvp3026xi(vga, ctlr, i);

       for(i = 0; i < 3; i++){
               _tvp3026xo(vga, ctlr, 0x2C, (i<<4)|(i<<2)|i);
               mga->pclk[i] = _tvp3026xi(vga, ctlr, 0x2D);
       }

       for(i = 0; i < 3; i++){
               _tvp3026xo(vga, ctlr, 0x2C, (i<<4)|(i<<2)|i);
               mga->mclk[i] = _tvp3026xi(vga, ctlr, 0x2E);
       }

       for(i = 0; i < 3; i++){
               _tvp3026xo(vga, ctlr, 0x2C, (i<<4)|(i<<2)|i);
               mga->lclk[i] = _tvp3026xi(vga, ctlr, 0x2F);
       }

       /* find out how much memory is here, some multiple of 2Meg */
       crtcexto(3, mga->crtcext[3] | 0x80);    /* mga mode */
       p = mga->membase2;
       n = (mga->devid==MGA2064? 4 : 8);
       for(i = 0; i < n; i++) {
               k = (2*i+1)*Meg;
               p[k] = 0;
               p[k] = i+1;
               *(mga->membase1+CACHEFLUSH) = 0;
               x[i] = p[k];
               trace("x[%d]=%d\n", i, x[i]);
       }
       for(i = 1; i < n; i++)
               if(x[i] != i+1)
                       break;
       vga->vmz = 2*i*Meg;
       trace("probe found %d megabytes\n", 2*i);
       crtcexto(3, mga->crtcext[3]);   /* restore mga mode */


       ctlr->flag |= Fsnarf;
}

static void
options(Vga* vga, Ctlr* ctlr)
{
       if(vga->virtx & 127)
               vga->virtx = (vga->virtx+127)&~127;
       ctlr->flag |= Foptions;
}

static void
init(Vga* vga, Ctlr* ctlr)
{
       Mode *mode;
       Ctlr *c;
       Mga *mga;
       int scale, offset, pixbuswidth;

       mga = vga->private;
       mode = vga->mode;

       ctlr->flag |= Ulinear;

       pixbuswidth = (vga->vmz == 2*Meg) ? 32 : 64;
       trace("pixbuswidth=%d\n", pixbuswidth);

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

       if(vga->f[0] == 0)
               vga->f[0] = vga->mode->frequency;

       /* supposed to let tvp reg 1D control sync polarity */
       vga->misc |= 0xC8;

       /*
        * In power graphics mode, supposed to use
        *      hblkend = htotal+4
        *      hblkstr = hdispend
        */
       if((vga->crt[0x00] & 0x0F) == 0x0F) {
               vga->crt[0x00]++;
               mode->ht += 8;
       }
       vga->crt[0x02] = vga->crt[0x01];
       vga->crt[0x03] = (((mode->ht>>3)-1) & 0x1F) | 0x80;
       vga->crt[0x05] = ((((mode->ht>>3)-1) & 0x20) << 2)
               | ((mode->ehs>>3) & 0x1F);

       offset = (vga->virtx*mode->z) >> ((pixbuswidth==32)? 6 : 7);
       vga->crt[0x13] = offset;
       vga->crt[0x14] = 0;
       vga->crt[0x17] = 0xE3;

       mga->crtcext[0] = (offset & 0x300) >> 4;
       mga->crtcext[1] = ((((mode->ht>>3)-5) & 0x100) >> 8)
               | ((((mode->x>>3)-1) & 0x100) >> 7)
               | (((mode->shs>>3) & 0x100) >> 6)  /* why not (shs>>3)-1 ? */
               | (((mode->ht>>3)-1) & 0x40);
       mga->crtcext[2] = (((mode->vt-2) & 0xC00) >> 10)
               | (((mode->y-1) & 0x400) >> 8)
               | ((mode->vrs & 0xC00) >> 7)
               | ((mode->vrs & 0xC00) >> 5);
       scale = mode->z == 8 ? 1 : (mode->z == 16? 2 : 4);
       if(pixbuswidth == 32)
               scale *= 2;
       scale--;
       mga->crtcext[3] = scale | 0x80;
       if(vga->vmz >= 8*Meg)
               mga->crtcext[3] |= 0x10;
       else if(vga->vmz == 2*Meg)
               mga->crtcext[3] |= 0x08;
       mga->crtcext[4] = 0;
       mga->crtcext[5] = 0;

       mga->tvp[0x0F] = (mode->z == 8) ? 0x06 : 0x07;
       mga->tvp[0x18] = (mode->z == 8) ? 0x80 :
               (mode->z == 16) ? 0x05 : 0x06;
       mga->tvp[0x19] = (mode->z == 8) ? 0x4C :
               (mode->z == 16) ? 0x54 : 0x5C;
       if(pixbuswidth == 32)
               mga->tvp[0x19]--;
       mga->tvp[0x1A] = (mode->z == 8) ? 0x25 :
               (mode->z == 16) ? 0x15 : 0x05;
       mga->tvp[0x1C] = 0;
       mga->tvp[0x1D] = (mode->y < 768) ? 0x00 : 0x03;
       mga->tvp[0x1E] = (mode->z == 8) ? 0x04 : 0x24; /* six bit mode */
       mga->tvp[0x2A] = 0;
       mga->tvp[0x2B] = 0x1E;
       mga->tvp[0x30] = 0xFF;
       mga->tvp[0x31] = 0xFF;
       mga->tvp[0x32] = 0xFF;
       mga->tvp[0x33] = 0xFF;
       mga->tvp[0x34] = 0xFF;
       mga->tvp[0x35] = 0xFF;
       mga->tvp[0x36] = 0xFF;
       mga->tvp[0x37] = 0xFF;
       mga->tvp[0x38] = 0;
       mga->tvp[0x39] = 0;
       mga->tvp[0x3A] = 0;
       mga->tvp[0x06] = 0;

       // From: "Bruce G. Stewart" <[email protected]>
       // 05-Jul-00 - Fix vertical blanking setup
       // This should probably be corrected in vga.c too.
       {
               // Start vertical blanking after the last displayed line
               // End vertical blanking after the total line count
               int svb = mode->y;
               int evb = mode->vt;

               // A field is 1/2 of the lines in interlaced mode
               if(mode->interlace == 'v'){
                       svb /= 2;
                       evb /= 2;
               }
               --svb;
               --evb;                  // line counter counts from 0

               vga->crt[0x15] = svb;
               vga->crt[0x07] = (vga->crt[0x07] & ~0x08) | ((svb & 0x100)>>5);
               vga->crt[0x09] = (vga->crt[0x09] & ~0x20) | ((svb & 0x200)>>4);
               // MGA specific: bits 10 and 11
               mga->crtcext[0x02] &=  ~0x18;
               mga->crtcext[0x02] |= ((svb & 0xC00)>>7);

               vga->crt[0x16]     = evb;
       }

       clockcalc(vga, ctlr, mode->z);


       mga->option = mga->option & ~0x3000;
       if(vga->vmz > 2*Meg)
               mga->option |= 0x1000;

       /* disable vga load (want to do fields in different order) */
       for(c = vga->link; c; c = c->link)
               if(strncmp(c->name, "vga", 3) == 0)
                       c->load = nil;

       ctlr->flag |= Finit;
}

static void
load(Vga* vga, Ctlr* ctlr)
{
       int i;
       Mga *mga;
       Pcidev* pci;

       mga = vga->private;
       pci = mga->pci;

       trace("loading crtcext0-5\n");
       /* turn on mga mode, set other crt high bits */
       for(i = 0; i < 6; i++)
               crtcexto(i, mga->crtcext[i]);

       trace("setting memory mode\n");
       /* set memory mode */
       pcicfgw32(pci, Option, mga->option);

       /* clocksource: pixel clock PLL */
       _tvp3026xo(vga, ctlr, 0x1A, mga->tvp[0x1A]);

       /* disable pclk and lclk */
       _tvp3026xo(vga, ctlr, 0x2C, 0x2A);
       _tvp3026xo(vga, ctlr, 0x2F, 0);
       _tvp3026xo(vga, ctlr, 0x2D, 0);

       trace("loading vga registers\n");
       /* vga misc, seq, and registers */
       vgao(MiscW, vga->misc);

       for(i = 2; i < 0x05; i++)
               vgaxo(Seqx, i, vga->sequencer[i]);

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

       /* apparently AGP needs this to restore start address */
       crtcexto(0, mga->crtcext[0]);

       trace("programming pclk\n");
       /* set up pclk */
       _tvp3026xo(vga, ctlr, 0x2C, 0);
       for(i = 0; i < 3; i++)
               _tvp3026xo(vga, ctlr, 0x2D, mga->pclk[i]);
       while(!(_tvp3026xi(vga, ctlr, 0x2D) & 0x40))
               ;

       trace("programming lclk\n");
       /* set up lclk */
       _tvp3026xo(vga, ctlr, 0x39, mga->tvp[0x39]);
       _tvp3026xo(vga, ctlr, 0x2C, 0);
       for(i = 0; i < 3; i++)
               _tvp3026xo(vga, ctlr, 0x2F, mga->lclk[i]);
       while(!(_tvp3026xi(vga, ctlr, 0x2F) & 0x40))
               ;

       trace("loading tvp registers\n");
       /* tvp registers, order matters */
       _tvp3026xo(vga, ctlr, 0x0F, mga->tvp[0x0F]);
       _tvp3026xo(vga, ctlr, 0x18, mga->tvp[0x18]);
       _tvp3026xo(vga, ctlr, 0x19, mga->tvp[0x19]);
       _tvp3026xo(vga, ctlr, 0x1A, mga->tvp[0x1A]);
       _tvp3026xo(vga, ctlr, 0x1C, mga->tvp[0x1C]);
       _tvp3026xo(vga, ctlr, 0x1D, mga->tvp[0x1D]);
       _tvp3026xo(vga, ctlr, 0x1E, mga->tvp[0x1E]);
       _tvp3026xo(vga, ctlr, 0x2A, mga->tvp[0x2A]);
       _tvp3026xo(vga, ctlr, 0x2B, mga->tvp[0x2B]);
       _tvp3026xo(vga, ctlr, 0x30, mga->tvp[0x30]);
       _tvp3026xo(vga, ctlr, 0x31, mga->tvp[0x31]);
       _tvp3026xo(vga, ctlr, 0x32, mga->tvp[0x32]);
       _tvp3026xo(vga, ctlr, 0x33, mga->tvp[0x33]);
       _tvp3026xo(vga, ctlr, 0x34, mga->tvp[0x34]);
       _tvp3026xo(vga, ctlr, 0x35, mga->tvp[0x35]);
       _tvp3026xo(vga, ctlr, 0x36, mga->tvp[0x36]);
       _tvp3026xo(vga, ctlr, 0x37, mga->tvp[0x37]);
       _tvp3026xo(vga, ctlr, 0x38, mga->tvp[0x38]);
       _tvp3026xo(vga, ctlr, 0x39, mga->tvp[0x39]);
       _tvp3026xo(vga, ctlr, 0x3A, mga->tvp[0x3A]);
       _tvp3026xo(vga, ctlr, 0x06, mga->tvp[0x06]);

       trace("done mga load\n");
       ctlr->flag |= Fload;
}

static void
dump(Vga* vga, Ctlr* ctlr)
{
       int i;
       char *name;
       Mga *mga;

       name = ctlr->name;
       mga = vga->private;

       printitem(name, "Devctrl");
       printreg(mga->devctrl);

       printitem(name, "Option");
       printreg(mga->option);

       printitem(name, "Crtcext");
       for(i = 0; i < 0x06; i++)
               printreg(mga->crtcext[i]);

       printitem(name, "TVP");
       for(i = 0; i < 64; i++)
               printreg(mga->tvp[i]);

       printitem(name, "PCLK");
       for(i = 0; i < 3; i++)
               printreg(mga->pclk[i]);

       printitem(name, "MCLK");
       for(i = 0; i < 3; i++)
               printreg(mga->mclk[i]);

       printitem(name, "LCLK");
       for(i = 0; i < 3; i++)
               printreg(mga->lclk[i]);
}

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

Ctlr mga2164whwgc = {
       "mga2164whwgc",                 /* name */
       0,                              /* snarf */
       0,                              /* options */
       0,                              /* init */
       0,                              /* 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.