void vDisableHDCP(u8 fgDisableHdcp)
{
MT8193_HDCP_FUNC();
if(fgDisableHdcp)
{
vHDCPReset();
if(fgDisableHdcp==1)
vMoveHDCPInternalKey(EXTERNAL_KEY);
else if(fgDisableHdcp==2)
vMoveHDCPInternalKey(INTERNAL_NOENCRYPT_KEY);
else if(fgDisableHdcp==3)
vMoveHDCPInternalKey(INTERNAL_ENCRYPT_KEY);
_bHdcpOff = 1;
}
else
{
vSetHDCPState(HDCP_RE_DO_AUTHENTICATION);
vSendHdmiCmd(HDMI_HDCP_PROTOCAL_CMD);
_bHdcpOff = 0;
}
#ifdef MTK_MT8193_HDCP_SUPPORT
_bHdcpOff = 0;
#else
_bHdcpOff = 1;
#endif
}
void vWriteDataHdmiGRL(u8 bAddr, u8 bCount, u8 *bVal)
{
u8 i;
MT8193_HDCP_FUNC();
for (i = 0; i < bCount; i++)
vWriteByteHdmiGRL(bAddr + i * 4, *(bVal + i));
}
void vMoveHDCPInternalKey(HDMI_HDCP_KEY_T key)
{
u8 *pbDramAddr;
u16 i;
MT8193_HDCP_FUNC();
bhdcpkey = key;
pbDramAddr = bHdcpKeyBuff;
for(i = 0; i < 287; i++)
{
if(key==INTERNAL_ENCRYPT_KEY)
{
pbDramAddr[i] = HDCP_ENCRYPT_KEY[i];
}
else if(key==INTERNAL_NOENCRYPT_KEY)
{
pbDramAddr[i] = HDCP_NOENCRYPT_KEY[i];
}
else if(key==EXTERNAL_KEY)
{
pbDramAddr[i] = bHdcpKeyExternalBuff[i];
}
}
}
u8 fgCompareRi(void)
{
u8 bTemp;
u8 bHDCPBuf[4];
MT8193_HDCP_FUNC();
/* Read R0/ Ri from Transmitter */
/* fgI2CDataRead(HDMI_DEV_GRL, GRL_RI_0, HDCP_RI_COUNT, bHDCPBuf+HDCP_RI_COUNT); */
bReadDataHdmiGRL(GRL_RI_0, HDCP_RI_COUNT, &bHDCPBuf[HDCP_RI_COUNT]);
/* Read R0'/ Ri' from Receiver */
fgDDCDataRead(RX_ID, RX_REG_RI, HDCP_RI_COUNT, bHDCPBuf);
MT8193_HDCP_LOG("bHDCPBuf[0]=0x%x,bHDCPBuf[1]=0x%x,bHDCPBuf[2]=0x%x,bHDCPBuf[3]=0x%x\n",
bHDCPBuf[0], bHDCPBuf[1], bHDCPBuf[2], bHDCPBuf[3]);
/* compare R0 and R0' */
for (bTemp = 0; bTemp < HDCP_RI_COUNT; bTemp++) {
if (bHDCPBuf[bTemp] == bHDCPBuf[bTemp + HDCP_RI_COUNT]) {
continue;
} else {
break;
}
}
if (bTemp == HDCP_RI_COUNT) {
return TRUE;
} else {
return FALSE;
}
}
void vHalHDCPReset(void)
{
u8 bTemp;
MT8193_HDCP_FUNC();
if (fgHostKey())
{
bTemp = HDCP_CTL_CP_RSTB | HDCP_CTL_HOST_KEY;
}
else
{
bTemp = HDCP_CTL_CP_RSTB;
}
vWriteByteHdmiGRL(GRL_HDCP_CTL, bTemp);
for(bTemp=0; bTemp<5; bTemp++)
{
udelay(255);
}
bTemp=bReadByteHdmiGRL(GRL_HDCP_CTL);
bTemp &= (~HDCP_CTL_CP_RSTB);
vWriteByteHdmiGRL(GRL_HDCP_CTL, bTemp);
vSetCTL0BeZero(FALSE);
}
void bReadDataHdmiGRL(u8 bAddr, u8 bCount, u8 *bVal)
{
u8 i;
MT8193_HDCP_FUNC();
for (i = 0; i < bCount; i++)
*(bVal + i) = bReadByteHdmiGRL(bAddr + i * 4);
}
void vEnableHashHardwrae(void)
{
u8 bData;
MT8193_HDCP_FUNC();
bData = bReadByteHdmiGRL(GRL_HDCP_CTL);
bData |= HDCP_CTL_SHA_EN;
vWriteByteHdmiGRL(GRL_HDCP_CTL, bData);
}
u8 bReadHdmiIntMask(void)
{
u8 bMask;
MT8193_HDCP_FUNC();
bMask = bReadByteHdmiGRL(GRL_INT_MASK);
return bMask;
}
u8 bReadHDCPStatus(void)
{
u8 bTemp;
MT8193_HDCP_FUNC();
bTemp = bReadByteHdmiGRL(GRL_HDCP_STA);
return bTemp;
}
u8 fgIsHDCPCtrlTimeOut(void)
{
MT8193_HDCP_FUNC();
if (mt8193_TmrValue[HDMI_HDCP_PROTOCAL_CMD] <= 0)
return TRUE;
else
return FALSE;
}
void vStopAn(void)
{
u8 bTemp;
MT8193_HDCP_FUNC();
bTemp = bReadByteHdmiGRL(GRL_HDCP_CTL);
bTemp |= HDCP_CTL_AN_STOP;
vWriteByteHdmiGRL(GRL_HDCP_CTL, bTemp);
}
void vEnableEncrpt(void)
{
u8 bTemp;
MT8193_HDCP_FUNC();
bTemp = bReadByteHdmiGRL(GRL_HDCP_CTL);
bTemp |= HDCP_CTL_ENC_EN;
vWriteByteHdmiGRL(GRL_HDCP_CTL, bTemp);
}
u8 fgHostKey(void)
{
u8 bTemp;
MT8193_HDCP_FUNC();
bTemp = bReadByteHdmiGRL(GRL_HDCP_CTL);
vWriteByteHdmiGRL(GRL_HDCP_CTL, bTemp | HDCP_CTL_HOST_KEY);
return TRUE;
}
void vHalWriteHashPort(u8 *prHashVBuff)
{
u8 bIndex;
MT8193_HDCP_FUNC();
for (bIndex = 0; bIndex < 20; bIndex++) {
vWriteByteHdmiGRL(GRL_REPEATER_HASH + bIndex * 4, *(prHashVBuff + bIndex));
}
}
void vReadKSVFIFO(void)
{
u8 bTemp, bIndex, bDevice_Count; /* , bBlock; */
u8 bStatus[2], bBstatus1;
MT8193_HDCP_FUNC();
fgDDCDataRead(RX_ID, RX_REG_BSTATUS1 + 1, 1, &bBstatus1);
fgDDCDataRead(RX_ID, RX_REG_BSTATUS1, 1, &bDevice_Count);
bDevice_Count &= DEVICE_COUNT_MASK;
if ((bDevice_Count & MAX_DEVS_EXCEEDED) || (bBstatus1 & MAX_CASCADE_EXCEEDED)) {
vSetHDCPState(HDCP_RE_DO_AUTHENTICATION);
vSendHdmiCmd(HDMI_HDCP_PROTOCAL_CMD);
return;
}
if (bDevice_Count > 32) {
for (bTemp = 0; bTemp < 2; bTemp++) /* retry 1 times */
{
fgDDCDataRead(RX_ID, RX_REG_BSTATUS1, 1, &bDevice_Count);
bDevice_Count &= DEVICE_COUNT_MASK;
if (bDevice_Count <= 32)
break;
}
if (bTemp == 2) {
bDevice_Count = 32;
}
}
vSetSharedInfo(SI_REPEATER_DEVICE_COUNT, bDevice_Count);
if (bDevice_Count == 0) {
for (bIndex = 0; bIndex < 5; bIndex++)
bKsv_buff[bIndex] = 0;
for (bIndex = 0; bIndex < 2; bIndex++)
bStatus[bIndex] = 0;
for (bIndex = 0; bIndex < 20; bIndex++)
bSHABuff[bIndex] = 0;
} else {
fgDDCDataRead(RX_ID, RX_REG_KSV_FIFO, bDevice_Count * 5, bKsv_buff);
}
fgDDCDataRead(RX_ID, RX_REG_BSTATUS1, 2, bStatus);
fgDDCDataRead(RX_ID, RX_REG_REPEATER_V, 20, bSHABuff);
if ((bDevice_Count * 5) < KSV_BUFF_SIZE)
vHalWriteKsvListPort(bKsv_buff, bDevice_Count, bStatus);
vHalWriteHashPort(bSHABuff);
vEnableHashHardwrae();
vSetHDCPState(HDCP_COMPARE_V);
/* set time-out value as 0.5 sec */
vSetHDCPTimeOut(HDCP_WAIT_V_RDY_TIMEOUE);
}
void vShowHdcpRawData(void)
{
u16 bTemp, i, j, k;
MT8193_HDCP_FUNC();
pr_debug("==============================hdcpkey==============================\n");
pr_debug(" | 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n");
pr_debug("===================================================================\n");
for (bTemp = 0; bTemp < 3; bTemp++) {
j = bTemp * 128;
for (i = 0; i < 8; i++) {
if (((i * 16) + j) < 0x10)
pr_debug("0%x: ", (i * 16) + j);
else
pr_debug("%x: ", (i * 16) + j);
for (k = 0; k < 16; k++) {
if (k == 15) {
if ((j + (i * 16 + k)) < 287) /* for Buffer overflow error */
{
if (bHdcpKeyExternalBuff[j + (i * 16 + k)] > 0x0f)
pr_debug("%2x\n",
bHdcpKeyExternalBuff[j +
(i * 16 +
k)]);
else
pr_debug("0%x\n",
bHdcpKeyExternalBuff[j +
(i * 16 +
k)]);
}
} else {
if ((j + (i * 16 + k)) < 287) /* for Buffer overflow error */
{
if (bHdcpKeyExternalBuff[j + (i * 16 + k)] > 0x0f)
pr_debug("%2x ",
bHdcpKeyExternalBuff[j +
(i * 16 +
k)]);
else
pr_debug("0%x ",
bHdcpKeyExternalBuff[j +
(i * 16 +
k)]);
} else {
pr_debug("\n");
pr_debug
("===================================================================\n");
return;
}
}
}
}
}
}
void vHDCPReset(void)
{
u8 bMask;
MT8193_HDCP_FUNC();
bMask = bReadHdmiIntMask();
vWriteHdmiIntMask((bMask|0xfe));//disable INT HDCP
vHalHDCPReset();
vSetHDCPState(HDCP_RECEIVER_NOT_READY);
}
void vEnableAuthHardware(void)
{
u8 bTemp;
MT8193_HDCP_FUNC();
bTemp = bReadByteHdmiGRL(GRL_HDCP_CTL);
bTemp |= HDCP_CTL_AUTHEN_EN;
vWriteByteHdmiGRL(GRL_HDCP_CTL, bTemp);
}
void vReadAksvFromReg(BYTE *PrBuff)
{
u8 bTemp, i;
MT8193_HDCP_FUNC();
for (i = 0; i < 5; i++) /* AKSV count 5 bytes */
{
bTemp = bReadByteHdmiGRL(GRL_RD_AKSV0 + i * 4);
*(PrBuff + i) = bTemp;
}
}
void vHDCPReset(void)
{
u8 bMask;
MT8193_HDCP_FUNC();
bMask = bReadHdmiIntMask();
vWriteHdmiIntMask(0xff); /* disable INT HDCP */
vHalHDCPReset();
vSetHDCPState(HDCP_RECEIVER_NOT_READY);
vSendHdmiCmd(HDMI_HDCP_PROTOCAL_CMD);
}
void mt8193_hdcpkey(u8 *pbhdcpkey)
{
u16 i;
MT8193_HDCP_FUNC();
for(i = 0; i < 287; i++)
{
bHdcpKeyExternalBuff[i] = *pbhdcpkey++;
}
}
void vSendAKey(u8 *prAKey)
{
u8 bData;
u16 ui2Index;
MT8193_HDCP_FUNC();
for(ui2Index=0; ui2Index<280; ui2Index++)
{
// get key from flash
bData = *(prAKey+ui2Index);
vHalSendAKey(bData);
}
}
void vWriteAksvKeyMask(u8 *PrData)
{
u8 bData;
/* - write wIdx into 92. */
MT8193_HDCP_FUNC();
bData = (*(PrData + 2) & 0x0f) | ((*(PrData + 3) & 0x0f) << 4);
vWriteHdmiSYSMsk(HDMI_SYS_CFG1C, (bData << 16), SYS_KEYMASK2);
bData = (*(PrData + 0) & 0x0f) | ((*(PrData + 1) & 0x0f) << 4);
vWriteHdmiSYSMsk(HDMI_SYS_CFG1C, (bData << 8), SYS_KEYMASK1);
}
void mt8193_hdcpkey(u8 *pbhdcpkey)
{
u16 i;
MT8193_HDCP_FUNC();
for (i = 0; i < 287; i++) {
bHdcpKeyExternalBuff[i] = *pbhdcpkey++;
}
vMoveHDCPInternalKey(EXTERNAL_KEY);
}
void vInitHdcpKeyGetMethod(u8 bMethod)
{
MT8193_HDCP_FUNC();
if (bMethod == NON_HOST_ACCESS_FROM_EEPROM) {
vWriteHdmiSYSMsk(HDMI_SYS_CFG1C, (I2CM_ON | EXT_E2PROM_ON),
(I2CM_ON | EXT_E2PROM_ON));
} else if (bMethod == NON_HOST_ACCESS_FROM_MCM) {
vWriteHdmiSYSMsk(HDMI_SYS_CFG1C, (I2CM_ON | MCM_E2PROM_ON),
(I2CM_ON | MCM_E2PROM_ON));
} else if (bMethod == NON_HOST_ACCESS_FROM_GCPU) {
vWriteHdmiSYSMsk(HDMI_SYS_CFG1C, AES_EFUSE_ENABLE,
(AES_EFUSE_ENABLE | I2CM_ON | EXT_E2PROM_ON | MCM_E2PROM_ON));
}
}
u8 bCheckHDCPStatus(u8 bMode)
{
u8 bStatus = 0;
MT8193_HDCP_FUNC();
bStatus = bReadByteHdmiGRL(GRL_HDCP_STA);
bStatus &= bMode;
if (bStatus) {
vWriteByteHdmiGRL(GRL_HDCP_STA, bMode);
return TRUE;
} else {
return FALSE;
}
}
void vHalWriteKsvListPort(u8 *prKsvData, u8 bDevice_Count, u8 *prBstatus)
{
u8 bIndex;
MT8193_HDCP_FUNC();
if ((bDevice_Count * 5) < KSV_BUFF_SIZE) {
for (bIndex = 0; bIndex < (bDevice_Count * 5); bIndex++) {
vWriteByteHdmiGRL(GRL_KSVLIST, *(prKsvData + bIndex));
}
for (bIndex = 0; bIndex < 2; bIndex++) {
vWriteByteHdmiGRL(GRL_KSVLIST, *(prBstatus + bIndex));
}
}
}
void vMiAnUpdateOrFix(u8 bUpdate)
{
u8 bTemp;
MT8193_HDCP_FUNC();
if (bUpdate == TRUE) {
bTemp = bReadByteHdmiGRL(GRL_CFG1);
bTemp |= CFG1_HDCP_DEBUG;
vWriteByteHdmiGRL(GRL_CFG1, bTemp);
} else {
bTemp = bReadByteHdmiGRL(GRL_CFG1);
bTemp &= ~CFG1_HDCP_DEBUG;
vWriteByteHdmiGRL(GRL_CFG1, bTemp);
}
}
void vRepeaterOnOff(u8 fgIsRep)
{
u8 bTemp;
MT8193_HDCP_FUNC();
bTemp = bReadByteHdmiGRL(GRL_HDCP_CTL);
if (fgIsRep == TRUE) {
bTemp |= HDCP_CTRL_RX_RPTR;
} else {
bTemp &= ~HDCP_CTRL_RX_RPTR;
}
vWriteByteHdmiGRL(GRL_HDCP_CTL, bTemp);
}
void vSendAKey(u8 *prAKey)
{
u8 bData;
u16 ui2Index;
MT8193_HDCP_FUNC();
for (ui2Index = 0; ui2Index < 280; ui2Index++) {
/* get key from flash */
if ((ui2Index == 5) && (bCheckPordHotPlug(PORD_MODE | HOTPLUG_MODE) == FALSE)) {
vSetHDCPState(HDCP_RECEIVER_NOT_READY);
return;
}
bData = *(prAKey + ui2Index);
vHalSendAKey(bData);
}
}
