Subversion Repositories planix.SVN

#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
#include "../port/error.h"

#define Image   IMAGE
#include <draw.h>
#include <memdraw.h>
#include <cursor.h>
#include "screen.h"

static int
clgd542xpageset(VGAscr*, int page)
{
        uchar gr09;
        int opage;
        
        if(vgaxi(Seqx, 0x07) & 0xF0)
                page = 0;
        gr09 = vgaxi(Grx, 0x09);
        if(vgaxi(Grx, 0x0B) & 0x20){
                vgaxo(Grx, 0x09, page<<2);
                opage = gr09>>2;
        }
        else{
                vgaxo(Grx, 0x09, page<<4);
                opage = gr09>>4;
        }

        return opage;
}

static void
clgd542xpage(VGAscr* scr, int page)
{
        lock(&scr->devlock);
        clgd542xpageset(scr, page);
        unlock(&scr->devlock);
}

static void
clgd542xlinear(VGAscr* scr, int, int)
{
        vgalinearpciid(scr, 0x1013, 0);
}

static void
clgd542xdisable(VGAscr*)
{
        uchar sr12;

        sr12 = vgaxi(Seqx, 0x12);
        vgaxo(Seqx, 0x12, sr12 & ~0x01);
}

static void
clgd542xenable(VGAscr* scr)
{
        uchar sr12;
        int mem, x;
 
        /*
         * Disable the cursor.
         */
        sr12 = vgaxi(Seqx, 0x12);
        vgaxo(Seqx, 0x12, sr12 & ~0x01);

        /*
         * Cursor colours.
         * Can't call setcolor here as cursor is already locked.
         */
        vgaxo(Seqx, 0x12, sr12|0x02);
        vgao(PaddrW, 0x00);
        vgao(Pdata, Pwhite);
        vgao(Pdata, Pwhite);
        vgao(Pdata, Pwhite);
        vgao(PaddrW, 0x0F);
        vgao(Pdata, Pblack);
        vgao(Pdata, Pblack);
        vgao(Pdata, Pblack);
        vgaxo(Seqx, 0x12, sr12);

        mem = 0;
        switch(vgaxi(Crtx, 0x27) & ~0x03){

        case 0x88:                              /* CL-GD5420 */
        case 0x8C:                              /* CL-GD5422 */
        case 0x94:                              /* CL-GD5424 */
        case 0x80:                              /* CL-GD5425 */
        case 0x90:                              /* CL-GD5426 */
        case 0x98:                              /* CL-GD5427 */
        case 0x9C:                              /* CL-GD5429 */
                /*
                 * The BIOS leaves the memory size in Seq0A, bits 4 and 3.
                 * See Technical Reference Manual Appendix E1, Section 1.3.2.
                 *
                 * The storage area for the 64x64 cursors is the last 16Kb of
                 * display memory.
                 */
                mem = (vgaxi(Seqx, 0x0A)>>3) & 0x03;
                break;

        case 0xA0:                              /* CL-GD5430 */
        case 0xA8:                              /* CL-GD5434 */
        case 0xAC:                              /* CL-GD5436 */
        case 0xB8:                              /* CL-GD5446 */
        case 0x30:                              /* CL-GD7543 */
                /*
                 * Attempt to intuit the memory size from the DRAM control
                 * register. Minimum is 512KB.
                 * If DRAM bank switching is on then there's double.
                 */
                x = vgaxi(Seqx, 0x0F);
                mem = (x>>3) & 0x03;
                if(x & 0x80)
                        mem++;
                break;

        case 0xBC:                              /* CL-GD5480 */
                mem = 2;                        /* 1024 = 256<<2 */
                x = vgaxi(Seqx, 0x0F);
                if((x & 0x18) == 0x18){
                        mem <<= 1;              /* 2048 = 256<<3 */
                        if(x & 0x80)
                                mem <<= 2;      /* 2048 = 256<<4 */
                }
                if(vgaxi(Seqx, 0x17) & 0x80)
                        mem <<= 1;
                break;

        default:                                /* uh, ah dunno */
                break;
        }
        scr->storage = ((256<<mem)-16)*1024;

        /*
         * Set the current cursor to index 0
         * and turn the 64x64 cursor on.
         */
        vgaxo(Seqx, 0x13, 0);
        vgaxo(Seqx, 0x12, sr12|0x05);
}

static void
clgd542xinitcursor(VGAscr* scr, int xo, int yo, int index)
{
        uchar *p, seq07;
        uint p0, p1;
        int opage, x, y;

        /*
         * Is linear addressing turned on? This will determine
         * how we access the cursor storage.
         */
        seq07 = vgaxi(Seqx, 0x07);
        opage = 0;
        p = scr->vaddr;
        if(!(seq07 & 0xF0)){
                lock(&scr->devlock);
                opage = clgd542xpageset(scr, scr->storage>>16);
                p += (scr->storage & 0xFFFF);
        }
        else
                p += scr->storage;
        p += index*1024;

        for(y = yo; y < 16; y++){
                p0 = scr->set[2*y];
                p1 = scr->set[2*y+1];
                if(xo){
                        p0 = (p0<<xo)|(p1>>(8-xo));
                        p1 <<= xo;
                }
                *p++ = p0;
                *p++ = p1;

                for(x = 16; x < 64; x += 8)
                        *p++ = 0x00;

                p0 = scr->clr[2*y]|scr->set[2*y];
                p1 = scr->clr[2*y+1]|scr->set[2*y+1];
                if(xo){
                        p0 = (p0<<xo)|(p1>>(8-xo));
                        p1 <<= xo;
                }
                *p++ = p0;
                *p++ = p1;

                for(x = 16; x < 64; x += 8)
                        *p++ = 0x00;
        }
        while(y < 64+yo){
                for(x = 0; x < 64; x += 8){
                        *p++ = 0x00;
                        *p++ = 0x00;
                }
                y++;
        }

        if(!(seq07 & 0xF0)){
                clgd542xpageset(scr, opage);
                unlock(&scr->devlock);
        }
}

static void
clgd542xload(VGAscr* scr, Cursor* curs)
{
        uchar sr12;

        /*
         * Disable the cursor.
         */
        sr12 = vgaxi(Seqx, 0x12);
        vgaxo(Seqx, 0x12, sr12 & ~0x01);

        memmove(&scr->Cursor, curs, sizeof(Cursor));
        clgd542xinitcursor(scr, 0, 0, 0);

        /*
         * Enable the cursor.
         */
        vgaxo(Seqx, 0x13, 0);
        vgaxo(Seqx, 0x12, sr12|0x05);
}

static int
clgd542xmove(VGAscr* scr, Point p)
{
        int index, x, xo, y, yo;

        index = 0;
        if((x = p.x+scr->offset.x) < 0){
                xo = -x;
                x = 0;
        }
        else
                xo = 0;
        if((y = p.y+scr->offset.y) < 0){
                yo = -y;
                y = 0;
        }
        else
                yo = 0;

        if(xo || yo){
                clgd542xinitcursor(scr, xo, yo, 1);
                index = 1;
        }
        vgaxo(Seqx, 0x13, index<<2);
        
        vgaxo(Seqx, 0x10|((x & 0x07)<<5), (x>>3) & 0xFF);
        vgaxo(Seqx, 0x11|((y & 0x07)<<5), (y>>3) & 0xFF);

        return 0;
}

VGAdev vgaclgd542xdev = {
        "clgd542x",

        0,
        0,
        clgd542xpage,
        clgd542xlinear,
};

VGAcur vgaclgd542xcur = {
        "clgd542xhwgc",

        clgd542xenable,
        clgd542xdisable,
        clgd542xload,
        clgd542xmove,
};