skystar2.c

linux TV 源码

    }
}

//-------------------------------------------------------------------
void FilterEnablePmtFilter(struct adapter * adapter, u32 op)
{
    dprintk("%s: op=%x\n", __FUNCTION__, op);

    if ( op == 0 )
    {
	WriteRegOp(adapter, 0x208, 2, ~0x00000008, 0);

    } else {

	WriteRegOp(adapter, 0x208, 1, 0, 0x00000008);
    }
}

//-------------------------------------------------------------------
void FilterEnableEmmFilter(struct adapter * adapter, u32 op)
{
    dprintk("%s: op=%x\n", __FUNCTION__, op);

    if ( op == 0 )
    {
	WriteRegOp(adapter, 0x208, 2, ~0x00000010, 0);

    } else {

	WriteRegOp(adapter, 0x208, 1, 0, 0x00000010);
    }
}

//-------------------------------------------------------------------
void FilterEnableEcmFilter(struct adapter * adapter, u32 op)
{
    dprintk("%s: op=%x\n", __FUNCTION__, op);

    if ( op == 0 )
    {
	WriteRegOp(adapter, 0x208, 2, ~0x00000020, 0);

    } else {

	WriteRegOp(adapter, 0x208, 1, 0, 0x00000020);
    }
}

//-------------------------------------------------------------------
void FilterEnableNullFilter(struct adapter *adapter, u32 op)
{
    dprintk("%s: op=%x\n", __FUNCTION__, op);

    if ( op == 0 )
    {
	WriteRegOp(adapter, 0x208, 2, ~0x00000040, 0);

    } else {

	WriteRegOp(adapter, 0x208, 1, 0, 0x00000040);
    }
}

//-------------------------------------------------------------------
void FilterEnableMaskFilter(struct adapter *adapter, u32 op)
{
    dprintk("%s: op=%x\n", __FUNCTION__, op);

    if ( op == 0 )
    {
	WriteRegOp(adapter, 0x208, 2, ~0x00000080, 0);

    } else {

	WriteRegOp(adapter, 0x208, 1, 0, 0x00000080);
    }
}


//-------------------------------------------------------------------
void CtrlEnableMAC(struct adapter *adapter, u32 op)
{
    if ( op == 0 )
    {
	WriteRegOp(adapter, 0x208, 2, ~0x00004000, 0);
	
    } else {
    
	WriteRegOp(adapter, 0x208, 1, 0, 0x00004000);
    }
}

//-------------------------------------------------------------------
int CASetMacDstAddrFilter(struct adapter *adapter, u8 *mac)
{
    u32 tmp1, tmp2;

    tmp1 = ( mac[3] << 0x18 ) | ( mac[2] << 0x10 ) | ( mac[1] << 0x08 ) | mac[0];
    tmp2 = ( mac[5] << 0x08 ) | mac[4];

    WriteRegDW(adapter, 0x418, tmp1);
    WriteRegDW(adapter, 0x41C, tmp2);

    return 0;
}

//-------------------------------------------------------------------
void SetIgnoreMACFilter(struct adapter * adapter, u8 op)
{
    if ( op != 0 )
    {
	WriteRegOp(adapter, 0x208, 2, ~0x00004000, 0);

	adapter->mac_filter = 1;

    } else {

	if ( adapter->mac_filter != 0 )
	{
	    adapter->mac_filter = 0;

	    WriteRegOp(adapter, 0x208, 1, 0, 0x00004000);
	}
    }
}

//-------------------------------------------------------------------
void CheckNullFilterEnable(struct adapter * adapter)
{
    FilterEnableNullFilter(adapter, 1);
    FilterEnableMaskFilter(adapter, 1);
}

//-------------------------------------------------------------------
void InitPIDsInfo(struct adapter *adapter)
{
    int i;

    for ( i = 0; i < 0x27; i++) adapter->pids[i] = 0x1FFF;
}

//-------------------------------------------------------------------
u32 CheckPID(struct adapter * adapter, u16 pid)
{
    u32 i;

    if ( pid == 0x1FFF ) return 0;

    for ( i = 0; i < 0x27; i++ )
    {
        if ( adapter->pids[i] == pid ) return 1;
    }

    return 0;
}

//-------------------------------------------------------------------
u32 PidSetGroupPID(struct adapter *adapter, u32 pid)
{
    u32 value;

    dprintk("%s: pid=%x\n", __FUNCTION__, pid);

    value = ( pid & 0x3FFF) | ( ReadRegDW(adapter, 0x30C) &  0xFFFF0000 );

    WriteRegDW(adapter, 0x30C, value);

    return value;
}

//-------------------------------------------------------------------
u32 PidSetGroupMASK(struct adapter *adapter, u32 pid)
{
    u32 value;

    dprintk("%s: pid=%x\n", __FUNCTION__, pid);

    value = ( ( pid & 0x3FFF ) << 0x10 ) | (ReadRegDW(adapter, 0x30C) & 0xFFFF );

    WriteRegDW(adapter, 0x30C, value);

    return value;
}

//-------------------------------------------------------------------
u32 PidSetStream1PID(struct adapter *adapter, u32 pid)
{
    u32 value;

    dprintk("%s: pid=%x\n", __FUNCTION__, pid);

    value = ( pid & 0x3FFF ) | ( ReadRegDW(adapter, 0x300) & 0xFFFFC000 );

    WriteRegDW(adapter, 0x300, value);

    return value;
}

//-------------------------------------------------------------------
u32 PidSetStream2PID(struct adapter *adapter, u32 pid)
{
    u32 value;

    dprintk("%s: pid=%x\n", __FUNCTION__, pid);

    value = ( ( pid & 0x3FFF ) << 0x10 ) | ( ReadRegDW(adapter, 0x300) & 0xFFFF );

    WriteRegDW(adapter, 0x300, value);

    return value;
}

//-------------------------------------------------------------------
u32 PidSetPcrPID(struct adapter *adapter, u32 pid)
{
    u32 value;

    dprintk("%s: pid=%x\n", __FUNCTION__, pid);

    value = (pid & 0x3FFF) | ( ReadRegDW(adapter, 0x304) & 0xFFFFC000 );

    WriteRegDW(adapter, 0x304, value);

    return value;
}

//-------------------------------------------------------------------
u32 PidSetPmtPID(struct adapter *adapter, u32 pid)
{
    u32 value;

    dprintk("%s: pid=%x\n", __FUNCTION__, pid);

    value = ( (pid & 0x3FFF) << 0x10) | ( ReadRegDW(adapter, 0x304) & 0x3FFF );

    WriteRegDW(adapter, 0x304, value);

    return value;
}

//-------------------------------------------------------------------
u32 PidSetEmmPID(struct adapter *adapter, u32 pid)
{
    u32 value;

    dprintk("%s: pid=%x\n", __FUNCTION__, pid);

    value = (pid & 0xFFFF) | ( ReadRegDW(adapter, 0x308) & 0xFFFF0000 );

    WriteRegDW(adapter, 0x308, value);

    return value;
}

//-------------------------------------------------------------------
u32 PidSetEcmPID(struct adapter *adapter, u32 pid)
{
    u32 value;

    dprintk("%s: pid=%x\n", __FUNCTION__, pid);

    value = (pid << 0x10 ) | ( ReadRegDW(adapter, 0x308) & 0xFFFF );

    WriteRegDW(adapter, 0x308, value);

    return value;
}

//-------------------------------------------------------------------
u32 PidGetStream1PID(struct adapter *adapter)
{
    return ReadRegDW(adapter, 0x300) & 0x0000FFFF;
}

//-------------------------------------------------------------------
u32 PidGetStream2PID(struct adapter *adapter)
{
    return ReadRegDW(adapter, 0x300) >> 0x10;
}

//-------------------------------------------------------------------
u32 PidGetPcrPID(struct adapter *adapter)
{
    return ReadRegDW(adapter, 0x304) & 0x0000FFFF;
}

//-------------------------------------------------------------------
u32 PidGetPmtPID(struct adapter *adapter)
{
    return ReadRegDW(adapter, 0x304) >> 0x10;
}

//-------------------------------------------------------------------
u32 PidGetEmmPID(struct adapter *adapter)
{
    return ReadRegDW(adapter, 0x308) & 0x0000FFFF;
}

//-------------------------------------------------------------------
u32 PidGetEcmPID(struct adapter *adapter)
{
    return ReadRegDW(adapter, 0x308) >> 0x10;
}

//-------------------------------------------------------------------
u32 PidGetGroupPID(struct adapter *adapter)
{
    return ReadRegDW(adapter, 0x30C) & 0x0000FFFF;
}

//-------------------------------------------------------------------
u32 PidGetGroupMASK(struct adapter *adapter)
{
    return ReadRegDW(adapter, 0x30C) >> 0x10;
}

//-------------------------------------------------------------------
void ResetHardwarePIDFilter(struct adapter *adapter)
{
    PidSetStream1PID(adapter, 0x1FFF);

    PidSetStream2PID(adapter, 0x1FFF);
    FilterEnableStream2Filter(adapter, 0);

    PidSetPcrPID(adapter, 0x1FFF);
    FilterEnablePcrFilter(adapter, 0);

    PidSetPmtPID(adapter, 0x1FFF);
    FilterEnablePmtFilter(adapter, 0);

    PidSetEcmPID(adapter, 0x1FFF);
    FilterEnableEcmFilter(adapter, 0);

    PidSetEmmPID(adapter, 0x1FFF);
    FilterEnableEmmFilter(adapter, 0);
}

//-------------------------------------------------------------------
void OpenWholeBandwidth(struct adapter * adapter)
{
    PidSetGroupPID(adapter, 0);

    PidSetGroupMASK(adapter, 0);

    FilterEnableMaskFilter(adapter, 1);
}

//-------------------------------------------------------------------
int AddHwPID(struct adapter * adapter, u32 pid)
{
    dprintk("%s: pid=%d\n", __FUNCTION__, pid);	

    if ( pid <= 0x1F ) return 1;

    if ( ( PidGetGroupMASK(adapter) == 0 ) && ( PidGetGroupPID(adapter) == 0 ) ) return 0;


    if ( ( PidGetStream1PID(adapter) & 0x1FFF ) == 0x1FFF )
    {
	PidSetStream1PID(adapter, pid & 0xFFFF );

        FilterEnableStream1Filter(adapter, 1);

        return 1;
    }

    if ( ( PidGetStream2PID(adapter) & 0x1FFF ) == 0x1FFF )
    {
	PidSetStream2PID(adapter, ( pid & 0xFFFF ) );

        FilterEnableStream2Filter(adapter, 1);

	return 1;
    }

    if ( ( PidGetPcrPID(adapter) & 0x1FFF ) == 0x1FFF )
    {
	PidSetPcrPID(adapter, ( pid & 0xFFFF ) );

        FilterEnablePcrFilter(adapter, 1);

	return 1;
    }

    if ( ( PidGetPmtPID(adapter) & 0x1FFF ) == 0x1FFF )
    {
	PidSetPmtPID(adapter, ( pid & 0xFFFF ) );

        FilterEnablePmtFilter(adapter, 1);

	return 1;
    }

    if ( ( PidGetEmmPID(adapter) & 0x1FFF ) == 0x1FFF )
    {
	PidSetEmmPID(adapter, ( pid & 0xFFFF ) );

        FilterEnableEmmFilter(adapter, 1);

        return 1;
    }

    if ( ( PidGetEcmPID(adapter) & 0x1FFF ) == 0x1FFF )
    {
	PidSetEcmPID(adapter, ( pid & 0xFFFF ) );

        FilterEnableEcmFilter(adapter, 1);

	return 1;
    }
    
    return -1;
}

//-------------------------------------------------------------------
int RemoveHwPID(struct adapter * adapter, u32 pid)
{
    dprintk("%s: pid=%d\n", __FUNCTION__, pid);	

    if ( pid <= 0x1F ) return 1;

    if ( ( PidGetStream1PID(adapter) & 0x1FFF ) == pid )
    {
	PidSetStream1PID(adapter, 0x1FFF);

	return 1;
    }

    if ( ( PidGetStream2PID(adapter) & 0x1FFF ) == pid )
    {
	PidSetStream2PID(adapter, 0x1FFF);

	FilterEnableStream2Filter(adapter, 0);

	return 1;
    }

    if ( ( PidGetPcrPID(adapter) & 0x1FFF ) == pid )
    {
	PidSetPcrPID(adapter, 0x1FFF);

	FilterEnablePcrFilter(adapter, 0);

	return 1;
    }

    if ( ( PidGetPmtPID(adapter) & 0x1FFF ) == pid )
    {
	PidSetPmtPID(adapter, 0x1FFF);

	FilterEnablePmtFilter(adapter, 0);

        return 1;
    }

    if ( ( PidGetEmmPID(adapter) & 0x1FFF ) == pid )
    {
	PidSetEmmPID(adapter, 0x1FFF);

	FilterEnableEmmFilter(adapter, 0);

	return 1;
    }

    if ( ( PidGetEcmPID(adapter) & 0x1FFF ) == pid )
    {
	PidSetEcmPID(adapter, 0x1FFF);

	FilterEnableEcmFilter(adapter, 0);

	return 1;
    }

    return -1;
}

//------------------------------------------------------------------------------
int AddPID(struct adapter * adapter, u32 pid)
{
    int i;

    dprintk("%s: pid=%d\n", __FUNCTION__, pid);

    if ( pid > 0x1FFE ) return -1;

    if ( CheckPID(adapter, pid) == 1 ) return 1;

    for ( i = 0; i < 0x27; i++)
    {
	if ( adapter->pids[i] == 0x1FFF )	// find free pid filter
	{
	    adapter->pids[i] = pid;	

	    if ( AddHwPID(adapter, pid) < 0 ) OpenWholeBandwidth(adapter);
	    
	    return 1;
	}
    }

    return -1;
}

//-------------------------------------------------------------------
int RemovePID(struct adapter * adapter, u32 pid)
{
    u32 i;

    dprintk("%s: pid=%d\n", __FUNCTION__, pid);	

    if ( pid > 0x1FFE ) return -1;

    for ( i = 0; i < 0x27; i++)
    {
	if ( adapter->pids[i] == pid )
	{
	    adapter->pids[i] = 0x1FFF;	

	    RemoveHwPID(adapter, pid);

	    return 1;
	}
    }

    return -1;
}

/////////////////////////////////////////////////////////////////////
//			DMA & IRQ
/////////////////////////////////////////////////////////////////////

//-------------------------------------------------------------------
void CtrlEnableSmc(struct adapter *adapter, u32 op)
{