irapi1.c

完整的红外线驱动程序,对电视行业的开发人员很有用

						ERomPrintFunc(0, "***IR_EJECT*** \n");
						l_InputKey = IR_EJECT;
					}
					else
					{
						ERomPrintFunc(0, "***IR_POWER*** \n");
						l_InputKey = IR_POWER;
					}
					break;
				case AUTO_IR_TRICKMODE_TEST: 
					// trickmode testing
					switch (key_gen % 5)
					{
					case 0:
						l_InputKey = IR_STEP;
						break;
					case 1:
						l_InputKey = IR_STEP_REV;
						break;
					case 2:
						l_InputKey = IR_FF;
						break;
					case 3:
						l_InputKey = IR_FR;
						break;
					case 4:
						l_InputKey = IR_PLAY;
						break;						
					}
					break;
				case AUTO_IR_TRICKMODE_PASSTHRU_TEST:
					// trickmode + passthru testing
				default:
					l_InputKey = 0xFFFF;
					break;

				}

				dbg_timeout = (200 + (0xff&rand_val))/9;
			}
			else
			{
				l_InputKey = 0xFFFF;
			}

		}
		else
		{
        while (ir_rdptr != ls500reg(IR_DRAM_WRITE_ADDRESS_REG)) 
        {
            IRCheckState ();
            ir_rdptr += 4;
            if (ir_rdptr >= ir_end_addr) 
            {
                ir_rdptr = ir_start_addr ;
            }
        }
		}

		if (0xFFFF != l_InputKey)
		{
			TRACE_KEY("IR_GetKey: l_InputKey = 0x%x\n",l_InputKey);
			SendIRMessageToIPQueue(l_InputKey );
			l_InputKey = 0xFFFF;
		}
		
    }  
}
#else

//-----------------------------------------------------------------------------
//  Function:
void IRtimerHandler1(
//
//  Description:
//      
//  Parameters:
        void
)
//
//  Returns: 
//      
//
//-----------------------------------------------------------------------------
{


    CIRnFPCounter1++;
    if (CIRnFPCounter1 >= 9)
    {
        CIRnFPCounter1 = 0;
        while (ir_rdptr != ls500reg(IR_DRAM_WRITE_ADDRESS_REG)) 
        {
            IRCheckState ();
            ir_rdptr += 4;
            if (ir_rdptr >= ir_end_addr) 
            {
                ir_rdptr = ir_start_addr;
            }
        }

		if (0xFFFF != l_InputKey)
		{
			TRACE_KEY("IR_GetKey: l_InputKey = 0x%x\n",l_InputKey);
			SendIRMessageToIPQueue(l_InputKey );
			l_InputKey = 0xFFFF;
		}
		
    }  

//	if (ls500reg(0x28))
//	{
//		SendIRMessageToIPQueue(ls500reg(0x28));
//		ls500reg(0x28) = 0;
//	}

}
#endif
#endif
//-----------------------------------------------------------------------------
//  Function:
static void irkey_filter (
//
//  Description:
//      filter repeat key will take effect ??
//      
//  Parameters:
        Uint32 ir_repeatKey
)
//
//  Returns: 
//      
//
//-----------------------------------------------------------------------------
{
    switch (ir_repeatKey) 
    {
    case IR_STEP:
    case IR_VOL_UP:
    case IR_VOL_DOWN:
    case IR_UP:
    case IR_LEFT:
    case IR_RIGHT:
    case IR_DOWN:
        l_InputKey = ir_repeatKey;   // This should be a fifo   
    	TRACE_KEY("irkey_filter: l_InputKey = %d\n",l_InputKey);
    break;
    
    default:
    break;
    }
}


//-----------------------------------------------------------------------------
//  Function:
static int chk_range (
//
//  Description:
//      for increasing COMMAND and REPEAT detect range 
//      COMMAND range is from (ire_cmd - ire_cmd_adjust) to (ire_cmd + ire_cmd_adjust)
//      REPEAT range is from (ire_repeat - ire_cmd_adjust) to (ire_repeat + ire_cmd_adjust)
//      
//  Parameters:
        Uint32 cmd, 
        Uint32 val, 
        Uint32 adjust
)
//
//  Returns: 
//      
//
//-----------------------------------------------------------------------------
{
    if ((cmd <= (val + adjust)) && (cmd >= (val - adjust)))
        return 1;
    else
        return 0;
}


//-----------------------------------------------------------------------------
//  Function:
static int chk_data_range (
//
//  Description:
//      for increasing DATA detect range 
//      DATA range is form ire_data_one to (ire_data_one + ire_data_adjust)
//      for this IR case, 0x2 and 0x3 treat as high, 0x0 and 0x1 treat as low
//      
//  Parameters:
        Uint32 cmd, 
        Uint32 val, 
        Uint32 adjust
)
//
//  Returns: 
//      
//
//-----------------------------------------------------------------------------
{
    if ((cmd <= (val + adjust)) && (cmd >= val))
        return 1;
    else
        return 0;
}


//-----------------------------------------------------------------------------
//  Function:
static Uint32 IRCheckState (
//
//  Description:
//      
//  Parameters:
        void
)
//
//  Returns: 
//      
//
//-----------------------------------------------------------------------------
{
    Uint32 cmd;
    Uint32 irKey = 0xFFFF;

    cmd = (*(volatile Uint32 *) (ir_rdptr | DRAM_BASE) & 0xffefffff);
   	TRACE_KEY("IRCheckState: ir_rdptr = 0x%x cmd = %d\n",ir_rdptr, cmd);
    if (cmd > ire_max) 
    {
   		TRACE("IRCheckState: Resetting to IRS_START\n");
        ir_state = IRS_START;
        return VENDOR_OPTION;
    }

    else if (cmd == 0) 
    {
        TRACE("Ignore = 0x%x %d\n", cmd,ir_state);
        return VENDOR_OPTION;
    }

    switch (ir_state) 
    {
    case IRS_START:
    	TRACE_KEY("IRS_START: cmd = %d ire_cmd(%d) ire_cmd_adjust(%d)\n",cmd,ire_cmd,ire_cmd_adjust);
        if (chk_range(cmd, ire_cmd, ire_cmd_adjust)) 
        {
	    	TRACE("Going to IRS_COMMAND state\n");
            ir_nbit = 0;
            ir_data = 0;
            ir_state = IRS_COMMAND;
            ir_repeat_cnt = 0;
        } 
        else if (chk_range(cmd, ire_repeat, ire_cmd_adjust))
        {
        	TRACE("Going to IRS_REPEAT state\n");
            ir_state = IRS_REPEAT;
        }
    break;

    case IRS_COMMAND:
    	TRACE("IRS_COMMAND: cmd = %d\n",cmd);
        ir_data >>= 1;
        if (chk_data_range(cmd, ire_data_one, ire_data_adjust))
            ir_data |= 0x80000000;

		TRACE_KEY("<->ir_nbit=%d\n",ir_nbit);
        if (++ir_nbit == 32) 
        {
        	TRACE_KEY("<> irnbit == 32\n");
            if ((ir_data & 0xffff) == ir_code)
             {
                irKey = (ir_data >> 16) & 0xff;
                if ( !shift_key_pressed && ( irKey != IR_SHIFT )) 
                { 
                    TRACE_KEY("<*> IR KEY = 0x%x (%x)\n", irKey, (ir_data & 0xffff));
                    l_InputKey = irKey;
                    ir_repeatKey = irKey;
                }
                else if ( shift_key_pressed && ( irKey != IR_SHIFT ) )
                {      // == 0xFF  (SHIFT + key)
                    irKey |= 0x80;
                    TRACE_KEY("<**> IR KEY = 0x%x\n", irKey);
                    l_InputKey = irKey;
                    shift_key_pressed = 0;
                }
#if defined(ESCHER)                
                else if ( shift_key_pressed && (irKey == IR_SHIFT) )
                {
                    TRACE_KEY("Got SHIFT key\n");
                    l_InputKey = IR_EJECT;
                    shift_key_pressed = 0;       
                }                   
#endif
                else if (irKey == IR_SHIFT) 
                {
                    TRACE("Got SHIFT key\n");
                    shift_key_pressed = 1;       
                }                   
            }
            ir_state = IRS_START;
        }
    break;
    
    case IRS_REPEAT:
        ir_state = IRS_START;
        ir_repeat_cnt++;
        TRACE("IRS_REPEAT: ir_repeat_cnt = %d \n", ir_repeat_cnt);
        if (ir_repeat_cnt > ir_repeat_time)
        {
            TRACE("Repeat = 0x%x \n", ir_repeatKey);
            irkey_filter( (Uint32)ir_repeatKey);
            ir_repeat_cnt = 0;
        }
        break;
    } // switch
        
        return (VENDOR_OPTION|irKey);
}


#ifdef AUTOMATED_IR_TEST_COMBOER
void IR_TraceKey(Uint16 key,Uint16 time,int i, Uint32 totaltime)
{
	char keyname[16];
	Boolean valid = TRUE;
	switch(key)
	{
		case IR_POWER:
			strcpy(keyname, "IR_POWER");
			break;
		case IR_SETUP_MENU: 
			strcpy(keyname, "IR_SETUP_MENU");
			break;
		case  IR_DISPLAY:
			strcpy(keyname, "IR_DISPLAY");
			break;
		case IR_EJECT:
			strcpy(keyname, "IR_EJECT");
			break;
		case IR_CAMCODER:
			strcpy(keyname, "IR_CAMCODER");
			break;
		case IR_HIDE:
			strcpy(keyname, "IR_HIDE");
			break;
		case IR_CMSKIP:
			strcpy(keyname, "IR_CMSKIP");
			break;
		case IR_EDIT:
			strcpy(keyname, "IR_EDIT");
			break;
		case IR_REC:
			strcpy(keyname, "IR_REC");
			break;
		case IR_QUALITY:
			strcpy(keyname, "IR_QUALITY");
			break;
		case IR_RETURN:
			strcpy(keyname, "IR_RETURN");
			break;
		case IR_TIMESHIFT:
			strcpy(keyname, "IR_TIMESHIFT");
			break;
		case IR_TMENU:
			strcpy(keyname, "IR_TMENU");
			break;
		case IR_RMENU:
			strcpy(keyname, "IR_RMENU");
			break;
		case IR_UP:
			strcpy(keyname, "IR_UP");
			break;
		case IR_DOWN:
			strcpy(keyname, "IR_DOWN");
			break;
		case IR_LEFT:
			strcpy(keyname, "IR_LEFT");
			break;
		case IR_RIGHT:
			strcpy(keyname, "IR_RIGHT");
			break;
		case IR_ENTER:
			strcpy(keyname, "IR_ENTER");
			break;
		case IR_SOURCE:
			strcpy(keyname, "IR_SOURCE");
			break;
		case IR_HDD_DVD:
			strcpy(keyname, "IR_HDD_DVD");
			break;
		case IR_PLAY:
			strcpy(keyname, "IR_PLAY");
			break;
		case IR_STEP_REV:
			strcpy(keyname, "IR_STEP_REV");
			break;
		case IR_STEP:
			strcpy(keyname, "IR_STEP");
			break;
		case IR_STOP:
			strcpy(keyname, "IR_STOP");
			break;
		case IR_PREV:
			strcpy(keyname, "IR_PREV_CLIP");	
			break;
		case IR_NEXT:
			strcpy(keyname, "IR_NEXT");
			break;
		case IR_FR:
			strcpy(keyname, "IR_FR");
			break;
		case IR_FF:
			strcpy(keyname, "IR_FF");
			break;
		case IR_NUM1:
			strcpy(keyname, "IR_NUM1");
			break;
		case IR_NUM2:
			strcpy(keyname, "IR_NUM2");
			break;
		case IR_NUM3:
			strcpy(keyname, "IR_NUM3");
			break;
		case IR_CH_UP:
			strcpy(keyname, "IR_CH_UP");
			break;
		case IR_NUM4:
			strcpy(keyname, "IR_NUM4");
			break;
		case IR_NUM5:
			strcpy(keyname, "IR_NUM5");
			break;
		case IR_NUM6:
			strcpy(keyname, "IR_NUM6");
			break;
		case IR_CH_DOWN:
			strcpy(keyname, "IR_CH_DOWN");
			break;
		case IR_NUM7:
			strcpy(keyname, "IR_NUM7");
			break;
		case IR_NUM8:
			strcpy(keyname, "IR_NUM8");
			break;
		case IR_NUM9:
			strcpy(keyname, "IR_NUM9");
			break;
		case IR_VOL_UP:
			strcpy(keyname, "IR_VOL_UP");
			break;
		case IR_NUM0:
			strcpy(keyname, "IR_NUM0");
			break;
		case IR_CLEAR:
			strcpy(keyname, "IR_CLEAR");
			break;
		case IR_AUDIO_MODE:
			strcpy(keyname, "IR_AUDIO_MODE");
			break;
		case IR_VOL_DOWN:
			strcpy(keyname, "IR_VOL_DOWN");
			break;
		case IR_RANDOM:
			strcpy(keyname, "IR_RANDOM");
			break;
		case IR_SURROUND:
			strcpy(keyname, "IR_SURROUND");
			break;
		case IR_VIDEO_MODE:
			strcpy(keyname, "IR_VIDEO_MODE");
			break;
		case IR_MUTE:
			strcpy(keyname, "IR_MUTE");
			break;
		case IR_ZOOM:
			strcpy(keyname, "IR_ZOOM");
			break;
		case IR_SET_MARK:
			strcpy(keyname, "IR_SET_MARK");
			break;
		case IR_REPEAT:
			strcpy(keyname, "IR_REPEAT");
			break;
		case IR_AB_REPEAT:
			strcpy(keyname, "IR_AB_REPEAT");
			break;
		case IR_PREV_START:
			strcpy(keyname, "IR_PREV_START");
			break;
		case IR_SHIFT:
			strcpy(keyname, "IR_SHIFT");
			break;
		case IR_SHUFFLE:
			strcpy(keyname, "IR_SHUFFLE");
			break;
		case IR_SUBT_MENU:
			strcpy(keyname, "IR_SUBT_MENU");
			break;
		case IR_PROGRAM:
			strcpy(keyname, "IR_PROGRAM");
			break;
		case IR_ANGLE_MENU:
			strcpy(keyname, "IR_ANGLE_MENU");
			break;
		case IR_AUDIO_MENU:
			strcpy(keyname, "IR_AUDIO_MENU");
			break;
		case IR_DIGEST:
			strcpy(keyname, "IR_DIGEST");
			break;
		case IR_PBC:
			strcpy(keyname, "IR_PBC");
			break;
		case IR_PIP:
			strcpy(keyname, "IR_PIP");
			break;
		case IR_PAUSE:
			strcpy(keyname, "IR_PAUSE");
			break;
		default:
			strcpy(keyname, "IR_INVALIDKEY");
			valid = FALSE;
			break;
	}
	if ((ls500reg(0x28) == 0xdeadbeef) && (i >= 0))
	{
	if (testcase->intervalmode == IR_Auto_Mode)
	{
		if (time < intervalMin)
		{
			valid = FALSE;
		}
		else if (time > intervalMax)
		{
			valid = FALSE;
		}
	}
	}
	if (valid != TRUE)
	{
		ERomPrintFunc(0,"***generate wrong case  key:%s(0x%x),allkeyArrNum = %d, time=%d, intervalmin=%d, intervalmax=%d\n",
				keyname,key,allkeyNum,time,intervalMin,intervalMax);
	}
	else
	{
		ERomPrintFunc(0,"***Send key:%s(0x%x), i=%d,after %d s send next key, Total time=%d s\n",keyname,key,i,time,totaltime);
	}
}
#endif



//-----------------------------------------------------------------------------
//  Function:
int IRPollKey(
//
//  Description:
//      
//  Parameters:
        void
)
//
//  Returns: 
//      
//
//-----------------------------------------------------------------------------
{
     while (ir_rdptr != ls500reg(IR_DRAM_WRITE_ADDRESS_REG)) 
     {
        IRCheckState ();
        ir_rdptr += 4;
        if (ir_rdptr >= ir_end_addr) 
        {
           ir_rdptr = ir_start_addr ;
        }
     }

	if (0xFFFF != l_InputKey)
	{
		return ((int) l_InputKey);
	}

	return 0;
}