/*
	Copyright (c) 2002, Thomas Kurschel

	Part of Radeon driver
	Multi-Monitor Settings interface
*/


#include "multimon.h"
#include "accelerant_ext.h"

#include <OS.h>
#include <Screen.h>

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


// prepare parameters so they recognized as tunneled settings
static void PrepareTunnel( 
	display_mode *mode, display_mode *low, display_mode *high )
{
	memset( mode, 0, sizeof( *mode ));

	// mark modes as settings tunnel
	mode->space = low->space = high->space = 0;
	low->virtual_width = 0xffff;
	low->virtual_height = 0xffff;
	high->virtual_width = 0;
	high->virtual_height = 0;
	mode->timing.pixel_clock = 0;
	low->timing.pixel_clock = 'TKTK';
	high->timing.pixel_clock = 'KTKT';
}


// retrieve value of setting "code"
static status_t GetSetting( 
	BScreen *screen, uint16 code, uint32 *setting )
{
	display_mode mode, low, high;
	status_t result;

	result = TestMultiMonSupport( screen );
	if( result != B_OK )
		return result;

	PrepareTunnel( &mode, &low, &high );

	mode.h_display_start = code;
	mode.v_display_start = 0;
	
	result = screen->ProposeMode( &mode, &low, &high );
	if( result != B_OK )
		return result;
		
	*setting = mode.timing.flags;
	
	return B_OK;
}


// set setting "code" to "value"
static status_t SetSetting( 
	BScreen *screen, uint16 code, uint32 value )
{
	display_mode mode, low, high;
	status_t result;
	
	result = TestMultiMonSupport( screen );
	if( result != B_OK )
		return result;
	
	PrepareTunnel( &mode, &low, &high );

	mode.h_display_start = code;
	mode.v_display_start = 1;
	mode.timing.flags = value;
	
	return screen->ProposeMode( &mode, &low, &high );
}


// retrieve n-th supported value of setting "code"
static status_t GetNthSupportedSetting( 
	BScreen *screen, uint16 code, int32 idx, uint32 *setting )
{
	display_mode mode, low, high;
	status_t result;

	result = TestMultiMonSupport( screen );
	if( result != B_OK )
		return result;

	PrepareTunnel( &mode, &low, &high );

	mode.h_display_start = code;
	mode.v_display_start = 2;
	mode.timing.flags = idx;
	
	result = screen->ProposeMode( &mode, &low, &high );
	if( result != B_OK )
		return result;
		
	*setting = mode.timing.flags;
	
	return B_OK;
}


// get current Swap Displays settings
status_t GetSwapDisplays( 
	BScreen *screen, bool *swap )
{
	status_t result;
	uint32 tmp;
	
	result = GetSetting( screen, ms_swap, &tmp );
	if( result != B_OK )
		return result;
		
	*swap = tmp != 0;
	
	return B_OK;
}


// set "Swap Displays"
status_t SetSwapDisplays( 
	BScreen *screen, bool swap )
{
	return SetSetting( screen, ms_swap, swap );
}


// get current "Use Laptop Panel" settings
status_t GetUseLaptopPanel( 
	BScreen *screen, bool *use )
{
	status_t result;
	uint32 tmp;
	
	result = GetSetting( screen, ms_use_laptop_panel, &tmp );
	if( result != B_OK )
		return result;
		
	*use = tmp != 0;
	return B_OK;
}


// set "Use Laptop Panel"
status_t SetUseLaptopPanel( 
	BScreen *screen, bool use )
{
	return SetSetting( screen, ms_use_laptop_panel, use );
}


// get n-th supported TV standard
status_t GetNthSupportedTVStandard( BScreen *screen, int idx, uint32 *standard )
{
	return GetNthSupportedSetting( 
		screen, ms_tv_standard, (int32)idx, standard );
}


// get current TV Standard settings
status_t GetTVStandard( BScreen *screen, uint32 *standard )
{
	return GetSetting( screen, ms_tv_standard, standard );
}


// set TV Standard
status_t SetTVStandard( BScreen *screen, uint32 standard )
{
	return SetSetting( screen, ms_tv_standard, standard );
}


// Verify existence of Multi-Monitor Settings Tunnel
status_t
TestMultiMonSupport(BScreen *screen)
{
	display_mode *modeList = NULL;
	display_mode low, high;
	uint32 count;
	status_t result;

	// take any valid mode	
	result = screen->GetModeList(&modeList, &count);
	if (result != B_OK)
		return result;

	if (count < 1)
		return B_ERROR;

	// set request bits		
	modeList[0].timing.flags |= RADEON_MODE_MULTIMON_REQUEST;
	modeList[0].timing.flags &= ~RADEON_MODE_MULTIMON_REPLY;
	low = high = modeList[0];

	result = screen->ProposeMode(&modeList[0], &low, &high);
	if (result != B_OK)
		goto out;

	// check reply bits	
	if ((modeList[0].timing.flags & RADEON_MODE_MULTIMON_REQUEST) == 0
		&& (modeList[0].timing.flags & RADEON_MODE_MULTIMON_REPLY) != 0)
		result = B_OK;
	else
		result = B_ERROR;

out:
	free(modeList);
	return result;
}