/*
        Copyright (c) 2002-2004, Thomas Kurschel
        

        Part of Radeon accelerant
                
        Multi-monitor management
*/

#include "radeon_accelerant.h"
#include "generic.h"
#include "GlobalData.h"


// transform official mode to internal, multi-screen mode enhanced mode
void Radeon_DetectMultiMode( virtual_card *vc, display_mode *mode )
{
        (void)vc;
        
        mode->timing.flags &= ~RADEON_MODE_MASK;
        
        // combine mode is used if virtual area is twice as visible area 
        // and if scrolling is enabled; if combining is impossible, use
        // cloning instead
        if( (mode->flags & B_SCROLL) == 0 )
                return;
        
        SHOW_FLOW0( 3, "possibly combine mode" );

        // remove scroll flag - we don't need it anymore
        mode->flags &= ~B_SCROLL;
                
        mode->timing.flags &= ~RADEON_MODE_POSITION_MASK;

        if( mode->virtual_width == 2 * mode->timing.h_display ) {
                SHOW_FLOW0( 2, "horizontal combine mode" );
                mode->timing.flags |= RADEON_MODE_POSITION_HORIZONTAL;
                mode->timing.flags &= ~RADEON_MODE_MASK;
                mode->timing.flags |= RADEON_MODE_COMBINE;
        } else if( mode->virtual_height == 2 * mode->timing.v_display ) {
                SHOW_FLOW0( 2, "vertical combine mode" );
                mode->timing.flags |= RADEON_MODE_POSITION_VERTICAL;
                mode->timing.flags &= ~RADEON_MODE_MASK;
                mode->timing.flags |= RADEON_MODE_COMBINE;
        } else {
                // ups, this isn't really a combine mode - restore flags
                SHOW_FLOW0( 2, "wasn't really a combine mode" );
                mode->timing.flags &= ~RADEON_MODE_MASK;
                mode->flags |= B_SCROLL;
        }
}

// make sure selected multi-screen mode is valid; adapt it if needed
void Radeon_VerifyMultiMode( virtual_card *vc, shared_info *si, display_mode *mode )
{
        // if there is no second port or no second monitor connected,
        // fall back to standard mode
        int num_usable_crtcs = vc->assigned_crtc[0] && si->crtc[0].chosen_displays != dd_none;
        
        if( si->num_crtc > 1 )
                num_usable_crtcs += vc->assigned_crtc[1] && si->crtc[1].chosen_displays != dd_none;
                
        if( num_usable_crtcs < 2 ) {
                SHOW_FLOW0( 2, "only one monitor - disabling any multi-mon mode" );
                // restore flags if combine mode is selected
                if( (mode->timing.flags & RADEON_MODE_MASK) == RADEON_MODE_COMBINE )
                        mode->flags |= B_SCROLL;

                mode->timing.flags &= ~RADEON_MODE_MASK;
                mode->timing.flags |= RADEON_MODE_STANDARD;
        }
}

// transform internal, multi-screen enabled display mode
// to official mode
void Radeon_HideMultiMode( virtual_card *vc, display_mode *mode )
{
        (void) vc;
        
        // restore flags for combine mode
        if( (mode->timing.flags & RADEON_MODE_MASK) == RADEON_MODE_COMBINE )
                mode->flags |= B_SCROLL;
}


// initialize multi-screen mode dependant variables
void Radeon_InitMultiModeVars( 
        accelerator_info *ai, display_mode *mode )
{
        virtual_card *vc = ai->vc;
        shared_info *si = ai->si;
        uint32 x, y;

        // setup single-screen mode
        vc->eff_width = mode->timing.h_display;
        vc->eff_height = mode->timing.v_display;
        
        if( vc->used_crtc[0] ) {
                si->crtc[0].rel_x = 0;
                si->crtc[0].rel_y = 0;
        } 
        
        if( vc->used_crtc[1] ) {
                si->crtc[1].rel_x = 0;
                si->crtc[1].rel_y = 0;
        }
        
        switch( mode->timing.flags & RADEON_MODE_MASK ) {
        case RADEON_MODE_COMBINE:
                // detect where second screen must be located and
                // adapt total visible area accordingly
                if( (mode->timing.flags & RADEON_MODE_POSITION_MASK) == RADEON_MODE_POSITION_HORIZONTAL ) {
                        vc->eff_width = 2 * mode->timing.h_display;
                        x = mode->timing.h_display;
                        y = 0;
                } else {
                        vc->eff_height = 2 * mode->timing.v_display;
                        x = 0;
                        y = mode->timing.v_display;
                }
                
                SHOW_FLOW( 3, "relative position of second screen: %d, %d", x, y );
                
                // set relative offset
                if( !vc->swap_displays ) {
                        si->crtc[1].rel_x = x;
                        si->crtc[1].rel_y = y;
                } else {
                        si->crtc[0].rel_x = x;
                        si->crtc[0].rel_y = y;
                }
                break;
                
        default:
                // else, ports are independant but show the same
                break;
        }
}


// mapping of internal TV standard code to public TV standard code
static const uint32 private2be[] = {
        0, 1, 3, 4, 103, 3/* PAL SCART - no public id, so I use PAL BDGHI */, 102 };

// check and execute tunnel settings command
status_t Radeon_CheckMultiMonTunnel( virtual_card *vc, display_mode *mode, 
        const display_mode *low, const display_mode *high, bool *isTunneled )
{
        if( (mode->timing.flags & RADEON_MODE_MULTIMON_REQUEST) != 0 &&
                (mode->timing.flags & RADEON_MODE_MULTIMON_REPLY) == 0 )
        {
                mode->timing.flags &= ~RADEON_MODE_MULTIMON_REQUEST;
                mode->timing.flags |= RADEON_MODE_MULTIMON_REPLY;
                
                // still process request, just in case someone set this flag
                // combination by mistake
                
                // TBD: disabled to shorten syslog 
                *isTunneled = true;
                return B_OK;
        }

        // check magic params
        if( mode->space != 0 || low->space != 0 || 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' )
        {
                *isTunneled = false;
                return B_OK;
        }
        
        *isTunneled = true;
        
        /*SHOW_FLOW( 1, "tunnel access code=%d, command=%d", 
                mode->h_display_start, mode->v_display_start );*/
        
        switch( mode->h_display_start ) {
        case ms_swap:
                switch( mode->v_display_start ) {
                case 0:
                        mode->timing.flags = vc->swap_displays;
                        return B_OK;
                        
                case 1:
                        vc->swap_displays = mode->timing.flags != 0;
                        vc->enforce_mode_change = true;
                        // write settings instantly
                        Radeon_WriteSettings( vc );
                        return B_OK;
                }
                break;
                
        case ms_use_laptop_panel:
                // we must refuse this setting if there is no laptop panel;
                // else, the preferences dialog would show this (useless) option
                if( (vc->connected_displays & dd_lvds) == 0 )
                        return B_ERROR;
                        
                switch( mode->v_display_start ) {
                case 0:
                        mode->timing.flags = vc->use_laptop_panel;
                        //SHOW_FLOW( 1, "get use_laptop_panel settings (%d)", mode->timing.flags );
                        return B_OK;
                        
                case 1:
                        vc->use_laptop_panel = mode->timing.flags != 0;
                        //SHOW_FLOW( 1, "set use_laptop_panel settings (%d)", vc->use_laptop_panel );
                        vc->enforce_mode_change = true;
                        Radeon_WriteSettings( vc );
                        return B_OK;
                }
                break;
                
        case ms_tv_standard:
                switch( mode->v_display_start ) {
                case 0:
                        mode->timing.flags = private2be[vc->tv_standard];
                        /*SHOW_FLOW( 1, "read tv_standard (internal %d, public %d)", 
                                vc->tv_standard, mode->timing.flags );*/
                        return B_OK;
                        
                case 1:
                        switch( mode->timing.flags ) {
                        case 0: vc->tv_standard = ts_off; break;
                        case 1: vc->tv_standard = ts_ntsc; break;
                        case 2: break; // ntsc j
                        case 3: vc->tv_standard = ts_pal_bdghi; break;
                        case 4: vc->tv_standard = ts_pal_m; break;
                        case 5: break; // pal n
                        case 6: break; // secam - I reckon not supported by hardware
                        case 101: break; // ntsc 443
                        case 102: vc->tv_standard = ts_pal_60; break;
                        case 103: vc->tv_standard = ts_pal_nc; break;
                        }
                        
                        SHOW_FLOW( 1, "set tv_standard (internal %d, public %d)", 
                                vc->tv_standard, mode->timing.flags );
                
                        vc->enforce_mode_change = true; 
                        Radeon_WriteSettings( vc );
                        return B_OK;
                        
                case 2: {
                        uint32 idx = mode->timing.flags;
                        
                        // we limit it explicetely to NTSC and PAL as all other
                        // modes are not fully implemented
                        if( idx < sizeof( private2be ) / sizeof( private2be[0] ) && 
                                idx < 3 ) {
                                mode->timing.flags = private2be[idx];
                                return B_OK;
                        } else
                                return B_ERROR;
                        }
                }
        }
        
        return B_ERROR;
}


// return true if both ports must be programmed
bool Radeon_NeedsSecondPort( display_mode *mode )
{
        switch( mode->timing.flags & RADEON_MODE_MASK ) {
        case RADEON_MODE_COMBINE:
                return true;
        default:
                return false;
        }
}


// return number of ports showing differents parts of frame buffer
bool Radeon_DifferentPorts( display_mode *mode )
{
        switch( mode->timing.flags & RADEON_MODE_MASK ) {
        case RADEON_MODE_COMBINE:
                return 2;
        default:
                return 1;
        }
}