/****************************************************************************** * -Copyright (c) 2004 Digital Stream Technologies Inc. All Rights Reserved. * * Module: dsthaldev.c * Author: Jun-ku Park, hwatk@dstreamtech.com * Description: DST HAL [Device] Platform/Project Indepedent Source * * notes: hwatk20040609 * * hwatk/20041116, DHL_DEV_NFLASHSetMode() 함수 추가. * * TO DO LIST * ******************************************************************************/ /****************************************************************************** * Global variable declaration ******************************************************************************/ /****************************************************************************** * Imported variable declaration ******************************************************************************/ /****************************************************************************** * Imported function declaration ******************************************************************************/ /****************************************************************************** * Local definitions ******************************************************************************/ /****************************************************************************** * Local typedefs ******************************************************************************/ /****************************************************************************** * Local function prototypes ******************************************************************************/ #include "dsthalcommon.h" #include "dstdddev.h" #ifdef DMALLOC #include #endif static DST_DEV_NFLASH sNFLASH[NFLASHID_MAX-1]; static DST_DEV_SFLASH sSFLASH[SFLASHID_MAX-1]; DS_U32 g_CaMutex = 0; #define LOCK_CA_MUTEX() do { \ if ( OS_TakeMutex(g_CaMutex) != OS_OK ) { \ printf("MUTEX ERROR, LINE=%d\n", __LINE__); \ goto done; \ } \ } while (0) #define UNLOCK_CA_MUTEX() do { \ if ( OS_GiveMutex(g_CaMutex) != OS_OK ) { \ printf("MUTEX ERROR, LINE=%d\n", __LINE__); \ } \ } while (0) #if 0 ___EEPROM_Functions__________() #endif #if defined(USE_EEPROM_FILE) static FILE *g_EepromFlashFile=(FILE *)0; #endif #define WR_CYCLE_DELAY 5 /* 5 ms EEPROM write cycle */ #define MAX_PAGE_LEN 32 #define PAGE_MASK (MAX_PAGE_LEN - 1) int DHL_DEV_WriteEEPROM(unsigned short WriteAddr,unsigned short length,unsigned char *wbuf) { DS_U32 i=CORE_OK; #if defined(USE_EEPROM_FILE) if (g_EepromFlashFile == (FILE *)0) { g_EepromFlashFile = fopen(EEPROM_FILE_PATH, "w+b"); if (g_EepromFlashFile == (FILE *)NULL) { printf("ERROR: Cannot open %s\n", EEPROM_FILE_PATH); return -1; } } if ( fseek( g_EepromFlashFile, WriteAddr, SEEK_SET ) ) { printf("ERROR: fseek()\n"); return -1; } i=fwrite( wbuf, 1, length, g_EepromFlashFile ); if ( i != length ) { printf("ERROR: cannot write EEPROM data into file.\n"); return -1; } #else DS_U8 WrBuf[MAX_PAGE_LEN+4]; DS_U32 WrLen; int result; //printf("|%s| WriteAddr: 0x%X, length:%d\n", __FUNCTION__, WriteAddr, length); while (length) { WrBuf[0] = WriteAddr & 0xff; i = (WriteAddr & (~PAGE_MASK)) + MAX_PAGE_LEN - WriteAddr; WrLen = length; if (WrLen > MAX_PAGE_LEN) { WrLen = MAX_PAGE_LEN; } if (WrLen > i) { WrLen = i; } length -= WrLen; memcpy (&(WrBuf[1]), wbuf, WrLen); result = DHL_SYS_I2cWriteEx(0,EEPROM_I2C_ADDRESS,1,(WriteAddr>>8)&0xFF,WrBuf,WrLen+1); if(result < 0){ printf("EEPROM I2C Write Error\n"); break; } /*================================================================= * Do acknowledge polling (wait for write operation to finish) *================================================================*/ for (i=0; i>8)&0xFF,WrBuf,1); if(result < 0){ //printf("|%s:%d| EEPROM I2C Write Error\n", __FUNCTION__, __LINE__); } else { break; } OS_mDelay(1); } result = DHL_SYS_I2cWriteEx(0,EEPROM_I2C_ADDRESS,1,(WriteAddr>>8)&0xFF,WrBuf,1); if(result < 0) { printf("|%s:%d| EEPROM I2C Write Error\n", __FUNCTION__, __LINE__); break; } WriteAddr+= WrLen; wbuf = (void *) ((DS_U32)wbuf + WrLen); } #endif return (i); } int DHL_DEV_ReadEEPROM(unsigned short addr,unsigned short length,unsigned char *rbuf) { int result = -1; int i = -1; if(addr+length > EEPROM_SIZE) { DHL_DbgPrintf( 0, DHLDBG_SYS, "Address + Length is not avail\n"); return -1; } #if defined(USE_EEPROM_FILE) if (g_EepromFlashFile == (FILE *)0) { g_EepromFlashFile = fopen(EEPROM_FILE_PATH, "r+b"); if ( !g_EepromFlashFile ) { g_EepromFlashFile = fopen(EEPROM_FILE_PATH, "w+b"); if ( !g_EepromFlashFile ) { printf("ERROR: Cannot open %s\n", EEPROM_FILE_PATH); return -1; } } } if ( fseek( g_EepromFlashFile, 0L, SEEK_SET ) ) { printf("ERROR: fseek()\n"); return -1; } i=fread( rbuf, 1, length, g_EepromFlashFile ); if (i != length) { printf("ERROR: cannot read EEPROM data from file. (addr: %d, length: %d, i:%d)\n", addr, length, i); perror("fread()"); return -1; } #else result = DHL_SYS_I2cReadEx(0,EEPROM_I2C_ADDRESS,1,addr,rbuf,length); if( result < 0){ DHL_DbgPrintf( 0, DHLDBG_SYS, "I2C Read Fail\n"); goto done; } done: #endif result = i; return result; } #if 0 ___NFLASH_Functions__________() #endif /**************************************************************************** DHL_RESULT DHL_DEV_NFLASHInit - Summary : Initialize NAND flash device, including NAND flash bus. - Argument NFLASHID { NFLASH_0 } Size - NAND Flash Size Start - NAND Flash Usable Area Start Offset End - NAND Flash Usable Area End Offset if ( End == 0 ) End = Start + Size - Returns : DHL_OK on success, DHL_FAIL on failure. ***************************************************************************/ DHL_RESULT DHL_DEV_InitNFLASH( NFLASHID NFlashId, DS_U32 Size, DS_U32 Start, DS_U32 End ) { DHL_RESULT dhlResult = DHL_OK; P_DST_DEV_NFLASH pNFlash; if ( NFlashId >= NFLASHID_MAX ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : NFLASH Id is invalid, Id = %d\n", NFlashId ); return DHL_FAIL_INVALID_HANDLE; } pNFlash = &sNFLASH[NFlashId-1]; #if 0 /* hwatk, 2004.06.30, Init에서는 State 검사하지 않음. */ if ( pNFlash->CurState != NFLASHSTATE_UNKNOWN ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : NFlash state is invalid, State = %d\n", pNFlash->CurState ); return DHL_FAIL; } if ( (Size <= 0) || ((Start > End) && End) || ( Start && End && (Start==End) ) ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : Invalid argument, Size=%lx, Start=%lx, End=%lx!\n", Size, Start, End ); return DHL_FAIL_INVALID_PARAM; } #endif pNFlash->NFlashId = NFlashId; if ( End == 0 ) End = Start + Size; dhlResult = DD_DEV_NFLASHInit( pNFlash, Size, Start, End ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : DD_DEV_NFLASHInit()\n" ); return dhlResult; } pNFlash->CurState = NFLASHSTATE_INIT; /* Initialize MUTEX */ return dhlResult; } /**************************************************************************** int DHL_DEV_NFLASHRead - Summary : Read data from NAND flash. - Argument NFLASHID { NFLASH_0 } Address pBuffer Len - Returns : Bytes read on success, -1 on failure. ***************************************************************************/ int DHL_DEV_ReadNFLASH( NFLASHID NFlashId, DS_U32 Address, DS_U8 *pBuffer, DS_U32 Len ) { int RetVal; P_DST_DEV_NFLASH pNFlash; if ( NFlashId >= NFLASHID_MAX ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : NFLASH Id is invalid, Id = %d\n", NFlashId ); return -1; } /* Take the MUTEX, notes : MUTEX should be taken before state checking. */ /* State Checking */ pNFlash = &sNFLASH[NFlashId-1]; if ( pNFlash->CurState != NFLASHSTATE_INIT ) {// NFLASHSTATE_START -> NFLASHSTATE_INIT DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : NFlash state is invalid, State = %d\n", pNFlash->CurState ); RetVal = -1; goto done; } /* Argument Checking */ if ( (pBuffer == (DS_U8)0) || (Len == 0) ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : Invalid Arguments, pBuffer = %lX, Len = %ld\n", pBuffer, Len ); RetVal = -1; goto done; } /* Checks that the Address - Len range is in usable area. */ if ( ( (Address < pNFlash->uAvlStart) || (Address > pNFlash->uAvlEnd) ) || ( ((Address+Len) < pNFlash->uAvlStart) || ((Address+Len) > pNFlash->uAvlEnd) ) || (Len > pNFlash->uSize) ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : the area is not in usable area. Address = %x, Len = %x\n", Address, Len ); RetVal = -1; goto done; } /* Call the lower device driver */ RetVal = DD_DEV_NFLASHRead( pNFlash, Address, pBuffer, Len ); if ( RetVal < 0 ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : DD_DEV_NFLASHRead()\n" ); RetVal = -1; goto done; } done: /* Give the MUTEX */ return RetVal; } /**************************************************************************** int DHL_DEV_NFLASHWrite - Summary : Write data on NAND flash. - Argument NFLASHID { NFLASH_0 } Address pBuffer Len - Returns : Bytes written on success, -1 on failure. ***************************************************************************/ int DHL_DEV_WriteNFLASH( NFLASHID NFlashId, DS_U32 Address, DS_U8 *pBuffer, DS_U32 Len ) { int RetVal; P_DST_DEV_NFLASH pNFlash; if ( NFlashId >= NFLASHID_MAX ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : NFLASH Id is invalid, Id = %d\n", NFlashId ); return DHL_FAIL_INVALID_HANDLE; } /* Take the MUTEX, notes : MUTEX should be taken before state checking. */ /* State Checking */ pNFlash = &sNFLASH[NFlashId-1]; if ( pNFlash->CurState != NFLASHSTATE_INIT ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : NFlash state is invalid, State = %d\n", pNFlash->CurState ); RetVal = -1; goto done; } /* Argument Checking */ if ( (pBuffer == (DS_U8)0) || (Len == 0) ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : Invalid Arguments, pBuffer = %lX, Len = %ld\n", pBuffer, Len ); RetVal = -1; goto done; } /* Checks that the Address - Len range is in usable area. */ if ( ( (Address < pNFlash->uAvlStart) || (Address > pNFlash->uAvlEnd) ) || ( ((Address+Len) < pNFlash->uAvlStart) || ((Address+Len) > pNFlash->uAvlEnd) ) || (Len > pNFlash->uSize)) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : the area is not in usable area. Address = %x, Len = %x\n", Address, Len ); RetVal = -1; goto done; } /* Call the lower device driver. */ RetVal = DD_DEV_NFLASHWrite( pNFlash, Address, pBuffer, Len ); if ( RetVal < 0 ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : DD_DEV_NFLASHWrite(), RetVal = %d\n", RetVal ); goto done; } done: /* Give the MUTEX */ return RetVal; } /**************************************************************************** DHL_RESULT DHL_DEV_NFLASHErase - Summary : Erase NAND Flash. - Argument NFLASHID { NFLASH_0 } Address Len - Returns : DHL_OK on success, DHL_FAIL on failure. ***************************************************************************/ DHL_RESULT DHL_DEV_EraseNFLASH( NFLASHID NFlashId, DS_U32 Address, DS_U32 Len ) { DHL_RESULT dhlResult = DHL_OK; P_DST_DEV_NFLASH pNFlash; if ( NFlashId >= NFLASHID_MAX ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : NFLASH Id is invalid, Id = %d\n", NFlashId ); return DHL_FAIL_INVALID_HANDLE; } /* Take the MUTEX, notes : MUTEX should be taken before state checking. */ /* State Checking */ pNFlash = &sNFLASH[NFlashId-1]; if ( pNFlash->CurState != NFLASHSTATE_INIT ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : NFlash state is invalid, State = %d\n", pNFlash->CurState ); return DHL_FAIL; } /* Argument Checking */ if ( Len == 0 ) { dhlResult = DHL_FAIL; goto done; } /* Checks that the Address - Len range is in usable area. */ if ( ( (Address < pNFlash->uAvlStart) || (Address > pNFlash->uAvlEnd) ) || ( ((Address+Len) < pNFlash->uAvlStart) || ((Address+Len) > pNFlash->uAvlEnd) ) || (Len > pNFlash->uSize) ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : the area is not in usable area. NFlashId = 0x%x, Address = %x, Len = %x\n", NFlashId, Address, Len ); dhlResult = DHL_FAIL; goto done; } /* Call the lower device driver */ dhlResult = DD_DEV_NFLASHErase( pNFlash, Address, Len ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : DD_DEV_NFLASHErase()\n" ); goto done; } done: /* Give the MUTEX */ return dhlResult; } int DHL_DEV_GetNFLASHSize(NFLASHID NFlashId) { P_DST_DEV_NFLASH pNFlash; pNFlash = &sNFLASH[NFlashId-1]; return pNFlash->uSize; } #if 0 ___SFLASH_Functions__________() #endif /**************************************************************************** DHL_RESULT DHL_DEV_SFLASHInit - Summary : Initialize NAND flash device, including NAND flash bus. - Argument SFLASHID { SFLASH_0 } Size - NAND Flash Size Start - NAND Flash Usable Area Start Offset End - NAND Flash Usable Area End Offset if ( End == 0 ) End = Start + Size; - Returns : DHL_OK on success, DHL_FAIL on failure. ***************************************************************************/ DHL_RESULT DHL_DEV_InitSFLASH( SFLASHID SFLASHId, DS_U32 Size, DS_U32 Start, DS_U32 End ) { DHL_RESULT dhlResult = DHL_OK; P_DST_DEV_SFLASH pSFLASH; if ( SFLASHId >= SFLASHID_MAX ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : SFLASH Id is invalid, Id = %d\n", SFLASHId ); return DHL_FAIL_INVALID_HANDLE; } pSFLASH = &sSFLASH[SFLASHId-1]; #if 0 /* hwatk, 2004.06.30, Init에서는 State 검사하지 않음. */ if ( pSFLASH->CurState != SFLASHSTATE_UNKNOWN ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : SFLASH state is invalid, State = %d\n", pSFLASH->CurState ); return DHL_FAIL; } #endif if ( (Size <= 0) || ((Start > End) && End) || ( Start && End && (Start==End) ) ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : Invalid argument, Size=%lx, Start=%lx, End=%lx!\n", Size, Start, End ); return DHL_FAIL_INVALID_PARAM; } if ( End == 0 ) End = Start + Size; dhlResult = DD_DEV_SFLASHInit( pSFLASH, Size, Start, End ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : DD_DEV_SFLASHInit()\n" ); return dhlResult; } pSFLASH->CurState = SFLASHSTATE_INIT; /* Initialize MUTEX */ return dhlResult; } /**************************************************************************** int DHL_DEV_SFLASHRead - Summary : Read data from NAND flash. - Argument SFLASHID { SFLASH_0 } Address pBuffer Len - Returns : Bytes read on success, -1 on failure. ***************************************************************************/ int DHL_DEV_ReadSFLASH( SFLASHID SFLASHId, DS_U32 Address, DS_U8 *pBuffer, DS_U32 Len ) { int RetVal; P_DST_DEV_SFLASH pSFLASH; if ( SFLASHId >= SFLASHID_MAX ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : SFLASH Id is invalid, Id = %d\n", SFLASHId ); return -1; } /* Take the MUTEX, notes : MUTEX should be taken before state checking. */ /* State Checking */ pSFLASH = &sSFLASH[SFLASHId-1]; if ( pSFLASH->CurState != SFLASHSTATE_START ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : SFLASH state is invalid, State = %d\n", pSFLASH->CurState ); RetVal = -1; goto done; } /* Argument Checking */ if ( (pBuffer == (DS_U8)0) || (Len == 0) ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : Invalid Arguments, pBuffer = %lX, Len = %ld\n", pBuffer, Len ); RetVal = -1; goto done; } /* Checks that the Address - Len range is in usable area. */ if ( ( (Address < pSFLASH->uAvlStart) || (Address > pSFLASH->uAvlEnd) ) || ( ((Address+Len) < pSFLASH->uAvlStart) || ((Address+Len) > pSFLASH->uAvlEnd) ) || ((Address+Len) > pSFLASH->uSize ) || (Len > pSFLASH->uSize) ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : the area is not in usable area. Address = %x, Len = %x\n", Address, Len ); RetVal = -1; goto done; } /* Call the lower device driver */ RetVal = DD_DEV_SFLASHRead( pSFLASH, Address, pBuffer, Len ); if ( RetVal < 0 ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : DD_DEV_SFLASHRead()\n" ); RetVal = -1; goto done; } done: /* Give the MUTEX */ return RetVal; } /**************************************************************************** int DHL_DEV_SFLASHWrite - Summary : Write data on NAND flash. - Argument SFLASHID { SFLASH_0 } Address pBuffer Len - Returns : Bytes written on success, -1 on failure. ***************************************************************************/ int DHL_DEV_WriteSFLASH( SFLASHID SFLASHId, DS_U32 Address, DS_U8 *pBuffer, DS_U32 Len ) { int RetVal; P_DST_DEV_SFLASH pSFLASH; if ( SFLASHId >= SFLASHID_MAX ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : SFLASH Id is invalid, Id = %d\n", SFLASHId ); return DHL_FAIL_INVALID_HANDLE; } /* Take the MUTEX, notes : MUTEX should be taken before state checking. */ /* State Checking */ pSFLASH = &sSFLASH[SFLASHId-1]; if ( pSFLASH->CurState != SFLASHSTATE_START ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : SFLASH state is invalid, State = %d\n", pSFLASH->CurState ); RetVal = -1; goto done; } /* Argument Checking */ if ( (pBuffer == (DS_U8)0) || (Len == 0) ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : Invalid Arguments, pBuffer = %lX, Len = %ld\n", pBuffer, Len ); RetVal = -1; goto done; } /* Checks that the Address - Len range is in usable area. */ if ( ( (Address < pSFLASH->uAvlStart) || (Address > pSFLASH->uAvlEnd) ) || ( ((Address+Len) < pSFLASH->uAvlStart) || ((Address+Len) > pSFLASH->uAvlEnd) ) || ((Address+Len) > pSFLASH->uSize ) || (Len > pSFLASH->uSize) ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : the area is not in usable area. Address = %x, Len = %x\n", Address, Len ); RetVal = -1; goto done; } /* Call the lower device driver. */ RetVal = DD_DEV_SFLASHWrite( pSFLASH, Address, pBuffer, Len ); if ( RetVal < 0 ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : DD_DEV_SFLASHWrite()\n" ); goto done; } done: /* Give the MUTEX */ return RetVal; } /**************************************************************************** DHL_RESULT DHL_DEV_SFLASHErase - Summary : Erase NAND Flash. - Argument SFLASHID { SFLASH_0 } Address Len - Returns : DHL_OK on success, DHL_FAIL on failure. ***************************************************************************/ DHL_RESULT DHL_DEV_EraseSFLASH( SFLASHID SFLASHId, DS_U32 Address, DS_U32 Len ) { DHL_RESULT dhlResult = DHL_OK; P_DST_DEV_SFLASH pSFLASH; if ( SFLASHId >= SFLASHID_MAX ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : SFLASH Id is invalid, Id = %d\n", SFLASHId ); return DHL_FAIL_INVALID_HANDLE; } /* Take the MUTEX, notes : MUTEX should be taken before state checking. */ /* State Checking */ pSFLASH = &sSFLASH[SFLASHId-1]; if ( pSFLASH->CurState != SFLASHSTATE_START ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : SFLASH state is invalid, State = %d\n", pSFLASH->CurState ); return DHL_FAIL; } /* Argument Checking */ if ( Len == 0 ) { dhlResult = DHL_FAIL; goto done; } /* Checks that the Address - Len range is in usable area. */ if ( ( (Address < pSFLASH->uAvlStart) || (Address > pSFLASH->uAvlEnd) ) || ( ((Address+Len) < pSFLASH->uAvlStart) || ((Address+Len) > pSFLASH->uAvlEnd) ) || ((Address+Len) > pSFLASH->uSize ) || (Len > pSFLASH->uSize) ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : the area is not in usable area. Address = %x, Len = %x\n", Address, Len ); dhlResult = DHL_FAIL; goto done; } /* Call the lower device driver */ dhlResult = DD_DEV_SFLASHErase( pSFLASH, Address, Len ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 1, DHLDBG_DEV, "ERROR : DD_DEV_SFLASHErase()\n" ); goto done; } done: /* Give the MUTEX */ return dhlResult; } #if 0 ___SMARTCARD_Functions__________() #endif P_DHL_CARD_CALLBACK g_CardCallback = 0; int delay = 0; int timeout = 1000; /**************************************************************************** DHL_RESULT DHL_DEV_InitCAS - Summary : Init CAS Interface - Argument - Returns : DHL_OK on success, DHL_FAIL on failure. ***************************************************************************/ DHL_RESULT DHL_DEV_InitSmartCardInterface(void *func) { DHL_RESULT dhlResult = DHL_OK; g_CaMutex = OS_CreateMutex( "CA_Mutex" ); dhlResult = DD_DEV_InitSmartCard(); g_CardCallback = (P_DHL_CARD_CALLBACK)func; return dhlResult; } /**************************************************************************** DHL_RESULT DHL_DEV_GetCARDStatus - Summary : Get CARD Status - Argument Status : Pointer for Status Data - Returns : DHL_OK on success, DHL_FAIL on failure. ***************************************************************************/ DHL_RESULT DHL_DEV_GetCARDStatus(DHL_DEV_CARD_STATUS *Status) { DHL_RESULT dhlResult = DHL_OK; LOCK_CA_MUTEX(); dhlResult = DD_DEV_GetCARDStatus(Status); UNLOCK_CA_MUTEX(); done: return dhlResult; } /**************************************************************************** DHL_RESULT DHL_DEV_WriteBlock - Summary : Write Block Data to CARD - Argument data : command & data format example - BCAS data[0] : AD_NAD data[1] : AD_PCB data[2] : AD_LEN data[3] : CLA - Actual Data Start to Writing data[4] : INS data[5] : P1 data[5] : P2 data[5] : LC . . . - Returns : DHL_OK on success, DHL_FAIL on failure. ***************************************************************************/ DS_S32 DHL_DEV_WriteCARDBlock( DS_U8 *data ) { return DD_DEV_WriteCARDBlock(data); } /**************************************************************************** DHL_RESULT DHL_DEV_ReadBlock - Summary : Write Block Data to CARD - Argument data : command & data format example - BCAS data[0] : AD_NAD data[1] : AD_PCB data[2] : AD_LEN return data[0] : CLA - Actual Data Start to read data[1] : INS data[2] : P1 data[3] : P2 data[4] : LC . . . - Returns : DHL_OK on success, DHL_FAIL on failure. ***************************************************************************/ DS_S32 DHL_DEV_ReadCARDBlock( DS_U8 PCB, DS_U8 *data ) { return DD_DEV_ReadCARDBlock(PCB,data); } /**************************************************************************** DHL_RESULT DHL_DEV_SmartCARDTransaction - Summary : 1 Transaction Function - Argument Status : Pointer for Status Data - Returns : DHL_OK on success, DHL_FAIL on failure. ***************************************************************************/ DHL_RESULT DHL_DEV_SmartCARDTransaction( DS_U8 *cmdBuf,DS_U32 CmdLen, DS_U8 *retBuf ) { DHL_RESULT dhlResult = DHL_OK; DS_S32 ret = 0; DS_U32 Time = 0; DS_BOOL retry = DS_FALSE; static DS_U32 c_pcb = 0; LOCK_CA_MUTEX(); do { cmdBuf[1] = (c_pcb % 2) ? S_SEQUENCE : N_SEQUENCE; // Prolog PCB byte의 bit 6 retry = 0; ret = DHL_DEV_WriteCARDBlock(cmdBuf); if( delay ) // delay 값이 정의된 경우 Command Write 이후 DELAY를 주게 되며, 이때 timeout이 적용된다. { while( Time < timeout ) { OS_mDelay(delay); ret = DHL_DEV_ReadCARDBlock( cmdBuf[1], retBuf ); if( dhlResult == DHL_OK ) goto done; Time += delay; } dhlResult = DHL_FAIL; goto done; } ret = DHL_DEV_ReadCARDBlock( cmdBuf[1], retBuf ); if( ret == -2) retry = 1; }while(retry); done: c_pcb++; if( ret != 0 ) dhlResult = DHL_FAIL; UNLOCK_CA_MUTEX(); return dhlResult; } #if 0 ___MULTI2_Functions__________() #endif DST_CA_PID_FILTER g_PidFilter[MAX_FILTER_COUNT]; /**************************************************************************** DHL_RESULT DHL_DEV_InitMULTI2 - Summary : Reset MULTI2, Clear - Argument - Returns : DHL_OK on success, DHL_FAIL on failure. ***************************************************************************/ DHL_RESULT DHL_CA_InitMULTI2(DS_U8 *SystemKey, DS_U8 *CBC) { DHL_RESULT dhlResult = DHL_OK; DS_U32 i = 0; for(i=0;i>8) & 0xFF; ch_buf[2] = (value>>16) & 0xFF; ch_buf[3] = (value>>24) & 0xFF; DHL_DEV_WriteEEPROM(addr, 4, ch_buf); } int get_eeprom(int addr) { DS_U8 ch_buf[4]; int value; DHL_DEV_ReadEEPROM(addr, 4, ch_buf); value = ch_buf[0]; value += ch_buf[1]<<8; value += ch_buf[2]<<16; value += ch_buf[3]<<24; printf("|%s| addr=0x%X, value=0x%08X\n", __FUNCTION__, addr, value); return value; } void test_eeprom(int addr, int len) { int n; for(n=addr; n