lg.c

M3355的源代码

/*====================================================================
 *
 *  Copyright (C) 1997 Acer Labs, Inc.  All Rights Reserved.
 *                  
 *  File:   lg.c
 *                                           
 *  Contents: LG VFD chip control
 *           
 *  History:
 *   Date            By         Reason
 *  =======  ====    =========   ======
 *  2003/7/15  Brook     Create
 ********************************************************************/

#include <gpio.h>
#include <xgpio.h>
#include <sci.h>
#include <platform.h>
#include "../fend/ir.h"

//extern unsigned long KeyTable[112];
//extern unsigned char IR_Custom_Code1  , IR_Custom_Code2 ;

/*** define the display setting ***/
#if VFD_DISP_MODE == 0x00
	#define VFD_SEG_NUM 16
	#define VFD_GRID_NUM 4
#elif VFD_DISP_MODE == 0x01
	#define VFD_SEG_NUM 16
	#define VFD_GRID_NUM 5
#elif VFD_DISP_MODE == 0x02
	#define VFD_SEG_NUM 16
	#define VFD_GRID_NUM 6
#elif VFD_DISP_MODE == 0x03
	#define VFD_SEG_NUM 15
	#define VFD_GRID_NUM 7
#elif VFD_DISP_MODE == 0x04
	#define VFD_SEG_NUM 14
	#define VFD_GRID_NUM 8
#elif VFD_DISP_MODE == 0x05
	#define VFD_SEG_NUM 13
	#define VFD_GRID_NUM 9
#elif VFD_DISP_MODE == 0x06
	#define VFD_SEG_NUM 12
	#define VFD_GRID_NUM 10
#elif VFD_DISP_MODE == 0x07
	#define VFD_SEG_NUM 11
	#define VFD_GRID_NUM 11
#elif VFD_DISP_MODE == 0x0c
	#define VFD_SEG_NUM 19
	#define VFD_GRID_NUM 6
#endif

#define VFD_KEY_NONE            0xFF
#define VFD_IR_NONE			0xFE

#define KEY_DOWN_TIMER		3000
#define IR_DOWN_TIMER		3000

extern unsigned long IRKeyClock;
extern unsigned long PKKeyClock;
extern long IRState;
extern long PKState;
extern BOOL I2CIsBusy;

BYTE tbl_bit_swap[256]={
                           0x00,0x80,0x40,0xc0,0x20,0xa0,0x60,0xe0,
                           0x10,0x90,0x50,0xd0,0x30,0xb0,0x70,0xf0,
                           0x08,0x88,0x48,0xc8,0x28,0xa8,0x68,0xe8,
                           0x18,0x98,0x58,0xd8,0x38,0xb8,0x78,0xf8,
                           0x04,0x84,0x44,0xc4,0x24,0xa4,0x64,0xe4,
                           0x14,0x94,0x54,0xd4,0x34,0xb4,0x74,0xf4,
                           0x0c,0x8c,0x4c,0xcc,0x2c,0xac,0x6c,0xec,
                           0x1c,0x9c,0x5c,0xdc,0x3c,0xbc,0x7c,0xfc,
                           0x02,0x82,0x42,0xc2,0x22,0xa2,0x62,0xe2,
                           0x12,0x92,0x52,0xd2,0x32,0xb2,0x72,0xf2,
                           0x0a,0x8a,0x4a,0xca,0x2a,0xaa,0x6a,0xea,
                           0x1a,0x9a,0x5a,0xda,0x3a,0xba,0x7a,0xfa,
                           0x06,0x86,0x46,0xc6,0x26,0xa6,0x66,0xe6,
                           0x16,0x96,0x56,0xd6,0x36,0xb6,0x76,0xf6,
                           0x0e,0x8e,0x4e,0xce,0x2e,0xae,0x6e,0xee,
                           0x1e,0x9e,0x5e,0xde,0x3e,0xbe,0x7e,0xfe,
                           0x01,0x81,0x41,0xc1,0x21,0xa1,0x61,0xe1,
                           0x11,0x91,0x51,0xd1,0x31,0xb1,0x71,0xf1,
                           0x09,0x89,0x49,0xc9,0x29,0xa9,0x69,0xe9,
                           0x19,0x99,0x59,0xd9,0x39,0xb9,0x79,0xf9,
                           0x05,0x85,0x45,0xc5,0x25,0xa5,0x65,0xe5,
                           0x15,0x95,0x55,0xd5,0x35,0xb5,0x75,0xf5,
                           0x0d,0x8d,0x4d,0xcd,0x2d,0xad,0x6d,0xed,
                           0x1d,0x9d,0x5d,0xdd,0x3d,0xbd,0x7d,0xfd,
                           0x03,0x83,0x43,0xc3,0x23,0xa3,0x63,0xe3,
                           0x13,0x93,0x53,0xd3,0x33,0xb3,0x73,0xf3,
                           0x0b,0x8b,0x4b,0xcb,0x2b,0xab,0x6b,0xeb,
                           0x1b,0x9b,0x5b,0xdb,0x3b,0xbb,0x7b,0xfb,
                           0x07,0x87,0x47,0xc7,0x27,0xa7,0x67,0xe7,
                           0x17,0x97,0x57,0xd7,0x37,0xb7,0x77,0xf7,
                           0x0f,0x8f,0x4f,0xcf,0x2f,0xaf,0x6f,0xef,
                           0x1f,0x9f,0x5f,0xdf,0x3f,0xbf,0x7f,0xff
                       };

BYTE frontTransmitData[28];
BYTE frontReceiveDdata[16];

DWORD PnlLastTable[VFD_GRID_NUM+1]=
    {
        0xffffffff,
        0xffffffff,
        0xffffffff,
        0xffffffff,
        0xffffffff,
        0xffffffff,
        0xffffffff
    };

//jane added for long press key
typedef struct
{
    BYTE	ShortKey;
    BYTE	LongKey;
    DWORD	KeyTimer;
}
LONGKEY;

LONGKEY SkipKeyMap[]=
    {
        {C_KEY_SKIP_L,C_KEY_REV,1000},
        {C_KEY_SKIP_R,C_KEY_FF,1000}
    };
LONGKEY EEPKeyMap[]=
    {
        //for eeprom hide key
        //{C_KEY_STEP,C_KEY_NP,5000},
        //{C_KEY_PAUSE,C_KEY_NP,5000},
        {C_KEY_1,C_KEY_A,500},
        {C_KEY_2,C_KEY_B,500},
        {C_KEY_3,C_KEY_C,500},
        {C_KEY_4,C_KEY_D,500},
        {C_KEY_5,C_KEY_E,500},
        {C_KEY_6,C_KEY_F,500},
        /*080314 Jacky TH Kuo for temp MP1 MP2*/
        //{C_KEY_ANGLE,C_KEY_LGMP1,3000},
        // {C_KEY_SUBTITLE,C_KEY_LGMP2,3000}
    };
LONGKEY FileopKeyMap[]=
    {
        //for fileopen
        {C_KEY_UP,C_KEY_PAGEUP,2000},
        {C_KEY_DOWN,C_KEY_PAGEDOWN,2000},

    };
LONGKEY PauseKeyMap[]=
    {
        //for pause
        {C_KEY_STEP,C_KEY_NP,5000},
        {C_KEY_PAUSE,C_KEY_NP,5000},
        {C_KEY_STOP,C_KEY_PROC_OFF,4000},
    };
typedef struct
{
    LONGKEY * LongKeyMap;
    BYTE		KeyNum;
    BOOL   	KeyMapFlag;
}
LONGKEYGROUP;

LONGKEYGROUP LongKeyGroup[]=
    {
        {SkipKeyMap,2,TRUE},
        {EEPKeyMap,6,FALSE},
        {FileopKeyMap,2,FALSE},
        {PauseKeyMap,3,FALSE}
    };

BOOL LongKeyFlag=FALSE;
void IR_IRQ(void)
{}

/*----------------------------------------------------------------------
 * Function_Name: VfdHold
 *
 * Description:	Hold Vfd Chip, pull VFD Strobe hi
 *
 * Arguments:
 *     DWORD* dwBuff - DisplayBuffer to set
 * Return Value: void
 *----------------------------------------------------------------------*/
void VfdHold()
{
#if 0
    /*WaitSem(SCI_semid);*/
    dis_dsp();

    SET_GPIO_W(SCI_MD | SCI_MC | SCI_VFD);/* SCI_MD write mode */
    SET_GPIO_HI(SCI_MD | SCI_MC | SCI_VFD);/* pull SCI_MD high */
#endif
}



/*----------------------------------------------------------------------
 * Function_Name: VfdRelease
 *
 * Description:	Release Vfd Chip, pull VFD Strobe low
 *
 * Arguments:
 *
 * Return Value: void
 *----------------------------------------------------------------------*/
void VfdRelease()
{
#if 0
    SciDelay(20);/* Delay >13.3us */


    SET_GPIO_W(SCI_MD | SCI_MC | SCI_VFD);/* SCI_MD write mode */
    SET_GPIO_HI(SCI_MD | SCI_MC );/* pull SCI_MC,SCI_MD high */
    SET_GPIO_LOW(SCI_VFD);/* pull SCI_MD low */

    /*SigSem(SCI_semid);*/
    ena_dsp();
    dly_tsk(1);/* wait for task dispatch */
#endif
}


/*----------------------------------------------------------------------
 * Function_Name: VfdCommand
 *
 * Description:	Send command to VFD controller
 *
 * Arguments:
 *     BYTE bCMD : VFD command
 *
 * Return Value: void
 *----------------------------------------------------------------------*/
void VfdCommand(BYTE cmd)
{
#if 0
    VfdHold();
    SciSetByteMF(cmd);
    VfdRelease();
#endif
}

/*----------------------------------------------------------------------
 * Function_Name: VfdDisplayOn
 *
 * Description:	Turn On the VFD Screen
 *
 * Arguments:
 *
 * Return Value: void
 *----------------------------------------------------------------------*/
void VfdDisplayOn()
{
#if 0
    /* Command: control display-dimming quantily */
    VfdCommand((BYTE)((DIMMING_RATE << 4) | VFD_DISP_MODE) | 0x08);
#endif
}

/*----------------------------------------------------------------------
 * Function_Name: VfdDisplayOff
 *
 * Description:	Turn Off the VFD Screen
 *
 * Arguments:
 *
 * Return Value: void
 *----------------------------------------------------------------------*/
void VfdDisplayOff()
{
#if 0
    /* Command: control display-dimming quantily */
    VfdCommand((BYTE)((DIMMING_RATE << 4) | VFD_DISP_MODE));
#endif
}

/*----------------------------------------------------------------------
 * Function_Name: VfdCls
 *
 * Description:	Initialize the Vfd RAMs that we can use them latter.
 *
 * Arguments:
 *
 * Return Value: void
 *----------------------------------------------------------------------*/

void VfdCls()
{
#if 0
    int i;
    VfdDisplayOff();
    for(i=1;i<=VFD_GRID_NUM;i++)/* Clear VFD RAMs */
    {
        VfdSetGrid(i,0x00000000);
    }
    VfdDisplayOn();
#endif
}


/*----------------------------------------------------------------------
 * Function_Name: VfdGetSw
 *
 * Description:	
 *
 * Arguments:
 *
 * Return Value: 
 *     BYTE - Lower 4 bits are the status of the 4 SW. 
 *            bit0: SW1 ~ bit3: SW4
 *----------------------------------------------------------------------*/

BYTE VfdGetSw()
{
#if 0
    BYTE bRet;
    VfdHold();
    /* Command : set SW input mode */
    SciSetByteMF(0xb0);
    SciDelay(80);
    bRet=SciGetByteMF();
    VfdRelease();
    return (bRet&0x0f);
#endif
}

/*----------------------------------------------------------------------
 * Function_Name: VfdSetLed
 *
 * Description:	Set value of 4 LEDs
 *
 * Arguments:
 *     BYTE bLEDs - 4 LED status , 1 as light. 
 *                 Lower 4 bits are the status of the 4 LED.
 *                 bit0: LED1 ~ bit3: LED4
 * Return Value: void
 *----------------------------------------------------------------------*/
void VfdSetLed(BYTE bLEDs)
{
#if 0
    /* Command : set LED mode, Lower 4 bits are the status of the 4 LED. */
    VfdCommand((bLEDs&0x0f)|0x90);
#endif
}

/*----------------------------------------------------------------------
 * Function_Name: VfdSetGrid
 *
 * Description:	Set one grid of VFD display Data
 *
 * Arguments:
 *     BYTE bGrid: grid offset (from 1 to 11)
 *     DWORD dwData: DATA to display RAM, (ignore higher 2 bytes)
 * Return Value: void
 *----------------------------------------------------------------------*/
//void VfdSetGrid(BYTE fld_transmit_seq,DWORD dwData1,DWORD dwData2)
//{
#if 0
VfdHold();
/* Command : set write display data to RAM mode */
SciSetByteMF(bGrid|0x80);
SciDelay(80);/* Delay >40us */
SciSetByteMF(BYTE1(dwData));
SciDelay(80);/* Delay >40us */
SciSetByteMF(BYTE0(dwData));
VfdRelease();
#endif

//  frontTransmitData[0] = 0xa0+fld_transmit_seq*2;
// frontTransmitData[1] = tbl_bit_swap[(BYTE)((dwData1&0xFF000000)>>24)];
//  frontTransmitData[2] = tbl_bit_swap[(BYTE)((dwData1&0x00FF0000)>>16)];
//  frontTransmitData[3] = tbl_bit_swap[(BYTE)((dwData1&0x0000FF00)>>8)];
//  frontTransmitData[4] = tbl_bit_swap[(BYTE)((dwData2&0xFF000000)>>24)];
// frontTransmitData[5] = tbl_bit_swap[(BYTE)((dwData2&0x00FF0000)>>16)];
// frontTransmitData[6] = tbl_bit_swap[(BYTE)((dwData2&0x0000FF00)>>8)];

//}

#if 0
/*----------------------------------------------------------------------
 * Function_Name: VfdSelfTest
 *
 * Description:	Customer use this function to build the panel header.
 *
 * Arguments:
 *
 * Return Value: void
 *----------------------------------------------------------------------*/
void VfdSelfTest()
{
    int i;
    BYTE b, bGrid;
    DWORD dw;
    DWORD LightTable[VFD_GRID_NUM+1];
    DWORD BlinkTable[VFD_GRID_NUM+1];

#if 1
    /******************************/
    /* Light VFD                  */
    /******************************/
    PRINTF("\nLight VFD\n");

    for (bGrid = 1; bGrid <= VFD_GRID_NUM; bGrid++)
    {
        LightTable[bGrid] = 0xffffffff;
        BlinkTable[bGrid] = 0x00000000;
    }

    /* Light ALL */
    VfdUpdate(LightTable);
    dly_tsk(300);

    /* Blink 3 times */
    for(i=0;i<3;i++)
    {
        VfdUpdate(BlinkTable);
        dly_tsk(100);
        VfdUpdate(LightTable);
        dly_tsk(200);
    }

    /* Off one bit each time */