/******************************************************************* * DMW_NvRam.c * * NvRam Access API * * Copyright 2003 Digital STREAM Technology, Inc. * All Rights Reserved * * $Id: DMW_NvRam.c,v 0.42 2004 cafrii Exp $ * ********************************************************************/ #include "DMW_Platform.h" #include "DHL_OSAL.h" #include "DHL_NVM.h" #include "DHL_DBG.h" #include "DMW_Config.h" #include "DMW_Status.h" #include "DMW_DebugUtil.h" #include "dmw_nvram_priv.h" #include "DMW_Mutex.h" #include "DMW_MsgQue.h" //#include DHL_MODULE("$nvm", 0); #define max(a,b) (((a) > (b)) ? (a) : (b)) #define min(a,b) (((a) < (b)) ? (a) : (b)) /*-------------------------------------------------------------- Configuration.. */ #define DMW_USE_MINIMIZE_FLASH_WRITE 1 /* neverdai add. 080930 이 모드가 1로 설정되면 counting 때문에 불필요하게 flash가 지워지는 경우를 최대한 줄인다. cafrii 100708, 이 모드를 디폴트로 적용하도록 함. */ #define DMW_SIZE_COUNTING_BUF 8 #define DMW_MAX_COUNTING_NUM (DMW_SIZE_COUNTING_BUF*8) /*8yte를 추가로 counting에 사용한다. 따라서 표현 가능한 숫자는 8*8=64+1(65)개가 된다.*/ /*------------------------------------------ HAL layer EEPROM / FlashRam / etc. */ enum NVRAM_DEVICE_LOCK_ENUM { NVRAM_DEVICE_LOCK_EEPROM = 0, NVRAM_DEVICE_LOCK_FLASH = 1, NVRAM_DEVICE_LOCK_FLASHBUF = 2, /* cafrii 040113 added to increase performance, we make separate lock for flash shadow buffer*/ }; #define NUM_NVRAM_DEVICE_LOCK 3 /* 주의! 이 값을 변경하면 nvramMutex 의 초기값도 꼭 추가해 주도록 하자.*/ #define USE_EEPROM_INIT_AT_DMW 1 /* EEPROM device init in MW level. it is for test debugging. Actually, eeprom driver initializes when first read() or write() function are called. so, this additional init at DMW level is not required. */ #if COMMENT ____NvRamMutex________(){} #endif static DMW_MUTEX nvramMutex[NUM_NVRAM_DEVICE_LOCK] = { /* { SemID, Owner, lockCnt, FailCnt, UseOsMutex, Name, flag, traceLvl } */ { 0, 0, 0, 0, TRUE, "NvMtx1", OS_SEM_PRIO, FALSE, }, { 0, 0, 0, 0, TRUE, "NvMtx2", OS_SEM_PRIO, FALSE, }, { 0, 0, 0, 0, TRUE, "NvMtx3", OS_SEM_PRIO, FALSE, }, }; void lock_nvram_sema4(int deviceid) { if (deviceid < 0 || deviceid >= NUM_NVRAM_DEVICE_LOCK) { dprint(0, "!! lock_nvram_sema4: invalid NvRam device ID %d\n", deviceid); return; } DMW_LockMutex(&nvramMutex[deviceid]); } void unlock_nvram_sema4(int deviceid) { if (deviceid < 0 || deviceid >= NUM_NVRAM_DEVICE_LOCK) { dprint(0, "!! lock_nvram_sema4: invalid NvRam device ID %d\n", deviceid); return; } DMW_UnlockMutex(&nvramMutex[deviceid]); } /* 주소 영역 0x00000000 ~ 0x7fffffff : eeprom 0x80000000 ~ 0xffffffff : flash memory nvram 영역. */ /* eeprom 관련 코드는 나중에 다시 정리 필요함. 반드시 SUPPORT_DMW_EEPROM 플래그와 같이 조건부 빌드가 되도록 하자. */ #if COMMENT ___Flash_Util_________(){} #endif /* count 값에 따른 bit map 예시: 0: ff ff ff ff ff ff ff ff 1: 7f ff ff ff ff ff ff ff 2: 3f ff ff ff ff ff ff ff 3: 1f ff ff ff ff ff ff ff 4: 0f ff ff ff ff ff ff ff 5: 07 ff ff ff ff ff ff ff .. 8: 00 ff ff ff ff ff ff ff 9: 00 7f ff ff ff ff ff ff .. 63: 00 00 00 00 00 00 00 01 64: 00 00 00 00 00 00 00 00 실제로는 0 과 64는 정상적인 값으로 취급하지 않는다. (특별한 의미로 사용) 1 ~ 63 사이의 값이 정상적인 값이다. */ static void p_set_flash_counting(int count, UINT8 *buf) { int i; int bufIdx; int bufOfs; count%=DMW_SIZE_COUNTING_BUF*8; bufIdx=count/8; bufOfs=count%8; for(i=0; i> bufOfs); // 보기 좋게 MSB 부터 clear 해 가자. for(i=bufIdx+1; i>(i%8))) break; } /*neverdai comment*/ /*리턴은 0부터 64까지의 값을 갖게 되지만 실제로 0이나 64값이 리턴되면 IsValidCount()에서 잘못된 값으로 간주되기 때문에 이 함수에서 특별한 에러 처리를 할 필요가 없음*/ return i; } #if COMMENT ____Wrappter___________(){} #endif /* DHL Wrappter 이다. debug message 처리 만 추가된 것임. */ #define DMW_NVM_FLASH_ID 0 /* DHL에서는 여러개의 flash를 사용할 수 있도록 id를 지정할 수 있게 되어 있으나, DMW에서는 하나의 flash 장치만 지원한다. */ void halFlashInit(UINT32 *pAddr1, UINT32 *pAddr2, UINT32 *pSize) { *pSize = DHL_NVM_FlashNvmBlockSize(); *pAddr1 = DHL_NVM_FlashNvmBlockAddr(0); *pAddr2 = DHL_NVM_FlashNvmBlockAddr(1); } STATUS halFlashRead(UINT32 addr, UINT32 size, UINT8 *buf) { DHL_RESULT dhlResult = DHL_OK; if (buf == NULL) return statusInvalidArgument; dhlResult = DHL_NVM_FlashRead(DMW_NVM_FLASH_ID, addr, buf, size); if (dhlResult) { dprint(0, "!! %s(%x, %d, %x): ReadFlash return %d\n", __func__, addr, size, buf, dhlResult); return statusFlashError; } return statusOK; } /* 참고: DHL의 flash write는 필요하면 자동으로 erase하는 기능이 포함되어 있다. */ STATUS halFlashWrite(UINT32 addr, UINT32 size, UINT8 *buf) { DHL_RESULT dhlResult = DHL_OK; if (buf == NULL) return statusInvalidArgument; dhlResult = DHL_NVM_FlashWrite(DMW_NVM_FLASH_ID, addr, buf, size); if (dhlResult) { dprint(0, "!! %s(%x, %d, %x): ProgramFlash return %d\n", __func__, addr, size, buf, dhlResult); return statusFlashError; } return statusOK; } void halFlashSync(void) { DHL_NVM_FlashSync(DMW_NVM_FLASH_ID); } #if COMMENT ____Flash_1___________(){} #endif /* Nor Flash Support Routines*/ /* Example: Spansion compatible Flash memory map bottom type device, uniform boot block size total 4M Byte 이 flash의 특징: 1 block size = 64 K byte (can be different by vendor) 8 bit wide 400000 +------------------------------+ | Block number 70 | 64 KByte | | 3F0000 +------------------------------+ | Block number 69 | | | 3E0000 +------------------------------+ | | | ... | 020000 +------------------------------+ | Block number 8 | 64 KByte | | 010000 +==============================+ 이하 아래 block 몇개는 작은 크기로 되어 있음 | Block number 7 | 00E000 +------------------------------+ | ... | 004000 +------------------------------+ | Block number 1 | 002000 +------------------------------+ | Block number 0 | 8 KByte 000000 +------------------------------+ 위 블럭중에서 firmware 용으로 사용하지 않는 두개 블럭을 NvRam device 1으로 선택해서 사용. */ /*---------------------------------------*/ /* Flash User parameters..*/ typedef struct { UINT32 start_addr; /* 이 Userblock의 시작 주소.. 플래시 메모리 전체 블럭 중에서 NvRam 저장 공간 용도로 사용할 block address.*/ UINT32 end_addr; /* 이 주소는 넘어가면 안됨*/ } FlashUserBlockInfo; FlashUserBlockInfo g_flashUserBlockInfo[2]; /*----------------------------------------------------------------------------------*/ #if COMMENT ____Flash_2___________(){} #endif /******************************************************************* Block의 맨 처음 32 byte는 ID record로서 NvRam I/O API로는 접근 불가. 오직 halFlashXX 루틴으로 update가능하며, count 정보를 비롯한 중요한 데이터가 기록된다. ID record (offset 0, 32 bytes) 0 1 2 3 4 5 6 7 8 9 A B C D E F +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 0x0000 |Magic|vr|ff| count | reserved | +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 0x0010 | reserved | +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ | | | ... | Magic : fixed. 0xCA, 0xFE vr : version. Count : flash revision count *******************************************************************/ #define FLASH_SYSTEM_VERSION 0x03 /* flash layout 버전 정보. 구조가 변경되면 이 값도 증가되어야 함. 8 bit 범위 내에서 정의되어야 함. 0 ~ 0xff 0x03: 2010/7/8, for newby, 새로운 디자인. 사실 layout은 변경 없음. 0x02: 32-bit count value is used. bit-wise operation. 0x01: 초기 layout. */ #define SIZE_OF_ID_RECORD 32 /* block 맨 앞에 ID로 사용되는 예약된 영역 크기*/ #define FLASH_RESERVED_SIZE SIZE_OF_ID_RECORD int FLASH_USER_AREA_SIZE; /* 실제로 user가 사용할 수 있는 flash block의 크기는 예약된 영역을 제외한 크기이다.*/ UINT8 g_NvFlashMagic[4] = { 0xca, 0xfe, FLASH_SYSTEM_VERSION, 0xff}; #define IsValidMagic(a) \ (((a)[0]==g_NvFlashMagic[0]) && ((a)[1]==g_NvFlashMagic[1]) && ((a)[2]==g_NvFlashMagic[2])) #define IsValidCount(c) (((c) >= 1) && ((c) <= DMW_MAX_COUNTING_NUM-1)) /* count 값이 유효한 범위 인지 체크. */ #define InitialCount() 0 /* nvm format 할 때의 count 값 */ #define StartCount() 1 /* reset후 최초 count 값. 1부터 시작해야 flash erase를 최소화 할 수 있음 */ #define NextCount(c) (((c) >= DMW_MAX_COUNTING_NUM-1) ? 1 : (c)+1) /* neverdai 080930 사용 가능한 값은 1에서부터 DMW_MAX_COUNTING_NUM-1이다. 0xff...나 0x00...을 사용하는 것이 적절치 않다고 하면 0과 DMW_MAX_COUNTING_NUM값은 사용할 수 없으며 따라서 실제 사용 가능한 count 값은 1에서부터 DMW_MAX_COUNTING_NUM-1이 된다.*/ UINT8 *g_NvFlashBuffer; /* shadow buffer g_NvFlashBufferValid가 TRUE인 경우에만 유효하다. 앞의 ID_RECORD 부분 만큼은 이 버퍼에 포함되지 않는다. */ BOOL g_NvFlashBufferValid = FALSE; /* TRUE일 때에만 g_NvFlashBuffer의 내용이 의미가 있다. */ BOOL g_NvFlashForceCacheDirty; /* cafrii 070402 add TRUE 이면 항상 cache가 dirty 하다고 가정.. 테스트 용도..*/ #define NVM_VERIFY_BUF_SZ 8192 UINT8 *g_NvVerifyBuffer; /* verify용 버퍼가 너무 작아서 HAL api가 너무 빈번히 실행.. 디버깅 시에 불편하므로, 크기를 키운다. FlashSync 에서만 사용하는데, 이 작업은 NwtTask에서만 실행되므로, race condition 걱정은 하지 않아도 된다. */ /*---------------------------------------------------------------------------- FlashNvmInit Flash를 NVM으로 사용하기 위한 초기화 작업을 한다. */ void FlashNvmInit(void) { UINT32 addr1, addr2, size; halFlashInit(&addr1, &addr2, &size); DHL_ASSERT(addr1!=addr2, "flash nvm block addr invalid!"); g_flashUserBlockInfo[0].start_addr = addr1; g_flashUserBlockInfo[0].end_addr = addr1 + size; g_flashUserBlockInfo[1].start_addr = addr2; g_flashUserBlockInfo[1].end_addr = addr2 + size; dprint(0, "FlashNvmInfo: blksz 0x%x-0x%x, addr[0] 0x%x, addr[1] 0x%x\n", size, FLASH_RESERVED_SIZE, g_flashUserBlockInfo[0].start_addr, g_flashUserBlockInfo[1].start_addr); FLASH_USER_AREA_SIZE = size - FLASH_RESERVED_SIZE; if (g_NvFlashBuffer == NULL) g_NvFlashBuffer = DHL_OS_Malloc(FLASH_USER_AREA_SIZE); if (g_NvVerifyBuffer == NULL) g_NvVerifyBuffer = DHL_OS_Malloc(NVM_VERIFY_BUF_SZ); DHL_ASSERT(g_NvFlashBuffer!=NULL, "flash nvm shadow buffer null"); DHL_ASSERT(g_NvVerifyBuffer!=NULL, "flash nvm verify buffer null"); /* flash buffer를 0이 아닌 0xff 로 초기화 해 놓으면 sync 속도가 조금 더 빨라질 수 있다. (이론적으로..) */ memset(g_NvFlashBuffer, 0xff, FLASH_USER_AREA_SIZE); /* 이 shadow buffer는 한번 할당되고 free 되지 않는다.*/ } /*---------------------------------------------------------------------------- FlashNvmGetAvailableSize 사용자가 사용 가능한 flash 영역의 크기 리턴. (바이트 단위) */ int FlashNvmGetAvailableSize() { return FLASH_USER_AREA_SIZE; } /*---------------------------------------------------------------------------- FlashInvalidFlashCache 테스트 용도.. DRAM에 있는 Buffer Cache를 invalidate 시킨다. Flash read/write stress test를 할 때 기록한 다음에 buffer를 통하지 않고 바로 읽기 위해서 사용한다. */ void FlashNvmInvalidateCacheBuffer() { g_NvFlashBufferValid = FALSE; } /*---------------------------------------------------------------------------- _FlashSelectValidBlock 두개의 block 중에서 어떤 것이 가장 valid한 것인지 결정하는 함수. pCount는 valid한 block에 기록되어 있는 counter 값으로 이 값이 현재 counter가 된다. valid 한 block을 리턴한다. (0 또는 1) valid한 것이 하나도 없다면 -1을 리턴한다. */ int _FlashSelectValidBlock(UINT8 *pCount) { /* return block number (0 or 1) if any block is valid.*/ /* return -1 if both block is invalid..*/ UINT8 buf0[4+DMW_SIZE_COUNTING_BUF], buf1[4+DMW_SIZE_COUNTING_BUF]; int r0, r1; UINT8 cnt0, cnt1; /* counter value to be compared..*/ int lvl; /* debug level */ dprint(2, "select valid flash block:\n"); r0 = halFlashRead(g_flashUserBlockInfo[0].start_addr, 4+DMW_SIZE_COUNTING_BUF, buf0); r1 = halFlashRead(g_flashUserBlockInfo[1].start_addr, 4+DMW_SIZE_COUNTING_BUF, buf1); buf0[3] = p_get_flash_counting(&buf0[4]); buf1[3] = p_get_flash_counting(&buf1[4]); /* comment: bufn[3] is temporary space. it is not saved in flash..*/ if (r0 == 0 && IsValidMagic(buf0) && /* check magic key*/ IsValidCount(buf0[3])) /* check counter*/ cnt0 = buf0[3]; else { lvl = buf0[3] ? 2 : 0; // cnt==0 는 format에 의한 초기값이므로 에러 상황이 아님. dprint(lvl, "%s Block 0 not valid! r %d, magic %02x%02x%02x, cnt %d\n", !lvl ? "!!" : " ", r0, buf0[0], buf0[1], buf0[2], buf0[3]); cnt0 = 0; /* meaning "INVALID!!"*/ } if (r1 == 0 && IsValidMagic(buf1) && /* check magic key*/ IsValidCount(buf1[3])) /* check counter*/ cnt1 = buf1[3]; else { lvl = buf0[3] ? 2 : 0; // cnt==0 는 format에 의한 초기값이므로 에러 상황이 아님. dprint(lvl, "%s Block 1 not valid! r %d, magic %02x%02x%02x, cnt %d\n", !lvl ? "!!" : " ", r1, buf1[0], buf1[1], buf1[2], buf1[3]); cnt1 = 0; /* meaning "INVALID!!"*/ } if (cnt0 == 0 && cnt1 == 0) { /* both block is invalid!!*/ dprint(2, " no valid block!\n"); return -1; } if (cnt0 && cnt1 == 0) { /* only block 0 is valid.*/ dprint(2, "== only block 0 valid, magic %02x%02x%02x, cnt %d\n", buf0[0], buf0[1], buf0[2], cnt0); if (pCount) *pCount = cnt0; return 0; } if (cnt0 == 0 && cnt1) { /* only block 1 is valid.*/ dprint(2, "== only block 1 valid, magic %02x%02x%02x, cnt %d\n", buf1[0], buf1[1], buf1[2], cnt1); if (pCount) *pCount = cnt1; return 1; } /* both blocks are valid. compare and choose newest one.. (big value) this count value is wrapping if reached at end. so just numerical order is not important. */ dprint(2, "== block 0/1 both valid.. cnt %d/%d\n", cnt0, cnt1); dprint(2, " block 0 magic %02x%02x%02x, cnt %d\n", buf0[0], buf0[1], buf0[2], cnt0); dprint(2, " block 1 magic %02x%02x%02x, cnt %d\n", buf1[0], buf1[1], buf1[2], cnt1); if (cnt0 < cnt1) { if (cnt1 - cnt0 < DMW_MAX_COUNTING_NUM/2) { /* +-----------------------------------+ 0 cnt0 cnt1 ff*/ if (cnt1 - cnt0 > 1) dprint(0, "!! warning! cnt0 %d < cnt1 %d not adjacent! use block 1\n", cnt0, cnt1); if (pCount) *pCount = cnt1; return 1; } else { /* count 1이 숫자상으로는 더 큰 값이지만 count 0가 더 최신이다.*/ /*+-----------------------------------+ 0 cnt0 cnt1 ff*/ if (cnt0 != 1 || cnt1 != DMW_MAX_COUNTING_NUM-1) dprint(0, "!! warning! cnt0 %d, cnt1 %d not adjacent! use block 0\n", cnt0, cnt1); if (pCount) *pCount = cnt0; return 0; } } else /* cnt1 <= cnt0*/ { if (cnt0 - cnt1 < DMW_MAX_COUNTING_NUM/2) { /* +-----------------------------------+*/ /* 0 cnt1 cnt0 ff*/ if (cnt0 - cnt1 > 1) dprint(0, "!! warning! cnt1 %d < cnt0 %d not adjacent! use block 1\n", cnt1, cnt0); if (pCount) *pCount = cnt0; return 0; } else { /* count 0이 숫자상으로는 더 큰 값이지만 count 1가 더 최신이다.*/ /* +-----------------------------------+*/ /* 0 cnt1 cnt0 ff*/ if (cnt1 != 1 || cnt0 != DMW_MAX_COUNTING_NUM-1) dprint(0, "!! warning! cnt1 %d, cnt0 %d not adjacent! use block 0\n", cnt1, cnt0); if (pCount) *pCount = cnt1; return 1; } } } /***************************************************************************** _FlashReadSync Flash Read나 Write를 할때 Shadow buffer 내용이 아직 invalid하면 먼저 flash device로부터 buffer로 읽어와서 sync를 한다. caller에서 이미 shadow buffer lock은 된 상태이므로 이 함수에서는 flash lock만 한다. *****************************************************************************/ STATUS _FlashReadSync() { int r, idx; UINT32 base; UINT8 count; lock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASH); /* flash memory*/ if (! g_NvFlashBufferValid) { /* synchronize!*/ /*dprint(2, "%s: flash shadow buffer not synchronized.. do sync now..\n", __FUNCTION__);*/ idx = _FlashSelectValidBlock(&count); if (idx != 0 && idx != 1) { /* 아직 flash IC의 내용이 전혀 초기화가 되지 않았거나 손상되었으므로 format이 필요한 경우이다.*/ dprint(0, "!! %s: both block invalid.. unformatted flash block !!!!\n", __FUNCTION__); /*memset(g_NvFlashBuffer, 0, sizeof(g_NvFlashBuffer));*/ r = statusNvRamNotFormatted; goto end_of_flash_read_sync; } /* idx is block number [0/1].. load flash content to shadow buffer. */ base = g_flashUserBlockInfo[idx].start_addr; dprint(2, " %s: block %d (%x), count 0x%x\n", __FUNCTION__, idx, base, count); r = halFlashRead(base + FLASH_RESERVED_SIZE, FLASH_USER_AREA_SIZE, g_NvFlashBuffer); if (r) { dprint(0, "!! %s: read error %d\n", __FUNCTION__, r); goto end_of_flash_read_sync; } g_NvFlashBufferValid = TRUE; } r = statusOK; end_of_flash_read_sync: unlock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASH); /*flash memory*/ return (STATUS)r; } /***************************************************************************** FlashNvmRead Flash Block 에서 데이터 읽기. 상대 주소 사용.. addr로 사용가능한 값의 범위: 0 ~ FLASH_USER_AREA_SIZE-1 *****************************************************************************/ STATUS FlashNvmRead(UINT32 addr, UINT32 size, UINT8 *buf) { int r; lock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASHBUF); /* flash shadow buffer*/ /* flash shadow buffer integrity check*/ if (! g_NvFlashBufferValid) { /* synchronize!*/ dprint(2, "%s: flash shadow buffer not synchronized.. do sync now..\n", __FUNCTION__); r = _FlashReadSync(); if (r) goto end_of_flash_read; } /* range check*/ if (addr >= (UINT32)FLASH_USER_AREA_SIZE || size >= (UINT32)FLASH_USER_AREA_SIZE || addr + size >= (UINT32)FLASH_USER_AREA_SIZE) { dprint(0, "!! %s: limit over.. addr %u, size %u, end %u\n", __FUNCTION__, addr, size, addr+size); r = statusOutOfRange; goto end_of_flash_read; } /* actual read here! */ memcpy(buf, g_NvFlashBuffer + addr, size); r = statusOK; end_of_flash_read: unlock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASHBUF); /* flash shadow buffer*/ return (STATUS)r; } /***************************************************************************** FlashNvmWrite Flash Target Block에 기록하기. addr는 Target Block에 대한 상대 주소. 0 ~ FLASH_USER_AREA_SIZE-1 target block은 FlashOpenWrite()에서 결정된다. (이 함수를 부르기 전에 꼭 불러야 함) 이 함수가 불리는 시점에서는 기존 데이터는 이미 지워져서 존재하지 않는다. 현재 bufferred write 방식이므로 이 함수에서 실제로 flash writing은 하지 않는다. *****************************************************************************/ STATUS FlashNvmWrite(UINT32 addr, UINT32 size, UINT8 *buf) { int r; lock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASHBUF); /* flash shadow buffer*/ /* flash shadow buffer integrity check*/ if (! g_NvFlashBufferValid) { /* synchronize!*/ dprint(2, "%s: flash shadow buffer not valid.. do sync now..\n", __FUNCTION__); r = _FlashReadSync(); if (r) goto end_of_flash_write; } if (addr >= (UINT32)FLASH_USER_AREA_SIZE || size >= (UINT32)FLASH_USER_AREA_SIZE || addr + size >= (UINT32)FLASH_USER_AREA_SIZE) { dprint(0, "!! %s: limit over.. addr %u, size %u, end %u\n", __FUNCTION__, addr, size, addr+size); r = statusOutOfRange; goto end_of_flash_write; } memcpy(g_NvFlashBuffer + addr, buf, size); r = statusOK; end_of_flash_write: unlock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASHBUF); /* flash shadow buffer*/ return (STATUS)r; } /***************************************************************************** FlashNvmSync Flash shadow buffer의 내용과 flash 실제 내용과 동기화하는 함수 pPartMapList는 flash buffer 내용 중에서 실제로 valid한 데이터가 존재하는 영역들을 알려주는 Map으로서 "영역" 들의 array 로 되어 있다. NULL을 지정하면 전체 영역을 update한다. 2010/7/8, part map list는 더 이상 사용하지 않으므로 코드 제거. *****************************************************************************/ STATUS FlashNvmSync(PartMapRange *pPartMapList) { #undef TMPBLKSZ #define TMPBLKSZ NVM_VERIFY_BUF_SZ STATUS r; int k, n, target; UINT8 count; /* flash count 값 */ UINT8 *source; UINT32 base; int size; UINT8 *tmp = g_NvVerifyBuffer; /* 기록한 다음에 제대로 기록되었는지 체크할때 사용되는 임시 버퍼*/ int this_size, offset; UINT8 header[4+DMW_SIZE_COUNTING_BUF]; // flash 영역 헤더 정보 UINT8 *pFlashShadowBuffer = NULL; // 기록 작업 수행시 사용하는 원본 버퍼 복사본. dprint(2, "%s\n", __FUNCTION__); if (! g_NvFlashBufferValid) { dprint(0, "!! flash shadow buffer invalid! skip!\n"); /* 한번도 Read/Write를 하지 않은 상태에서 Sync를 call한 상황.*/ /* 실제로 synchronize를 할 data가 없으므로 success/fail 둘 다 의미 없음..*/ return statusNotInitialized; } /*--------------------------------------------- Flash shadow buffer g_NvFlashBuffer 데이터를 실제 Flash memory 에 기록한다. shadow buffer를 lock하는 시간을 최소화 하기 위해 shadow buffer 전체를 복사해 놓고 시작하자. definition: UINT8 g_NvFlashBuffer[FLASH_USER_AREA_SIZE];*/ pFlashShadowBuffer = (UINT8 *) DHL_OS_Malloc(sizeof(UINT8)*FLASH_USER_AREA_SIZE); if (pFlashShadowBuffer == NULL) { dprint(0, "!! flash shadow buffer duplicate err\n"); return statusOutOfMemory; } /* 이제 이후 부터는 함수 return할 때 메모리를 꼭 Free를 시켜야 함.*/ /* duplicate with lock */ lock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASHBUF); memcpy(pFlashShadowBuffer, g_NvFlashBuffer, sizeof(UINT8)*FLASH_USER_AREA_SIZE); unlock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASHBUF); /* FlashRead/Write 에서는 FlashBuf를 먼저 lock 한 다음에 Flash를 lock 하고 있다. 따라서 FlashBuf mutex와 Flash mutex는 서로 DeadLock이 될 가능성이 있기 때문에 가능하면 서로 중첩해서 mutex lock을 하지 말도록 하자. ---------------------------------------------*/ lock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASH); /* Flash shadow buffer g_NvFlashBuffer 데이터를 Flash에 기록하기 전에 실제 Flash memory 내용과 차이가 있는지 체크한다. 실제 내용과 차이가 없다면 굳이 다시 기록할 필요가 없기 때문. */ n = _FlashSelectValidBlock(&count); /* n은 valid 한 block 번호. 0 or 1*/ if (n != 0 && n != 1) { /* no valid block!! compare check를 할 필요가 없다. 둘 다 invalid 이므로 target으로는 아무거나 고르면 된다. 0 default*/ target = 0; count = StartCount(); } else { target = (n == 0) ? 1 : 0; /* write target은 invalid block 또는 둘 중에서 오래된 block으로 정한다. valid block이 0이면 1을 삭제하고 1이 valid하면 0을 삭제한다.*/ base = g_flashUserBlockInfo[n].start_addr + FLASH_RESERVED_SIZE; /* 앞부분 예약 영역은 제외한다.*/ size = FLASH_USER_AREA_SIZE; /* 전체 크기.*/ source = pFlashShadowBuffer; /* 비교할 데이터 포인터..*/ /*dprint(2, " compare before start synching..\n");*/ if (g_NvFlashForceCacheDirty) { dprint(0, "!! force cache dirty flag..\n"); goto start_flash_sync; } // *, /, % 연산자 사용을 최소화 하도록 로직 개선. for (k=0; k= 0) { dprint(2, "!! mismatch found, offset [%u], buf %u != flash %u\n", k*TMPBLKSZ+offset, source[k*TMPBLKSZ+offset], tmp[offset]); goto start_flash_sync; } #else /* 어디가 어떻게 mismatch 되는지 알 필요가 없는 경우에는 그냥 memcmp를 */ /* 사용해서 실행 속도를 높이자.*/ if (memcmp(&source[k], tmp, this_size)) { dprint(2, " flash cache dirty. sync now.. target %d\n", target); goto start_flash_sync; } #endif } dprint(2, " flash cache consistent. no need to sync\n"); r = statusOK; goto end_of_flash_sync; } start_flash_sync: /*--------------------------------------------- 이제 실제 flash memory에 기록한다. target은 삭제할 user block이다. 0 아니면 1 둘중 하나임. user block이 한개 이상의 flash block으로 이루어져 있을 수 있다.. 복수개의 flash block으로 이루어진 경우를 간주해야 하며, 이 경우 invalid block인지 아닌지도 체크해야 한다.*/ dprint(2, " Target block for write: %d (%x), last count: %d\n", target, g_flashUserBlockInfo[target].start_addr, count); base = g_flashUserBlockInfo[target].start_addr + FLASH_RESERVED_SIZE; /* 앞부분 예약 영역은 제외한다.*/ /* 지금까지 buffer된 데이터 기록.*/ dprint(2, " write buffered data..\n"); if (1) /* 전체 block을 다 기록..*/ { size = FLASH_USER_AREA_SIZE; /* 전체 크기.*/ source = pFlashShadowBuffer; /* 기록할 데이터 포인터..*/ dprint(2, " update entire region, addr %x size %x src %x\n", base, size, source); r = halFlashWrite(base, size, source); if (r) { dprint(0, "!! %s: halFlashWrite(%x, sz %x) err %d\n", __FUNCTION__, base, size, r); goto end_of_flash_sync; } dprint(2, " verification..\n"); for (k=0; k= 0) { dprint(0, "!! verify err! [%u] buf %u != flash %u\n", k+offset, source[k+offset], tmp[offset]); r = statusError; /* statusVerifyError..*/ goto end_of_flash_sync; } } /* end verify */ } /* write magic key and count */ /* 디버깅 테스트 용으로, 기존 데이터를 먼저 보여준다. */ halFlashRead(g_flashUserBlockInfo[target].start_addr, 4+DMW_SIZE_COUNTING_BUF, header); dprint(2, " write magic key.. (old data: %02x%02x%02x, old cnt %d)\n", header[0], header[1], header[2], p_get_flash_counting(&header[4])); /* 새로운 값을 준비하고 기록한다. */ memcpy(header, g_NvFlashMagic, 4); count = NextCount(count); p_set_flash_counting(count, &header[4]); base = g_flashUserBlockInfo[target].start_addr; r = halFlashWrite(base, 4+DMW_SIZE_COUNTING_BUF, header); if (r) { dprint(0, "!! %s: halFlashWrite(magic, cnt %d) err %d\n", __FUNCTION__, count, r); } else dprint(2, "==== Block %d (%x): new count %d updated\n", target, base, count); /* 100422, nvram update 후 flush 해준다 */ halFlashSync(); end_of_flash_sync: if (pFlashShadowBuffer) DHL_OS_Free((void**)&pFlashShadowBuffer); unlock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASH); return (STATUS)r; } /*------------------------------------------ FlashNvmFormat */ STATUS FlashNvmFormat(void) { int r, r0; int target; UINT8 buf[4+DMW_SIZE_COUNTING_BUF]={0,0,0,0,}; UINT8 cnt = 1; UINT32 base; lock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASH); dprint(2, "%s:\n", __FUNCTION__); /* 두 block을 모두 삭제한다.*/ for (target=0; target<2; target++) { base = g_flashUserBlockInfo[target].start_addr; memcpy(buf, g_NvFlashMagic, 4); cnt = InitialCount(); /* 최초의 값은 모두 0으로 한다. 아직 제대로 된 데이터가 기록되지 않았으므로 invalid 하다는 정보를 남겨둬야 한다. */ p_set_flash_counting(cnt, &buf[4]); /*dprint(3, " write magic key and initial count value %d\n", cnt);*/ r = halFlashWrite(base, 4+DMW_SIZE_COUNTING_BUF, buf); if (r) { dprint(0, "!! %s: halFlashWrite(magic, cnt %d) err %d\n", __FUNCTION__, cnt, r); } else dprint(2, " Block %d (%x): new count %d updated\n", target, base, cnt); } // 다음번에 _ReadSync 를 하지 않고 바로 write 가능하도록.. memset(g_NvFlashBuffer, 0xff, FLASH_USER_AREA_SIZE); g_NvFlashBufferValid = TRUE; dprint(1, " Format completed\n"); unlock_nvram_sema4(NVRAM_DEVICE_LOCK_FLASH); return (STATUS)r; } STATUS FlashNvmCheckValid(void) { STATUS status; UINT8 buf[10]; /* 만약 flash cache가 수정된 상태라면 부주의로 invalidate 하다가는 데이터를 잃어버릴 것이다. 사용 금지.. FlashNvmInvalidateCacheBuffer(); */ /* this cause flash read sync. reading ANY byte is ok.*/ status = FlashNvmRead(0, 1, buf); if (status) { dprint(0, "!! flash seems unformatted\n"); return status; } #if 0 /* bug! this is not needed and below code has error!*/ if (memcmp(buf, g_NvFlashMagic, 3)) { return statusNotInitialized; } #endif return statusOK; } #if COMMENT ____NvRamWorkerThread_____(){} #endif /******************************************************************* NvRam WorkerThread Main purpose of this task is background FlashSync.. ********************************************************************/ #define NWT_TASK_PRIORITY TASK_PRI_DMW_FLASH #define NWT_STACK_SIZE 8192 volatile DHL_OS_TASK_ID g_NvRam_WorkerTask; UINT32 g_NvRam_FlashSyncCount; /* 아직 test용임.. caller가 언제 flash sync가 종료되었는지를 알수 있도록 count 값을 제공하자.. */ BOOL g_NvRam_FlashSyncWorking; typedef enum { /* NvRam Worker Task Command*/ NWTCMD_FlashSync = 0xB0, /*NWTCMD_FlashFormat, *//*not defined..*/ /*NWTCMD_Flashxxxx, */ NWTCMD_Shutdown, } NWTCMD; /*----------------------------------------------*/ /* User Message Queue implementation*/ typedef struct { NWTCMD cmd; //UINT32 param; } NwtCmdMsg; static const char *NwtCmdName(NwtCmdMsg *msg) { if (msg->cmd == NWTCMD_FlashSync) return "sync"; if (msg->cmd == NWTCMD_Shutdown) return "shutdown"; return "?"; } static DMW_MSGQUE g_NvmMsgQue; #define SZ_USER_MSG_Q 50 //NwtCmdMsg g_NvRam_WorkerUserQ[SZ_USER_MSG_Q]; /* Mutex = { SemID, Owner, lockCnt, FailCnt, UseOsMutex, Name, flag, traceLvl }*/ static DMW_MUTEX NwtMsgQueMutex = { 0, 0, 0, 0, FALSE, "NwtMsgQ", OS_SEM_PRIO, 1, }; void NwtLockMutex(BOOL bLock) { if (bLock) DMW_LockMutex(&NwtMsgQueMutex); else DMW_UnlockMutex(&NwtMsgQueMutex); } void TestPrintUserMsgQ() { NwtLockMutex(TRUE); DMW_SYS_PrintUserMsgs(&g_NvmMsgQue, (DMW_FN_MSG_NAME)NwtCmdName); NwtLockMutex(FALSE); } static BOOL NwtIsSyncCmd(NwtCmdMsg *msg, UINT32 param) { return (msg->cmd == NWTCMD_FlashSync) ? TRUE : FALSE; } int tNvRamWorker(int arg) { NwtCmdMsg um; STATUS status; UINT32 tick; int delay = 1000/10; /*------------------------------ command message 받는 부분. ------------------------------*/ label_loop_begin: status = DMW_SYS_GetUserMsg(&g_NvmMsgQue, &um, DHL_TIMEOUT_FOREVER); if (status) { DHL_OS_Delay(delay); goto label_loop_begin; } NwtLockMutex(TRUE); g_NvRam_FlashSyncWorking = TRUE; NwtLockMutex(FALSE); /*------------------------------ command message 처리 부분.. ------------------------------*/ if (um.cmd == NWTCMD_FlashSync) { int i, ptr; //UINT32 count = um.param; BOOL bFutureFlashSyncFound = FALSE; dprint(2, "NWTCMD_FlashSync:\n"); /* We must not do flash sync whenever command receives. first, we should peek user msg Queue.. */ NwtLockMutex(TRUE); bFutureFlashSyncFound = DMW_SYS_CheckSpecificMsgExist(&g_NvmMsgQue, (DMW_FN_MSG_CHECK)NwtIsSyncCmd, 0); NwtLockMutex(FALSE); if (bFutureFlashSyncFound) { dprint(2, "\t!! this flash sync cmd is ignored by future FlashSync..\n"); goto label_loop_begin; } /* Now, do flash sync..*/ dprint(2, "\t--> Start flash sync (NULL)\n"); tick = DHL_OS_GetMsCount(); FlashNvmSync(NULL); NwtLockMutex(TRUE); g_NvRam_FlashSyncCount++; /* cafrii 050413 add for provide info to caller when sync end*/ g_NvRam_FlashSyncWorking = FALSE; NwtLockMutex(FALSE); dprint(2, "\t<-- End flash sync (NULL), %d ms\n", (DHL_OS_GetMsCount()-tick)); } else if (um.cmd == NWTCMD_Shutdown) { dprint(2, "NWTCMD_Shutdown:\n"); goto label_loop_end; } goto label_loop_begin; /*------------------------------ task 종료.. shutdown ------------------------------*/ label_loop_end: dprint(2, "NvRam Worker task is about to shutdown..\n"); NwtLockMutex(TRUE); g_NvRam_FlashSyncWorking = FALSE; NwtLockMutex(FALSE); g_NvRam_WorkerTask = 0; DHL_OS_SelfDeleteTask(); return 0; } int NwtCreateResources() { DHL_OS_TASK_ID tid; if (g_NvRam_WorkerTask == 0) { dprint(2, "** create Nwt Task..\n"); tid = DHL_OS_CreateTask((DHL_OS_TASKFUNCTION) tNvRamWorker, "NwtTask", NWT_TASK_PRIORITY, NWT_STACK_SIZE, 0); if (tid == (DHL_OS_TASK_ID)0) { dprint(0, "!! NwtTask spawn err!\n"); return statusOutOfResource; } dprint(2, " task %x created.\n", tid); g_NvRam_WorkerTask = tid; } return statusOK; } STATUS NwtSendCommand(NWTCMD cmd, UINT32 param) { NwtCmdMsg um; STATUS status; memset(&um, 0, sizeof(NwtCmdMsg)); um.cmd = cmd; //um.param = param; NwtLockMutex(TRUE); status = DMW_SYS_AddUserMsg(&g_NvmMsgQue, &um); NwtLockMutex(FALSE); return status; } #if COMMENT ______NvRam_API_______(){} #endif /******************************************************************* NvRamInit NvRam을 사용하기 위해서 초기화를 한다. 실제로 format, reset 등의 작업을 하는 것이 아님에 유의. ********************************************************************/ void NvRamInit(void) { DMW_SYS_InitMsgQue(&g_NvmMsgQue, sizeof(NwtCmdMsg), SZ_USER_MSG_Q, (DMW_FN_MSG_NAME)NwtCmdName); FlashNvmInit(); /* eeprom은 동적 init을 하도록 이미 되어 있으니 불필요.*/ } /******************************************************************* NvRamGetAvailableSize ********************************************************************/ UINT32 NvRamGetAvailableSize(int device) { /*------------------- device 1 -------------------*/ if (device) /* device 1*/ return FlashNvmGetAvailableSize(); #if SUPPORT_DMW_EEPROM return EepromGetAvailableSize(); #else return 0; #endif } /******************************************************************* NvRamCheckValid ********************************************************************/ STATUS NvRamCheckValid(void) { /* eeprom의 경우는 valid check가 불가능.*/ return FlashNvmCheckValid(); } /******************************************************************* NvRamRead NvRam 데이터를 읽는다. device 1의 경우 (flash) shadow buffer와 I/O를 수행. ********************************************************************/ STATUS NvRamRead(UINT32 address, UINT32 size, UINT8 *buf) { int err; if (NwtCreateResources()) return statusOutOfResource; if (size == 0) return statusOK; /*------------------- device 1 -------------------*/ if (address & 0x80000000) /* device 1*/ { err = FlashNvmRead(address & 0x7fffffff, size, buf); return (STATUS)err; } /*------------------- device 0 -------------------*/ #if SUPPORT_DMW_EEPROM err = EepromRead(address, size, buf); return err; #else return statusNotImpl; #endif /* SUPPORT_DMW_EEPROM*/ } /******************************************************************* NvRamWrite NvRam에 데이터를 기록한다. device 1의 경우 (flash) shadow buffer와 I/O를 수행. ********************************************************************/ STATUS NvRamWrite(UINT32 address, UINT32 size, UINT8 *buf) { int err; if (NwtCreateResources()) return statusOutOfResource; if (size == 0) return statusOK; /*------------------- device 1 -------------------*/ if (address & 0x80000000) /* device 1*/ { err = FlashNvmWrite(address & 0x7fffffff, size, buf); return (STATUS)err; } /*------------------- device 0 -------------------*/ #if SUPPORT_DMW_EEPROM err = EepromWrite(address, size, buf); return err; #else return statusNotImpl; #endif /* SUPPORT_DMW_EEPROM*/ } /******************************************************************* NvRamSync flash 영역의 주소일 경우 shadow buffer 내용과 실제 device 내용을 일치시킨다. 즉 buffer->flash로 기록함. ********************************************************************/ STATUS NvRamSync(UINT32 addr, PartMapRange *pPartMapList) { STATUS r; if (NwtCreateResources()) return statusOutOfResource; if (addr & 0x80000000) { r = NwtSendCommand(NWTCMD_FlashSync, 0); dprint(2, "NvRamSync: deferred to NWT..\n"); return r; } #if SUPPORT_DMW_EEPROM /* device 0에 대해서는 sync 개념이 없다.*/ return statusOK; #else /* eeprom 기능 없음.*/ return statusNotImpl; #endif } /******************************************************************* NvRamIsSyncEnd NvRamSync 작업이 종료되서 idle 상태이면 TRUE를 리턴. ********************************************************************/ BOOL NvRamIsSyncEnd() { /* return TRUE if Sync is completed.*/ BOOL bSyncWorking; NwtLockMutex(TRUE); if (!DMW_SYS_UserMsgExist(&g_NvmMsgQue) && g_NvRam_FlashSyncWorking == FALSE) bSyncWorking = FALSE; else bSyncWorking = TRUE; NwtLockMutex(FALSE); return !bSyncWorking; } /******************************************************************* NvRamWaitForSyncEnd NvRam Sync 작업이 진행중일 경우 종료될 때 까지 기다린다. ********************************************************************/ void NvRamWaitForSyncEnd() { UINT32 ms0, ms1, ms; ms0 = ms1 = DHL_OS_GetMsCount(); while (!NvRamIsSyncEnd()) { ms = DHL_OS_GetMsCount(); if (ms-ms1 > 4000) { dprint(0, "!! nvm sync too slow! %u ms elapsed?\n", ms-ms0); ms1 = ms; } DHL_OS_Delay(100); } } /******************************************************************* NvRamInvalidateCache flash shadow buffer의 내용을 무효화 시킨다. 이후 NvRamRead/Write를 할 때 다시 device로부터 읽어들인다. ********************************************************************/ void NvRamInvalidateCache() { /*device 0:*/ /*EEPROM에는 cache가 없다.*/ /* device 1:*/ FlashNvmInvalidateCacheBuffer(); } /******************************************************************* NvRamFormat nvm device를 포맷한다. flash nvm에만 해당. ********************************************************************/ STATUS NvRamFormat() { NvRamWaitForSyncEnd(); return FlashNvmFormat(); } /******************************************************************* NvRamShutdown ********************************************************************/ STATUS NvRamShutdown() { UINT32 tickStart; NwtSendCommand(NWTCMD_Shutdown, 0); /* shutdown 될 때까지 기다려야 한다..*/ tickStart = DHL_OS_GetMsCount(); while (g_NvRam_WorkerTask && DHL_OS_GetMsCount() - tickStart < 6*1000) DHL_OS_Delay(1000/4); dprint(2, "NvRamShutdown: WorkerTask %s died\n", g_NvRam_WorkerTask ? "NOT" : ""); return g_NvRam_WorkerTask ? statusError : statusOK; } #if COMMENT ____Test___________(){} #endif void _dump_eeprom(int start, int size) { int i; UINT8 t[1]; DHL_OS_Printf("Secret Dump of EEPROM (%x~%x)\n", start, start+size); for (i=0; i d 0xbb000000 + offset */ void _dump_flash(UINT32 start, UINT32 size) { #define DUMP_CHUNK_SIZE 512 unsigned int i, k, len, r; UINT8 t[DUMP_CHUNK_SIZE]; //int oldflag = g_Trace_NvRamDebug; //g_Trace_NvRamDebug = 1; if (start & 0xf) { size += (start & 0xf); start &= ~0xf; } DHL_OS_Printf("==== Secret Dump of Flash (%x~%x) ====\n", start, start+size); for (i=0; i<(size+DUMP_CHUNK_SIZE-1)/DUMP_CHUNK_SIZE; i++) { len = min(size - DUMP_CHUNK_SIZE*i, DUMP_CHUNK_SIZE); r = halFlashRead(start+i*DUMP_CHUNK_SIZE, len, t); /* len 크기만 읽어도 되고, 다 읽어도 되고..*/ /* display..*/ for (k=0; k