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

        Part of Radeon accelerant
                
        Hardware cursor support.
*/


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

static void moveOneCursor( accelerator_info *ai, int crtc_idx, int x, int y );

// set standard foreground/background colours
void Radeon_SetCursorColors( accelerator_info *ai, int crtc_idx ) 
{
        SHOW_FLOW0( 3, "" );
        
        if( crtc_idx == 0 ) {
                OUTREG( ai->regs, RADEON_CUR_CLR0, 0xffffff );
                OUTREG( ai->regs, RADEON_CUR_CLR1, 0 );
        } else {
                OUTREG( ai->regs, RADEON_CUR2_CLR0, 0xffffff );
                OUTREG( ai->regs, RADEON_CUR2_CLR1, 0 );
        }
}

// public function to set shape of cursor
status_t SET_CURSOR_SHAPE( uint16 width, uint16 height, uint16 hot_x, uint16 hot_y, 
                                                   uint8 *andMask, uint8 *xorMask) 
{
        virtual_card *vc = ai->vc;
        uint8 *fb_cursor = vc->cursor.data;
        int row, col_byte;

        /* NOTE: Currently, for BeOS, cursor width and height must be equal to 16. */
/*      if( width != 16 || height != 16 )
                return B_ERROR;*/

        if( hot_x >= width || hot_y >= height )
                return B_ERROR;
                
        // TBD: should we sync here? I'd say so, but if I fail, we deadlock
                        
        vc->cursor.hot_x = hot_x;
        vc->cursor.hot_y = hot_y;
                
        for( row = 0; row < 64; ++row ) {
                for( col_byte = 0; col_byte < 64 / 8; ++col_byte ) {
                        if( row < height && col_byte < (width + 7) / 8 ) {
                                fb_cursor[row * 64/8 * 2 + col_byte] = *andMask++;
                                fb_cursor[row * 64/8 * 2 + col_byte + 64/8] = *xorMask++;
                        } else {
                                fb_cursor[row * 64/8 * 2 + col_byte] = 0xff;
                                fb_cursor[row * 64/8 * 2 + col_byte + 64/8] = 0;
                        }
                }
        }
        
        return B_OK;
}


// public function to move cursor 
void MOVE_CURSOR(uint16 x, uint16 y) 
{
        virtual_card *vc = ai->vc;
        bool move_screen = false;
        uint16 hds, vds;
        
        // alignment mask for horizontal position
        uint16 h_adjust = 7;
        
        ACQUIRE_BEN( ai->si->engine.lock );
        
        hds = vc->mode.h_display_start;
        vds = vc->mode.v_display_start;

        // clamp cursor (negative positions are impossible due to uint16)
        if (x >= vc->mode.virtual_width) 
                x = vc->mode.virtual_width - 1;
        if (y >= vc->mode.virtual_height) 
                y = vc->mode.virtual_height - 1;

        // if scrolling enabled, i.e. we have a larger virtual screen,
        // pan display accordingly
        if( vc->scroll ) {
                if( x >= (vc->mode.timing.h_display + hds) ) {
                        hds = ((x - vc->mode.timing.h_display) + 1 + h_adjust) & ~h_adjust;
                        move_screen = true;
                } else if( x < hds ) {
                        hds = x & ~h_adjust;
                        move_screen = true;
                }
                if( y >= (vc->mode.timing.v_display + vds) ) {
                        vds = y - vc->mode.timing.v_display + 1;
                        move_screen = true;
                } else if( y < vds ) {
                        vds = y;
                        move_screen = true;
                }

                if( move_screen )
                        Radeon_MoveDisplay( ai, hds, vds );
        }
        
        // adjust according to virtual screen position
        x -= hds;
        y -= vds;

        // go
        if( vc->used_crtc[0] )
                moveOneCursor( ai, 0, x, y );
        if( vc->used_crtc[1] )
                moveOneCursor( ai, 1, x, y );
                        
        RELEASE_BEN( ai->si->engine.lock );
}


// public function to show cursor
void SHOW_CURSOR( bool is_visible )
{
        virtual_card *vc = ai->vc;
        
        SHOW_FLOW0( 4, "" );
        
        ACQUIRE_BEN( ai->si->engine.lock );
        
        // this is the public statement
        vc->cursor.is_visible = is_visible;
        
        // the following functions take also care to not
        // show the cursor if it's on the other port
        if( vc->used_crtc[0] )
                Radeon_ShowCursor( ai, 0 );
        if( vc->used_crtc[1] )
                Radeon_ShowCursor( ai, 1 );
        
        RELEASE_BEN( ai->si->engine.lock );
}


// move cursor on one port
//      main_port - common data is stored here
void moveOneCursor( accelerator_info *ai, int crtc_idx, int x, int y )
{
        virtual_card *vc = ai->vc;
        crtc_info *crtc = &ai->si->crtc[crtc_idx];
        int xorigin, yorigin;
        bool prev_state;

        // adjust according to relative screen position 
        x -= crtc->rel_x;
        y -= crtc->rel_y;
        
        // and to hot spot
        x -= vc->cursor.hot_x;
        y -= vc->cursor.hot_y;

        // check whether the cursor is (partially) visible on this screen
        prev_state = crtc->cursor_on_screen;
        crtc->cursor_on_screen = true;

        // in theory, cursor can be up to 64 pixels off screen, 
        // but there were display errors
        if( y > crtc->mode.timing.v_display ||
                x > crtc->mode.timing.h_display ||
                x <= -16 || y <= -16 )
        {
                crtc->cursor_on_screen = false;
        }
        
        if( prev_state != crtc->cursor_on_screen ) 
                Radeon_ShowCursor( ai, crtc_idx );

        if( !crtc->cursor_on_screen )
                return;

        // if upper-left corner of cursor is outside of
        // screen, we have to use special registers to clip it
        xorigin = 0;
        yorigin = 0;
                
        if( x < 0 )
                xorigin = -x;
        
        if( y < 0 )
                yorigin = -y;

        if( crtc_idx == 0 )     {
                OUTREG( ai->regs, RADEON_CUR_HORZ_VERT_OFF, RADEON_CUR_LOCK
                        | (xorigin << 16)
                        | yorigin );
                OUTREG( ai->regs, RADEON_CUR_HORZ_VERT_POSN, RADEON_CUR_LOCK
                        | ((xorigin ? 0 : x) << 16)
                        | (yorigin ? 0 : y) );
                OUTREG( ai->regs, RADEON_CUR_OFFSET, 
                        vc->cursor.fb_offset + xorigin + yorigin * 16 );
        } else {
                OUTREG( ai->regs, RADEON_CUR2_HORZ_VERT_OFF, RADEON_CUR2_LOCK
                        | (xorigin << 16)
                        | yorigin );
                OUTREG( ai->regs, RADEON_CUR2_HORZ_VERT_POSN, RADEON_CUR2_LOCK
                        | ((xorigin ? 0 : x) << 16)
                        | (yorigin ? 0 : y) );
                OUTREG( ai->regs, RADEON_CUR2_OFFSET, 
                        vc->cursor.fb_offset + xorigin + yorigin * 16 );
        }
}


// show cursor on one port, depending on official whishes and whether
// cursor is located on this subscreen
void Radeon_ShowCursor( accelerator_info *ai, int crtc_idx )
{
        virtual_card *vc = ai->vc;
        crtc_info *crtc = &ai->si->crtc[crtc_idx];
        uint32 tmp;

        if( crtc_idx == 0 ) {
                tmp = INREG( ai->regs, RADEON_CRTC_GEN_CNTL );
                
                if( vc->cursor.is_visible && crtc->cursor_on_screen ) {
                        tmp |= RADEON_CRTC_CUR_EN;
                } else {
                        tmp &= ~RADEON_CRTC_CUR_EN;
                }

                OUTREG( ai->regs, RADEON_CRTC_GEN_CNTL, tmp );
                
        } else {
                tmp = INREG( ai->regs, RADEON_CRTC2_GEN_CNTL );
        
                if( vc->cursor.is_visible && crtc->cursor_on_screen )
                        tmp |= RADEON_CRTC2_CUR_EN;
                else
                        tmp &= ~RADEON_CRTC2_CUR_EN;

                OUTREG( ai->regs, RADEON_CRTC2_GEN_CNTL, tmp );
        }
}