vfdht.c

vfd ht modifiedd for 8202

/*
** FILE 
** vfd.c
**
** DESCRIPTION
** handle VFD functions.
*/
/*** zyf 2000/11/01 ***/
#ifdef  HT1621_PANNEL
const UINT16  send_ht_cmd[5]={0x0802,0x0808,0x080a,0x0852,0x0806};
#endif


/*
** FUNCTION
** vfd_dot
**
** DESCRIPTION
** set/reset VFD bit according to method and bit-position(p)
**
** *NOTE*
** method 0:	SET
** method 1:	RESET
** method 2:	TOGGLE
*/
void   vfd_dot(UINT32 method, UINT32 p)
{
	UINT32 A   = p>>3;
	UINT32 tag = 1<<(p&0x07);
	BYTE  *ptr = &vfd_mem[A];
	BYTE	 x   = *ptr;
	
	if (method==0)
		x |= tag; 
	else if (--method==0)
		x &= ~tag; 
	else
		x ^= tag; 
	
	*ptr        = x;
	
}


void	__vfd_set_pause(void)
{
	//erase_vfd_mem();
	vfd_mem[VFDA_P0] = 0;
	vfd_mem[VFDA_P1] = VFD_7SEG_P;
	vfd_mem[VFDA_M0] = VFD_7SEG_A;
	vfd_mem[VFDA_M1] = VFD_7SEG_U;
	vfd_mem[VFDA_S0] = VFD_7SEG_S;
	vfd_mem[VFDA_S1] = VFD_7SEG_E;
	
}


void	__vfd_set_play(void)
{
	//erase_vfd_mem();
	vfd_mem[VFDA_P0] = 0;
	vfd_mem[VFDA_P1] = 0;
	vfd_mem[VFDA_M0] = VFD_7SEG_P;
	vfd_mem[VFDA_M1] = VFD_7SEG_L;
	vfd_mem[VFDA_S0] = VFD_7SEG_A;
	vfd_mem[VFDA_S1] = VFD_7SEG_Y;
}


void	__vfd_set_step(void)
{
	//erase_vfd_mem();
	vfd_mem[VFDA_P0] = 0;
	vfd_mem[VFDA_P1] = 0;
	vfd_mem[VFDA_M0] = VFD_7SEG_S;
	vfd_mem[VFDA_M1] = VFD_7SEG_T;
	vfd_mem[VFDA_S0] = VFD_7SEG_E;
	vfd_mem[VFDA_S1] = VFD_7SEG_P;
	
}

void	__vfd_set_open(void)
{
	erase_vfd_mem();
	vfd_mem[VFDA_P0]  = 0;
	vfd_mem[VFDA_P01] = 0;
	/*** zyf 2000/11/22 ***/
	vfd_mem[VFDA_P1]  = 0;
	vfd_mem[VFDA_P11] = 0;
	vfd_mem[VFDA_M0]  = VFD_7SEG_O&0x70;
	vfd_mem[VFDA_M01] = ((VFD_7SEG_O<<4)&0xf0)|((VFD_7SEG_P>>4)&0x07);
	vfd_mem[VFDA_M1]  = (VFD_7SEG_P<<4)&0xf0;
	vfd_mem[VFDA_M11] = VFD_7SEG_E&0x70;
	vfd_mem[VFDA_S0]  = (VFD_7SEG_E<<4)&0xf0;
	vfd_mem[VFDA_S01] = VFD_7SEG_N&0x70;
	vfd_mem[VFDA_S1]  = (VFD_7SEG_N<<4)&0xf0; 
	
}

void	__vfd_set_close(void)
{
	erase_vfd_mem();
	vfd_mem[VFDA_P0]  = 0;
	vfd_mem[VFDA_P01] = 0;
	vfd_mem[VFDA_P1]  = VFD_7SEG_C&0x70;
	vfd_mem[VFDA_P11] = (VFD_7SEG_C<<4)&0xf0;
	vfd_mem[VFDA_M0]  = VFD_7SEG_L&0x70;
	vfd_mem[VFDA_M01] = ((VFD_7SEG_L<<4)&0xf0)|((VFD_7SEG_O>>4)&0x07);
	vfd_mem[VFDA_M1]  = (VFD_7SEG_O<<4)&0xf0;
	vfd_mem[VFDA_M11] = VFD_7SEG_S&0x70;
	vfd_mem[VFDA_S0]  = (VFD_7SEG_S<<4)&0xf0;
	vfd_mem[VFDA_S01] = VFD_7SEG_E&0x70;
	vfd_mem[VFDA_S1]  = (VFD_7SEG_E<<4)&0xf0;
	
}
void  vfd_set_nodisk(void)
{
	erase_vfd_mem();        //zyf 2000/10/09
	vfd_mem[VFDA_P0]  = VFD_7SEG_N&0x70;
	vfd_mem[VFDA_P01] = (VFD_7SEG_N<<4)&0xf0;
	vfd_mem[VFDA_P1]  = VFD_7SEG_O&0x70;
	vfd_mem[VFDA_P11] = (VFD_7SEG_O<<4)&0xf0;
	vfd_mem[VFDA_M0]  = VFD_7SEG_D&0x70;
	vfd_mem[VFDA_M01] = ((VFD_7SEG_D<<4)&0xf0)|((VFD_7SEG_I>>4)&0x07);
	vfd_mem[VFDA_M1]  = (VFD_7SEG_I<<4)&0xf0;
	vfd_mem[VFDA_M11] = VFD_7SEG_S&0x70;
	vfd_mem[VFDA_S0]  = (VFD_7SEG_S<<4)&0xf0;
	vfd_mem[VFDA_S01] =VFD_7SEG_C&0x70;
	vfd_mem[VFDA_S1]  = (VFD_7SEG_C<<4)&0xf0;
    
} 

/*** zhyf 1-2-13 10:13 ***/  
void vfd_set_p3disc(void)
{
	vfd_mem[VFDA_P0]   = VFD_7SEG_P&0x70;
	vfd_mem[VFDA_P01]  = (VFD_7SEG_P<<4)&0xf0;
	vfd_mem[VFDA_P1]   = VFD_7SEG_3&0xf0;
	vfd_mem[VFDA_P11]  = (VFD_7SEG_3<<4)&0xf0;
	vfd_mem[VFDA_M0]   = VFD_7SEG_D&0x70;
	vfd_mem[VFDA_M01]  = ((VFD_7SEG_D<<4)&0xf0)|((VFD_7SEG_I>>4)&0x07);
	vfd_mem[VFDA_M1]   = (VFD_7SEG_I<<4)&0xf0;
	vfd_mem[VFDA_M11]  = VFD_7SEG_S&0x70;
	vfd_mem[VFDA_S0]   = (VFD_7SEG_S<<4)&0xf0;
	vfd_mem[VFDA_S01]  = VFD_7SEG_C&0x70;
	vfd_mem[VFDA_S1]   = (VFD_7SEG_C<<4)&0xf0;
    
}  


void __vfd_set_pgm(BYTE method)
{
	BYTE    i,trk;	
	trk = cd_trk_hi-cd_trk_lo;
	/*** zyf 2000/11/03 add ***/
	if(cd_trk_now>16) 
	{;}//vfd_set_dot(VFD_DOT_OVER);}
	if(trk-1>16)
		trk = 16;
	
	for(i=1;i<=trk;i++)
	{
		if(method==0)
			vfd_mem[vfd_prg[i]>>3]|= (1<<(vfd_prg[i]&0x07));
		else if(--method==0)
			vfd_mem[vfd_prg[i]>>3]&= ~(1<<(vfd_prg[i]&0x07));
		else
			vfd_mem[vfd_prg[i]>>3]^= (1<<(vfd_prg[i]&0x07));    
	}
	
}

/*** program playback display control 
zyf 2000/11/16
***/
void   vfd_prog_dis(BYTE prog_cnt,UINT16 num)
{
	
} 

void   vfd_set_7seg(UINT32 t, UINT32 mm) 
{
	int	A, B,C,D;
	int	BCDQ = DIV10(mm);
	int	BCDR = mm-10*BCDQ;
	
	
	switch(play_state)
	{
	case VCD_STATE_MP3_FILELIST:    //Jeff 20010718
	case VCD_STATE_NORMAL:
	case VCD_STATE_9FRAMES:
	case VCD_STATE_PREVIEW:
	case VCD_STATE_INTRO:
	case VCD_STATE_FASTFORWARD:
	case VCD_STATE_FASTBACKWARD:
		
	case VCD_STATE_SLOW:
	case VCD_STATE_STOP:
		// case VCD_STATE_STEP:
		
		if (t==0)
		{ 
			
			A=VFDA_P0; C=VFDA_P01;  
			B=VFDA_P1;D=VFDA_P11; 
			
			vfd_mem[A]	= (vfd_mem[A]&(~VFD_7SEG_DIG_MASK)) | (vfd_digit[BCDQ]&0xf0);
			vfd_mem[C]	= (vfd_mem[C]&(~VFD_7SEG_MASK)) | ((vfd_digit[BCDQ]<<4)&0xf0);
			vfd_mem[B]	= (vfd_mem[B]&(~VFD_7SEG_DIG_MASK)) | (vfd_digit[BCDR]&0x70);
			vfd_mem[D]	= (vfd_mem[D]&(~VFD_7SEG_MASK)) | ((vfd_digit[BCDR]<<4)&0xf0);
			
			
		}
		else if (--t==0)
		{
			A=VFDA_M0; B=VFDA_M1;  
			C=VFDA_M01;            
			vfd_mem[A]	= (vfd_mem[A]&(~VFD_7SEG_DIG_MASK)) | (vfd_digit[BCDQ]&0xf0);
			vfd_mem[C]	= (vfd_mem[C]&(~VFD_7SEG_MASK))| ((vfd_digit[BCDQ]<<4)&0xf0)|(shuffle_flag<<3);
			vfd_mem[C] |= (vfd_mem[C]&(~VFD_7SEG_DIG_MASK)) | ((vfd_digit[BCDR]>>4)&0x07);
			vfd_mem[B]	= (vfd_mem[B]&(~VFD_7SEG_MASK)) | ((vfd_digit[BCDR]<<4)&0xf0);
			
			
		}
		else 
		{  
			A=VFDA_S0; B=VFDA_S1; 
			C=VFDA_S01;D=VFDA_M11; 
			vfd_mem[D]	= (vfd_mem[D]&(~VFD_7SEG_DIG_MASK)) | (vfd_digit[BCDQ]&0xf0);
			vfd_mem[A]	= (vfd_mem[A]&(~VFD_7SEG_MASK)) | ((vfd_digit[BCDQ]<<4)&0xf0);
			vfd_mem[C]	= (vfd_mem[C]&(~VFD_7SEG_DIG_MASK)) | (vfd_digit[BCDR]&0xf0);
			vfd_mem[B]	= (vfd_mem[B]&(~VFD_7SEG_MASK)) | ((vfd_digit[BCDR]<<4)&0xf0);
			
		}
		break;
	default:
		break;
	} 
	/*** zyf 2000/11/16 ***/
	
#ifdef VFD_DOT_INTRO 
	if(play_state!=VCD_STATE_INTRO)
		vfd_reset_dot(VFD_DOT_INTRO);
	else
		vfd_set_dot(VFD_DOT_INTRO);   
#endif
	
	if(shuffle_flag)
		vfd_set_dot(VFD_DOT_RAN);
	else
		vfd_reset_dot(VFD_DOT_RAN);    
	
}


/*
** FUNCTION
** polling_vfdr
**
** DESCRIPTION
** check if polling-ready
*/
int	polling_vfdr(void)
{
#ifndef HT1621_PANNEL
#ifdef SUPPORT_VFD
	UINT16    i;
	UINT32    temp;
	UINT32    key_data;
	BYTE      key_recv=0;
	static    BYTE      key_state=0;
	static    BYTE      vfd_state=0;
	static    UINT32    key_previ=0;
	//return 0;
	switch(vfd_state)
	{       //pppp
			/*
			case VFD_IDLE:
			regs0->vfd_cfg = 0x0;
			regs0->vfd_cfg = 0x0128;
			regs0->vfd_func = 0;
			vfd_state       = VFD_READ;
			break;
		*/
	case VFD_READ:
		regs0->vfd_cfg  = 0x0;
		regs0->vfd_cfg  = 0x0124;
		regs0->vfd_func = 0;
		regs0->vfd_cmd  = 0x4342;
		regs0->vfd_func = RF_VFD_FUNC_POLL_SIZE(2)|RF_VFD_FUNC_PMODE;
		vfd_state       = VFD_READ_BUSY;
		break;
	case VFD_READ_BUSY:
		if(regs0->vfd_func&(3<<10))
			break;
		key_data=(reverse[regs0->vfd_dat0>>8])|(reverse[regs0->vfd_dat0]<<8) \
			| (reverse[regs0->vfd_dat1>>8]<<16);
		if(key_data==0)
		{ 
			key_state = 0;
			key_previ = 0;
		}
		else
		{
			if(key_data!=key_previ)
			{
				if(key_state==0)
				{
					key_state = 1;
					key_previ  = key_data;
               	}
			}
			else
			{
				if(key_state==1)
				{
					key_state = 2;
					
#ifdef  MONE_VFDR 
					for(i=0;i<24;i++)
					{
						temp = 0x01<<i;
						if(key_data&temp)
                        {
							key_recv = i+1;  
#ifdef VFD_TEST
							psprintf(linebuf, "Key %02d\n",key_recv);
							if(key_recv!=0) {
								//osd_print1(linebuf);
								strcpy(RegionValStr[REGION1], linebuf);
								PrintOsdMsg(STR_OS_SPACE, REGION1, 1, 1);
							}
#endif                
							break;
                        }
					}
#endif/*MONE_VFDR*/
#ifdef VFD_TEST
					break;
#endif
					call_ir_func(vfd_keycode[key_recv-1]);
					
					
					
				}
			}
		}
		
		vfd_state =  VFD_READ;
		return 1;    
		
		break;
	default:
		vfd_state = VFD_READ;
		break;
	}
#endif        
	return 0; 
#endif
}  

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

int	polling_vfd(void)
{
#ifdef    SUPPORT_VFD
	UINT16    dat_h;
	UINT16    dat_l;
	static    BYTE i = 0;
	static    BYTE vfd_state=0;
	
	switch(vfd_state)
	{       //pppp
			/*
			case VFD_IDLE:
			regs0->vfd_cfg=0x0;
			regs0->vfd_cfg=0x0128;
			regs0->vfd_func = 0;
			vfd_state       = VFD_WRITE;
			break;
		*/
    case VFD_WRITE:
		regs0->vfd_cfg=0x0;
		regs0->vfd_cfg=0x0128;
		regs0->vfd_func     = 0;
		if(i==15)
		{
            dat_h=reverse[((((VFD_CMD_WR<<1)|(i*2))<<7)&0xff00)>>8];
            dat_l=reverse[((((VFD_CMD_WR<<1)|(i*2))<<7)|(vfd_mem[i]>>1))&0x00ff];
            regs0->vfd_dat0 = (dat_h<<8)|dat_l;
            regs0->vfd_dat1 = reverse[((vfd_mem[i]<<7)&0x80)|(vfd_mem[0]>>1)]<<8;
            regs0->vfd_func	= RF_VFD_FUNC_WRITE
				| RF_VFD_FUNC_CMD_SIZE(2)
				| RF_VFD_FUNC_CMODE;  
		}                  
		else
		{
            dat_h=reverse[((((VFD_CMD_WR<<1)|(i*2))<<7)&0xff00)>>8];
            dat_l=reverse[((((VFD_CMD_WR<<1)|(i*2))<<7)|(vfd_mem[i]>>1))&0x00ff];
            regs0->vfd_dat0 = (dat_h<<8)|dat_l;
            regs0->vfd_dat1 = ((reverse[((vfd_mem[i]<<7)&0x80)|((vfd_mem[i+1]>>1)&0x7f)]<<8)&0xff00)|reverse[((vfd_mem[i+1]<<7)&0x80)|(vfd_mem[i+2]>>1)];
            regs0->vfd_dat2 = ((reverse[((vfd_mem[i+2]<<7)&0x80)|(vfd_mem[i+3]>>1)]<<8)&0xff00); 
            regs0->vfd_func	= RF_VFD_FUNC_WRITE
				| RF_VFD_FUNC_CMD_SIZE(4)
				| RF_VFD_FUNC_CMODE;    
        }       
		i+=3;
		if(i>15)
			i=0;
		//i+=3;
		vfd_state = VFD_WRITE_BUSY;
		break;     
	case VFD_WRITE_BUSY:
		if(regs0->vfd_func&(3<<10))
			break;
		vfd_state = VFD_WRITE;
		break;
	default:
		vfd_state = VFD_WRITE;
		break;
	}     
#endif
	return 0;
}



/*
** FUNCTION
** reset_HT1621_LCD
**
** DESCRIPTION
** setup VFD.  Should only called at power-up or emergency.
*/
void	reset_vfd(void)
{
	UINT16   i;
	UINT16   cmd_data;
	UINT16   cmd_data_h;
	UINT16   cmd_data_l;
	
	for(i=0;i<5;i++)
	{  
		regs0->vfd_cfg        = 0x0130;
		regs0->vfd_func       = 0;
		cmd_data=((send_ht_cmd[i]<<4)&0xff00)>>8;
		cmd_data_h=reverse[cmd_data];
		cmd_data=(send_ht_cmd[i]<<4)&0x00ff;
		cmd_data_l=reverse[cmd_data];
		cmd_data=(cmd_data_h<<8)|cmd_data_l;
		regs0->vfd_dat0     = cmd_data;
		regs0->vfd_func     = RF_VFD_FUNC_WRITE
			| RF_VFD_FUNC_CMD_SIZE(1)
			| RF_VFD_FUNC_CMODE;
		
		do {
#ifdef	__LX4080
			asm volatile ("nop; nop");
#endif
		} while ((regs0->vfd_func & RF_VFD_FUNC_STATUS) != RF_VFD_FUNC_STATUS_FREE);
		
	} 
	for(i=0;i<16;i++)
    { 
		regs0->vfd_cfg        = 0x0130;
		regs0->vfd_func       = 0; 
		cmd_data  =((((VFD_CMD_WR<<1)|i*2)<<7)&0xff00)>>8;
		cmd_data_h=reverse[cmd_data]<<8;
		cmd_data  =(((VFD_CMD_WR<<1)|i*2)<<7)&0x0080;
		cmd_data_l=reverse[cmd_data];
		cmd_data  =cmd_data_h|cmd_data_l;
		regs0->vfd_dat0     =cmd_data;
		regs0->vfd_dat1     =0x0000;
		regs0->vfd_func     = RF_VFD_FUNC_WRITE
			| RF_VFD_FUNC_CMD_SIZE(2)
			| RF_VFD_FUNC_CMODE; 
		do {
#ifdef	__LX4080
			asm volatile ("nop; nop");
#endif
		} while ((regs0->vfd_func & RF_VFD_FUNC_STATUS) != RF_VFD_FUNC_STATUS_FREE);
	}   
	
}

/*
** FUNCTION
** erase_vfd_mem
**
** DESCRIPTION
** clear vfd memory.
*/


void erase_vfd_mem(void)
{
#ifdef SUPPORT_VFD	
	unsigned  i;
	for(i=0;i<VFD_MEM_LEN; i++)
	{
		vfd_mem[i]=0;
	}
	
#endif
}