skystar2.c

linux TV 源码

	};
	
	if ( retries == 0 ) printk("%s: SRAM timeout\n", __FUNCTION__);
		
	value = ReadRegDW(adapter, 0x700) >> 0x10;

	*buf = ( value & 0xff );

	addr++;
	buf++;
    }
}

//-------------------------------------------------------------------
void SRAM_writeChunk(struct adapter * adapter, u32 addr, u8 * buf, u16 len)
{
    u32 bank;
	
    bank = 0;

    if ( adapter->dwSramType == 0x20000 )
    {
	bank = ( addr & 0x18000 ) << 0x0D;
    }

    if ( adapter->dwSramType == 0x00000 )
    {
    	if ( (addr >> 0x0F) == 0 ) bank = 0x20000000; else bank = 0x10000000;
    }

    FlexSramWrite(adapter, bank, addr & 0x7FFF, buf, len);
}

//-------------------------------------------------------------------
void SRAM_readChunk(struct adapter * adapter, u32 addr, u8 * buf, u16 len)
{
    u32 bank;

    bank = 0;

    if ( adapter->dwSramType == 0x20000 )
    {
	bank = ( addr & 0x18000 ) << 0x0D;
    }

    if ( adapter->dwSramType == 0x00000 )
    {
	if ( ( addr >> 0x0F ) == 0 ) bank = 0x20000000; else bank = 0x10000000;
    }

    FlexSramRead(adapter, bank, addr & 0x7FFF, buf, len);
}

//-------------------------------------------------------------------
void SRAM_read(struct adapter * adapter, u32 addr, u8 * buf, u32 len)
{
    u32 length;

    while ( len != 0 )
    {
	length = len;

	// check if the address range belongs to the same 
	// 32K memory chip. If not, the data is read from 
	// one chip at a time.
	if ( (addr >> 0x0F) != ( (addr+len-1) >> 0x0F ) )
	{
	    length = ( ( (addr >> 0x0F) + 1 ) << 0x0F ) - addr;
	}

	SRAM_readChunk(adapter, addr, buf, length);

	addr = addr + length;
	buf  = buf  + length;
	len  = len  - length;
    }
}

//-------------------------------------------------------------------
void SRAM_write(struct adapter * adapter, u32 addr, u8 * buf, u32 len)
{
    u32 length;

    while ( len != 0 )
    {
	length = len;

	// check if the address range belongs to the same 
	// 32K memory chip. If not, the data is written to
	// one chip at a time.
	if ( ( addr >> 0x0F ) != ( (addr+len-1) >> 0x0F ) )
	{
	    length = ( ( ( addr >> 0x0F )+1 ) << 0x0F ) - addr;
	}

	SRAM_writeChunk(adapter, addr, buf, length);

	addr = addr + length;
	buf  = buf  + length;
	len  = len  - length;
    } 
}

//-------------------------------------------------------------------
void SRAM_setSize(struct adapter * adapter, u32 mask)
{
    WriteRegDW(adapter, 0x71C, ( mask | ( ~0x30000 & ReadRegDW(adapter, 0x71C) ) ) );
}

//-------------------------------------------------------------------
u32 SRAM_init(struct adapter * adapter)
{
    u32 tmp;

    tmp = ReadRegDW(adapter, 0x71C);

    WriteRegDW(adapter, 0x71C, 1);

    if ( ReadRegDW(adapter, 0x71C) != 0) 
    {
	WriteRegDW(adapter, 0x71C, tmp);

	adapter->dwSramType = tmp & 0x30000;

        dprintk("%s: dwSramType = %x\n", __FUNCTION__, adapter->dwSramType);

    } else {

	adapter->dwSramType = 0x10000;

        dprintk("%s: dwSramType = %x\n", __FUNCTION__, adapter->dwSramType);
    }

    return adapter->dwSramType;
}

//-------------------------------------------------------------------
int SRAM_testLocation(struct adapter * adapter, u32 mask, u32 addr)
{
    u8  tmp1, tmp2;

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

    SRAM_setSize(adapter, mask);
    SRAM_init(adapter);

    tmp2 = 0xA5;
    tmp1 = 0x4F;

    SRAM_write(adapter, addr,     &tmp2, 1);
    SRAM_write(adapter, addr + 4, &tmp1, 1);

    tmp2 = 0;

    linuxdelayms(20);

    SRAM_read(adapter, addr, &tmp2, 1);
    SRAM_read(adapter, addr, &tmp2, 1);
    
    dprintk("%s: wrote 0xA5, read 0x%2x\n", __FUNCTION__, tmp2);

    if ( tmp2 != 0xA5 ) return 0;

    tmp2 = 0x5A;
    tmp1 = 0xF4;

    SRAM_write(adapter, addr,     &tmp2, 1);
    SRAM_write(adapter, addr + 4, &tmp1, 1);

    tmp2 = 0;

    linuxdelayms(20);

    SRAM_read(adapter, addr, &tmp2, 1);
    SRAM_read(adapter, addr, &tmp2, 1);

    dprintk("%s: wrote 0x5A, read 0x%2x\n", __FUNCTION__, tmp2);

    if ( tmp2 != 0x5A ) return 0;

    return 1;
}

//-------------------------------------------------------------------
u32 SRAM_length(struct adapter * adapter)
{
    if ( adapter->dwSramType == 0x10000 ) return  32768; //  32K
    if ( adapter->dwSramType == 0x00000 ) return  65536; //  64K        
    if ( adapter->dwSramType == 0x20000 ) return 131072; // 128K

    return 32768; // 32K
}

//////////////////////////////////////////////////////////////////////
// FlexcopII can work with 32K, 64K or 128K of external SRAM memory.
//  - for 128K there are 4x32K chips at bank 0,1,2,3.
//  - for  64K there are 2x32K chips at bank 1,2.
//  - for  32K there is one 32K chip at bank 0.
//
// FlexCop works only with one bank at a time. The bank is selected
// by bits 28-29 of the 0x700 register.
//
// bank 0 covers addresses 0x00000-0x07FFF
// bank 1 covers addresses 0x08000-0x0FFFF
// bank 2 covers addresses 0x10000-0x17FFF
// bank 3 covers addresses 0x18000-0x1FFFF
/////////////////////////////////////////////////////////////////////
//-------------------------------------------------------------------
int SramDetectForFlex2(struct adapter * adapter)
{
    u32 tmp, tmp2, tmp3;
    
    dprintk("%s:\n", __FUNCTION__);

    tmp = ReadRegDW(adapter, 0x208);
    WriteRegDW(adapter, 0x208, 0);

    tmp2 = ReadRegDW(adapter, 0x71C);

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

    WriteRegDW(adapter, 0x71C, 1);

    tmp3 = ReadRegDW(adapter, 0x71C);

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

    WriteRegDW(adapter, 0x71C, tmp2);

    // check for internal SRAM ???
    tmp3--;
    if ( tmp3 != 0 )
    {
	SRAM_setSize(adapter, 0x10000);
	SRAM_init(adapter);
	WriteRegDW(adapter, 0x208, tmp);

	dprintk("%s: sram size = 32K\n", __FUNCTION__);

	return 32;
    }

    if ( SRAM_testLocation(adapter, 0x20000, 0x18000) != 0 )
    {
	SRAM_setSize(adapter, 0x20000);
	SRAM_init(adapter);
	WriteRegDW(adapter, 0x208, tmp);

	dprintk("%s: sram size = 128K\n", __FUNCTION__);

	return 128;
    }

    if ( SRAM_testLocation(adapter, 0x00000, 0x10000) != 0 )
    {
	SRAM_setSize(adapter, 0x00000);
	SRAM_init(adapter);
	WriteRegDW(adapter, 0x208, tmp);

	dprintk("%s: sram size = 64K\n", __FUNCTION__);

	return 64;
    }

    if ( SRAM_testLocation(adapter, 0x10000, 0x00000) != 0 )
    {
	SRAM_setSize(adapter, 0x10000);
	SRAM_init(adapter);
	WriteRegDW(adapter, 0x208, tmp);

	dprintk("%s: sram size = 32K\n", __FUNCTION__);

	return 32;
    }

    SRAM_setSize(adapter, 0x10000);
    SRAM_init(adapter);
    WriteRegDW(adapter, 0x208, tmp);

    dprintk("%s: SRAM detection failed. Set to 32K \n", __FUNCTION__);

    return 0;
}

//-------------------------------------------------------------------
void SLL_detectSramSize(struct adapter * adapter)
{
    SramDetectForFlex2(adapter);
}

/////////////////////////////////////////////////////////////////////
//	EEPROM (Skystar2 has one "24LC08B" chip on board)
////////////////////////////////////////////////////////////////////

//-------------------------------------------------------------------
int EEPROM_write(struct adapter * adapter, u16 addr, u8 *buf, u16 len)
{
    return FLEXI2C_write(adapter, 0x20000000, 0x50, addr, buf, len);
}

//-------------------------------------------------------------------
int EEPROM_read(struct adapter * adapter, u16 addr, u8 *buf, u16 len)
{
    return FLEXI2C_read(adapter, 0x20000000, 0x50, addr, buf, len);
}

//-------------------------------------------------------------------
u8 calc_LRC(u8 * buf, u32 len)
{
    u32 i;
    u8 sum;
	
    sum = 0;

    for (i = 0; i < len; i++) sum = sum ^ buf[i];

    return sum;
}

//-------------------------------------------------------------------
int EEPROM_LRC_read(struct adapter * adapter, u32 addr, u32 len, u8 * buf, u32 retries)
{
    int i;

    for ( i = 0; i < retries; i++)
    {
        if ( EEPROM_read(adapter, addr, buf, len) == len )
        {
	    if ( calc_LRC(buf, len-1) == buf[len-1] ) return 1;
	}
    }

    return 0;
}

//-------------------------------------------------------------------
int EEPROM_LRC_write(struct adapter * adapter, u32 addr, u32 len, u8 * wbuf, u8 * rbuf, u32 retries)
{
    int i;

    for ( i = 0; i < retries; i++)
    {
	if ( EEPROM_write(adapter, addr, wbuf, len) == len )
	{
	    if ( EEPROM_LRC_read(adapter, addr, len, rbuf, retries) == 1 ) return 1;
	}
    }
    
    return 0;
}

/////////////////////////////////////////////////////////////////////
// These functions could be called from the initialization routine 
// to unlock SkyStar2 cards, locked by "Europe On Line".
//	
// in cards from "Europe On Line" the key is:
//
//	u8 key[20] = {
//	     0xB2, 0x01, 0x00, 0x00,
//	     0x00, 0x00, 0x00, 0x00,
//	     0x00, 0x00, 0x00, 0x00,
//	     0x00, 0x00, 0x00, 0x00,
//	};
//
//	LRC = 0xB3;
//
// in unlocked cards the key is:
//
//	u8 key[20] = {
//	     0xB2, 0x00, 0x00, 0x00,
//	     0x00, 0x00, 0x00, 0x00,
//	     0x00, 0x00, 0x00, 0x00,
//	     0x00, 0x00, 0x00, 0x00,
//	};
//
//     LRC = 0xB2;
/////////////////////////////////////////////////////////////////////

//-------------------------------------------------------------------
int EEPROM_writeKey(struct adapter * adapter, u8 * key, u32 len)
{
    u8 rbuf[20];
    u8 wbuf[20];

    if ( len != 16 ) return 0;

    memcpy(wbuf, key, len);

    wbuf[16] = 0;
    wbuf[17] = 0;
    wbuf[18] = 0;
    wbuf[19] = calc_LRC(wbuf, 19);

    return EEPROM_LRC_write(adapter, 0x3E4, 20, wbuf, rbuf, 4);
}

//-------------------------------------------------------------------
int EEPROM_readKey(struct adapter * adapter, u8 * key, u32 len)
{
    u8 buf[20];

    if ( len != 16 ) return 0;

    if ( EEPROM_LRC_read(adapter, 0x3E4, 20, buf, 4) == 0 ) return 0;

    memcpy(key, buf, len);

    return 1;
}

//-------------------------------------------------------------------
int EEPROM_getMacAddr(struct adapter * adapter, char type, u8 * mac)
{
    u8 tmp[8];

    if ( EEPROM_LRC_read(adapter, 0x3F8, 8, tmp, 4) != 0 )
    {
	if ( type != 0 )
	{
	    mac[0] = tmp[0];
	    mac[1] = tmp[1];
	    mac[2] = tmp[2];
	    mac[3] = 0xFE;
	    mac[4] = 0xFF;
	    mac[5] = tmp[3];
	    mac[6] = tmp[4];
	    mac[7] = tmp[5];
	
	} else {

	    mac[0] = tmp[0];
	    mac[1] = tmp[1];
	    mac[2] = tmp[2];
	    mac[3] = tmp[3];
	    mac[4] = tmp[4];
	    mac[5] = tmp[5];
	}

	return 1;

    } else {

        if ( type == 0 )
	{
	    memset(mac, 0, 6);

	} else {

	    memset(mac, 0, 8);
	}
	
	return 0;
    }
}

//-------------------------------------------------------------------
char EEPROM_setMacAddr(struct adapter * adapter, char type, u8 * mac)
{
    u8 tmp[8]; 

    if ( type != 0 )
    {
	tmp[0] = mac[0];
	tmp[1] = mac[1];
	tmp[2] = mac[2];
	tmp[3] = mac[5];
	tmp[4] = mac[6];
	tmp[5] = mac[7];

    } else {

	tmp[0] = mac[0];
	tmp[1] = mac[1];
	tmp[2] = mac[2];
	tmp[3] = mac[3];
	tmp[4] = mac[4];
	tmp[5] = mac[5];
    }

    tmp[6] = 0;
    tmp[7] = calc_LRC(tmp, 7);
		
    if ( EEPROM_write(adapter, 0x3F8, tmp, 8) == 8 ) return 1;

    return 0;
}

/////////////////////////////////////////////////////////////////////
//			PID filter
/////////////////////////////////////////////////////////////////////

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

    if ( op == 0 )
    {
	WriteRegOp(adapter, 0x208, 2, ~0x00000001, 0);
		
    } else {

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

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

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

    } else {

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

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

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

    } else {

	WriteRegOp(adapter, 0x208, 1, 0, 0x00000004);