Subversion Repositories planix.SVN

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

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

enum {
        Rid = 0,
        Renable,
        Rwidth,
        Rheight,
        Rmaxwidth,
        Rmaxheight,
        Rdepth,
        Rbpp,
        Rpseudocolor,
        Rrmask,
        Rgmask,
        Rbmask,
        Rbpl,
        Rfbstart,
        Rfboffset,
        Rfbmaxsize,
        Rfbsize,
        Rcap,
        Rmemstart,
        Rmemsize,
        Rconfigdone,
        Rsync,
        Rbusy,
        Rguestid,
        Rcursorid,
        Rcursorx,
        Rcursory,
        Rcursoron,
        Rhostbpp,
        Nreg,

        Crectfill = 1<<0,
        Crectcopy = 1<<1,
        Crectpatfill = 1<<2,
        Coffscreen = 1<<3,
        Crasterop = 1<<4,
        Ccursor = 1<<5,
        Ccursorbypass = 1<<6,
        Ccursorbypass2 = 1<<7,
        C8bitemulation = 1<<8,
        Calphacursor = 1<<9,

        Rpalette = 1024,
};      

typedef struct Vmware   Vmware;
struct Vmware {
        ulong   mmio;
        ulong   fb;

        ulong   ra;
        ulong   rd;

        ulong   r[Nreg];

        char    chan[32];
        int     depth;
};

static char*
rname[Nreg] = {
        "ID",
        "Enable",
        "Width",
        "Height",
        "MaxWidth",
        "MaxHeight",
        "Depth",
        "Bpp",
        "PseudoColor",
        "RedMask",
        "GreenMask",
        "BlueMask",
        "Bpl",
        "FbStart",
        "FbOffset",
        "FbMaxSize",
        "FbSize",
        "Cap",
        "MemStart",
        "MemSize",
        "ConfigDone",
        "Sync",
        "Busy",
        "GuestID",
        "CursorID",
        "CursorX",
        "CursorY",
        "CursorOn",
        "HostBpp",
};

static ulong
vmrd(Vmware *vm, int i)
{
        outportl(vm->ra, i);
        return inportl(vm->rd);
}

static void
vmwr(Vmware *vm, int i, ulong v)
{
        outportl(vm->ra, i);
        outportl(vm->rd, v);
}

static uint
bits(ulong a)
{
        int b;

        for(b=0; a; a>>=1)
                if(a&1)
                        b++;
        return b;
}

static void
snarf(Vga* vga, Ctlr* ctlr)
{
        int extra, i;
        Pcidev *p;
        Vmware *vm;

        p = vga->pci;
        if(p == nil)
                error("%s: vga->pci not set\n", ctlr->name);

        vm = alloc(sizeof(Vmware));

        switch(p->did){
        case 0x710:     /* VMware video chipset #1 */
                vm->ra = 0x4560;
                vm->rd = 0x4560+4;
                break;

        case 0x405:     /* VMware video chipset #2, untested */
                vm->ra = p->mem[0].bar&~3;
                vm->rd = vm->ra+1;
                break;

        default:
                error("%s: unrecognized chipset %.4ux\n", ctlr->name, p->did);
        }

        for(i=0; i<Nreg; i++)
                vm->r[i] = vmrd(vm, i);

//vmwr(vm, Renable, 0);
        /*
         * Figure out color channel.  Delay errors until init,
         * which is after the register dump.
         */
        vm->depth = vm->r[Rbpp];
        extra = vm->r[Rbpp] - vm->r[Rdepth];
        if(vm->r[Rrmask] > vm->r[Rgmask] && vm->r[Rgmask] > vm->r[Rbmask]){
                if(extra)
                        sprint(vm->chan, "x%d", extra);
                else
                        vm->chan[0] = '\0';
                sprint(vm->chan+strlen(vm->chan), "r%dg%db%d", bits(vm->r[Rrmask]),
                        bits(vm->r[Rgmask]), bits(vm->r[Rbmask]));
        }else if(vm->r[Rbmask] > vm->r[Rgmask] && vm->r[Rgmask] > vm->r[Rrmask]){
                sprint(vm->chan, "b%dg%dr%d", bits(vm->r[Rbmask]),
                        bits(vm->r[Rgmask]), bits(vm->r[Rrmask]));
                if(extra)
                        sprint(vm->chan+strlen(vm->chan), "x%d", extra);
        }else
                sprint(vm->chan, "unknown");

        /* Record the frame buffer start, size */
        vga->vmb = vm->r[Rfbstart];
        vga->apz = vm->r[Rfbmaxsize];

        vga->private = vm;
        ctlr->flag |= Fsnarf;
}


static void
options(Vga*, Ctlr* ctlr)
{
        ctlr->flag |= Hlinear|Henhanced|Foptions;
}


static void
clock(Vga*, Ctlr*)
{
        /* BEST CLOCK ROUTINE EVER! */
}

static void
init(Vga* vga, Ctlr* ctlr)
{
        Vmware *vm;

        vm = vga->private;

        vmwr(vm, Rid, (0x900000<<8)|2);
        if(vmrd(vm, Rid)&0xFF != 2)
                error("old vmware svga version %lud; need version 2\n",
                        vmrd(vm,Rid)&0xFF);

        ctlr->flag |= Ulinear;
        if(strcmp(vm->chan, "unknown") == 0)
                error("couldn't translate color masks into channel\n");

        /* Always use the screen depth, and clip the screen size */
        vga->mode->z = vm->r[Rbpp];
        if(vga->mode->x > vm->r[Rmaxwidth])
                vga->mode->x = vm->r[Rmaxwidth];
        if(vga->mode->y > vm->r[Rmaxheight])
                vga->mode->y = vm->r[Rmaxheight];

        vm->r[Rwidth] = vga->mode->x;
        vm->r[Rheight] = vga->mode->y;

        /* Figure out the channel string */
        strcpy(vga->mode->chan, vm->chan);

        /* Record the bytes per line */
        ctlr->flag |= Finit;
}

static void
load(Vga* vga, Ctlr *ctlr)
{
        char buf[64];
        int x;
        Vmware *vm;

        vm = vga->private;
        vmwr(vm, Rwidth, vm->r[Rwidth]);
        vmwr(vm, Rheight, vm->r[Rheight]);
        vmwr(vm, Renable, 1);
        vmwr(vm, Rguestid, 0x5010);     /* OS type is "Other" */

        x = vmrd(vm, Rbpl)/(vm->depth/8);
        if(x != vga->mode->x){
                vga->virtx = x;
                sprint(buf, "%ludx%ludx%d %s", vga->virtx, vga->virty,
                        vga->mode->z, vga->mode->chan);
                vgactlw("size", buf);
        }
        ctlr->flag |= Fload;
}

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

        vm = vga->private;

        for(i=0; i<Nreg; i++){
                printitem(ctlr->name, rname[i]);
                Bprint(&stdout, " %.8lux\n", vm->r[i]);
        }

        printitem(ctlr->name, "chan");
        Bprint(&stdout, " %s\n", vm->chan);
        printitem(ctlr->name, "depth");
        Bprint(&stdout, " %d\n", vm->depth);
        printitem(ctlr->name, "linear");
        
}

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

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