haiku.git

/*
 * Copyright 2008-2010, François Revol, revol@free.fr. All rights reserved.
 * Copyright 2004-2007, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "toscalls.h"
#include "video.h"
#include "mmu.h"
//#include "images.h"

#include <arch/cpu.h>
#include <boot/stage2.h>
#include <boot/platform.h>
#include <boot/menu.h>
#include <boot/kernel_args.h>
#include <boot/platform/generic/video.h>
#include <util/list.h>
#include <drivers/driver_settings.h>
#include <GraphicsDefs.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#define TRACE_VIDEO
#ifdef TRACE_VIDEO
#	define TRACE(x) dprintf x
#else
#	define TRACE(x) ;
#endif


static void
dump_vars() {
	dprintf("v_bas_ad: %d\n", *TOSVAR_v_bas_ad);
	dprintf("Physbase %p\n", Physbase());
	dprintf("Logbase %p\n", Logbase());

}

// There are several API available to set video modes on atari platforms,
// cf. http://toshyp.atari.org/en/004.html

class ModeOps {
public:
	ModeOps(const char *name) { fName = name; fInitStatus = B_NO_INIT; };
	~ModeOps() {};
	const char *Name() const { return fName; };
	virtual status_t	Init() { fInitStatus = B_OK; };
	status_t	InitStatus() const { return fInitStatus; };
	struct video_mode	*AllocMode();

	// mode handling
	virtual status_t	Enumerate() = 0;
	virtual status_t	Decode(int16 id, struct video_mode *mode);
	virtual status_t	Get(struct video_mode *mode) = 0;
	virtual status_t	Set(const struct video_mode *mode) = 0;
	virtual status_t	Unset(const struct video_mode *mode) { return B_OK; };

	// current settings
	virtual status_t	SetPalette(const struct video_mode *mode,
							const uint8 *palette) { return B_OK; };
	virtual addr_t		Framebuffer() { return NULL; };

	virtual int16	Width(const struct video_mode *mode=NULL);
	virtual int16	Height(const struct video_mode *mode=NULL);
	virtual int16	Depth(const struct video_mode *mode=NULL);
	virtual int16	BytesPerRow(const struct video_mode *mode=NULL);
	
	virtual void	MakeLabel(const struct video_mode *mode, char *label,
						size_t len);

private:
	const char *fName;
protected:
	status_t fInitStatus;
};

struct video_mode {
	list_link	link;
	ModeOps		*ops;
	color_space	space;
	uint16		mode;
	uint16		width, height, bits_per_pixel;
	uint32		bytes_per_row;
status_t	Set() { ops->Set(this); };
status_t	Unset() { ops->Unset(this); };
};

static struct list sModeList;
static video_mode *sMode, *sDefaultMode;
static uint32 sModeCount;
static addr_t sFrameBuffer;
static bool sModeChosen;


static int
compare_video_modes(video_mode *a, video_mode *b)
{
	int compare = a->width - b->width;
	if (compare != 0)
		return compare;

	compare = a->height - b->height;
	if (compare != 0)
		return compare;

	compare = a->bits_per_pixel - b->bits_per_pixel;
	if (compare != 0)
		return compare;

	compare = a->mode - b->mode;
	if (compare != 0)
		return compare;

	return 0;
}


/*!	Insert the video mode into the list, sorted by resolution and bit depth.
	Higher resolutions/depths come first.
*/
static void
add_video_mode(video_mode *videoMode)
{
	video_mode *mode = NULL;
	while ((mode = (video_mode *)list_get_next_item(&sModeList, mode))
			!= NULL) {
		int compare = compare_video_modes(videoMode, mode);
		if (compare == 0) {
			// mode already exists
			return;
		}

		if (compare > 0)
			break;
	}

	list_insert_item_before(&sModeList, mode, videoMode);
	sModeCount++;
}

//	#pragma mark - 


struct video_mode *
ModeOps::AllocMode()
{
	
	video_mode *videoMode = (video_mode *)malloc(sizeof(struct video_mode));
	if (videoMode == NULL)
		return NULL;

	videoMode->ops = this;
	return videoMode;
}

status_t
ModeOps::Decode(int16 id, struct video_mode *mode)
{
	mode->ops = this;
	mode->mode = id;
	return B_OK;
}


int16
ModeOps::Width(const struct video_mode *mode)
{
	return mode ? mode->width : 0;
}


int16
ModeOps::Height(const struct video_mode *mode)
{
	return mode ? mode->height : 0;
}


int16
ModeOps::Depth(const struct video_mode *mode)
{
	return mode ? mode->bits_per_pixel : 0;
}


int16
ModeOps::BytesPerRow(const struct video_mode *mode)
{
	return mode ? mode->bytes_per_row : 0;
}


void
ModeOps::MakeLabel(const struct video_mode *mode, char *label, size_t len)
{
	sprintf(label, "%ux%u %u bit (%s)", mode->width, mode->height,
			mode->bits_per_pixel, mode->ops->Name());

}


//	#pragma mark - ST/TT XBIOS API

class STModeOps : public ModeOps {
public:
	STModeOps() : ModeOps("ST/TT") {};
	~STModeOps() {};
	virtual status_t	Init();

	virtual status_t	Enumerate();
	virtual status_t	Decode(int16 id, struct video_mode *mode);
	virtual status_t	Get(struct video_mode *mode);
	virtual status_t	Set(const struct video_mode *mode);
	virtual status_t	Unset(const struct video_mode *mode);

	virtual status_t	SetPalette(const struct video_mode *mode,
							const uint8 *palette);
	virtual addr_t		Framebuffer();
	virtual void		MakeLabel(const struct video_mode *mode,
							char *label, size_t len);
private:
	static int16		fPreviousMode;
	static bool			fIsTT;
};


int16 STModeOps::fPreviousMode = -1;
bool STModeOps::fIsTT = false;


status_t
STModeOps::Init()
{
	const tos_cookie *c = tos_find_cookie('_VDO');
	if (c == NULL)
		return ENODEV;
	if (c->ivalue >> 16 < 1)
		return ENODEV;
	if (c->ivalue >= 2)
		fIsTT = true;
	fInitStatus = B_OK;
	return fInitStatus;
}



status_t
STModeOps::Enumerate()
{
	if (fInitStatus < B_OK)
		return fInitStatus;

	static int16 modes[] = { 0, /*TT:*/ 4, 7 };
	for (int i = 0; i < sizeof(modes) / sizeof(int16); i++) {
		if (!fIsTT && i > 0)
			break;

		video_mode *videoMode = AllocMode();
		if (videoMode == NULL)
			continue;

		if (Decode(modes[i], videoMode) != B_OK)
			continue;
		add_video_mode(videoMode);

	}
	return B_OK;

#if 0
	// TODO: use TT video monitor detection and build possible mode list there...
	return ENODEV;
#endif
}


status_t
STModeOps::Decode(int16 id, struct video_mode *mode)
{
	mode->ops = this;
	mode->mode = id;

	switch (id) {
		case 0:
			mode->width = 320;
			mode->height = 200;
			mode->bits_per_pixel = 4;
			break;
		case 4:
			mode->width = 640;
			mode->height = 480;
			mode->bits_per_pixel = 4;
			break;
		case 7:
			mode->width = 320;
			mode->height = 480;
			mode->bits_per_pixel = 8;
			break;
		default:
			mode->bits_per_pixel = 0;
			break;
	}

	mode->bytes_per_row = mode->width * mode->bits_per_pixel / 8;
	return B_OK;
}


status_t
STModeOps::Get(struct video_mode *mode)
{
	if (fInitStatus < B_OK)
		return fInitStatus;

	int16 m = Getrez();
	return Decode(m, mode);
}


status_t
STModeOps::Set(const struct video_mode *mode)
{
	if (fInitStatus < B_OK)
		return fInitStatus;
	if (mode == NULL)
		return B_BAD_VALUE;

	fPreviousMode = Getrez();

#warning M68K: FIXME: allocate framebuffer
	dprintf("Switching to mode 0x%04x\n", mode->mode);
	//VsetScreen(((uint32)0x00d00000), ((uint32)0x00d00000), 3, mode->mode);
	Setscreen(-1, -1, mode->mode, 0);
	if (Getrez() != mode->mode) {
		dprintf("failed to set mode %d. Current is %d\n", mode->mode, fPreviousMode);
		fPreviousMode = -1;
	}

	return B_OK;
}


status_t
STModeOps::Unset(const struct video_mode *mode)
{
	if (fInitStatus < B_OK)
		return fInitStatus;

	if (fPreviousMode != -1) {
		dprintf("Reverting to mode 0x%04x\n", fPreviousMode);
		Setscreen(-1, -1, fPreviousMode, 0);
		fPreviousMode = -1;
	}

	return B_OK;
}


status_t
STModeOps::SetPalette(const struct video_mode *mode, const uint8 *palette)
{
	switch (mode->bits_per_pixel) {
		case 4:
			//VsetRGB(0, 16, palette);
			//XXX: Use ESet*
			break;
		case 8:
			//VsetRGB(0, 256, palette);
			//XXX: Use ESet*
			break;
		default:
			break;
	}
}


addr_t
STModeOps::Framebuffer()
{
	addr_t fb = (addr_t)Physbase();
	return fb;
}


void
STModeOps::MakeLabel(const struct video_mode *mode, char *label,
	size_t len)
{
	ModeOps::MakeLabel(mode, label, len);
	label += strlen(label);
	// XXX no len check
	sprintf(label, " 0x%04x", mode->mode);
}


static STModeOps sSTModeOps;


//	#pragma mark - Falcon XBIOS API

class FalconModeOps : public ModeOps {
public:
	FalconModeOps() : ModeOps("Falcon") {};
	~FalconModeOps() {};
	virtual status_t	Init();

	virtual status_t	Enumerate();
	virtual status_t	Decode(int16 id, struct video_mode *mode);
	virtual status_t	Get(struct video_mode *mode);
	virtual status_t	Set(const struct video_mode *mode);
	virtual status_t	Unset(const struct video_mode *mode);

	virtual status_t	SetPalette(const struct video_mode *mode,
							const uint8 *palette);
	virtual addr_t		Framebuffer();
	virtual void		MakeLabel(const struct video_mode *mode,
							char *label, size_t len);
private:
	static int16		fPreviousMode;
};


int16 FalconModeOps::fPreviousMode = -1;


status_t
FalconModeOps::Init()
{
	const tos_cookie *c = tos_find_cookie('_VDO');
	if (c == NULL)
		return ENODEV;
	if (c->ivalue < 0x00030000)
		return ENODEV;
	fInitStatus = B_OK;
	return fInitStatus;
}



status_t
FalconModeOps::Enumerate()
{
	if (fInitStatus < B_OK)
		return fInitStatus;

	static int16 modes[] = {
		0x001b, 0x001c, 0x002b, 0x002c, 
		0x003a, 0x003b, 0x003c, 0x000c, 
		0x0034, 0x0004
		/*0x003a, 0x003b, 0x0003, 0x000c, 
		0x000b, 0x0033, 0x000c, 0x001c*/ };
	for (int i = 0; i < sizeof(modes) / sizeof(int16); i++) {
		video_mode *videoMode = AllocMode();
		if (videoMode == NULL)
			continue;

		if (Decode(modes[i], videoMode) != B_OK)
			continue;
		add_video_mode(videoMode);

	}
	return B_OK;

#if 0
	// TODO: use falcon video monitor detection and build possible mode list there...
	int16 monitor;
	bool vga = false;
	bool tv = false;
	monitor = VgetMonitor();
	switch (monitor) {
		case 0:
			panic("Monochrome ?\n");
			break;
		case 2:
			vga = true;
			break;
		case 3:
			tv = true;
			break;
		//case 4 & 5: check for CT60
		case 1:
		default:
			dprintf("monitor type %d\n", monitor);
			break;
	}
	return ENODEV;
#endif
}


status_t
FalconModeOps::Decode(int16 id, struct video_mode *mode)
{
	bool vga = (id & 0x0010) != 0;
	//bool pal = (id & 0x0020) != 0;
	bool overscan = (id & 0x0040) != 0;
	bool st = (id & 0x0080) != 0;
	bool interlace = (id & 0x0100) != 0;
	bool dbl = interlace;

	mode->ops = this;
	mode->mode = id;
	// cf. F30.TXT
	mode->width = (id & 0x0008) ? 640 : 320;
	mode->height = (vga ? (interlace ? 400 : 200) : (dbl ? 240 : 480));
	if (overscan) {
		// *= 1.2
		mode->width = (mode->width * 12) / 10;
		mode->height = (mode->width * 12) / 10;
	}
	mode->bits_per_pixel = 1 << (id & 0x0007);
	mode->bytes_per_row = mode->width * mode->bits_per_pixel / 8;
	return B_OK;
}


status_t
FalconModeOps::Get(struct video_mode *mode)
{
	if (fInitStatus < B_OK)
		return fInitStatus;

	int16 m = VsetMode(VM_INQUIRE);
	return Decode(m, mode);
}


status_t
FalconModeOps::Set(const struct video_mode *mode)
{
	if (fInitStatus < B_OK)
		return fInitStatus;
	if (mode == NULL)
		return B_BAD_VALUE;

	fPreviousMode = VsetMode(VM_INQUIRE);

#warning M68K: FIXME: allocate framebuffer
	dprintf("Switching to mode 0x%04x\n", mode->mode);
	//VsetScreen(((uint32)0x00d00000), ((uint32)0x00d00000), 3, mode->mode);
	VsetScreen(((uint32)0x00c00000), ((uint32)0x00c00000), 3, mode->mode);
	//VsetScreen(((uint32)-1), ((uint32)-1), 3, mode->mode);

	return B_OK;
}


status_t
FalconModeOps::Unset(const struct video_mode *mode)
{
	if (fInitStatus < B_OK)
		return fInitStatus;

	if (fPreviousMode != -1) {
		dprintf("Reverting to mode 0x%04x\n", fPreviousMode);
		VsetScreen(-1, -1, 3, fPreviousMode);
		fPreviousMode = -1;
	}

	return B_OK;
}


status_t
FalconModeOps::SetPalette(const struct video_mode *mode, const uint8 *palette)
{
	switch (mode->bits_per_pixel) {
		case 4:
			VsetRGB(0, 16, palette);
			break;
		case 8:
			VsetRGB(0, 256, palette);
			break;
		default:
			break;
	}
}


addr_t
FalconModeOps::Framebuffer()
{
	addr_t fb = (addr_t)Physbase();
	return fb;
}


void
FalconModeOps::MakeLabel(const struct video_mode *mode, char *label,
	size_t len)
{
	ModeOps::MakeLabel(mode, label, len);
	label += strlen(label);
	// XXX no len check
	int16 m = mode->mode;
	sprintf(label, " 0x%04x", mode->mode);
	/*sprintf(label, "%s%s%s%s",
		m & 0x0010 ? " vga" : " tv",
		m & 0x0020 ? " pal" : "",
		m & 0x0040 ? " oscan" : "",
		//m & 0x0080 ? " tv" : "",
		m & 0x0100 ? " ilace" : "");*/
}


static FalconModeOps sFalconModeOps;


//	#pragma mark - Milan XBIOS API

class MilanModeOps : public ModeOps {
public:
	MilanModeOps() : ModeOps("Milan") {};
	~MilanModeOps() {};
	virtual status_t	Init();

	virtual status_t	Enumerate();
	virtual status_t	Decode(int16 id, struct video_mode *mode);
	virtual status_t	Get(struct video_mode *mode);
	virtual status_t	Set(const struct video_mode *mode);
	virtual status_t	Unset(const struct video_mode *mode);

	virtual status_t	SetPalette(const struct video_mode *mode,
							const uint8 *palette);
	virtual addr_t		Framebuffer();
	virtual void		MakeLabel(const struct video_mode *mode,
							char *label, size_t len);
private:
	static int16		fPreviousMode;
};


int16 MilanModeOps::fPreviousMode = -1;


status_t
MilanModeOps::Init()
{
	const tos_cookie *c = tos_find_cookie('_MIL');
	if (c == NULL)
		return ENODEV;
	fInitStatus = B_OK;
	return fInitStatus;
}



status_t
MilanModeOps::Enumerate()
{
	if (fInitStatus < B_OK)
		return fInitStatus;

	SCREENINFO info;
	info.size = sizeof(info);
	

	static int16 modes[] = {
		0x001b, 0x001c, 0x002b, 0x002c, 
		0x003a, 0x003b, 0x003c, 0x000c, 
		0x0034, 0x0004
		/*0x003a, 0x003b, 0x0003, 0x000c, 
		0x000b, 0x0033, 0x000c, 0x001c*/ };
	for (int i = 0; i < sizeof(modes) / sizeof(int16); i++) {
		video_mode *videoMode = AllocMode();
		if (videoMode == NULL)
			continue;

		if (Decode(modes[i], videoMode) != B_OK)
			continue;
		add_video_mode(videoMode);

	}
	return B_OK;

#if 0
	// TODO: use Milan video monitor detection and build possible mode list there...
	int16 monitor;
	bool vga = false;
	bool tv = false;
	monitor = VgetMonitor();
	switch (monitor) {
		case 0:
			panic("Monochrome ?\n");
			break;
		case 2:
			vga = true;
			break;
		case 3:
			tv = true;
			break;
		//case 4 & 5: check for CT60
		case 1:
		default:
			dprintf("monitor type %d\n", monitor);
			break;
	}
	return ENODEV;
#endif
}


status_t
MilanModeOps::Decode(int16 id, struct video_mode *mode)
{
	SCREENINFO info;
	info.size = sizeof(info);
	info.devID = mode->mode;
	info.scrFlags = 0;

	mode->ops = this;
	mode->mode = id;

	Setscreen(-1,&info,MI_MAGIC,CMD_GETINFO);
	
	if (info.scrFlags & SCRINFO_OK == 0)
		return B_ERROR;

	// cf. F30.TXT
	mode->width = info.scrWidth;
	mode->height = info.scrHeight;
	mode->bits_per_pixel = info.scrPlanes;
	mode->bytes_per_row = mode->width * mode->bits_per_pixel / 8;
	return B_OK;
}


status_t
MilanModeOps::Get(struct video_mode *mode)
{
	if (fInitStatus < B_OK)
		return fInitStatus;

	int16 m = -1;
	Setscreen(-1,&m,MI_MAGIC,CMD_GETMODE);
	if (m == -1)
		return B_ERROR;
	return Decode(m, mode);
}


status_t
MilanModeOps::Set(const struct video_mode *mode)
{
	if (fInitStatus < B_OK)
		return fInitStatus;
	if (mode == NULL)
		return B_BAD_VALUE;

	Setscreen(-1,&fPreviousMode,MI_MAGIC,CMD_GETMODE);

#warning M68K: FIXME: allocate framebuffer
	dprintf("Switching to mode 0x%04x\n", mode->mode);
	//VsetScreen(((uint32)0x00d00000), ((uint32)0x00d00000), 3, mode->mode);
	//VsetScreen(((uint32)-1), ((uint32)-1), 3, mode->mode);
	Setscreen(-1,mode->mode,MI_MAGIC,CMD_SETMODE);

	return B_OK;
}


status_t
MilanModeOps::Unset(const struct video_mode *mode)
{
	if (fInitStatus < B_OK)
		return fInitStatus;

	if (fPreviousMode != -1) {
		dprintf("Reverting to mode 0x%04x\n", fPreviousMode);
		Setscreen(-1,fPreviousMode,MI_MAGIC,CMD_SETMODE);
		fPreviousMode = -1;
	}

	return B_OK;
}


status_t
MilanModeOps::SetPalette(const struct video_mode *mode, const uint8 *palette)
{
	switch (mode->bits_per_pixel) {
		case 4:
			//VsetRGB(0, 16, palette);
			break;
		case 8:
			//VsetRGB(0, 256, palette);
			break;
		default:
			break;
	}
}


addr_t
MilanModeOps::Framebuffer()
{
	//XXX
	addr_t fb = (addr_t)Physbase();
	return fb;
}


void
MilanModeOps::MakeLabel(const struct video_mode *mode, char *label,
	size_t len)
{
	ModeOps::MakeLabel(mode, label, len);
	label += strlen(label);
	// XXX no len check
	int16 m = mode->mode;
	sprintf(label, " 0x%04x", mode->mode);
	/*sprintf(label, "%s%s%s%s",
		m & 0x0010 ? " vga" : " tv",
		m & 0x0020 ? " pal" : "",
		m & 0x0040 ? " oscan" : "",
		//m & 0x0080 ? " tv" : "",
		m & 0x0100 ? " ilace" : "");*/
}


static MilanModeOps sMilanModeOps;


//	#pragma mark - ARAnyM NFVDI API

/* NatFeat VDI */
#define FVDIDRV_NFAPI_VERSION	0x14000960L
#define FVDI_GET_VERSION	0
#define FVDI_GET_FBADDR	11
#define FVDI_SET_RESOLUTION	12
#define FVDI_GET_WIDTH	13
#define FVDI_GET_HEIGHT	14
#define FVDI_OPENWK 15
#define FVDI_CLOSEWK 16
#define FVDI_GETBPP	17


class NFVDIModeOps : public ModeOps {
public:
	NFVDIModeOps() : ModeOps("NFVDI") {};
	~NFVDIModeOps() {};
	virtual status_t	Init();
	virtual status_t	Enumerate();
	virtual status_t	Get(struct video_mode *mode);
	virtual status_t	Set(const struct video_mode *mode);
	virtual status_t	Unset(const struct video_mode *mode);
	virtual addr_t		Framebuffer();

	virtual int16	Width(const struct video_mode *mode=NULL);
	virtual int16	Height(const struct video_mode *mode=NULL);
	virtual int16	Depth(const struct video_mode *mode=NULL);

private:
	int32 fNatFeatId;
};


status_t
NFVDIModeOps::Init()
{
	// NF calls not available when the ctor is called
	fNatFeatId = nat_feat_getid("fVDI");
	if (fNatFeatId == 0)
		return B_ERROR;
	dprintf("fVDI natfeat id 0x%08lx\n", fNatFeatId);
	
	int32 version = nat_feat_call(fNatFeatId, FVDI_GET_VERSION);
	dprintf("fVDI NF version %lx\n", version);
	if (version < FVDIDRV_NFAPI_VERSION)
		return B_ERROR;
	fInitStatus = B_OK;
	return fInitStatus;
}


status_t
NFVDIModeOps::Enumerate()
{
	if (fNatFeatId == 0)
		return B_NO_INIT;

	video_mode * mode;

	mode = AllocMode();
	if (mode == NULL)
		return B_ERROR;

	Get(mode);
	//mode->space = ;
	mode->mode = 0;
	mode->width = 800;
	mode->height = 600;
	mode->bits_per_pixel = 8;
	mode->bytes_per_row = mode->width * mode->bits_per_pixel / 8;

	add_video_mode(mode);


	mode = AllocMode();
	if (mode == NULL)
		return B_ERROR;

	Get(mode);
	//mode->space = ;
	mode->mode = 0;
	mode->width = 1024;
	mode->height = 768;
	mode->bits_per_pixel = 16;
	mode->bytes_per_row = mode->width * mode->bits_per_pixel / 8;

	add_video_mode(mode);


	return B_OK;
}


status_t
NFVDIModeOps::Get(struct video_mode *mode)
{
	if (mode == NULL)
		return B_BAD_VALUE;
	if (fNatFeatId == 0)
		return B_NOT_SUPPORTED;
	mode->width = Width();
	mode->height = Height();
	mode->bits_per_pixel = Depth();
	mode->bytes_per_row = mode->width * mode->bits_per_pixel / 8;
	dprintf("Get: %dx%d\n", mode->width, mode->height);
	return B_OK;
}


status_t
NFVDIModeOps::Set(const struct video_mode *mode)
{
	if (mode == NULL)
		return B_BAD_VALUE;
	if (fNatFeatId == 0)
		return B_NOT_SUPPORTED;
	status_t err;
	dprintf("fVDI::Set(%ldx%ld %ld)\n",
		(int32)Width(mode), (int32)Height(mode), (int32)Depth(mode));
	err = nat_feat_call(fNatFeatId, FVDI_SET_RESOLUTION,
		(int32)Width(mode), (int32)Height(mode), (int32)Depth(mode));
	err = toserror(err);
	err = nat_feat_call(fNatFeatId, FVDI_OPENWK);

	return B_OK;
}


status_t
NFVDIModeOps::Unset(const struct video_mode *mode)
{
	if (mode == NULL)
		return B_BAD_VALUE;
	if (fNatFeatId == 0)
		return B_NOT_SUPPORTED;
	nat_feat_call(fNatFeatId, FVDI_CLOSEWK);
	return B_OK;
}


addr_t
NFVDIModeOps::Framebuffer()
{
	addr_t fb;
	if (fNatFeatId == 0)
		return (addr_t)NULL;
	fb = (addr_t)nat_feat_call(fNatFeatId, FVDI_GET_FBADDR);
	dprintf("fb 0x%08lx\n", fb);
	return fb;
}


int16
NFVDIModeOps::Width(const struct video_mode *mode)
{
	if (mode)
		return ModeOps::Width(mode);
	if (fNatFeatId == 0)
		return 0;
	return (int16)nat_feat_call(fNatFeatId, FVDI_GET_WIDTH);
}


int16
NFVDIModeOps::Height(const struct video_mode *mode)
{
	if (mode)
		return ModeOps::Height(mode);
	if (fNatFeatId == 0)
		return 0;
	return (int16)nat_feat_call(fNatFeatId, FVDI_GET_HEIGHT);
}


int16
NFVDIModeOps::Depth(const struct video_mode *mode)
{
	if (mode)
		return ModeOps::Depth(mode);
	if (fNatFeatId == 0)
		return 0;
	return (int16)nat_feat_call(fNatFeatId, FVDI_GETBPP);
}


static NFVDIModeOps sNFVDIModeOps;


//	#pragma mark -


bool
video_mode_hook(Menu *menu, MenuItem *item)
{
	// find selected mode
	video_mode *mode = NULL;

	Menu* submenu = item->Submenu();
	MenuItem* subitem = submenu->FindMarked();
	if (subitem != NULL) {
		switch (submenu->IndexOf(subitem)) {
			case 0:
				// "Default" mode special
				sMode = sDefaultMode;
				sModeChosen = false;
				return true;
			//case 1:
				// "Standard VGA" mode special
				// sets sMode to NULL which triggers VGA mode
				//break;
			default:
				mode = (video_mode *)subitem->Data();
				break;
		}
	}

	if (mode != sMode) {
		// update standard mode
		// ToDo: update fb settings!
		sMode = mode;
platform_switch_to_logo();
	}

	sModeChosen = true;
	return true;
}


Menu *
video_mode_menu()
{
	Menu *menu = new(nothrow) Menu(CHOICE_MENU, "Select Video Mode");
	MenuItem *item;

	menu->AddItem(item = new(nothrow) MenuItem("Default"));
	item->SetMarked(true);
	item->Select(true);
	item->SetHelpText("The Default video mode is the one currently configured "
		"in the system. If there is no mode configured yet, a viable mode will "
		"be chosen automatically.");

	//menu->AddItem(new(nothrow) MenuItem("Standard VGA"));

	video_mode *mode = NULL;
	while ((mode = (video_mode *)list_get_next_item(&sModeList, mode)) != NULL) {
		char label[64];
		mode->ops->MakeLabel(mode, label, sizeof(label));

		menu->AddItem(item = new(nothrow) MenuItem(label));
		item->SetData(mode);
	}

	menu->AddSeparatorItem();
	menu->AddItem(item = new(nothrow) MenuItem("Return to main menu"));
	item->SetType(MENU_ITEM_NO_CHOICE);

	return menu;
}


void
platform_blit4(addr_t frameBuffer, const uint8 *data,
	uint16 width, uint16 height, uint16 imageWidth, uint16 left, uint16 top)
{
	if (!data)
		return;
}


extern "C" void
platform_set_palette(const uint8 *palette)
{
	if (sMode)
		sMode->ops->SetPalette(sMode, palette);
}


//	#pragma mark -


extern "C" void
platform_switch_to_logo(void)
{
	// in debug mode, we'll never show the logo
	if ((platform_boot_options() & BOOT_OPTION_DEBUG_OUTPUT) != 0)
		return;

	addr_t lastBase = gKernelArgs.frame_buffer.physical_buffer.start;
	size_t lastSize = gKernelArgs.frame_buffer.physical_buffer.size;

	if (sMode != NULL) {
		sMode->Set();

		gKernelArgs.frame_buffer.width = sMode->ops->Width(sMode);
		gKernelArgs.frame_buffer.height = sMode->ops->Height(sMode);
		gKernelArgs.frame_buffer.bytes_per_row = sMode->ops->BytesPerRow(sMode);
		gKernelArgs.frame_buffer.depth = sMode->ops->Depth(sMode);
		gKernelArgs.frame_buffer.physical_buffer.size = 
			gKernelArgs.frame_buffer.height
			* gKernelArgs.frame_buffer.bytes_per_row;
		gKernelArgs.frame_buffer.physical_buffer.start =
			sMode->ops->Framebuffer();
		//XXX: FIXME: this is just for testing...
		sFrameBuffer = sMode->ops->Framebuffer();
	} else {
		gKernelArgs.frame_buffer.enabled = false;
		return;
	}
	gKernelArgs.frame_buffer.enabled = true;

#if 1
	// If the new frame buffer is either larger than the old one or located at
	// a different address, we need to remap it, so we first have to throw
	// away its previous mapping
	if (lastBase != 0
		&& (lastBase != gKernelArgs.frame_buffer.physical_buffer.start
			|| lastSize < gKernelArgs.frame_buffer.physical_buffer.size)) {
		mmu_free((void *)sFrameBuffer, lastSize);
		lastBase = 0;
	}
	if (lastBase == 0) {
		// the graphics memory has not been mapped yet!
		sFrameBuffer = mmu_map_physical_memory(
			gKernelArgs.frame_buffer.physical_buffer.start,
			gKernelArgs.frame_buffer.physical_buffer.size, kDefaultPageFlags);
	}
#endif
	video_display_splash(sFrameBuffer);
	dump_vars();
	spin(10000000);
	platform_switch_to_text_mode();
	dprintf("splash done\n");
	dump_vars();
}


extern "C" void
platform_switch_to_text_mode(void)
{
	if (!gKernelArgs.frame_buffer.enabled) {
		return;
	}

	if (sMode)
		sMode->Unset();

	gKernelArgs.frame_buffer.enabled = 0;
}


extern "C" status_t
platform_init_video(void)
{
	gKernelArgs.frame_buffer.enabled = 0;
	list_init(&sModeList);

	dprintf("current video mode: \n");
	dprintf("Vsetmode(-1): 0x%08x\n", VsetMode(VM_INQUIRE));
	dump_vars();

	// NF VDI does not implement FVDI_GET_FBADDR :(
	//sNFVDIModeOps.Init();
	//sNFVDIModeOps.Enumerate();

	if (sMilanModeOps.Init() == B_OK) {
		sMilanModeOps.Enumerate();
	} else if (sFalconModeOps.Init() == B_OK) {
		sFalconModeOps.Enumerate();
	} else if (sSTModeOps.Init() == B_OK) {
		sSTModeOps.Enumerate();
	} else {
		dprintf("No usable video API found\n");
	}
	
	return B_OK;
}