io/graphic/gcard.cc

/*
 *      PearPC
 *      gcard.cc
 *
 *      Copyright (C) 2003, 2004 Sebastian Biallas (sb@biallas.net)
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License version 2 as
 *      published by the Free Software Foundation.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <cstdlib>
#include <cstring>

#include "debug/tracers.h"
#include "system/display.h"
#include "system/arch/sysendian.h"
#include "tools/snprintf.h"
#include "cpu/cpu.h"
#include "io/pic/pic.h"
#include "gcard.h"

struct VMode {
        int width, height, bytesPerPixel;
};

static VMode stdVModes[] = {
        {width: 640, height: 480, bytesPerPixel: 2},
        {width: 640, height: 480, bytesPerPixel: 4},
        {width: 800, height: 600, bytesPerPixel: 2},
        {width: 800, height: 600, bytesPerPixel: 4},
        {width: 1024, height: 768, bytesPerPixel: 2},
        {width: 1024, height: 768, bytesPerPixel: 4},
        {width: 1152, height: 864, bytesPerPixel: 2},
        {width: 1152, height: 864, bytesPerPixel: 4},
        {width: 1280, height: 720, bytesPerPixel: 2},
        {width: 1280, height: 720, bytesPerPixel: 4},
        {width: 1280, height: 768, bytesPerPixel: 2},
        {width: 1280, height: 768, bytesPerPixel: 4},
        {width: 1280, height: 960, bytesPerPixel: 2},
        {width: 1280, height: 960, bytesPerPixel: 4},
        {width: 1280, height: 1024, bytesPerPixel: 2},
        {width: 1280, height: 1024, bytesPerPixel: 4},
        {width: 1360, height: 768, bytesPerPixel: 2},
        {width: 1360, height: 768, bytesPerPixel: 4},
        {width: 1600, height: 900, bytesPerPixel: 2},
        {width: 1600, height: 900, bytesPerPixel: 4},
        {width: 1600, height: 1024, bytesPerPixel: 2},
        {width: 1600, height: 1024, bytesPerPixel: 4},
        {width: 1600, height: 1200, bytesPerPixel: 2},
        {width: 1600, height: 1200, bytesPerPixel: 4},
};

static Container *gGraphicModes;

PCI_GCard::PCI_GCard()
        :PCI_Device("pci-graphic", 0x00, 0x07)
{
        mIORegSize[0] = 0x800000;
        mIORegType[0] = PCI_ADDRESS_SPACE_MEM_PREFETCH;

//      mConfig[0x00] = 0x02;   // vendor ID
//      mConfig[0x01] = 0x10;
//      mConfig[0x02] = 0x45;   // unit ID
//      mConfig[0x03] = 0x52;
        mConfig[0x00] = 0x66;   // vendor ID
        mConfig[0x01] = 0x66;
        mConfig[0x02] = 0x66;   // unit ID
        mConfig[0x03] = 0x66;

        mConfig[0x08] = 0x00;   // revision
        mConfig[0x09] = 0x00;
        mConfig[0x0a] = 0x00;
        mConfig[0x0b] = 0x03;

        mConfig[0x0e] = 0x00;   // header-type
        
        assignMemAddress(0, IO_GCARD_FRAMEBUFFER_PA_START);
        
        mConfig[0x3c] = IO_PIC_IRQ_GCARD;
        mConfig[0x3d] = 1;
        mConfig[0x3e] = 0;
        mConfig[0x3f] = 0;
}

bool PCI_GCard::readDeviceMem(uint r, uint32 address, uint32 &data, uint size)
{
        IO_GRAPHIC_TRACE("read %d, %08x, %d\n", r, address, size);
        data = 0;
        return true;
}

bool PCI_GCard::writeDeviceMem(uint r, uint32 address, uint32 data, uint size)
{
        IO_GRAPHIC_TRACE("write %d, %08x, %08x, %d\n", r, address, data, size);
        return true;
}

#define MAYBE_PPC_HALF_TO_BE(a) ppc_half_from_LE(a)
#define MAYBE_PPC_WORD_TO_BE(a) ppc_word_from_LE(a)
#define MAYBE_PPC_DWORD_TO_BE(a) ppc_dword_from_LE(a)

/*#define MAYBE_PPC_HALF_TO_BE(a) (a)
#define MAYBE_PPC_WORD_TO_BE(a) (a)
#define MAYBE_PPC_DWORD_TO_BE(a) (a)*/

void FASTCALL gcard_write_1(uint32 addr, uint32 data)
{
        addr -= IO_GCARD_FRAMEBUFFER_PA_START;
        *(uint8*)(gFrameBuffer+addr) = data;
        damageFrameBuffer(addr);
}

void FASTCALL gcard_write_2(uint32 addr, uint32 data)
{
        addr -= IO_GCARD_FRAMEBUFFER_PA_START;
        *(uint16*)(gFrameBuffer+addr) = MAYBE_PPC_HALF_TO_BE(data);
        damageFrameBuffer(addr);
}

void FASTCALL gcard_write_4(uint32 addr, uint32 data)
{
        addr -= IO_GCARD_FRAMEBUFFER_PA_START;
        *(uint32*)(gFrameBuffer+addr) = MAYBE_PPC_WORD_TO_BE(data);
        damageFrameBuffer(addr);
}

void FASTCALL gcard_write_8(uint32 addr, uint64 data)
{
        addr -= IO_GCARD_FRAMEBUFFER_PA_START;
        *(uint64*)(gFrameBuffer+addr) = MAYBE_PPC_DWORD_TO_BE(data);
        damageFrameBuffer(addr);
}

void FASTCALL gcard_write_16(uint32 addr, uint128 *data)
{
        addr-= IO_GCARD_FRAMEBUFFER_PA_START;
#if HOST_ENDIANESS == HOST_ENDIANESS_LE
        uint8 *src = (uint8 *)data;

        for (int i=0; i<16; i++) {
                gFrameBuffer[addr+15-i] = src[i];
        }
#elif HOST_ENDIANESS == HOST_ENDIANESS_BE
        memmove(gFrameBuffer+addr, data, 16);
#else
#error Unsupported endianess
#endif
        //*(uint64*)(gFrameBuffer+addr) = MAYBE_PPC_DWORD_TO_BE(data->h);
        //*(uint64*)(gFrameBuffer+addr+8) = MAYBE_PPC_DWORD_TO_BE(data->l);
        damageFrameBuffer(addr);
}

void FASTCALL gcard_write_16_native(uint32 addr, uint128 *data)
{
        addr-= IO_GCARD_FRAMEBUFFER_PA_START;

        memmove(gFrameBuffer+addr, data, 16);

        damageFrameBuffer(addr);
}

void FASTCALL gcard_read_1(uint32 addr, uint32 &data)
{
        addr-= IO_GCARD_FRAMEBUFFER_PA_START;
        data = (*(uint8*)(gFrameBuffer+addr));
}

void FASTCALL gcard_read_2(uint32 addr, uint32 &data)
{
        addr-= IO_GCARD_FRAMEBUFFER_PA_START;
        data = MAYBE_PPC_HALF_TO_BE(*(uint16*)(gFrameBuffer+addr));
}

void FASTCALL gcard_read_4(uint32 addr, uint32 &data)
{
        addr-= IO_GCARD_FRAMEBUFFER_PA_START;
        data = MAYBE_PPC_WORD_TO_BE(*(uint32*)(gFrameBuffer+addr));
}

void FASTCALL gcard_read_8(uint32 addr, uint64 &data)
{
        addr-= IO_GCARD_FRAMEBUFFER_PA_START;
        data = MAYBE_PPC_DWORD_TO_BE(*(uint64*)(gFrameBuffer+addr));
}

void FASTCALL gcard_read_16(uint32 addr, uint128 *data)
{
        addr-= IO_GCARD_FRAMEBUFFER_PA_START;
#if HOST_ENDIANESS == HOST_ENDIANESS_LE
        uint8 *store = (uint8 *)data;

        for (int i=0; i<16; i++) {
                store[i] = gFrameBuffer[addr+15-i];
        }
#elif HOST_ENDIANESS == HOST_ENDIANESS_BE
        memmove(data, gFrameBuffer+addr, 16);
#else
#error Unsupported endianess
#endif
        //data->h = MAYBE_PPC_DWORD_TO_BE(*(uint64*)(gFrameBuffer+addr));
        //data->l = MAYBE_PPC_DWORD_TO_BE(*(uint64*)(gFrameBuffer+addr+8));
}

void FASTCALL gcard_read_16_native(uint32 addr, uint128 *data)
{
        addr-= IO_GCARD_FRAMEBUFFER_PA_START;

        memmove(data, gFrameBuffer+addr, 16);
}

static bool gVBLon = false;
static int gCurrentGraphicMode;

void gcard_raise_interrupt()
{
        if (gVBLon) pic_raise_interrupt(IO_PIC_IRQ_GCARD);
}

void gcard_osi(int cpu)
{
        IO_GRAPHIC_TRACE("osi: %d\n", ppc_cpu_get_gpr(cpu, 5));
        switch (ppc_cpu_get_gpr(cpu, 5)) {
        case 4:
                // cmount
                return;
        case 28: {
                // set_vmode
                uint vmode = ppc_cpu_get_gpr(cpu, 6)-1;
                if (vmode > gGraphicModes->count() || ppc_cpu_get_gpr(cpu, 7)) {
                        ppc_cpu_set_gpr(cpu, 3, 1);
                        return;
                }
                DisplayCharacteristics *chr = (DisplayCharacteristics *)(*gGraphicModes)[vmode];
                IO_GRAPHIC_TRACE("set mode %d\n", vmode);
                if (gDisplay->changeResolution(*chr)) {
                        ppc_cpu_set_gpr(cpu, 3, 0);
                        gcard_set_mode(*chr);
                } else {
                        ppc_cpu_set_gpr(cpu, 3, 1);
                }
                return;
        }
        case 29: {
/*              
typedef struct osi_get_vmode_info {
        short           num_vmodes;
        short           cur_vmode;              // 1,2,... 
        short           num_depths;
        short           cur_depth_mode;         // 0,1,2,... 
        short           w,h;
        int             refresh;                // Hz/65536 

        int             depth;
        short           row_bytes;
        short           offset;
} osi_get_vmode_info_t;
*/
                // get_vmode_info
                int vmode = ppc_cpu_get_gpr(cpu, 6) - 1;
                int depth_mode = ppc_cpu_get_gpr(cpu, 7);
                if (vmode == -1) {
                        vmode = gCurrentGraphicMode;
                        depth_mode = ((DisplayCharacteristics *)(*gGraphicModes)[vmode])->bytesPerPixel*8;
                }
                if (vmode > (int)gGraphicModes->count() || vmode < 0) {
                        ppc_cpu_set_gpr(cpu, 3, 1);
                        return;
                }
                DisplayCharacteristics *chr = ((DisplayCharacteristics *)(*gGraphicModes)[vmode]);
                ppc_cpu_set_gpr(cpu, 3, 0);
                ppc_cpu_set_gpr(cpu, 4, (gGraphicModes->count()<<16) | (vmode+1));
                ppc_cpu_set_gpr(cpu, 5, (1<<16) | 0);
                ppc_cpu_set_gpr(cpu, 6, (chr->width << 16) | chr->height);
                ppc_cpu_set_gpr(cpu, 7, chr->vsyncFrequency << 16);
                ppc_cpu_set_gpr(cpu, 8, chr->bytesPerPixel*8);
                ppc_cpu_set_gpr(cpu, 9, ((chr->scanLineLength)<<16) | 0);
                return;
        }
        case 31:
                // set_video_power
                ppc_cpu_set_gpr(cpu, 3, 0);
                return;
        case 39:
                IO_GRAPHIC_TRACE("video_ctrl: %d\n", ppc_cpu_get_gpr(cpu, 6));
                // video_ctrl
                switch (ppc_cpu_get_gpr(cpu, 6)) {
                case 0:
                        gVBLon = false;
                        break;
                case 1:
                        gVBLon = true;
                        break;
                default:
                        IO_GRAPHIC_ERR("39\n");
                }
                ppc_cpu_set_gpr(cpu, 3, 0);
                return;
        case 47:
//              printf("%c\n", gCPU.gpr[6]);
                return;
        case 59: {
                // set_color
                uint32 r7 = ppc_cpu_get_gpr(cpu, 7);
                gDisplay->setColor(ppc_cpu_get_gpr(cpu, 6), MK_RGB((r7>>16)&0xff, (r7>>8)&0xff, r7&0xff));
                ppc_cpu_set_gpr(cpu, 3, 0);
                return;
        }
        case 64: {
                // get_color
                RGB c = gDisplay->getColor(ppc_cpu_get_gpr(cpu, 6));
                ppc_cpu_set_gpr(cpu, 3, (RGB_R(c) << 16) | (RGB_G(c) << 8) | (RGB_B(c)));
                return;
        }
        case 116:
                // hardware_cursor_bla
//              SINGLESTEP("hw cursor!! %d, %d, %d\n", gCPU.gpr[6], gCPU.gpr[7], gCPU.gpr[8]);
                IO_GRAPHIC_TRACE("hw cursor!! %d, %d, %d\n", ppc_cpu_get_gpr(cpu, 6), ppc_cpu_get_gpr(cpu, 7), ppc_cpu_get_gpr(cpu, 8));
                gDisplay->setHWCursor(ppc_cpu_get_gpr(cpu, 6), ppc_cpu_get_gpr(cpu, 7), ppc_cpu_get_gpr(cpu, 8), NULL);
                return;
        }
        IO_GRAPHIC_ERR("unknown osi function\n");
}

/*
 * displayCharacteristicsFromString tries to create a(n unfinished) characteristic
 * from a String of the form [0-9]+x[0-9]+x(15|32)(@[0-9]+)?
 */
 
bool displayCharacteristicsFromString(DisplayCharacteristics &aChar, const String &s)
{
        String width, height, depth;
        String tmp, tmp2;
        if (!s.leftSplit('x', width, tmp)) return false;
        if (!width.toInt(aChar.width)) return false;
        if (!tmp.leftSplit('x', height, tmp2)) return false;
        if (!height.toInt(aChar.height)) return false;
        if (tmp2.leftSplit('@', depth, tmp)) {
                if (!depth.toInt(aChar.bytesPerPixel)) return false;    
                if (!tmp.toInt(aChar.vsyncFrequency)) return false;     
        } else {
                aChar.vsyncFrequency = -1;
                if (!tmp2.toInt(aChar.bytesPerPixel)) return false;
        }
        aChar.scanLineLength = -1;
        aChar.redShift = -1;
        aChar.redSize = -1;
        aChar.greenShift = -1;
        aChar.greenSize = -1;
        aChar.blueShift = -1;
        aChar.blueSize = -1;
        return true;
}

void gcard_add_characteristic(const DisplayCharacteristics &aChar)
{
        if (!gcard_supports_characteristic(aChar)) {
                DisplayCharacteristics *chr = new DisplayCharacteristics;
                *chr = aChar;
                gGraphicModes->insert(chr);
        }
}

bool gcard_supports_characteristic(const DisplayCharacteristics &aChar)
{
        return gGraphicModes->contains(&aChar);
}

/*
 *      gcard_finish_characteristic will fill out all fields 
 *      of aChar that aren't initialized yet (set to -1).
 */
bool gcard_finish_characteristic(DisplayCharacteristics &aChar)
{
        if (aChar.width == -1 || aChar.height == -1 || aChar.bytesPerPixel == -1) return false;
        if (aChar.vsyncFrequency == -1) aChar.vsyncFrequency = 60;
        if (aChar.scanLineLength == -1) aChar.scanLineLength = aChar.width * aChar.bytesPerPixel;
        switch (aChar.bytesPerPixel) {
        case 2:
                
                if (aChar.redShift == -1) aChar.redShift = 10;
                if (aChar.redSize == -1) aChar.redSize = 5;
                if (aChar.greenShift == -1) aChar.greenShift = 5;
                if (aChar.greenSize == -1) aChar.greenSize = 5;
                if (aChar.blueShift == -1) aChar.blueShift = 0;
                if (aChar.blueSize == -1) aChar.blueSize = 5;
                break;
        case 4:
                if (aChar.redShift == -1) aChar.redShift = 16;
                if (aChar.redSize == -1) aChar.redSize = 8;
                if (aChar.greenShift == -1) aChar.greenShift = 8;
                if (aChar.greenSize == -1) aChar.greenSize = 8;
                if (aChar.blueShift == -1) aChar.blueShift = 0;
                if (aChar.blueSize == -1) aChar.blueSize = 8;
                break;
        default:
                return false;
        }
        return true;
}

bool gcard_set_mode(DisplayCharacteristics &mode)
{
        uint tmp = gGraphicModes->getObjIdx(gGraphicModes->find(&mode));
        if (tmp == InvIdx) {
                return false;
        } else {
                gCurrentGraphicMode = tmp;
                return true;
        }
}

void gcard_init_modes()
{
        gGraphicModes = new Array(true);
        for (uint i=0; i < (sizeof stdVModes / sizeof stdVModes[0]); i++) {
                DisplayCharacteristics chr;
                chr.width = stdVModes[i].width;
                chr.height = stdVModes[i].height;
                chr.bytesPerPixel = stdVModes[i].bytesPerPixel;
                chr.scanLineLength = -1;
                chr.vsyncFrequency = -1;
                chr.redShift = -1;
                chr.redSize = -1;
                chr.greenShift = -1;
                chr.greenSize = -1;
                chr.blueShift = -1;
                chr.blueSize = -1;
                gcard_finish_characteristic(chr);
                gcard_add_characteristic(chr);
        }
}

void gcard_init_host_modes()
{
        Array modes(true);      
        gDisplay->getHostCharacteristics(modes);
        foreach (DisplayCharacteristics, chr, modes, {
                gcard_finish_characteristic(*chr);
                gcard_add_characteristic(*chr);
        });
}

void gcard_init()
{
        gPCI_Devices->insert(new PCI_GCard());
}

void gcard_done()
{
}

void gcard_init_config()
{
}
1	dpavlin	1	/*
2			* PearPC
3			* gcard.cc
4			*
5			* Copyright (C) 2003, 2004 Sebastian Biallas (sb@biallas.net)
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License version 2 as
9			* published by the Free Software Foundation.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19			*/
20
21			#include <cstdlib>
22			#include <cstring>
23
24			#include "debug/tracers.h"
25			#include "system/display.h"
26			#include "system/arch/sysendian.h"
27			#include "tools/snprintf.h"
28			#include "cpu/cpu.h"
29			#include "io/pic/pic.h"
30			#include "gcard.h"
31
32			struct VMode {
33			int width, height, bytesPerPixel;
34			};
35
36			static VMode stdVModes[] = {
37			{width: 640, height: 480, bytesPerPixel: 2},
38			{width: 640, height: 480, bytesPerPixel: 4},
39			{width: 800, height: 600, bytesPerPixel: 2},
40			{width: 800, height: 600, bytesPerPixel: 4},
41			{width: 1024, height: 768, bytesPerPixel: 2},
42			{width: 1024, height: 768, bytesPerPixel: 4},
43			{width: 1152, height: 864, bytesPerPixel: 2},
44			{width: 1152, height: 864, bytesPerPixel: 4},
45			{width: 1280, height: 720, bytesPerPixel: 2},
46			{width: 1280, height: 720, bytesPerPixel: 4},
47			{width: 1280, height: 768, bytesPerPixel: 2},
48			{width: 1280, height: 768, bytesPerPixel: 4},
49			{width: 1280, height: 960, bytesPerPixel: 2},
50			{width: 1280, height: 960, bytesPerPixel: 4},
51			{width: 1280, height: 1024, bytesPerPixel: 2},
52			{width: 1280, height: 1024, bytesPerPixel: 4},
53			{width: 1360, height: 768, bytesPerPixel: 2},
54			{width: 1360, height: 768, bytesPerPixel: 4},
55			{width: 1600, height: 900, bytesPerPixel: 2},
56			{width: 1600, height: 900, bytesPerPixel: 4},
57			{width: 1600, height: 1024, bytesPerPixel: 2},
58			{width: 1600, height: 1024, bytesPerPixel: 4},
59			{width: 1600, height: 1200, bytesPerPixel: 2},
60			{width: 1600, height: 1200, bytesPerPixel: 4},
61			};
62
63			static Container *gGraphicModes;
64
65			PCI_GCard::PCI_GCard()
66			:PCI_Device("pci-graphic", 0x00, 0x07)
67			{
68			mIORegSize[0] = 0x800000;
69			mIORegType[0] = PCI_ADDRESS_SPACE_MEM_PREFETCH;
70
71			// mConfig[0x00] = 0x02; // vendor ID
72			// mConfig[0x01] = 0x10;
73			// mConfig[0x02] = 0x45; // unit ID
74			// mConfig[0x03] = 0x52;
75			mConfig[0x00] = 0x66; // vendor ID
76			mConfig[0x01] = 0x66;
77			mConfig[0x02] = 0x66; // unit ID
78			mConfig[0x03] = 0x66;
79
80			mConfig[0x08] = 0x00; // revision
81			mConfig[0x09] = 0x00;
82			mConfig[0x0a] = 0x00;
83			mConfig[0x0b] = 0x03;
84
85			mConfig[0x0e] = 0x00; // header-type
86
87			assignMemAddress(0, IO_GCARD_FRAMEBUFFER_PA_START);
88
89			mConfig[0x3c] = IO_PIC_IRQ_GCARD;
90			mConfig[0x3d] = 1;
91			mConfig[0x3e] = 0;
92			mConfig[0x3f] = 0;
93			}
94
95			bool PCI_GCard::readDeviceMem(uint r, uint32 address, uint32 &data, uint size)
96			{
97			IO_GRAPHIC_TRACE("read %d, %08x, %d\n", r, address, size);
98			data = 0;
99			return true;
100			}
101
102			bool PCI_GCard::writeDeviceMem(uint r, uint32 address, uint32 data, uint size)
103			{
104			IO_GRAPHIC_TRACE("write %d, %08x, %08x, %d\n", r, address, data, size);
105			return true;
106			}
107
108			#define MAYBE_PPC_HALF_TO_BE(a) ppc_half_from_LE(a)
109			#define MAYBE_PPC_WORD_TO_BE(a) ppc_word_from_LE(a)
110			#define MAYBE_PPC_DWORD_TO_BE(a) ppc_dword_from_LE(a)
111
112			/*#define MAYBE_PPC_HALF_TO_BE(a) (a)
113			#define MAYBE_PPC_WORD_TO_BE(a) (a)
114			#define MAYBE_PPC_DWORD_TO_BE(a) (a)*/
115
116			void FASTCALL gcard_write_1(uint32 addr, uint32 data)
117			{
118			addr -= IO_GCARD_FRAMEBUFFER_PA_START;
119			(uint8)(gFrameBuffer+addr) = data;
120			damageFrameBuffer(addr);
121			}
122
123			void FASTCALL gcard_write_2(uint32 addr, uint32 data)
124			{
125			addr -= IO_GCARD_FRAMEBUFFER_PA_START;
126			(uint16)(gFrameBuffer+addr) = MAYBE_PPC_HALF_TO_BE(data);
127			damageFrameBuffer(addr);
128			}
129
130			void FASTCALL gcard_write_4(uint32 addr, uint32 data)
131			{
132			addr -= IO_GCARD_FRAMEBUFFER_PA_START;
133			(uint32)(gFrameBuffer+addr) = MAYBE_PPC_WORD_TO_BE(data);
134			damageFrameBuffer(addr);
135			}
136
137			void FASTCALL gcard_write_8(uint32 addr, uint64 data)
138			{
139			addr -= IO_GCARD_FRAMEBUFFER_PA_START;
140			(uint64)(gFrameBuffer+addr) = MAYBE_PPC_DWORD_TO_BE(data);
141			damageFrameBuffer(addr);
142			}
143
144			void FASTCALL gcard_write_16(uint32 addr, uint128 *data)
145			{
146			addr-= IO_GCARD_FRAMEBUFFER_PA_START;
147			#if HOST_ENDIANESS == HOST_ENDIANESS_LE
148			uint8 src = (uint8 )data;
149
150			for (int i=0; i<16; i++) {
151			gFrameBuffer[addr+15-i] = src[i];
152			}
153			#elif HOST_ENDIANESS == HOST_ENDIANESS_BE
154			memmove(gFrameBuffer+addr, data, 16);
155			#else
156			#error Unsupported endianess
157			#endif
158			//(uint64)(gFrameBuffer+addr) = MAYBE_PPC_DWORD_TO_BE(data->h);
159			//(uint64)(gFrameBuffer+addr+8) = MAYBE_PPC_DWORD_TO_BE(data->l);
160			damageFrameBuffer(addr);
161			}
162
163			void FASTCALL gcard_write_16_native(uint32 addr, uint128 *data)
164			{
165			addr-= IO_GCARD_FRAMEBUFFER_PA_START;
166
167			memmove(gFrameBuffer+addr, data, 16);
168
169			damageFrameBuffer(addr);
170			}
171
172			void FASTCALL gcard_read_1(uint32 addr, uint32 &data)
173			{
174			addr-= IO_GCARD_FRAMEBUFFER_PA_START;
175			data = ((uint8)(gFrameBuffer+addr));
176			}
177
178			void FASTCALL gcard_read_2(uint32 addr, uint32 &data)
179			{
180			addr-= IO_GCARD_FRAMEBUFFER_PA_START;
181			data = MAYBE_PPC_HALF_TO_BE((uint16)(gFrameBuffer+addr));
182			}
183
184			void FASTCALL gcard_read_4(uint32 addr, uint32 &data)
185			{
186			addr-= IO_GCARD_FRAMEBUFFER_PA_START;
187			data = MAYBE_PPC_WORD_TO_BE((uint32)(gFrameBuffer+addr));
188			}
189
190			void FASTCALL gcard_read_8(uint32 addr, uint64 &data)
191			{
192			addr-= IO_GCARD_FRAMEBUFFER_PA_START;
193			data = MAYBE_PPC_DWORD_TO_BE((uint64)(gFrameBuffer+addr));
194			}
195
196			void FASTCALL gcard_read_16(uint32 addr, uint128 *data)
197			{
198			addr-= IO_GCARD_FRAMEBUFFER_PA_START;
199			#if HOST_ENDIANESS == HOST_ENDIANESS_LE
200			uint8 store = (uint8 )data;
201
202			for (int i=0; i<16; i++) {
203			store[i] = gFrameBuffer[addr+15-i];
204			}
205			#elif HOST_ENDIANESS == HOST_ENDIANESS_BE
206			memmove(data, gFrameBuffer+addr, 16);
207			#else
208			#error Unsupported endianess
209			#endif
210			//data->h = MAYBE_PPC_DWORD_TO_BE((uint64)(gFrameBuffer+addr));
211			//data->l = MAYBE_PPC_DWORD_TO_BE((uint64)(gFrameBuffer+addr+8));
212			}
213
214			void FASTCALL gcard_read_16_native(uint32 addr, uint128 *data)
215			{
216			addr-= IO_GCARD_FRAMEBUFFER_PA_START;
217
218			memmove(data, gFrameBuffer+addr, 16);
219			}
220
221			static bool gVBLon = false;
222			static int gCurrentGraphicMode;
223
224			void gcard_raise_interrupt()
225			{
226			if (gVBLon) pic_raise_interrupt(IO_PIC_IRQ_GCARD);
227			}
228
229			void gcard_osi(int cpu)
230			{
231			IO_GRAPHIC_TRACE("osi: %d\n", ppc_cpu_get_gpr(cpu, 5));
232			switch (ppc_cpu_get_gpr(cpu, 5)) {
233			case 4:
234			// cmount
235			return;
236			case 28: {
237			// set_vmode
238			uint vmode = ppc_cpu_get_gpr(cpu, 6)-1;
239			if (vmode > gGraphicModes->count() \|\| ppc_cpu_get_gpr(cpu, 7)) {
240			ppc_cpu_set_gpr(cpu, 3, 1);
241			return;
242			}
243			DisplayCharacteristics chr = (DisplayCharacteristics )(*gGraphicModes)[vmode];
244			IO_GRAPHIC_TRACE("set mode %d\n", vmode);
245			if (gDisplay->changeResolution(*chr)) {
246			ppc_cpu_set_gpr(cpu, 3, 0);
247			gcard_set_mode(*chr);
248			} else {
249			ppc_cpu_set_gpr(cpu, 3, 1);
250			}
251			return;
252			}
253			case 29: {
254			/*
255			typedef struct osi_get_vmode_info {
256			short num_vmodes;
257			short cur_vmode; // 1,2,...
258			short num_depths;
259			short cur_depth_mode; // 0,1,2,...
260			short w,h;
261			int refresh; // Hz/65536
262
263			int depth;
264			short row_bytes;
265			short offset;
266			} osi_get_vmode_info_t;
267			*/
268			// get_vmode_info
269			int vmode = ppc_cpu_get_gpr(cpu, 6) - 1;
270			int depth_mode = ppc_cpu_get_gpr(cpu, 7);
271			if (vmode == -1) {
272			vmode = gCurrentGraphicMode;
273			depth_mode = ((DisplayCharacteristics )(gGraphicModes)[vmode])->bytesPerPixel*8;
274			}
275			if (vmode > (int)gGraphicModes->count() \|\| vmode < 0) {
276			ppc_cpu_set_gpr(cpu, 3, 1);
277			return;
278			}
279			DisplayCharacteristics chr = ((DisplayCharacteristics )(*gGraphicModes)[vmode]);
280			ppc_cpu_set_gpr(cpu, 3, 0);
281			ppc_cpu_set_gpr(cpu, 4, (gGraphicModes->count()<<16) \| (vmode+1));
282			ppc_cpu_set_gpr(cpu, 5, (1<<16) \| 0);
283			ppc_cpu_set_gpr(cpu, 6, (chr->width << 16) \| chr->height);
284			ppc_cpu_set_gpr(cpu, 7, chr->vsyncFrequency << 16);
285			ppc_cpu_set_gpr(cpu, 8, chr->bytesPerPixel*8);
286			ppc_cpu_set_gpr(cpu, 9, ((chr->scanLineLength)<<16) \| 0);
287			return;
288			}
289			case 31:
290			// set_video_power
291			ppc_cpu_set_gpr(cpu, 3, 0);
292			return;
293			case 39:
294			IO_GRAPHIC_TRACE("video_ctrl: %d\n", ppc_cpu_get_gpr(cpu, 6));
295			// video_ctrl
296			switch (ppc_cpu_get_gpr(cpu, 6)) {
297			case 0:
298			gVBLon = false;
299			break;
300			case 1:
301			gVBLon = true;
302			break;
303			default:
304			IO_GRAPHIC_ERR("39\n");
305			}
306			ppc_cpu_set_gpr(cpu, 3, 0);
307			return;
308			case 47:
309			// printf("%c\n", gCPU.gpr[6]);
310			return;
311			case 59: {
312			// set_color
313			uint32 r7 = ppc_cpu_get_gpr(cpu, 7);
314			gDisplay->setColor(ppc_cpu_get_gpr(cpu, 6), MK_RGB((r7>>16)&0xff, (r7>>8)&0xff, r7&0xff));
315			ppc_cpu_set_gpr(cpu, 3, 0);
316			return;
317			}
318			case 64: {
319			// get_color
320			RGB c = gDisplay->getColor(ppc_cpu_get_gpr(cpu, 6));
321			ppc_cpu_set_gpr(cpu, 3, (RGB_R(c) << 16) \| (RGB_G(c) << 8) \| (RGB_B(c)));
322			return;
323			}
324			case 116:
325			// hardware_cursor_bla
326			// SINGLESTEP("hw cursor!! %d, %d, %d\n", gCPU.gpr[6], gCPU.gpr[7], gCPU.gpr[8]);
327			IO_GRAPHIC_TRACE("hw cursor!! %d, %d, %d\n", ppc_cpu_get_gpr(cpu, 6), ppc_cpu_get_gpr(cpu, 7), ppc_cpu_get_gpr(cpu, 8));
328			gDisplay->setHWCursor(ppc_cpu_get_gpr(cpu, 6), ppc_cpu_get_gpr(cpu, 7), ppc_cpu_get_gpr(cpu, 8), NULL);
329			return;
330			}
331			IO_GRAPHIC_ERR("unknown osi function\n");
332			}
333
334			/*
335			* displayCharacteristicsFromString tries to create a(n unfinished) characteristic
336			* from a String of the form [0-9]+x[0-9]+x(15\|32)(@[0-9]+)?
337			*/
338
339			bool displayCharacteristicsFromString(DisplayCharacteristics &aChar, const String &s)
340			{
341			String width, height, depth;
342			String tmp, tmp2;
343			if (!s.leftSplit('x', width, tmp)) return false;
344			if (!width.toInt(aChar.width)) return false;
345			if (!tmp.leftSplit('x', height, tmp2)) return false;
346			if (!height.toInt(aChar.height)) return false;
347			if (tmp2.leftSplit('@', depth, tmp)) {
348			if (!depth.toInt(aChar.bytesPerPixel)) return false;
349			if (!tmp.toInt(aChar.vsyncFrequency)) return false;
350			} else {
351			aChar.vsyncFrequency = -1;
352			if (!tmp2.toInt(aChar.bytesPerPixel)) return false;
353			}
354			aChar.scanLineLength = -1;
355			aChar.redShift = -1;
356			aChar.redSize = -1;
357			aChar.greenShift = -1;
358			aChar.greenSize = -1;
359			aChar.blueShift = -1;
360			aChar.blueSize = -1;
361			return true;
362			}
363
364			void gcard_add_characteristic(const DisplayCharacteristics &aChar)
365			{
366			if (!gcard_supports_characteristic(aChar)) {
367			DisplayCharacteristics *chr = new DisplayCharacteristics;
368			*chr = aChar;
369			gGraphicModes->insert(chr);
370			}
371			}
372
373			bool gcard_supports_characteristic(const DisplayCharacteristics &aChar)
374			{
375			return gGraphicModes->contains(&aChar);
376			}
377
378			/*
379			* gcard_finish_characteristic will fill out all fields
380			* of aChar that aren't initialized yet (set to -1).
381			*/
382			bool gcard_finish_characteristic(DisplayCharacteristics &aChar)
383			{
384			if (aChar.width == -1 \|\| aChar.height == -1 \|\| aChar.bytesPerPixel == -1) return false;
385			if (aChar.vsyncFrequency == -1) aChar.vsyncFrequency = 60;
386			if (aChar.scanLineLength == -1) aChar.scanLineLength = aChar.width * aChar.bytesPerPixel;
387			switch (aChar.bytesPerPixel) {
388			case 2:
389
390			if (aChar.redShift == -1) aChar.redShift = 10;
391			if (aChar.redSize == -1) aChar.redSize = 5;
392			if (aChar.greenShift == -1) aChar.greenShift = 5;
393			if (aChar.greenSize == -1) aChar.greenSize = 5;
394			if (aChar.blueShift == -1) aChar.blueShift = 0;
395			if (aChar.blueSize == -1) aChar.blueSize = 5;
396			break;
397			case 4:
398			if (aChar.redShift == -1) aChar.redShift = 16;
399			if (aChar.redSize == -1) aChar.redSize = 8;
400			if (aChar.greenShift == -1) aChar.greenShift = 8;
401			if (aChar.greenSize == -1) aChar.greenSize = 8;
402			if (aChar.blueShift == -1) aChar.blueShift = 0;
403			if (aChar.blueSize == -1) aChar.blueSize = 8;
404			break;
405			default:
406			return false;
407			}
408			return true;
409			}
410
411			bool gcard_set_mode(DisplayCharacteristics &mode)
412			{
413			uint tmp = gGraphicModes->getObjIdx(gGraphicModes->find(&mode));
414			if (tmp == InvIdx) {
415			return false;
416			} else {
417			gCurrentGraphicMode = tmp;
418			return true;
419			}
420			}
421
422			void gcard_init_modes()
423			{
424			gGraphicModes = new Array(true);
425			for (uint i=0; i < (sizeof stdVModes / sizeof stdVModes[0]); i++) {
426			DisplayCharacteristics chr;
427			chr.width = stdVModes[i].width;
428			chr.height = stdVModes[i].height;
429			chr.bytesPerPixel = stdVModes[i].bytesPerPixel;
430			chr.scanLineLength = -1;
431			chr.vsyncFrequency = -1;
432			chr.redShift = -1;
433			chr.redSize = -1;
434			chr.greenShift = -1;
435			chr.greenSize = -1;
436			chr.blueShift = -1;
437			chr.blueSize = -1;
438			gcard_finish_characteristic(chr);
439			gcard_add_characteristic(chr);
440			}
441			}
442
443			void gcard_init_host_modes()
444			{
445			Array modes(true);
446			gDisplay->getHostCharacteristics(modes);
447			foreach (DisplayCharacteristics, chr, modes, {
448			gcard_finish_characteristic(*chr);
449			gcard_add_characteristic(*chr);
450			});
451			}
452
453			void gcard_init()
454			{
455			gPCI_Devices->insert(new PCI_GCard());
456			}
457
458			void gcard_done()
459			{
460			}
461
462			void gcard_init_config()
463			{
464			}