r2d_task_i_phillips.c

MMI层OBJ不能完全编译

#include "sys_types.h"
#include "r2d/lcds/i_sample/r2d_tfd_lcd.h"
#include "rvm/rvm_use_id_list.h"
#include "r2d/lcds/i_sample/lcd_if.h"
#include "dma/dma_api.h"
#include "dma/dma_message.h"

// added by santosh
#include "lcd_pwr.h"
// added by santosh

#ifdef R2D_USE_LCD_DMA
#include "r2d/lcds/i_sample/r2d_lcd_dma.h"
extern T_RVF_ADDR_ID r2d_addr_id;
volatile UINT8 r2d_lcd_dma_ok = 1;
T_DMA_CHANNEL r2d_lcd_dma_channel;
T_DMA_CHANNEL_PARAMETERS r2d_lcd_dma_channel_info;
UINT32   r2d_lcd_dma_bytes_to_transfer = 0;
volatile T_R2D_LCD_DMA_STATE r2d_lcd_dma_state = R2D_LCD_DMA_UNINITILISED;

void r2d_dma_callback(void *response);
static E_LCD_IF_CALLBACK_RET f_lcd_if_dummy_callback (void);

#endif

#define LITTLE_ENDIAN 0
#define BIG_ENDIAN    1 

#define FRAME_BUFFER_ENDIAN LITTLE_ENDIAN  
#define FRAME_BUFFER_INVERTED 0 //input framebuffer is in inverd RGB format

UINT16  *tab_temp;

void r2d_lcd_power_on(void)
{
}

void r2d_lcd_power_off(void)
{
}

void r2d_refresh(void)
{

#ifndef _WINDOWS
    SYS_UWORD16 buf;
    UINT16 v;
    UINT8 nibble1,nibble2;
    UINT16 s_color,colorL,colorR;
    UINT32 i;

#ifdef R2D_USE_LCD_DMA
    UINT16 received_event;
#endif

    tab_temp=(UINT16 *)r2d_g_framebuffer->p_memory_words;

#if (R2D_REFRESH == R2D_HORIZONTAL)
    rvf_send_trace("R2D REFRESH",strlen("R2D REFRESH"), NULL_PARAM,
            RV_TRACE_LEVEL_DEBUG_HIGH, R2D_USE_ID );


	// added by santosh ---- begins

// stop the timer2
(void) NU_Control_Timer (&lcd_sleep_timer2,NU_DISABLE_TIMER);
(void) NU_Reset_Timer(&lcd_sleep_timer2,&lcd_sleep_timer2_expiration,0,0,NU_DISABLE_TIMER);
(void) NU_Control_Timer (&lcd_sleep_timer2,NU_ENABLE_TIMER);

// LCD DISPLAY ON
buf= 0xAF; 
f_lcd_if_poll_write(C_LCD_IF_CS0, &buf, 1, C_LCD_IF_INSTRUCTION);

// stop the timer1
(void) NU_Control_Timer (&lcd_sleep_timer1,NU_DISABLE_TIMER);
(void)NU_Reset_Timer(&lcd_sleep_timer1,&lcd_sleep_timer1_expiration,0,0,NU_DISABLE_TIMER);
(void) NU_Control_Timer (&lcd_sleep_timer1,NU_ENABLE_TIMER);

// added by santosh ---- ends



    /** Set address */
    buf = 0x21; // RAM Address
    f_lcd_if_poll_write(C_LCD_IF_CS0, &buf, 1, C_LCD_IF_INSTRUCTION);

    buf = 0x0000;

    f_lcd_if_poll_write(C_LCD_IF_CS0, &buf, 1, C_LCD_IF_DISPLAY); 

    buf = 0x22; // RAM Write
    f_lcd_if_poll_write(C_LCD_IF_CS0, &buf, 1, C_LCD_IF_INSTRUCTION);

    /* Philips LCD is configured in MSB first mode. So exchane nibbles
       of each byte */
    for (i=0;i<176*220;i++) 
    {
        v= tab_temp[i];
#if (FRAME_BUFFER_INVERTED==1)
#warn   "R2D Refresh Getting Compiled for Negated Input Buffer"
        v=~v;
#endif

#if (FRAME_BUFFER_ENDIAN==BIG_ENDIAN) // need to convert to Little endian
        colorL=(v&0xFF00)>>8;
        colorR=(v&0xFF);
        v=(colorR<<8)|colorL;                   
#elif (FRAME_BUFFER_ENDIAN==LITTLE_ENDIAN) //no need to conver to Little endian
#warn   "R2D Refresh Getting Compiled for Little Endian Input Buffer"
#endif
        tab_temp[i]=v;

    }

#ifdef R2D_USE_LCD_DMA
    if(r2d_lcd_dma_ok == 1)
    {
        UINT8 nmb_frames;
        r2d_lcd_dma_bytes_to_transfer = 176 * 220 * sizeof(UINT16);
        nmb_frames = r2d_lcd_dma_bytes_to_transfer / (C_LCD_IF_TX_FIFO_SIZE * sizeof (UINT16));
        r2d_lcd_dma_channel_info.source_address = (UINT32)&(tab_temp[0]);
        r2d_lcd_dma_channel_info.nmb_frames = (nmb_frames ? nmb_frames : 1);
        r2d_lcd_dma_channel_info.nmb_elements =
            ((C_LCD_IF_TX_FIFO_SIZE * sizeof (UINT16)) < r2d_lcd_dma_bytes_to_transfer) 
            ? (C_LCD_IF_TX_FIFO_SIZE ) : r2d_lcd_dma_bytes_to_transfer / 2;

        dma_set_channel_parameters (r2d_lcd_dma_channel, &r2d_lcd_dma_channel_info);

        /* Wait till we get event from dma callback  */
        for(;;)
        {
            received_event = rvf_wait ( EVENT_MASK(RVF_APPL_EVT_1), 0);
            if(received_event & EVENT_MASK(RVF_APPL_EVT_1))
            {
                if(r2d_lcd_dma_state == R2D_LCD_DMA_IDLE
                        || r2d_lcd_dma_state == R2D_LCD_DMA_ERROR )
                {
                    break;
                }
            }
        }
    }
    else
    {
        rvf_send_trace("R2D DMA_DISABLED",strlen("R2D DMA_DISABLED"), NULL_PARAM,
                RV_TRACE_LEVEL_DEBUG_HIGH, R2D_USE_ID );

        f_lcd_if_poll_write(C_LCD_IF_CS0, &(tab_temp[0]),176 * 220 , C_LCD_IF_DISPLAY);
    }
#else // !USE_LCD_DMA

    f_lcd_if_poll_write(C_LCD_IF_CS0, &(tab_temp[0]), 176 * 220, C_LCD_IF_DISPLAY);

#endif // USE_LCD_DMA       

#else // R2D HORIZONTAL
#error "R2D Vertical for This Chipset Not Supported"
#endif
#else // _WINDOWS
#warn "r2d_refresh Is Empty Function for WINDOWS Build"
#endif
}

#ifdef R2D_USE_LCD_DMA

void r2d_dma_callback(void *response)
{
    T_DMA_STATUS_RSP_MSG *dma_status_rsp_msg = (T_DMA_STATUS_RSP_MSG *)response;

    switch(dma_status_rsp_msg->result.status)
    {

        case DMA_RESERVE_OK:
            r2d_lcd_dma_channel = dma_status_rsp_msg->result.channel;
            r2d_lcd_dma_state = R2D_LCD_DMA_IDLE;
            break;

        case DMA_PARAM_SET:
            r2d_lcd_dma_state = R2D_LCD_DMA_CHANNEL_PARAM_SET;
            f_lcd_if_dma_enable(C_LCD_IF_CS0,0,C_LCD_IF_DISPLAY);
            break;

        case DMA_COMPLETED:
            {
                UINT16 bytes_transfered =  ( r2d_lcd_dma_channel_info.nmb_elements
                        * r2d_lcd_dma_channel_info.nmb_frames
                        * 2);
                f_lcd_if_dma_disable(C_LCD_IF_CS0,f_lcd_if_dummy_callback); 

                if(r2d_lcd_dma_state == R2D_LCD_DMA_CHANNEL_PARAM_SET)
                {
                    r2d_lcd_dma_state = R2D_LCD_DMA_IDLE;   
                    r2d_lcd_dma_bytes_to_transfer -= bytes_transfered;

                    if(r2d_lcd_dma_bytes_to_transfer > 0)
                    {
                        r2d_lcd_dma_channel_info.source_address = ((UINT32)&(tab_temp[0])) + bytes_transfered;              
                        r2d_lcd_dma_channel_info.nmb_frames = 1;
                        r2d_lcd_dma_channel_info.nmb_elements = r2d_lcd_dma_bytes_to_transfer / 2 ;
                        dma_set_channel_parameters (r2d_lcd_dma_channel, &r2d_lcd_dma_channel_info);        
                    }
                    else
                    {
                        rvf_send_event( r2d_addr_id,EVENT_MASK(RVF_APPL_EVT_1));
                    }
                    break;
                }           
            }
        case DMA_NO_CHANNEL:
        case DMA_TOO_MANY_REQUESTS:
        case DMA_INVALID_PARAMETER:
        case DMA_NOT_READY:
        case DMA_MEMORY_ERROR:
        case DMA_ACTION_NOT_ALLOWED:
        case DMA_CHANNEL_BUSY:
        case DMA_QUEUED:
        case DMA_TIMEOUT_SOURCE:
        case DMA_TIMEOUT_DESTINATION:
        case DMA_MISS_EVENT:
        default:

            r2d_lcd_dma_ok = 0;
            r2d_lcd_dma_state = R2D_LCD_DMA_ERROR;
            rvf_send_trace("R2D DMA_ERROR",strlen("R2D DMA_ERROR"),dma_status_rsp_msg->result.status ,
                    RV_TRACE_LEVEL_DEBUG_HIGH, R2D_USE_ID );            
            rvf_send_event( r2d_addr_id,EVENT_MASK(RVF_APPL_EVT_1));        
            break;
    } /* switch dma_status_rsp_msg->result.status */

    rvf_free_buf(response);
    return;
}

    static E_LCD_IF_CALLBACK_RET
f_lcd_if_dummy_callback (void)
{
    /* nothing */
    return 0;
}

#endif /* USE_LCD_DMA  */