source: svn/trunk/newcon3bcm2_21bu/dta/src/hdcplib/bhdcplib_keyloader.c @ 2

Last change on this file since 2 was 2, checked in by phkim, 11 years ago

1.phkim

  1. revision copy newcon3sk r27
  • Property svn:executable set to *
File size: 16.3 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2002-2010, Broadcom Corporation
3 *     All Rights Reserved
4 *     Confidential Property of Broadcom Corporation
5 *
6 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
8 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9 *
10 * $brcm_Workfile: bhdcplib_keyloader.c $
11 * $brcm_Revision: Hydra_Software_Devel/9 $
12 * $brcm_Date: 7/6/10 4:24p $
13 *
14 * Module Description:
15 *
16 * Revision History:
17 *
18 * $brcm_Log: /magnum/syslib/hdcplib/7468/bhdcplib_keyloader.c $
19 *
20 * Hydra_Software_Devel/9   7/6/10 4:24p vle
21 * SW7420-874: Update print out message indicating which version of
22 * hdcplib keyloader is being used.
23 *
24 * Hydra_Software_Devel/8   7/2/10 5:54p vle
25 * SW7420-874: 7410 shares the same HSM code base as 7420 B0
26 *
27 * Hydra_Software_Devel/7   6/3/10 6:31p vle
28 * SW7550-452: Update hdcplib keyloader as latest 7550 HSM code has
29 * changed.
30 *
31 * Hydra_Software_Devel/6   1/18/10 4:59p vle
32 * SW7550-102: Add new HDCP keyloader routine for 7550/7408.
33 *
34 * Hydra_Software_Devel/5   12/9/09 1:56a vle
35 * SW7468-18: Add HDCPLIB support for 7468, 7408, 7208 and 7550
36 *
37 * Hydra_Software_Devel/4   11/6/09 11:12a vle
38 * SW7125-68: uses new keyloading process for new HSM
39 *
40 * Hydra_Software_Devel/3   4/10/09 4:41p vle
41 * PR47665: Update hdcplib keyloader routine to use new HSM PI
42 *
43 * Hydra_Software_Devel/2   3/18/08 7:18p vle
44 * PR 39991: Rename HDMIlib to HDCPlib. Remove unused implementation.
45 *
46 * Hydra_Software_Devel/1   2/26/08 5:43p jgarrett
47 * PR 39991: Renaming new HDMlib to HDCPlib
48 *
49 * Hydra_Software_Devel/Syslib_Initiative/3   2/21/08 5:01p vle
50 * PR 31924: Update to use the update BHDCPlib
51 *
52 * Hydra_Software_Devel/Syslib_Initiative/2   2/15/08 10:03p vle
53 * PR 31924: Update to use the improved HDMI Syslib
54 *
55 * Hydra_Software_Devel/Syslib_Initiative/1   1/31/08 10:36p vle
56 * PR 31924: Add implementation of BHDCPLIB_FastLoadEncryptedHdcpKeys
57 *
58 ***************************************************************************/
59
60#include "bstd.h"
61#include "bkni.h"
62#include "bhdcplib_keyloader.h"
63
64#if (CONFIG_ENABLE_SCM==1)
65
66#include "brap_scm_interface.h"
67#include "brap_scm.h"
68#include "gist.h"
69
70#define SCM_CMD_SIZE    0x300
71#define SCM_RSP_SIZE    0x500
72
73static uint32_t *scm_hdcp_cmdb = NULL;
74static uint32_t *scm_hdcp_rspb = NULL;
75static BRAP_SCM_CmdPayload scm_hdcp_txfr;
76int scm_send_command(BRAP_SCM_CmdPayload *txfr);
77
78#else
79#include "bhsm.h"
80#include "bhsm_keyladder.h"
81#include "bhsm_keyladder_enc.h"
82#endif
83
84BDBG_MODULE(BHDCPLIB_KEYLOADER) ;
85
86#if ((BCHP_CHIP == 7550) || (BCHP_CHIP == 7408))
87BERR_Code BHDCPlib_FastLoadEncryptedHdcpKeys(
88        BHDCPlib_Handle hHDCPlib)
89{
90
91        unsigned int i;
92        BHDCPlib_EncryptedHdcpKeyStruct * EncryptedHdcpKeys;
93
94#if (CONFIG_ENABLE_SCM==1)
95        BSCM_hdcp_key_message *scm_hdcp_msg;
96        BSCM_command *scm_cmd;
97
98        BDBG_ASSERT(hHDCPlib);
99
100        BDBG_ERR(("Version 20110712 - HDCPlib keyloader for 97550 SCM")) ; 
101        if (scm_hdcp_cmdb == NULL) {
102                scm_hdcp_cmdb = BMEM_Heap_AllocAligned(GetHEAP(), SCM_CMD_SIZE, 2, 0);
103        }
104        if (scm_hdcp_rspb == NULL) {
105                scm_hdcp_rspb = BMEM_Heap_AllocAligned(GetHEAP(), SCM_RSP_SIZE, 2, 0);
106        }
107
108        EncryptedHdcpKeys = (BHDCPlib_EncryptedHdcpKeyStruct *) &hHDCPlib->stHdcpConfiguration.TxKeySet.TxKeyStructure;
109
110        for (i=0; i<BAVC_HDMI_HDCP_N_PRIVATE_KEYS; i++) 
111        {
112                if (!(hHDCPlib->stHdcpConfiguration.RxInfo.RxBksv[i/8]&(1<<(i%8))))
113                        continue;
114
115                scm_cmd = (BSCM_command *)scm_hdcp_cmdb;
116                scm_cmd->type = BSCM_P_eSCMCmdType_eHDCPKey;
117                scm_hdcp_msg = (BSCM_hdcp_key_message *)scm_cmd->payload;
118                BKNI_Memset(scm_hdcp_msg, 0, sizeof(BSCM_hdcp_key_message));
119                scm_hdcp_msg->keyslot_number = i;
120                scm_hdcp_msg->cus_key = EncryptedHdcpKeys[i].cusKeySel;
121                scm_hdcp_msg->key_var = EncryptedHdcpKeys[i].cusKeyVarL;
122               
123                scm_hdcp_msg->ca_data[0] = EncryptedHdcpKeys[i].TCaDataHi;
124                scm_hdcp_msg->ca_data[1] = EncryptedHdcpKeys[i].TCaDataLo;
125                scm_hdcp_msg->ca_data[2] = EncryptedHdcpKeys[i].CaDataHi;
126                scm_hdcp_msg->ca_data[3] = EncryptedHdcpKeys[i].CaDataLo;
127                scm_hdcp_msg->hdcp_key[0] = EncryptedHdcpKeys[i].HdcpKeyHi;
128                scm_hdcp_msg->hdcp_key[1] = EncryptedHdcpKeys[i].HdcpKeyLo;
129
130                scm_hdcp_txfr.ui32DramCmdBufAddress = (uint32_t)scm_hdcp_cmdb;
131                scm_hdcp_txfr.ui32DramCmdBufSize = sizeof(BSCM_hdcp_key_message)+4;
132                scm_hdcp_txfr.ui32DramRespBufAddress = (uint32_t)scm_hdcp_rspb;
133                scm_hdcp_txfr.ui32DramRespBufSize = 4;
134
135                scm_hdcp_rspb[0] = 0xFFFFFFFF;
136                if (scm_send_command(&scm_hdcp_txfr) != 0) 
137                {
138                        BDBG_ERR(("Fail on scm_send_command BSCM_P_eSCMCmdType_eHDCPkey"));
139                }
140        }
141        return BERR_SUCCESS;
142#else
143        BERR_Code errCode = BERR_SUCCESS;
144        uint32_t KeyParameter ;
145        BHSM_GenerateKey2IO_t           generateKey2IO;
146        BHSM_GenerateKeyXIO_t           generateKeyXIO;
147        BHSM_GenerateHDMIKeyIO_t     generateHDMIKeyIO;
148       
149       
150        BDBG_ASSERT(hHDCPlib) ;
151       
152        BDBG_ERR(("Version 20090403 - HDCPlib keyloader for 97550/97408")) ; 
153       
154        EncryptedHdcpKeys = (BHDCPlib_EncryptedHdcpKeyStruct *) &hHDCPlib->stHdcpConfiguration.TxKeySet.TxKeyStructure;
155       
156        BKNI_Memset( &generateKey2IO, 0, sizeof(BHSM_GenerateKey2IO_t))  ;     
157        BKNI_Memset( &generateKeyXIO, 0, sizeof(BHSM_GenerateKeyXIO_t));
158        BKNI_Memset( &generateHDMIKeyIO, 0, sizeof(BHSM_GenerateHDMIKeyIO_t));
159       
160        for (i =0; i< BAVC_HDMI_HDCP_N_PRIVATE_KEYS; i++)
161        {
162                if (!(hHDCPlib->stHdcpConfiguration.RxInfo.RxBksv[i / 8] & (1 << (i % 8))))
163                        continue ;
164/*
165                generateKey2IO.bOTPkey = false;
166*/
167                generateKey2IO.eKey2Source = BHSM_Key2Source_eCustKey;
168                generateKey2IO.eOperation = BHSM_Operation_eCP ; 
169                generateKey2IO.unCustKey = EncryptedHdcpKeys[i].cusKeySel ;
170                generateKey2IO.unKeyVar = EncryptedHdcpKeys[i].cusKeyVarL ;
171                BKNI_Memset(generateKey2IO.procIn, 0, 16);
172                BDBG_MSG(("generateKey2IO.unCustKey = %x generateKey2IO.unKeyVar = %x\n",generateKey2IO.unCustKey, generateKey2IO.unKeyVar));
173                errCode=  BHSM_GenerateKey2 (hHDCPlib->stDependencies.hHsm, &generateKey2IO);
174
175                if (errCode != 0) 
176                {
177                        BDBG_ERR(("BHSM_GenerateKey2 key2 errCode: %x\n", errCode ));
178                        goto done;
179                }
180
181                /* generate Key3 from key 2*/
182                generateKeyXIO.eOperation = BHSM_Operation_eCP;
183                generateKeyXIO.eKeyDest = BHSM_KeyBuffer_eKey3 ;       
184                BKNI_Memset(generateKeyXIO.procIn, 0, 16);
185                KeyParameter = EncryptedHdcpKeys[i].TCaDataHi;
186                BDBG_MSG(("EncryptedHdcpKeys[i].TCaDataHi = %x\n",KeyParameter));
187                generateKeyXIO.procIn[0]  =  (KeyParameter >> 24) & 0xff ;
188                generateKeyXIO.procIn[1]  =  (KeyParameter >> 16) & 0xff ;
189                generateKeyXIO.procIn[2]  =  (KeyParameter >> 8) & 0xff ;
190                generateKeyXIO.procIn[3]  =  (KeyParameter) & 0xff ;
191
192                KeyParameter = EncryptedHdcpKeys[i].TCaDataLo;
193                BDBG_MSG(("EncryptedHdcpKeys[i].TCaDataLo = %x\n",KeyParameter));
194                generateKeyXIO.procIn[4]  =  (KeyParameter >> 24) & 0xff ;
195                generateKeyXIO.procIn[5]  =  (KeyParameter >> 16) & 0xff ;
196                generateKeyXIO.procIn[6]  =  (KeyParameter >> 8) & 0xff ;
197                generateKeyXIO.procIn[7]  =  (KeyParameter) & 0xff ;                                   
198
199                KeyParameter = EncryptedHdcpKeys[i].CaDataHi;
200                BDBG_MSG(("EncryptedHdcpKeys[i].CaDataHi = %x\n",KeyParameter));
201                generateKeyXIO.procIn[8]  =  (KeyParameter >> 24) & 0xff ;
202                generateKeyXIO.procIn[9]  =  (KeyParameter >> 16) & 0xff ;
203                generateKeyXIO.procIn[10]  =  (KeyParameter >> 8) & 0xff ;
204                generateKeyXIO.procIn[11]  =  (KeyParameter) & 0xff ;
205
206                KeyParameter = EncryptedHdcpKeys[i].CaDataLo;
207                BDBG_MSG(("EncryptedHdcpKeys[i].CaDataLo = %x\n",KeyParameter));
208                generateKeyXIO.procIn[12]  =  (KeyParameter >> 24) & 0xff ;
209                generateKeyXIO.procIn[13]  =  (KeyParameter >> 16) & 0xff ;
210                generateKeyXIO.procIn[14]  =  (KeyParameter >> 8) & 0xff ;
211                generateKeyXIO.procIn[15]  =  (KeyParameter) & 0xff ;                                   
212
213                errCode=  BHSM_GenerateKeyX (hHDCPlib->stDependencies.hHsm, &generateKeyXIO);
214                if (errCode != 0) 
215                {
216                        BDBG_ERR(("BHSM_GenerateKeyX key3 errCode: %x\n", errCode ));
217                        goto done;
218                }       
219
220                /* generate Key4(HDCP key) from key 3*/
221                BKNI_Memset(&generateHDMIKeyIO.procIn, 0, sizeof(generateHDMIKeyIO.procIn));                           
222                KeyParameter = EncryptedHdcpKeys[i].HdcpKeyHi;
223                BDBG_MSG(("EncryptedHdcpKeys[i].HdcpKeyHi = %x\n",KeyParameter));
224                generateHDMIKeyIO.procIn[0]  =  (KeyParameter >> 24) & 0xff ;
225                generateHDMIKeyIO.procIn[1]  =  (KeyParameter >> 16) & 0xff ;
226                generateHDMIKeyIO.procIn[2]  =  (KeyParameter >> 8) & 0xff ;
227                generateHDMIKeyIO.procIn[3]  =  (KeyParameter) & 0xff ;
228
229                KeyParameter = EncryptedHdcpKeys[i].HdcpKeyLo;
230                BDBG_MSG(("EncryptedHdcpKeys[i].HdcpKeyLo = %x\n",KeyParameter));
231                generateHDMIKeyIO.procIn[4]  =  (KeyParameter >> 24) & 0xff ;
232                generateHDMIKeyIO.procIn[5]  =  (KeyParameter >> 16) & 0xff ;
233                generateHDMIKeyIO.procIn[6]  =  (KeyParameter >> 8) & 0xff ;
234                generateHDMIKeyIO.procIn[7]  =  (KeyParameter) & 0xff ;                                 
235
236                generateHDMIKeyIO.keySlot = i ;
237
238                errCode= BHSM_GenerateHDMIKey (hHDCPlib->stDependencies.hHsm, &generateHDMIKeyIO) ;     
239                if (errCode != 0) 
240                {
241                        BDBG_ERR(("BHSM_GenerateHDMIKey key4 errCode: %x\n", errCode ));
242                        goto done;
243                }       
244        }
245done:
246        return( errCode );
247#endif 
248}
249
250#elif ((BCHP_CHIP == 7125) || (BCHP_CHIP == 7340) || (BCHP_CHIP == 7342) \
251        || ((BCHP_CHIP == 7420) && (BCHP_VER >= BCHP_VER_A1)) \
252        || (BCHP_CHIP == 7468) || (BCHP_CHIP == 7208) || (BCHP_CHIP == 7410))
253
254BERR_Code BHDCPlib_FastLoadEncryptedHdcpKeys(
255        BHDCPlib_Handle hHDCPlib)
256{
257        BERR_Code errCode = BERR_SUCCESS;
258#if DEBUG_PROCOUT       
259        BHSM_ProcOutCmdIO_t     procOutCmdIO;   
260#endif
261        BHSM_GenerateRouteKeyIO_t               generateRouteKeyIO;
262        BHSM_ConfigKeySlotIDDataIO_t    configKeySlotIDDataIO;
263       
264        unsigned int i;
265        uint32_t KeyParameter ;
266        BHDCPlib_EncryptedHdcpKeyStruct * EncryptedHdcpKeys;
267       
268        BDBG_ASSERT(hHDCPlib) ;
269
270        BDBG_ERR(("Version 20090403 - HDCPlib keyloader for 97125/97420/97410/97340/97342/97468/97208")) ; 
271
272
273        /* Get HDCP Encrypted Keys */
274        EncryptedHdcpKeys = (BHDCPlib_EncryptedHdcpKeyStruct *) &hHDCPlib->stHdcpConfiguration.TxKeySet.TxKeyStructure;
275
276        BKNI_Memset( &generateRouteKeyIO, 0, sizeof(BHSM_GenerateRouteKeyIO_t))  ;     
277        BKNI_Memset( &configKeySlotIDDataIO, 0, sizeof(BHSM_ConfigKeySlotIDDataIO_t));
278
279        for (i =0; i< BAVC_HDMI_HDCP_N_PRIVATE_KEYS; i++)
280        {
281                if (!(hHDCPlib->stHdcpConfiguration.RxInfo.RxBksv[i / 8] & (1 << (i % 8))))
282                        continue ;
283
284                /* Call BHSM_configKeySlotIDData() to set up ID part of  configuration odd key */
285                configKeySlotIDDataIO.keyDestBlckType  = BCMD_KeyDestBlockType_eCA;
286                configKeySlotIDDataIO.keyDestEntryType = BCMD_KeyDestEntryType_eOddKey;
287                configKeySlotIDDataIO.unKeySlotNum        = i;
288                configKeySlotIDDataIO.caKeySlotType    = BCMD_XptSecKeySlot_eType0;
289                configKeySlotIDDataIO.CAVendorID        = 0x1234;
290                configKeySlotIDDataIO.STBOwnerIDSelect = BCMD_STBOwnerID_eOTPVal;
291                configKeySlotIDDataIO.ModuleID     = BCMD_ModuleID_eModuleID_3;
292                configKeySlotIDDataIO.TestKey2Select   = 0;
293
294                errCode = BHSM_ConfigKeySlotIDData(hHDCPlib->stDependencies.hHsm, &configKeySlotIDDataIO); 
295                if (errCode != 0) 
296                {
297                        BDBG_ERR(("BHSM_ConfigKeySlotIDData errCode: %x\n", errCode));
298                        goto done;
299                } 
300
301                /* generate Key3 from custom key */
302                generateRouteKeyIO.keyLadderType = EncryptedHdcpKeys[i].Alg;
303               
304                generateRouteKeyIO.rootKeySrc =  BCMD_RootKeySrc_eCusKey; 
305                generateRouteKeyIO.customerSubMode = BCMD_CustomerSubMode_eGeneralPurpose1;
306                generateRouteKeyIO.ucSwizzle1Index = 0;
307                generateRouteKeyIO.swizzleType = BCMD_SwizzleType_eSwizzle0;
308               
309                generateRouteKeyIO.bUseCustKeyLowDecrypt =  false ;
310                generateRouteKeyIO.ucCustKeyLow = EncryptedHdcpKeys[i].cusKeySel;       
311                generateRouteKeyIO.ucKeyVarLow = EncryptedHdcpKeys[i].cusKeyVarL;       
312               
313                generateRouteKeyIO.bUseCustKeyHighDecrypt = false ;
314                generateRouteKeyIO.ucCustKeyHigh = EncryptedHdcpKeys[i].cusKeySel; 
315                generateRouteKeyIO.ucKeyVarHigh = EncryptedHdcpKeys[i].cusKeyVarH;     
316
317                generateRouteKeyIO.virtualKeyLadderID = BCMD_VKL0;
318                generateRouteKeyIO.keyLayer = BCMD_KeyRamBuf_eKey3 ;
319                generateRouteKeyIO.bIs3DESDecrypt = false ;     /* true - encryption, false - decryption */
320
321                generateRouteKeyIO.keyLadderType = BCMD_KeyLadderType_e3DESABA;
322               
323                generateRouteKeyIO.keySize= BCMD_KeySize_e64;
324                generateRouteKeyIO.ucKeyDataLen = 8 ;
325               
326                BKNI_Memset(&generateRouteKeyIO.aucKeyData, 0, sizeof(generateRouteKeyIO.aucKeyData));                         
327                KeyParameter = EncryptedHdcpKeys[i].HdcpKeyHi;
328                generateRouteKeyIO.aucKeyData[0]  =  (KeyParameter >> 24) & 0xff ;
329                generateRouteKeyIO.aucKeyData[1]  =  (KeyParameter >> 16) & 0xff ;
330                generateRouteKeyIO.aucKeyData[2]  =  (KeyParameter >>   8) & 0xff ;
331                generateRouteKeyIO.aucKeyData[3]  =  (KeyParameter)           & 0xff ;
332               
333                KeyParameter = EncryptedHdcpKeys[i].HdcpKeyLo;
334                generateRouteKeyIO.aucKeyData[4]  =  (KeyParameter >> 24) & 0xff ;
335                generateRouteKeyIO.aucKeyData[5]  =  (KeyParameter >> 16) & 0xff ;
336                generateRouteKeyIO.aucKeyData[6]  =  (KeyParameter >>  8) & 0xff ;
337                generateRouteKeyIO.aucKeyData[7]  =  (KeyParameter)           & 0xff ;                                 
338                       
339                generateRouteKeyIO.bIsRouteKeyRequired = true;
340                generateRouteKeyIO.keyDestBlckType = BCMD_KeyDestBlockType_eHdmi;
341
342                generateRouteKeyIO.keyDestEntryType = BCMD_KeyDestEntryType_eOddKey;   
343
344                generateRouteKeyIO.caKeySlotType = BCMD_XptSecKeySlot_eType0 ;
345                generateRouteKeyIO.keyMode = BCMD_KeyMode_eRegular;
346
347                generateRouteKeyIO.unKeySlotNum =   i ; 
348                errCode= BHSM_GenerateRouteKey (hHDCPlib->stDependencies.hHsm, &generateRouteKeyIO) ;   
349                BDBG_MSG(("generateRouteKeyIO key 3 unStatus = 0x%08X\n", generateRouteKeyIO.unStatus)) ;
350                if (errCode != 0) 
351                {
352                        BDBG_ERR(("BHSM_GenerateRouteKey key3 errCode: %x\n", errCode ));
353                        goto done;
354                }       
355        }
356
357done:
358        return( errCode );
359}
360
361
362#else
363
364BERR_Code BHDCPlib_FastLoadEncryptedHdcpKeys(
365        BHDCPlib_Handle hHDCPlib)
366{
367        BERR_Code errCode = BERR_SUCCESS;
368#if DEBUG_PROCOUT       
369        BHSM_ProcOutCmdIO_t     procOutCmdIO;   
370#endif
371        BHSM_GenerateRouteKeyIO_t               generateRouteKeyIO;
372       
373        unsigned int i;
374        uint32_t KeyParameter ;
375        BHDCPlib_EncryptedHdcpKeyStruct * EncryptedHdcpKeys;
376       
377        BDBG_ASSERT(hHDCPlib) ;
378
379        BDBG_MSG(("Version 20080114")) ; 
380
381
382        /* Get HDCP Encrypted Keys */
383        EncryptedHdcpKeys = (BHDCPlib_EncryptedHdcpKeyStruct *) &hHDCPlib->stHdcpConfiguration.TxKeySet.TxKeyStructure;
384
385        BKNI_Memset( &generateRouteKeyIO, 0, sizeof(BHSM_GenerateRouteKeyIO_t))  ;     
386
387        for (i =0; i< BAVC_HDMI_HDCP_N_PRIVATE_KEYS; i++)
388        {
389                if (!(hHDCPlib->stHdcpConfiguration.RxInfo.RxBksv[i / 8] & (1 << (i % 8))))
390                        continue ;
391
392                /* generate Key3 from custom key */
393                generateRouteKeyIO.keyLadderType = EncryptedHdcpKeys[i].Alg;
394               
395                generateRouteKeyIO.rootKeySrc =  BCMD_RootKeySrc_eCusKey; 
396                generateRouteKeyIO.ucSwizzle1Index = 0;
397                generateRouteKeyIO.swizzleType = BCMD_SwizzleType_eSwizzle0;
398               
399                generateRouteKeyIO.bUseCustKeyLowDecrypt =  false ;
400                generateRouteKeyIO.ucCustKeyLow = EncryptedHdcpKeys[i].cusKeySel;       
401                generateRouteKeyIO.ucKeyVarLow = EncryptedHdcpKeys[i].cusKeyVarL;       
402               
403                generateRouteKeyIO.bUseCustKeyHighDecrypt = false ;
404                generateRouteKeyIO.ucCustKeyHigh = EncryptedHdcpKeys[i].cusKeySel; 
405                generateRouteKeyIO.ucKeyVarHigh = EncryptedHdcpKeys[i].cusKeyVarH;     
406
407                generateRouteKeyIO.keyDest= BCMD_KeyRamBuf_eKey3KeyLadder3 ;
408                generateRouteKeyIO.bIs3DESDecrypt = false ;     /* true - encryption, false - decryption */
409
410                generateRouteKeyIO.keyLadderType = BCMD_KeyLadderType_e3DESABA;
411               
412
413                generateRouteKeyIO.keySize= BCMD_KeySize_e64;
414                generateRouteKeyIO.ucKeyDataLen = 8 ;
415               
416                BKNI_Memset(&generateRouteKeyIO.aucKeyData, 0, sizeof(generateRouteKeyIO.aucKeyData));                         
417                KeyParameter = EncryptedHdcpKeys[i].HdcpKeyHi;
418                generateRouteKeyIO.aucKeyData[0]  =  (KeyParameter >> 24) & 0xff ;
419                generateRouteKeyIO.aucKeyData[1]  =  (KeyParameter >> 16) & 0xff ;
420                generateRouteKeyIO.aucKeyData[2]  =  (KeyParameter >>   8) & 0xff ;
421                generateRouteKeyIO.aucKeyData[3]  =  (KeyParameter)           & 0xff ;
422               
423                KeyParameter = EncryptedHdcpKeys[i].HdcpKeyLo;
424                generateRouteKeyIO.aucKeyData[4]  =  (KeyParameter >> 24) & 0xff ;
425                generateRouteKeyIO.aucKeyData[5]  =  (KeyParameter >> 16) & 0xff ;
426                generateRouteKeyIO.aucKeyData[6]  =  (KeyParameter >>  8) & 0xff ;
427                generateRouteKeyIO.aucKeyData[7]  =  (KeyParameter)           & 0xff ;                                 
428                       
429                generateRouteKeyIO.bIsRouteKeyRequired = true;
430                generateRouteKeyIO.keyDestBlckType = BCMD_KeyDestBlockType_eHdmi;
431
432                generateRouteKeyIO.keyDestEntryType = BCMD_KeyDestEntryType_eOddKey;   
433
434                generateRouteKeyIO.caKeySlotType = BCMD_XptSecKeySlot_eType0 ;
435
436                generateRouteKeyIO.unKeySlotNum =   i ; 
437                errCode= BHSM_GenerateRouteKey (hHDCPlib->stDependencies.hHsm, &generateRouteKeyIO) ;   
438                BDBG_MSG(("generateRouteKeyIO unStatus = 0x%08X\n", generateRouteKeyIO.unStatus)) ;
439                if (errCode != 0) 
440                {
441                        BDBG_ERR(("BHSM_GenerateRouteKey errCode: %x\n", errCode ));
442                        return errCode;
443                }       
444        }
445
446        return( errCode );
447}
448
449#endif
450
Note: See TracBrowser for help on using the repository browser.