/*
        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;
}