haiku.git

/*
	Copyright 2008 Haiku, Inc.  All rights reserved.
	Distributed under the terms of the MIT license.

	Authors:
	Gerald Zajac 2008
*/

#include "accel.h"

#include <unistd.h>


// Macros for memory mapped I/O.
//==============================

#define INREG8(addr)		*((vuint8*)(gInfo.regs + addr))
#define INREG16(addr)		*((vuint16*)(gInfo.regs + addr))
#define INREG32(addr)		*((vuint32*)(gInfo.regs + addr))

#define OUTREG8(addr, val)	*((vuint8*)(gInfo.regs + addr)) = val
#define OUTREG16(addr, val)	*((vuint16*)(gInfo.regs + addr)) = val
#define OUTREG32(addr, val)	*((vuint32*)(gInfo.regs + addr)) = val


// Functions for PIO.
//===================

uint32 ReadPIO(uint32 addr, uint8 numBytes)
{
	S3GetSetPIO gsp;
	gsp.magic = S3_PRIVATE_DATA_MAGIC;
	gsp.offset = addr;
	gsp.size = numBytes;
	gsp.value = 0;

	status_t result = ioctl(gInfo.deviceFileDesc, S3_GET_PIO, &gsp, sizeof(gsp));
	if (result != B_OK)
		TRACE("ReadPIO() failed, result = 0x%x\n", result);

	return gsp.value;
}


void WritePIO(uint32 addr, uint8 numBytes, uint32 value)
{
	S3GetSetPIO gsp;
	gsp.magic = S3_PRIVATE_DATA_MAGIC;
	gsp.offset = addr;
	gsp.size = numBytes;
	gsp.value = value;

	status_t result = ioctl(gInfo.deviceFileDesc, S3_SET_PIO, &gsp, sizeof(gsp));
	if (result != B_OK)
		TRACE("WritePIO() failed, result = 0x%x\n", result);
}


// Functions to read 8/16/32 bit registers.
//=========================================

uint8 ReadReg8(uint32 addr)
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64)
		return ReadPIO(addr, 1);

	return INREG8(addr);
}


uint16 ReadReg16(uint32 addr)
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64)
		return ReadPIO(addr, 2);

	return INREG16(addr);
}


uint32 ReadReg32(uint32 addr)
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64)
		return ReadPIO(addr, 4);

	return INREG32(addr);
}


// Functions to write 8/16/32 bit registers.
//=========================================

void WriteReg8(uint32 addr, uint8 value)
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64)
		WritePIO(addr, 1, value);
	else
		OUTREG8(addr, value);
}


void WriteReg16(uint32 addr, uint16 value)
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64)
		WritePIO(addr, 2, value);
	else
		OUTREG16(addr, value);
}


void WriteReg32(uint32 addr, uint32 value)
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64)
		WritePIO(addr, 4, value);
	else
		OUTREG32(addr, value);
}


// Functions to read/write CRTC registers.
//========================================

uint8 ReadCrtcReg(uint8 index)
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64) {
		WritePIO_8(0x3d4, index);
		return ReadPIO_8(0x3d5);
	}

	OUTREG8(0x83d4, index);
	return INREG8(0x83d5);
}


void WriteCrtcReg(uint8 index, uint8 value)
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64) {
		WritePIO_8(0x3d4, index);
		WritePIO_8(0x3d5, value);
	} else {
		OUTREG8(0x83d4, index);
		OUTREG8(0x83d5, value);
	}
}


void WriteCrtcReg(uint8 index, uint8 value, uint8 mask)
{
	// Write a value to a CRTC reg using a mask.  The mask selects the
	// bits to be modified.

	if (gInfo.sharedInfo->chipType == S3_TRIO64) {
		WritePIO_8(0x3d4, index);
		WritePIO_8(0x3d5, (ReadPIO_8(0x3d5) & ~mask) | (value & mask));
	} else {
		OUTREG8(0x83d4, index);
		OUTREG8(0x83d5, (INREG8(0x83d5) & ~mask) | (value & mask));
	}
}


// Functions to read/write Sequence registers.
//============================================

uint8 ReadSeqReg(uint8 index)
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64) {
		WritePIO_8(0x3c4, index);
		return ReadPIO_8(0x3c5);
	}

	OUTREG8(0x83c4, index);
	return INREG8(0x83c5);
}


void WriteSeqReg(uint8 index, uint8 value)
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64) {
		WritePIO_8(0x3c4, index);
		WritePIO_8(0x3c5, value);
	} else {
		OUTREG8(0x83c4, index);
		OUTREG8(0x83c5, value);
	}
}


void WriteSeqReg(uint8 index, uint8 value, uint8 mask)
{
	// Write a value to a Sequencer reg using a mask.  The mask selects the
	// bits to be modified.

	if (gInfo.sharedInfo->chipType == S3_TRIO64) {
		WritePIO_8(0x3c4, index);
		WritePIO_8(0x3c5, (ReadPIO_8(0x3c5) & ~mask) | (value & mask));
	} else {
		OUTREG8(0x83c4, index);
		OUTREG8(0x83c5, (INREG8(0x83c5) & ~mask) | (value & mask));
	}
}


// Functions to read/write the misc output register.
//==================================================

uint8 ReadMiscOutReg()
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64)
		return ReadPIO_8(0x3cc);

	return INREG8(0x83cc);
}


void WriteMiscOutReg(uint8 value)
{
	if (gInfo.sharedInfo->chipType == S3_TRIO64)
		WritePIO_8(0x3c2, value);
	else
		OUTREG8(0x83c2, value);
}


void WriteIndexedColor(uint8 index, uint8 red, uint8 green, uint8 blue)
{
	// Write an indexed color.  Argument index is the index (0-255) of the
	// color, and arguments red, green, & blue are the components of the color.

	// Note that although the Trio64V+ chip supports MMIO in nearly all areas,
	// it does not support MMIO for setting indexed colors;  thus, use PIO to
	// set the indexed color.

	if (gInfo.sharedInfo->chipType == S3_TRIO64
			|| gInfo.sharedInfo->chipType == S3_TRIO64_VP) {
		WritePIO_8(0x3c8, index);	// color index
		WritePIO_8(0x3c9, red);
		WritePIO_8(0x3c9, green);
		WritePIO_8(0x3c9, blue);
	} else {
		OUTREG8(0x83c8, index);		// color index
		OUTREG8(0x83c9, red);
		OUTREG8(0x83c9, green);
		OUTREG8(0x83c9, blue);
	}
}