/***************************************************************************
 *     Copyright (c) 2002-2010, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile: bhdcplib_keyloader.c $
 * $brcm_Revision: Hydra_Software_Devel/9 $
 * $brcm_Date: 7/6/10 4:24p $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log: /magnum/syslib/hdcplib/7468/bhdcplib_keyloader.c $
 * 
 * Hydra_Software_Devel/9   7/6/10 4:24p vle
 * SW7420-874: Update print out message indicating which version of
 * hdcplib keyloader is being used.
 * 
 * Hydra_Software_Devel/8   7/2/10 5:54p vle
 * SW7420-874: 7410 shares the same HSM code base as 7420 B0
 * 
 * Hydra_Software_Devel/7   6/3/10 6:31p vle
 * SW7550-452: Update hdcplib keyloader as latest 7550 HSM code has
 * changed.
 * 
 * Hydra_Software_Devel/6   1/18/10 4:59p vle
 * SW7550-102: Add new HDCP keyloader routine for 7550/7408.
 * 
 * Hydra_Software_Devel/5   12/9/09 1:56a vle
 * SW7468-18: Add HDCPLIB support for 7468, 7408, 7208 and 7550
 * 
 * Hydra_Software_Devel/4   11/6/09 11:12a vle
 * SW7125-68: uses new keyloading process for new HSM
 * 
 * Hydra_Software_Devel/3   4/10/09 4:41p vle
 * PR47665: Update hdcplib keyloader routine to use new HSM PI
 * 
 * Hydra_Software_Devel/2   3/18/08 7:18p vle
 * PR 39991: Rename HDMIlib to HDCPlib. Remove unused implementation.
 * 
 * Hydra_Software_Devel/1   2/26/08 5:43p jgarrett
 * PR 39991: Renaming new HDMlib to HDCPlib
 * 
 * Hydra_Software_Devel/Syslib_Initiative/3   2/21/08 5:01p vle
 * PR 31924: Update to use the update BHDCPlib
 * 
 * Hydra_Software_Devel/Syslib_Initiative/2   2/15/08 10:03p vle
 * PR 31924: Update to use the improved HDMI Syslib
 * 
 * Hydra_Software_Devel/Syslib_Initiative/1   1/31/08 10:36p vle
 * PR 31924: Add implementation of BHDCPLIB_FastLoadEncryptedHdcpKeys
 * 
 ***************************************************************************/

#include "bstd.h"
#include "bkni.h"
#include "bhdcplib_keyloader.h"

#if (CONFIG_ENABLE_SCM==1)

#include "brap_scm_interface.h"
#include "brap_scm.h"
#include "gist.h"

#define SCM_CMD_SIZE	0x300
#define SCM_RSP_SIZE	0x500

static uint32_t *scm_hdcp_cmdb = NULL;
static uint32_t *scm_hdcp_rspb = NULL;
static BRAP_SCM_CmdPayload scm_hdcp_txfr;
int scm_send_command(BRAP_SCM_CmdPayload *txfr);

#else
#include "bhsm.h"
#include "bhsm_keyladder.h"
#include "bhsm_keyladder_enc.h"
#endif

BDBG_MODULE(BHDCPLIB_KEYLOADER) ;

#if ((BCHP_CHIP == 7550) || (BCHP_CHIP == 7408))
BERR_Code BHDCPlib_FastLoadEncryptedHdcpKeys(
	BHDCPlib_Handle hHDCPlib)
{

	unsigned int i;
	BHDCPlib_EncryptedHdcpKeyStruct * EncryptedHdcpKeys;

#if (CONFIG_ENABLE_SCM==1)
	BSCM_hdcp_key_message *scm_hdcp_msg;
	BSCM_command *scm_cmd;

	BDBG_ASSERT(hHDCPlib);

	BDBG_ERR(("Version 20110712 - HDCPlib keyloader for 97550 SCM")) ; 
	if (scm_hdcp_cmdb == NULL) {
		scm_hdcp_cmdb = BMEM_Heap_AllocAligned(GetHEAP(), SCM_CMD_SIZE, 2, 0);
	}
	if (scm_hdcp_rspb == NULL) {
		scm_hdcp_rspb = BMEM_Heap_AllocAligned(GetHEAP(), SCM_RSP_SIZE, 2, 0);
	}

	EncryptedHdcpKeys = (BHDCPlib_EncryptedHdcpKeyStruct *) &hHDCPlib->stHdcpConfiguration.TxKeySet.TxKeyStructure;

	for (i=0; i<BAVC_HDMI_HDCP_N_PRIVATE_KEYS; i++) 
	{
		if (!(hHDCPlib->stHdcpConfiguration.RxInfo.RxBksv[i/8]&(1<<(i%8))))
			continue;

		scm_cmd = (BSCM_command *)scm_hdcp_cmdb;
		scm_cmd->type = BSCM_P_eSCMCmdType_eHDCPKey;
		scm_hdcp_msg = (BSCM_hdcp_key_message *)scm_cmd->payload;
		BKNI_Memset(scm_hdcp_msg, 0, sizeof(BSCM_hdcp_key_message));
		scm_hdcp_msg->keyslot_number = i;
		scm_hdcp_msg->cus_key = EncryptedHdcpKeys[i].cusKeySel;
		scm_hdcp_msg->key_var = EncryptedHdcpKeys[i].cusKeyVarL;
		
		scm_hdcp_msg->ca_data[0] = EncryptedHdcpKeys[i].TCaDataHi;
		scm_hdcp_msg->ca_data[1] = EncryptedHdcpKeys[i].TCaDataLo;
		scm_hdcp_msg->ca_data[2] = EncryptedHdcpKeys[i].CaDataHi;
		scm_hdcp_msg->ca_data[3] = EncryptedHdcpKeys[i].CaDataLo;
		scm_hdcp_msg->hdcp_key[0] = EncryptedHdcpKeys[i].HdcpKeyHi;
		scm_hdcp_msg->hdcp_key[1] = EncryptedHdcpKeys[i].HdcpKeyLo;

		scm_hdcp_txfr.ui32DramCmdBufAddress = (uint32_t)scm_hdcp_cmdb;
		scm_hdcp_txfr.ui32DramCmdBufSize = sizeof(BSCM_hdcp_key_message)+4;
		scm_hdcp_txfr.ui32DramRespBufAddress = (uint32_t)scm_hdcp_rspb;
		scm_hdcp_txfr.ui32DramRespBufSize = 4;

		scm_hdcp_rspb[0] = 0xFFFFFFFF;
		if (scm_send_command(&scm_hdcp_txfr) != 0) 
		{
			BDBG_ERR(("Fail on scm_send_command BSCM_P_eSCMCmdType_eHDCPkey"));
		}
	}
	return BERR_SUCCESS;
#else
	BERR_Code errCode = BERR_SUCCESS;
	uint32_t KeyParameter ;
	BHSM_GenerateKey2IO_t		generateKey2IO;
	BHSM_GenerateKeyXIO_t		generateKeyXIO;
	BHSM_GenerateHDMIKeyIO_t     generateHDMIKeyIO;
	
	
	BDBG_ASSERT(hHDCPlib) ;
	
	BDBG_ERR(("Version 20090403 - HDCPlib keyloader for 97550/97408")) ; 
	
	EncryptedHdcpKeys = (BHDCPlib_EncryptedHdcpKeyStruct *) &hHDCPlib->stHdcpConfiguration.TxKeySet.TxKeyStructure;
	
	BKNI_Memset( &generateKey2IO, 0, sizeof(BHSM_GenerateKey2IO_t))  ;	
	BKNI_Memset( &generateKeyXIO, 0, sizeof(BHSM_GenerateKeyXIO_t));
	BKNI_Memset( &generateHDMIKeyIO, 0, sizeof(BHSM_GenerateHDMIKeyIO_t));
	
	for (i =0; i< BAVC_HDMI_HDCP_N_PRIVATE_KEYS; i++)
	{
		if (!(hHDCPlib->stHdcpConfiguration.RxInfo.RxBksv[i / 8] & (1 << (i % 8))))
			continue ;
/*
		generateKey2IO.bOTPkey = false;
*/
		generateKey2IO.eKey2Source = BHSM_Key2Source_eCustKey;
		generateKey2IO.eOperation = BHSM_Operation_eCP ; 
		generateKey2IO.unCustKey = EncryptedHdcpKeys[i].cusKeySel ;
		generateKey2IO.unKeyVar = EncryptedHdcpKeys[i].cusKeyVarL ;
		BKNI_Memset(generateKey2IO.procIn, 0, 16);
		BDBG_MSG(("generateKey2IO.unCustKey = %x generateKey2IO.unKeyVar = %x\n",generateKey2IO.unCustKey, generateKey2IO.unKeyVar));
		errCode=  BHSM_GenerateKey2 (hHDCPlib->stDependencies.hHsm, &generateKey2IO);

		if (errCode != 0) 
		{
			BDBG_ERR(("BHSM_GenerateKey2 key2 errCode: %x\n", errCode ));
			goto done;
		}

		/* generate Key3 from key 2*/
		generateKeyXIO.eOperation = BHSM_Operation_eCP;
		generateKeyXIO.eKeyDest = BHSM_KeyBuffer_eKey3 ;	
		BKNI_Memset(generateKeyXIO.procIn, 0, 16);
		KeyParameter = EncryptedHdcpKeys[i].TCaDataHi;
		BDBG_MSG(("EncryptedHdcpKeys[i].TCaDataHi = %x\n",KeyParameter));
		generateKeyXIO.procIn[0]  =  (KeyParameter >> 24) & 0xff ;
		generateKeyXIO.procIn[1]  =  (KeyParameter >> 16) & 0xff ;
		generateKeyXIO.procIn[2]  =  (KeyParameter >> 8) & 0xff ;
		generateKeyXIO.procIn[3]  =  (KeyParameter) & 0xff ;

		KeyParameter = EncryptedHdcpKeys[i].TCaDataLo;
		BDBG_MSG(("EncryptedHdcpKeys[i].TCaDataLo = %x\n",KeyParameter));
		generateKeyXIO.procIn[4]  =  (KeyParameter >> 24) & 0xff ;
		generateKeyXIO.procIn[5]  =  (KeyParameter >> 16) & 0xff ;
		generateKeyXIO.procIn[6]  =  (KeyParameter >> 8) & 0xff ;
		generateKeyXIO.procIn[7]  =  (KeyParameter) & 0xff ;					

		KeyParameter = EncryptedHdcpKeys[i].CaDataHi;
		BDBG_MSG(("EncryptedHdcpKeys[i].CaDataHi = %x\n",KeyParameter));
		generateKeyXIO.procIn[8]  =  (KeyParameter >> 24) & 0xff ;
		generateKeyXIO.procIn[9]  =  (KeyParameter >> 16) & 0xff ;
		generateKeyXIO.procIn[10]  =  (KeyParameter >> 8) & 0xff ;
		generateKeyXIO.procIn[11]  =  (KeyParameter) & 0xff ;

		KeyParameter = EncryptedHdcpKeys[i].CaDataLo;
		BDBG_MSG(("EncryptedHdcpKeys[i].CaDataLo = %x\n",KeyParameter));
		generateKeyXIO.procIn[12]  =  (KeyParameter >> 24) & 0xff ;
		generateKeyXIO.procIn[13]  =  (KeyParameter >> 16) & 0xff ;
		generateKeyXIO.procIn[14]  =  (KeyParameter >> 8) & 0xff ;
		generateKeyXIO.procIn[15]  =  (KeyParameter) & 0xff ;					

		errCode=  BHSM_GenerateKeyX (hHDCPlib->stDependencies.hHsm, &generateKeyXIO);
		if (errCode != 0) 
		{
			BDBG_ERR(("BHSM_GenerateKeyX key3 errCode: %x\n", errCode ));
			goto done;
		}	

		/* generate Key4(HDCP key) from key 3*/
		BKNI_Memset(&generateHDMIKeyIO.procIn, 0, sizeof(generateHDMIKeyIO.procIn));				
		KeyParameter = EncryptedHdcpKeys[i].HdcpKeyHi;
		BDBG_MSG(("EncryptedHdcpKeys[i].HdcpKeyHi = %x\n",KeyParameter));
		generateHDMIKeyIO.procIn[0]  =  (KeyParameter >> 24) & 0xff ;
		generateHDMIKeyIO.procIn[1]  =  (KeyParameter >> 16) & 0xff ;
		generateHDMIKeyIO.procIn[2]  =  (KeyParameter >> 8) & 0xff ;
		generateHDMIKeyIO.procIn[3]  =  (KeyParameter) & 0xff ;

		KeyParameter = EncryptedHdcpKeys[i].HdcpKeyLo;
		BDBG_MSG(("EncryptedHdcpKeys[i].HdcpKeyLo = %x\n",KeyParameter));
		generateHDMIKeyIO.procIn[4]  =  (KeyParameter >> 24) & 0xff ;
		generateHDMIKeyIO.procIn[5]  =  (KeyParameter >> 16) & 0xff ;
		generateHDMIKeyIO.procIn[6]  =  (KeyParameter >> 8) & 0xff ;
		generateHDMIKeyIO.procIn[7]  =  (KeyParameter) & 0xff ;					

		generateHDMIKeyIO.keySlot = i ;

		errCode= BHSM_GenerateHDMIKey (hHDCPlib->stDependencies.hHsm, &generateHDMIKeyIO) ;	
		if (errCode != 0) 
		{
			BDBG_ERR(("BHSM_GenerateHDMIKey key4 errCode: %x\n", errCode ));
			goto done;
		}	
	}
done:
	return( errCode );
#endif	
}

#elif ((BCHP_CHIP == 7125) || (BCHP_CHIP == 7340) || (BCHP_CHIP == 7342) \
	|| ((BCHP_CHIP == 7420) && (BCHP_VER >= BCHP_VER_A1)) \
	|| (BCHP_CHIP == 7468) || (BCHP_CHIP == 7208) || (BCHP_CHIP == 7410))

BERR_Code BHDCPlib_FastLoadEncryptedHdcpKeys(
	BHDCPlib_Handle hHDCPlib)
{
	BERR_Code errCode = BERR_SUCCESS;
#if DEBUG_PROCOUT	
	BHSM_ProcOutCmdIO_t	procOutCmdIO;	
#endif
	BHSM_GenerateRouteKeyIO_t		generateRouteKeyIO;
	BHSM_ConfigKeySlotIDDataIO_t	configKeySlotIDDataIO;
	
	unsigned int i;
	uint32_t KeyParameter ;
	BHDCPlib_EncryptedHdcpKeyStruct * EncryptedHdcpKeys;
	
	BDBG_ASSERT(hHDCPlib) ;

	BDBG_ERR(("Version 20090403 - HDCPlib keyloader for 97125/97420/97410/97340/97342/97468/97208")) ; 


	/* Get HDCP Encrypted Keys */
	EncryptedHdcpKeys = (BHDCPlib_EncryptedHdcpKeyStruct *) &hHDCPlib->stHdcpConfiguration.TxKeySet.TxKeyStructure;

	BKNI_Memset( &generateRouteKeyIO, 0, sizeof(BHSM_GenerateRouteKeyIO_t))  ;	
	BKNI_Memset( &configKeySlotIDDataIO, 0, sizeof(BHSM_ConfigKeySlotIDDataIO_t));

	for (i =0; i< BAVC_HDMI_HDCP_N_PRIVATE_KEYS; i++)
	{
		if (!(hHDCPlib->stHdcpConfiguration.RxInfo.RxBksv[i / 8] & (1 << (i % 8))))
			continue ;

		/* Call BHSM_configKeySlotIDData() to set up ID part of  configuration odd key */
		configKeySlotIDDataIO.keyDestBlckType  = BCMD_KeyDestBlockType_eCA;
		configKeySlotIDDataIO.keyDestEntryType = BCMD_KeyDestEntryType_eOddKey;
		configKeySlotIDDataIO.unKeySlotNum	  = i;
		configKeySlotIDDataIO.caKeySlotType    = BCMD_XptSecKeySlot_eType0;
		configKeySlotIDDataIO.CAVendorID	= 0x1234;
		configKeySlotIDDataIO.STBOwnerIDSelect = BCMD_STBOwnerID_eOTPVal;
		configKeySlotIDDataIO.ModuleID	   = BCMD_ModuleID_eModuleID_3;
		configKeySlotIDDataIO.TestKey2Select   = 0;

		errCode = BHSM_ConfigKeySlotIDData(hHDCPlib->stDependencies.hHsm, &configKeySlotIDDataIO); 
		if (errCode != 0) 
		{
			BDBG_ERR(("BHSM_ConfigKeySlotIDData errCode: %x\n", errCode));
			goto done;
		} 

		/* generate Key3 from custom key */
		generateRouteKeyIO.keyLadderType = EncryptedHdcpKeys[i].Alg;
		
		generateRouteKeyIO.rootKeySrc =  BCMD_RootKeySrc_eCusKey; 
		generateRouteKeyIO.customerSubMode = BCMD_CustomerSubMode_eGeneralPurpose1;
		generateRouteKeyIO.ucSwizzle1Index = 0;
		generateRouteKeyIO.swizzleType = BCMD_SwizzleType_eSwizzle0;
		
		generateRouteKeyIO.bUseCustKeyLowDecrypt =  false ;
		generateRouteKeyIO.ucCustKeyLow = EncryptedHdcpKeys[i].cusKeySel;	 
		generateRouteKeyIO.ucKeyVarLow = EncryptedHdcpKeys[i].cusKeyVarL;	
		
		generateRouteKeyIO.bUseCustKeyHighDecrypt = false ;
		generateRouteKeyIO.ucCustKeyHigh = EncryptedHdcpKeys[i].cusKeySel;  
		generateRouteKeyIO.ucKeyVarHigh = EncryptedHdcpKeys[i].cusKeyVarH;	

		generateRouteKeyIO.virtualKeyLadderID = BCMD_VKL0;
		generateRouteKeyIO.keyLayer = BCMD_KeyRamBuf_eKey3 ;
		generateRouteKeyIO.bIs3DESDecrypt = false ;	/* true - encryption, false - decryption */

		generateRouteKeyIO.keyLadderType = BCMD_KeyLadderType_e3DESABA;
		
		generateRouteKeyIO.keySize= BCMD_KeySize_e64;
		generateRouteKeyIO.ucKeyDataLen = 8 ;
		
		BKNI_Memset(&generateRouteKeyIO.aucKeyData, 0, sizeof(generateRouteKeyIO.aucKeyData));				
		KeyParameter = EncryptedHdcpKeys[i].HdcpKeyHi;
		generateRouteKeyIO.aucKeyData[0]  =  (KeyParameter >> 24) & 0xff ;
		generateRouteKeyIO.aucKeyData[1]  =  (KeyParameter >> 16) & 0xff ;
		generateRouteKeyIO.aucKeyData[2]  =  (KeyParameter >>   8) & 0xff ;
		generateRouteKeyIO.aucKeyData[3]  =  (KeyParameter)           & 0xff ;
		
		KeyParameter = EncryptedHdcpKeys[i].HdcpKeyLo;
		generateRouteKeyIO.aucKeyData[4]  =  (KeyParameter >> 24) & 0xff ;
		generateRouteKeyIO.aucKeyData[5]  =  (KeyParameter >> 16) & 0xff ;
		generateRouteKeyIO.aucKeyData[6]  =  (KeyParameter >>  8) & 0xff ;
		generateRouteKeyIO.aucKeyData[7]  =  (KeyParameter)           & 0xff ;					
			
		generateRouteKeyIO.bIsRouteKeyRequired = true;
		generateRouteKeyIO.keyDestBlckType = BCMD_KeyDestBlockType_eHdmi;

		generateRouteKeyIO.keyDestEntryType = BCMD_KeyDestEntryType_eOddKey;	

		generateRouteKeyIO.caKeySlotType = BCMD_XptSecKeySlot_eType0 ;
		generateRouteKeyIO.keyMode = BCMD_KeyMode_eRegular;

		generateRouteKeyIO.unKeySlotNum =   i ; 
		errCode= BHSM_GenerateRouteKey (hHDCPlib->stDependencies.hHsm, &generateRouteKeyIO) ;	
		BDBG_MSG(("generateRouteKeyIO key 3 unStatus = 0x%08X\n", generateRouteKeyIO.unStatus)) ;
		if (errCode != 0) 
		{
			BDBG_ERR(("BHSM_GenerateRouteKey key3 errCode: %x\n", errCode ));
			goto done;
		}	
	}

done:
	return( errCode );
}


#else

BERR_Code BHDCPlib_FastLoadEncryptedHdcpKeys(
	BHDCPlib_Handle hHDCPlib)
{
	BERR_Code errCode = BERR_SUCCESS;
#if DEBUG_PROCOUT	
	BHSM_ProcOutCmdIO_t	procOutCmdIO;	
#endif
	BHSM_GenerateRouteKeyIO_t		generateRouteKeyIO;
	
	unsigned int i;
	uint32_t KeyParameter ;
	BHDCPlib_EncryptedHdcpKeyStruct * EncryptedHdcpKeys;
	
	BDBG_ASSERT(hHDCPlib) ;

	BDBG_MSG(("Version 20080114")) ; 


	/* Get HDCP Encrypted Keys */
	EncryptedHdcpKeys = (BHDCPlib_EncryptedHdcpKeyStruct *) &hHDCPlib->stHdcpConfiguration.TxKeySet.TxKeyStructure;

	BKNI_Memset( &generateRouteKeyIO, 0, sizeof(BHSM_GenerateRouteKeyIO_t))  ;	

	for (i =0; i< BAVC_HDMI_HDCP_N_PRIVATE_KEYS; i++)
	{
		if (!(hHDCPlib->stHdcpConfiguration.RxInfo.RxBksv[i / 8] & (1 << (i % 8))))
			continue ;

		/* generate Key3 from custom key */
		generateRouteKeyIO.keyLadderType = EncryptedHdcpKeys[i].Alg;
		
		generateRouteKeyIO.rootKeySrc =  BCMD_RootKeySrc_eCusKey; 
		generateRouteKeyIO.ucSwizzle1Index = 0;
		generateRouteKeyIO.swizzleType = BCMD_SwizzleType_eSwizzle0;
		
		generateRouteKeyIO.bUseCustKeyLowDecrypt =  false ;
		generateRouteKeyIO.ucCustKeyLow = EncryptedHdcpKeys[i].cusKeySel;	 
		generateRouteKeyIO.ucKeyVarLow = EncryptedHdcpKeys[i].cusKeyVarL;	
		
		generateRouteKeyIO.bUseCustKeyHighDecrypt = false ;
		generateRouteKeyIO.ucCustKeyHigh = EncryptedHdcpKeys[i].cusKeySel;  
		generateRouteKeyIO.ucKeyVarHigh = EncryptedHdcpKeys[i].cusKeyVarH;	

		generateRouteKeyIO.keyDest= BCMD_KeyRamBuf_eKey3KeyLadder3 ;
		generateRouteKeyIO.bIs3DESDecrypt = false ;	/* true - encryption, false - decryption */

		generateRouteKeyIO.keyLadderType = BCMD_KeyLadderType_e3DESABA;
		

		generateRouteKeyIO.keySize= BCMD_KeySize_e64;
		generateRouteKeyIO.ucKeyDataLen = 8 ;
		
		BKNI_Memset(&generateRouteKeyIO.aucKeyData, 0, sizeof(generateRouteKeyIO.aucKeyData));				
		KeyParameter = EncryptedHdcpKeys[i].HdcpKeyHi;
		generateRouteKeyIO.aucKeyData[0]  =  (KeyParameter >> 24) & 0xff ;
		generateRouteKeyIO.aucKeyData[1]  =  (KeyParameter >> 16) & 0xff ;
		generateRouteKeyIO.aucKeyData[2]  =  (KeyParameter >>   8) & 0xff ;
		generateRouteKeyIO.aucKeyData[3]  =  (KeyParameter)           & 0xff ;
		
		KeyParameter = EncryptedHdcpKeys[i].HdcpKeyLo;
		generateRouteKeyIO.aucKeyData[4]  =  (KeyParameter >> 24) & 0xff ;
		generateRouteKeyIO.aucKeyData[5]  =  (KeyParameter >> 16) & 0xff ;
		generateRouteKeyIO.aucKeyData[6]  =  (KeyParameter >>  8) & 0xff ;
		generateRouteKeyIO.aucKeyData[7]  =  (KeyParameter)           & 0xff ;					
			
		generateRouteKeyIO.bIsRouteKeyRequired = true;
		generateRouteKeyIO.keyDestBlckType = BCMD_KeyDestBlockType_eHdmi;

		generateRouteKeyIO.keyDestEntryType = BCMD_KeyDestEntryType_eOddKey;	

		generateRouteKeyIO.caKeySlotType = BCMD_XptSecKeySlot_eType0 ;

		generateRouteKeyIO.unKeySlotNum =   i ; 
		errCode= BHSM_GenerateRouteKey (hHDCPlib->stDependencies.hHsm, &generateRouteKeyIO) ;	
		BDBG_MSG(("generateRouteKeyIO unStatus = 0x%08X\n", generateRouteKeyIO.unStatus)) ;
		if (errCode != 0) 
		{
			BDBG_ERR(("BHSM_GenerateRouteKey errCode: %x\n", errCode ));
			return errCode;
		}	
	}

	return( errCode );
}

#endif