/*
** FILE 
** vfd.c
**
** DESCRIPTION
** handle VFD functions.
*/
#include "user_init.h"
#include "config.h"
#include "global.h"
#include "sio.h"
//#include "ircode.h"   //JJDing 2002/08/30,code reduced 
#include "irconfig.h"                       //JJDing 2002/08/30.code reduced
#include "ircmd.h"
#include "func.h"
#include "osd.h"
#include "regmap.h"
#include "avd.h"
#include "reverse.h"
#include "iop.h"
#include "memmap.h"
#include "auctrl.h"
#include "vfd.h"
#include "vfdmap.h"
#include "vfdkey.h"
#include "fs9660.h"                         //wyf .


#if defined(DEBUG_VFDSEG)||defined(VFD_KEY_TEST)
int  vfd_digital = 0;
#endif

#if VFD_DRIVER==SPL10                       //zhg 2002/10/16
extern BYTE Select_Dir_flag;        //zhg 2002/09/26 13:50
#endif

#ifdef VFD_KEY_TEST
void print_debug_msg(BYTE data)
{
#ifdef DEBUG_VFDSEG 
        vfd_digital++;
        if(vfd_digital > 96) 
            vfd_digital = 1; 
            polling_vfd();
        psprintf(RegionValStr[REGION2], "VFDSEG: %02d", vfd_digital-1);  
        PrintOsdMsg(STR_OS_NULL, REGION2, 0, 1, CH_N);  
#endif
        //psprintf(linebuf, "KEY=%02d,FUN=%02d,MEM=%02d,BIT=%02d,KEY=%03d\n",
        //             data, vfd_keycode[data - 1], vfd_digital / 8,
        //             vfd_digital % 8, vfd_digital);
        //epp_write_slow(linebuf);
        //osd_print(linebuf);
        psprintf(RegionValStr[REGION0], "VFDKEY: %02d\n", data);
        PrintOsdMsg(STR_OS_NULL, REGION0, 0, 1, CH_N);
        //ZHX 062303
}
#endif

#ifdef SUPPORT_VFD_SW
/*==========================================================
void polling_vfd_sw()
Use 16312's data setting command to read its switch port.
and control volume via the port status.
 
SUNPLUS huziqin 2003-6-4 12:31
==========================================================*/
#define ROTATE_L  0x02//0x0d
#define ROTATE_R  0x01//0x0e
void polling_vfd_sw()
{
    BYTE data;
    static BYTE old_data;
    data = regs0->iop_data[1];
    if(old_data != data)
    {
        old_data = data;
        //psprintf(RegionValStr[REGION2], "VFDSWKEY: %02x\n", data);
        //PrintOsdMsg(STR_OS_NULL, REGION2, 5, 1, CH_N);
        if(data == ROTATE_L)
            ircmd_volume_down();
        else if(data == ROTATE_R)
            ircmd_volume_up();
    }
}
#endif

#if (VFD_DRIVER==NEC16312)&&defined(IR_NEC)
/*============================================================
set_vfd_light_level(BYTE level)
Use 16312's display control command to set lighting level 

in: level---only the lower 3bits is valid,that mean we have 8
    grade of lighting control.
    
out: this parameter will sent to 16312 throught vfd port.    

SUNPLUS huziqin 2003-6-4 12:16
============================================================*/
void vfd_set_light_level(void)
{
    static BYTE vfd_level = 4;
    static BYTE level_flag = 1;
    BYTE   *p = (BYTE *) (SDRAM_BASE_CACHED + regs0->iopya * 1024 + 0x400);
    if (level_flag)  vfd_level --;
    else   vfd_level ++;
    psprintf(RegionValStr[REGION1], "VFD LEVEL: %d\n", vfd_level);
    PrintOsdMsg(STR_OS_NULL, REGION1, 1, 1, CH_N);
    if(vfd_level ==4) {
    	 level_flag = 1;
    	 *(p+1) = 0x8f;
    } else {
         if (!vfd_level) level_flag = 0;
         *(p+1) = 0x88 |vfd_level;
      }
}

/*============================================================
void set_vfd_led(BYTE led_port)
Use 16312's data setting command to control its led port.
in: led---the lower 4 bits stand for the 4 led.

SUNPLUS huziqin 2003-6-4 12:27
============================================================*/
void vfd_set_led(void)
{
    static BYTE led;
    led ++;
    if (led > 3)  led = 0;    	
    *led_port = (~(1<<led))&0x0f;   
}

#endif

/*===============================================================
polling_vfdr()
Description:
    polling the key data register,if there is key down,a flag
    bit of the key data register will be set,then we get the key 
    data by reading lower 6 bits of this regs.Once the key data is get,
    we should clear the flag bit.
    To identify long press key and short press key,vfdr_long_count
    is defined,if (vfdr_long_count > 20),we consider it long,else
    short.

in:
    none
out:
    none
global r:
    VFD_NORM_RECV()
    game_ret_flag
global w:
    CLR_VFD_NORM_RECV()
    game_ret_flag
behavious:
    call_ir_func()
    
SUNPLUS huziqin 2003-8-4
===============================================================*/
BYTE game_ret_flag;
#if(VFD_DRIVER==NEC16312||VFD_DRIVER==UPD16311)
//#define DEBUG_VFDR
int polling_vfdr()
{
#ifdef SUPPORT_VFD_SW
    BYTE vfd_key_data = 0;
    static int vfdr_count = 0;
    static int vfdr_long_count = 0;
    static BYTE vfdr_state = 0;
    static BYTE old_key_data = 0;

    switch(vfdr_state)
    {
        case 0:  //check key down
            if(VFD_NORM_RECV())
            {
#ifdef DEBUG_VFDR           
                //epp_write("key down\n");
#endif
        vfd_key_data = GET_VFD_KEY();
        CLR_VFD_NORM_RECV();
                old_key_data = vfd_key_data; 
                vfdr_state = 1;
            }
            break;
        case 1:  //check release
            if(VFD_NORM_RECV())
            {
#ifdef DEBUG_VFDR           
                //epp_write("down2\n");
#endif
                CLR_VFD_NORM_RECV();
                vfdr_count = 0;
                vfdr_long_count ++;
            }
            else
            {
#ifdef DEBUG_VFDR           
                //epp_write("no key\n");
#endif
                if(vfdr_count ++ > 100)
                {
                    vfdr_state = 2;
                }
            }
            break;
        case 2:  //check long or short and execute  
            if(vfdr_long_count > 40)
            {
#ifdef DEBUG_VFDR           
                epp_write("long\n");
#endif
            }
            else
            {
#ifdef DEBUG_VFDR           
                epp_write("short\n");
#endif
            }
#ifdef VFD_KEY_TEST
            print_debug_msg(vfd_key_data);
#else
            if(game_ret_flag)
                game_ret_flag=0;
            else            
                call_ir_func(vfd_keycode[old_key_data-1]);
#endif
            
            //clear var
            vfdr_long_count = 0;
            vfdr_state = 0;
            vfdr_count = 0;
            old_key_data = 0;
            break;
        default:
            break;
    }//end of switch
#else //-----------------upper is SUPPORT_VFD_SW------------------------
    UINT32  key_data;
    key_data = GET_VFD_KEY(); 

#ifdef VFD_KEY_TEST
    print_debug_msg(key_data);
#else   
    call_ir_func(vfd_keycode[key_data - 1]);
#endif 
#endif  //upper is not SUPPORT_VFD_SW  
    return key_data;
}
#endif  //(VFD_DRIVER==NEC16312)



#if ((VFD_DRIVER==SPL10)||(VFD_DRIVER==SPL10_FOR_718))
BYTE    vfdr_1s_timer = 0;
BYTE    key_long_press = 0;
int polling_vfdr(void)
{
    static int vfdr_count = 0;
    static BYTE vfdr_state = 0;
    static BYTE old_key_data = 0;
    UINT32  key_data;
    key_data = GET_VFD_KEY(); 
#ifdef VFD_KEY_TEST
    print_debug_msg(key_data);
    return;
#endif
    switch (vfdr_state)
    {
        case 0x00:
            if(key_data != 0)
            {
                vfdr_count++;
                vfdr_state++;
                vfdr_1s_timer = 200;
                //vfdr_1s_timer=50;
                old_key_data = key_data;
                //  epp_write_wait("vfdr state 1\n");
                //psprintf(linebuf,"%d",key_data);
                //epp_write_wait(linebuf);
            }
            break;
        case 0x01:
            if(key_data != 0)
            {
                vfdr_count++;
                //psprintf(linebuf,"%d\n",vfdr_count);
                //epp_write_wait(linebuf);
            }
            if(vfdr_1s_timer == 0 || key_data == 0)
            {
                if(vfdr_count > 10)
                {
                    key_long_press = 1;
                    vfdr_state++;
                    vfdr_1s_timer = 30;
                    //epp_write_wait("long press\n");

                }
                else
                {
                    key_long_press = 0;
                    vfdr_state = 0;
                    //epp_write_wait("short press\n");                  
                }
                call_ir_func(vfd_keycode[old_key_data - 1]);
                vfdr_count = 0;
            }
            break;
        case 0x02:
            if(key_data != 0)
                vfdr_count++;
            if(vfdr_1s_timer == 0)
            {
                if(vfdr_count < 5)
                {
                    key_long_press = 2;
                    vfdr_state = 0;
                    //epp_write_wait("long press release\n");
                    call_ir_func(vfd_keycode[old_key_data - 1]);
                }
                else
                    vfdr_1s_timer = 30;
                vfdr_count = 0;
            }

            break;
        default:
            break;
    }
}
#endif  //(VFD_DRIVER==SPL10)


/*
** FUNCTION
** polling_vfd
** 
** DESCRIPTION
** checking if we could issue VFD task
*/

int polling_vfd(void)
{
#ifdef DEBUG_VFDSEG
    static int j = 0;
    init_vfd_clear(0xff);
#ifdef DEBUG_IR_CODE
    j++;
    if (j > 8)  j = 1;
    if (j%2)             //ZHX 033103
#else
    if(j ^= 0x01)
#endif
        vfd_dot(0, vfd_digital-1);
#else
    switch (play_state)
    {
        case VCD_STATE_NORMAL:
        case VCD_STATE_FREEZE:
        case VCD_STATE_SLOW:                //wyf.2-6-28 14:29
        case VCD_STATE_STEP:
        case VCD_STATE_PAUSE:
        case VCD_STATE_FORWARD:
        case VCD_STATE_BACKWARD:
            if(play_state == VCD_STATE_PAUSE) 
#if VFD_DRIVER==SPL10                       //zhg 2002/10/16
            vfd_show_time();
#else
            vfd_pause();
#endif
            else {
               cd_pause_ss = 0;   //ZHX 092703
               vfd_normal_state();
             }
            break;
        case VCD_STATE_STOP:                //zhyf for intro end show total time 2-10-25 9:03
#ifdef VFDVOL_DISPLAY
            volFlag = 0;
#endif            	
           vfd_stop();
            break;
        case VCD_STATE_OPEN:
            osd_time_flag = 0;                  //ZHX 062403
#ifdef VFDVOL_DISPLAY
            volFlag = 0;
#endif            	
            init_vfd_clear(0);
            vfd_open();
#if VFD_DRIVER==HT1621      //ZHX 040203 LCD ERR AT OPEN
            PrintOsdMsg(STR_OS_NULL, REGION2, 0, 0, CH_N); 
#endif
            break;
        case VCD_STATE_CLOSE:
        case VCD_STATE_READTOC:
            init_vfd_clear(0);
            vfd_close();
            break;
            #ifdef POWER_KEY         //zhyf test 2-9-12 10:30 
                   case VCD_STATE_POWER:
            osd_time_flag = 0;                  //ZHX 062403
#ifdef VFDVOL_DISPLAY
            volFlag = 0;
#endif            	
                            init_vfd_clear(0);      
            break;
            #endif
        default:
            break;
    }

#endif
    return 0;
}


void init_vfd_clear(BYTE c)
{
#ifdef SUPPORT_VFD
#if (VFD_DRIVER==NEC16312||VFD_DRIVER==SPL10||\
     VFD_DRIVER==SPL10_FOR_718||VFD_DRIVER==UPD16311)
    BYTE    i;
    BYTE   *p = (BYTE *) (SDRAM_BASE_CACHED + regs0->iopya * 1024 + 0x404);

    for(i = 0; i < INIT_IOP_VFD_SENT_CNT; i++)
    {
        *(p + i) = c;
    }
#endif

#if VFD_DRIVER==HT1621
    BYTE    i;
    BYTE   *p =
        (BYTE *) (SDRAM_BASE_CACHED + regs0->iopya * 1024 + LCD_CMD_OFFSET);
    for(i = 0; i < INIT_IOP_VFD_PARA_0; i++)
    {
        *(p + i) = c;
    }
#endif
#endif
}


 /*
  ** FUNCTION
  ** reset_vfd
  **
  ** DESCRIPTION
  ** setup VFD.  Should only called at power-up or emergency.
  */
#ifdef IR_NEC
void reset_vfd(void)
{
#ifdef SUPPORT_VFD
#if  (VFD_DRIVER==NEC16312||VFD_DRIVER==SPL10||\
      VFD_DRIVER==SPL10_FOR_718||VFD_DRIVER==UPD16311)
    BYTE   *p = (BYTE *) (SDRAM_BASE_CACHED + regs0->iopya * 1024 + 0x400);

    vfd_mem = (BYTE *) (SDRAM_BASE_CACHED + regs0->iopya * 1024 + 0x404);
    led_port = (p + 0);
   *led_port = 0x0f;    //LED data(the lower 4 bits)
    *(p + 1) = 0x8f;   //lighting level(the lower 4 bits)
    
    init_vfd_clear(0);
#endif

#if VFD_DRIVER==HT1621
    int     i;
    BYTE   *p = (BYTE *) (SDRAM_BASE_CACHED + regs0->iopya * 1024 + 0x400);

    vfd_mem =
        (BYTE *) (SDRAM_BASE_CACHED + regs0->iopya * 1024 + LCD_CMD_OFFSET);
    *(p + 0) = (INIT_IOP_VFD_PARA_0);
    for(i = 1; i <= LCD_CMD_TABLE_LEN; i++)
        *(p + i) = bLcdCmdTable[i - 1];
    init_vfd_clear(0);
#endif
#endif
}
#else
void reset_vfd(void)
{
#ifdef SUPPORT_VFD
#if  VFD_DRIVER==NEC16312||VFD_DRIVER==SPL10
    BYTE   *p = (BYTE *) (SDRAM_BASE_CACHED + regs0->iopya * 1024 + 0x400);

    vfd_mem = (BYTE *) (SDRAM_BASE_CACHED + regs0->iopya * 1024 + 0x404);
    *(p + 0) = 0x0f;
    *(p + 1) = 0x02;
    *(p + 2) = 0x8c;
    *(p + 3) = 0xc0;
    init_vfd_clear(0);//don't earse or else when turn on VFD flash a moment.wangbin 2003-05
#endif

#if VFD_DRIVER==HT1621
    int     i;
    BYTE   *p = (BYTE *) (SDRAM_BASE_CACHED + regs0->iopya * 1024 + 0x400);

    vfd_mem =
        (BYTE *) (SDRAM_BASE_CACHED + regs0->iopya * 1024 + LCD_CMD_OFFSET);
    *(p + 0) = (INIT_IOP_VFD_PARA_0);
    for(i = 1; i <= LCD_CMD_TABLE_LEN; i++)
        *(p + i) = bLcdCmdTable[i - 1];
    init_vfd_clear(0);
#endif
#endif
}
#endif

void vfd_dot(BYTE method, BYTE vfd_dot)
{
#ifdef SUPPORT_VFD
    if(method)
        vfd_mem[vfd_dot / 8] |= (1 << (vfd_dot % 8));
    else
        vfd_mem[vfd_dot / 8] &= (~(1 << (vfd_dot % 8)));
#endif
}

#if 0 //(VFD_MODULE==VFD_EQ)
void show_VFD_EQ_init(void)
{
    int i;
    
    for(i=0;i<VFD_EQ_MAX;i++)
      vfd_mem[vfd_eq[i]]=0;
        
    vfd_eq_display = 1;
    eq_UI_init();
    AVAPI_control(C_WRITE, AVAPI_SPECTRUM, C_ON);
        
}

void show_VFD_EQ(BYTE *EQ_value)
{
   int i,j;
   
   for(i=0;i<VFD_EQ_MAX;i++)
     vfd_mem[vfd_eq[i]]=0;
          
   if(vfd_eq_display && (!(MENU_SLIST() && MENU_PSEG())))
   {
      for(j=1;j<=VFD_EQ_MAX;j++) 
      {
        for(i=0;i<(EQ_value[j]/3);i++)
     vfd_dot(1,vfd_eq[VFD_EQ_MAX-j]*8+i);
      } 
      
      #if 0
      for(i=0;i<(bEqValue[1]/3);i++)
        vfd_dot(1,vfd_eq[3]*8+i);
  
      for(i=0;i<(bEqValue[2]/3);i++)
        vfd_dot(1,vfd_eq[2]*8+i);
  
      for(i=0;i<(bEqValue[3]/3);i++)
        vfd_dot(1,vfd_eq[1]*8+i);
  
      for(i=0;i<(bEqValue[4]/3);i++)
        vfd_dot(1,vfd_eq[0]*8+i);
      #endif
   }
}
#endif