Smart-agriculture-project
/
smart-green-house
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
smart-green-house/project_ZigBee/Components/osal/mcu/cc2530/OSAL_Nv.c

1500 lines
42 KiB
C
Raw Permalink Normal View History

version1版本硬件模块代码
2023-10-28 18:00:47 +08:00
/******************************************************************************
Filename: OSAL_Nv.c
Revised: $Date: 2011-06-05 18:52:21 -0700 (Sun, 05 Jun 2011) $
Revision: $Revision: 26212 $
Description: This module contains the OSAL non-volatile memory functions.
Copyright 2006-2011 Texas Instruments Incorporated. All rights reserved.
IMPORTANT: Your use of this Software is limited to those specific rights
granted under the terms of a software license agreement between the user
who downloaded the software, his/her employer (which must be your employer)
and Texas Instruments Incorporated (the "License"). You may not use this
Software unless you agree to abide by the terms of the License. The License
limits your use, and you acknowledge, that the Software may not be modified,
copied or distributed unless embedded on a Texas Instruments microcontroller
or used solely and exclusively in conjunction with a Texas Instruments radio
frequency transceiver, which is integrated into your product. Other than for
the foregoing purpose, you may not use, reproduce, copy, prepare derivative
works of, modify, distribute, perform, display or sell this Software and/or
its documentation for any purpose.
YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE
PROVIDED <EFBFBD>AS IS<EFBFBD> WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE,
NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL
TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,
NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER
LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE
OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT
OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
(INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
Should you have any questions regarding your right to use this Software,
contact Texas Instruments Incorporated at www.TI.com.
******************************************************************************/
/******************************************************************************
Notes:
- A trick buried deep in initPage() requires that the MSB of the NV Item Id
is to be reserved for use by this module.
******************************************************************************/
/*********************************************************************
* INCLUDES
*/
#include "hal_adc.h"
#include "hal_flash.h"
#include "hal_types.h"
#include "OSAL_Nv.h"
#include "ZComDef.h"
/*********************************************************************
* CONSTANTS
*/
#define OSAL_NV_PAGE_SIZE HAL_FLASH_PAGE_SIZE
#define OSAL_NV_PAGES_USED HAL_NV_PAGE_CNT
#define OSAL_NV_PAGE_BEG HAL_NV_PAGE_BEG
#define OSAL_NV_PAGE_END (OSAL_NV_PAGE_BEG + OSAL_NV_PAGES_USED - 1)
#define OSAL_NV_ACTIVE 0x00
#define OSAL_NV_ERASED 0xFF
#define OSAL_NV_ERASED_ID 0xFFFF
#define OSAL_NV_ZEROED_ID 0x0000
// Reserve MSB of Id to signal a search for the "old" source copy (new write interrupted/failed.)
#define OSAL_NV_SOURCE_ID 0x8000
// In case pages 0-1 are ever used, define a null page value.
#define OSAL_NV_PAGE_NULL 0
// In case item Id 0 is ever used, define a null item value.
#define OSAL_NV_ITEM_NULL 0
#define OSAL_NV_WORD_SIZE HAL_FLASH_WORD_SIZE
#define OSAL_NV_PAGE_HDR_OFFSET 0
#define OSAL_NV_MAX_HOT 3
static const uint16 hotIds[OSAL_NV_MAX_HOT] = {
ZCD_NV_NWKKEY,
ZCD_NV_NWK_ACTIVE_KEY_INFO,
ZCD_NV_NWK_ALTERN_KEY_INFO,
};
/*********************************************************************
* MACROS
*/
#define OSAL_NV_CHECK_BUS_VOLTAGE HalAdcCheckVdd(VDD_MIN_NV)
#define OSAL_NV_DATA_SIZE( LEN ) \
(((LEN) >= ((uint16)(65536UL - OSAL_NV_WORD_SIZE))) ? \
((uint16)(65536UL - OSAL_NV_WORD_SIZE)) : \
((((LEN) + OSAL_NV_WORD_SIZE - 1) / OSAL_NV_WORD_SIZE) * OSAL_NV_WORD_SIZE))
#define OSAL_NV_ITEM_SIZE( LEN ) \
(((LEN) >= ((uint16)(65536UL - OSAL_NV_WORD_SIZE - OSAL_NV_HDR_SIZE))) ? \
((uint16)(65536UL - OSAL_NV_WORD_SIZE)) : \
(((((LEN) + OSAL_NV_WORD_SIZE - 1) / OSAL_NV_WORD_SIZE) * OSAL_NV_WORD_SIZE) + OSAL_NV_HDR_SIZE))
#define COMPACT_PAGE_CLEANUP( COM_PG ) st ( \
/* In order to recover from a page compaction that is interrupted,\
* the logic in osal_nv_init() depends upon the following order:\
* 1. State of the target of compaction is changed to ePgInUse.\
* 2. Compacted page is erased.\
*/\
setPageUse( pgRes, TRUE ); /* Mark the reserve page as being in use. */\
erasePage( (COM_PG) ); \
\
pgRes = (COM_PG); /* Set the reserve page to be the newly erased page. */\
)
/*********************************************************************
* TYPEDEFS
*/
typedef struct
{
uint16 id;
uint16 len; // Enforce Flash-WORD size on len.
uint16 chk; // Byte-wise checksum of the 'len' data bytes of the item.
uint16 stat; // Item status.
} osalNvHdr_t;
// Struct member offsets.
#define OSAL_NV_HDR_ID 0
#define OSAL_NV_HDR_LEN 2
#define OSAL_NV_HDR_CHK 4
#define OSAL_NV_HDR_STAT 6
#define OSAL_NV_HDR_ITEM 2 // Length of any item of a header struct.
#define OSAL_NV_HDR_SIZE 8
#define OSAL_NV_HDR_HALF (OSAL_NV_HDR_SIZE / 2)
typedef struct
{
uint16 active;
uint16 inUse;
uint16 xfer;
uint16 spare;
} osalNvPgHdr_t;
// Struct member offsets.
#define OSAL_NV_PG_ACTIVE 0
#define OSAL_NV_PG_INUSE 2
#define OSAL_NV_PG_XFER 4
#define OSAL_NV_PG_SPARE 6
#define OSAL_NV_PAGE_HDR_SIZE 8
#define OSAL_NV_PAGE_HDR_HALF (OSAL_NV_PAGE_HDR_SIZE / 2)
typedef enum
{
eNvXfer,
eNvZero
} eNvHdrEnum;
typedef enum
{
ePgActive,
ePgInUse,
ePgXfer,
ePgSpare
} ePgHdrEnum;
/*********************************************************************
* GLOBAL VARIABLES
*/
#ifndef OAD_KEEP_NV_PAGES
// When NV pages are to remain intact during OAD download,
// the image itself should not include NV pages.
#pragma location="ZIGNV_ADDRESS_SPACE"
__no_init uint8 _nvBuf[OSAL_NV_PAGES_USED * OSAL_NV_PAGE_SIZE];
#pragma required=_nvBuf
#endif // OAD_KEEP_NV_PAGES
/*********************************************************************
* LOCAL VARIABLES
*/
// Offset into the page of the first available erased space.
static uint16 pgOff[OSAL_NV_PAGES_USED];
// Count of the bytes lost for the zeroed-out items.
static uint16 pgLost[OSAL_NV_PAGES_USED];
static uint8 pgRes; // Page reserved for item compacting transfer.
// Saving ~100 code bytes to move a uint8* parameter/return value from findItem() to a global.
static uint8 findPg;
// NV page and offsets for hot items.
static uint8 hotPg[OSAL_NV_MAX_HOT];
static uint16 hotOff[OSAL_NV_MAX_HOT];
/*********************************************************************
* LOCAL FUNCTIONS
*/
static uint8 initNV( void );
static void setPageUse( uint8 pg, uint8 inUse );
static uint16 initPage( uint8 pg, uint16 id, uint8 findDups );
static void erasePage( uint8 pg );
static uint8 compactPage( uint8 srcPg, uint16 skipId );
static uint16 findItem( uint16 id );
static uint8 initItem( uint8 flag, uint16 id, uint16 len, void *buf );
static void setItem( uint8 pg, uint16 offset, eNvHdrEnum stat );
static uint16 setChk( uint8 pg, uint16 offset, uint16 chk );
static uint16 calcChkB( uint16 len, uint8 *buf );
static uint16 calcChkF( uint8 pg, uint16 offset, uint16 len );
static void writeWord( uint8 pg, uint16 offset, uint8 *buf );
static void writeWordH( uint8 pg, uint16 offset, uint8 *buf );
static void writeWordM( uint8 pg, uint16 offset, uint8 *buf, uint16 cnt );
static void writeBuf( uint8 pg, uint16 offset, uint16 len, uint8 *buf );
static void xferBuf( uint8 srcPg, uint16 srcOff, uint8 dstPg, uint16 dstOff, uint16 len );
static uint8 writeItem( uint8 pg, uint16 id, uint16 len, void *buf, uint8 flag );
static uint8 hotItem(uint16 id);
static void hotItemUpdate(uint8 pg, uint16 off, uint16 id);
/*********************************************************************
* @fn initNV
*
* @brief Initialize the NV flash pages.
*
* @param none
*
* @return TRUE
*/
static uint8 initNV( void )
{
osalNvPgHdr_t pgHdr;
uint8 oldPg = OSAL_NV_PAGE_NULL;
uint8 findDups = FALSE;
uint8 pg;
pgRes = OSAL_NV_PAGE_NULL;
for ( pg = OSAL_NV_PAGE_BEG; pg <= OSAL_NV_PAGE_END; pg++ )
{
HalFlashRead(pg, OSAL_NV_PAGE_HDR_OFFSET, (uint8 *)(&pgHdr), OSAL_NV_HDR_SIZE);
if ( pgHdr.active == OSAL_NV_ERASED_ID )
{
if ( pgRes == OSAL_NV_PAGE_NULL )
{
pgRes = pg;
}
else
{
setPageUse( pg, TRUE );
}
}
// An Xfer from this page was in progress.
else if ( pgHdr.xfer != OSAL_NV_ERASED_ID )
{
oldPg = pg;
}
}
// If a page compaction was interrupted before the old page was erased.
if ( oldPg != OSAL_NV_PAGE_NULL )
{
/* Interrupted compaction before the target of compaction was put in use;
* so erase the target of compaction and start again.
*/
if ( pgRes != OSAL_NV_PAGE_NULL )
{
erasePage( pgRes );
(void)compactPage( oldPg, OSAL_NV_ITEM_NULL );
}
/* Interrupted compaction after the target of compaction was put in use,
* but before the old page was erased; so erase it now and create a new reserve page.
*/
else
{
erasePage( oldPg );
pgRes = oldPg;
}
}
else if ( pgRes != OSAL_NV_PAGE_NULL )
{
erasePage( pgRes ); // The last page erase could have been interrupted by a power-cycle.
}
/* else if there is no reserve page, COMPACT_PAGE_CLEANUP() must have succeeded to put the old
* reserve page (i.e. the target of the compacted items) into use but got interrupted by a reset
* while trying to erase the page to be compacted. Such a page should only contain duplicate items
* (i.e. all items will be marked 'Xfer') and thus should have the lost count equal to the page
* size less the page header.
*/
for ( pg = OSAL_NV_PAGE_BEG; pg <= OSAL_NV_PAGE_END; pg++ )
{
// Calculate page offset and lost bytes - any "old" item triggers an N^2 re-scan from start.
if ( initPage( pg, OSAL_NV_ITEM_NULL, findDups ) != OSAL_NV_ITEM_NULL )
{
findDups = TRUE;
pg = (OSAL_NV_PAGE_BEG - 1); // Pre-decrement so that loop increment will start over at zero.
continue;
}
}
if (findDups)
{
// Final pass to calculate page lost after invalidating duplicate items.
for ( pg = OSAL_NV_PAGE_BEG; pg <= OSAL_NV_PAGE_END; pg++ )
{
(void)initPage( pg, OSAL_NV_ITEM_NULL, FALSE );
}
}
if ( pgRes == OSAL_NV_PAGE_NULL )
{
uint8 idx, mostLost = 0;
for ( idx = 0; idx < OSAL_NV_PAGES_USED; idx++ )
{
// Is this the page that was compacted?
if (pgLost[idx] == (OSAL_NV_PAGE_SIZE - OSAL_NV_PAGE_HDR_SIZE))
{
mostLost = idx;
break;
}
/* This check is not expected to be necessary because the above test should always succeed
* with an early loop exit.
*/
else if (pgLost[idx] > pgLost[mostLost])
{
mostLost = idx;
}
}
pgRes = mostLost + OSAL_NV_PAGE_BEG;
erasePage( pgRes ); // The last page erase had been interrupted by a power-cycle.
}
return TRUE;
}
/*********************************************************************
* @fn setPageUse
*
* @brief Set page header active/inUse state according to 'inUse'.
*
* @param pg - Valid NV page to verify and init.
* @param inUse - Boolean TRUE if inUse, FALSE if only active.
*
* @return none
*/
static void setPageUse( uint8 pg, uint8 inUse )
{
osalNvPgHdr_t pgHdr;
pgHdr.active = OSAL_NV_ZEROED_ID;
if ( inUse )
{
pgHdr.inUse = OSAL_NV_ZEROED_ID;
}
else
{
pgHdr.inUse = OSAL_NV_ERASED_ID;
}
writeWord( pg, OSAL_NV_PAGE_HDR_OFFSET, (uint8*)(&pgHdr) );
}
/*********************************************************************
* @fn initPage
*
* @brief Walk the page items; calculate checksums, lost bytes & page offset.
*
* @param pg - Valid NV page to verify and init.
* @param id - Valid NV item Id to use function as a "findItem".
* If set to NULL then just perform the page initialization.
* @param findDups - TRUE on recursive call from initNV() to find and zero-out duplicate items
* left from a write that is interrupted by a reset/power-cycle.
* FALSE otherwise.
*
* @return If 'id' is non-NULL and good checksums are found, return the offset
* of the data corresponding to item Id; else OSAL_NV_ITEM_NULL.
*/
static uint16 initPage( uint8 pg, uint16 id, uint8 findDups )
{
uint16 offset = OSAL_NV_PAGE_HDR_SIZE;
uint16 sz, lost = 0;
osalNvHdr_t hdr;
do
{
HalFlashRead(pg, offset, (uint8 *)(&hdr), OSAL_NV_HDR_SIZE);
if ( hdr.id == OSAL_NV_ERASED_ID )
{
break;
}
// Get the actual size in bytes which is the ceiling(hdr.len)
sz = OSAL_NV_DATA_SIZE( hdr.len );
// A bad 'len' write has blown away the rest of the page.
if (sz > (OSAL_NV_PAGE_SIZE - OSAL_NV_HDR_SIZE - offset))
{
lost += (OSAL_NV_PAGE_SIZE - offset);
offset = OSAL_NV_PAGE_SIZE;
break;
}
offset += OSAL_NV_HDR_SIZE;
if ( hdr.id != OSAL_NV_ZEROED_ID )
{
/* This trick allows function to do double duty for findItem() without
* compromising its essential functionality at powerup initialization.
*/
if ( id != OSAL_NV_ITEM_NULL )
{
/* This trick allows asking to find the old/transferred item in case
* of a successful new item write that gets interrupted before the
* old item can be zeroed out.
*/
if ( (id & 0x7fff) == hdr.id )
{
if ( (((id & OSAL_NV_SOURCE_ID) == 0) && (hdr.stat == OSAL_NV_ERASED_ID)) ||
(((id & OSAL_NV_SOURCE_ID) != 0) && (hdr.stat != OSAL_NV_ERASED_ID)) )
{
return offset;
}
}
}
// When invoked from the osal_nv_init(), verify checksums and find & zero any duplicates.
else
{
if ( hdr.chk == calcChkF( pg, offset, hdr.len ) )
{
if ( findDups )
{
if ( hdr.stat == OSAL_NV_ERASED_ID )
{
/* The trick of setting the MSB of the item Id causes the logic
* immediately above to return a valid page only if the header 'stat'
* indicates that it was the older item being transferred.
*/
uint16 off = findItem( (hdr.id | OSAL_NV_SOURCE_ID) );
if ( off != OSAL_NV_ITEM_NULL )
{
setItem( findPg, off, eNvZero ); // Mark old duplicate as invalid.
}
}
}
// Any "old" item immediately exits and triggers the N^2 exhaustive initialization.
else if ( hdr.stat != OSAL_NV_ERASED_ID )
{
return OSAL_NV_ERASED_ID;
}
}
else
{
setItem( pg, offset, eNvZero ); // Mark bad checksum as invalid.
lost += (OSAL_NV_HDR_SIZE + sz);
}
}
}
else
{
lost += (OSAL_NV_HDR_SIZE + sz);
}
offset += sz;
} while (offset < (OSAL_NV_PAGE_SIZE - OSAL_NV_HDR_SIZE));
pgOff[pg - OSAL_NV_PAGE_BEG] = offset;
pgLost[pg - OSAL_NV_PAGE_BEG] = lost;
return OSAL_NV_ITEM_NULL;
}
/*********************************************************************
* @fn erasePage
*
* @brief Erases a page in Flash.
*
* @param pg - Valid NV page to erase.
*
* @return none
*/
static void erasePage( uint8 pg )
{
HalFlashErase(pg);
pgOff[pg - OSAL_NV_PAGE_BEG] = OSAL_NV_PAGE_HDR_SIZE;
pgLost[pg - OSAL_NV_PAGE_BEG] = 0;
}
/*********************************************************************
* @fn compactPage
*
* @brief Compacts the page specified.
*
* @param srcPg - Valid NV page to erase.
* @param skipId - Item Id to not compact.
*
* @return TRUE if valid items from 'srcPg' are successully compacted onto the 'pgRes';
* FALSE otherwise.
* Note that on a failure, this could loop, re-erasing the 'pgRes' and re-compacting with
* the risk of infinitely looping on HAL flash failure.
* Worst case scenario: HAL flash starts failing in general, perhaps low Vdd?
* All page compactions will fail which will cause all osal_nv_write() calls to return
* NV_OPER_FAILED.
* Eventually, all pages in use may also be in the state of "pending compaction" where
* the page header member OSAL_NV_PG_XFER is zeroed out.
* During this "HAL flash brown-out", the code will run and OTA should work (until low Vdd
* causes an actual chip brown-out, of course.) Although no new NV items will be created
* or written, the last value written with a return value of SUCCESS can continue to be
* read successfully.
* If eventually HAL flash starts working again, all of the pages marked as
* "pending compaction" may or may not be eventually compacted. But, initNV() will
* deterministically clean-up one page pending compaction per power-cycle
* (if HAL flash is working.) Nevertheless, one erased reserve page will be maintained
* through such a scenario.
*/
static uint8 compactPage( uint8 srcPg, uint16 skipId )
{
uint16 srcOff;
uint8 rtrn;
// To minimize code size, only check for a clean page here where it's absolutely required.
for (srcOff = 0; srcOff < OSAL_NV_PAGE_SIZE; srcOff++)
{
HalFlashRead(pgRes, srcOff, &rtrn, 1);
if (rtrn != OSAL_NV_ERASED)
{
erasePage(pgRes);
return FALSE;
}
}
srcOff = OSAL_NV_PAGE_HDR_SIZE;
rtrn = TRUE;
while ( srcOff < (OSAL_NV_PAGE_SIZE - OSAL_NV_HDR_SIZE ) )
{
osalNvHdr_t hdr;
uint16 sz, dstOff = pgOff[pgRes-OSAL_NV_PAGE_BEG];
HalFlashRead(srcPg, srcOff, (uint8 *)(&hdr), OSAL_NV_HDR_SIZE);
if ( hdr.id == OSAL_NV_ERASED_ID )
{
break;
}
// Get the actual size in bytes which is the ceiling(hdr.len)
sz = OSAL_NV_DATA_SIZE( hdr.len );
if ( sz > (OSAL_NV_PAGE_SIZE - OSAL_NV_HDR_SIZE - srcOff) )
{
break;
}
if ( sz > (OSAL_NV_PAGE_SIZE - OSAL_NV_HDR_SIZE - dstOff) )
{
rtrn = FALSE;
break;
}
srcOff += OSAL_NV_HDR_SIZE;
if ( (hdr.id != OSAL_NV_ZEROED_ID) && (hdr.id != skipId) )
{
if ( hdr.chk == calcChkF( srcPg, srcOff, hdr.len ) )
{
/* Prevent excessive re-writes to item header caused by numerous, rapid, & successive
* OSAL_Nv interruptions caused by resets.
*/
if ( hdr.stat == OSAL_NV_ERASED_ID )
{
setItem( srcPg, srcOff, eNvXfer );
}
if ( writeItem( pgRes, hdr.id, hdr.len, NULL, FALSE ) )
{
dstOff += OSAL_NV_HDR_SIZE;
xferBuf( srcPg, srcOff, pgRes, dstOff, sz );
// Calculate and write the new checksum.
if (hdr.chk == calcChkF(pgRes, dstOff, hdr.len))
{
if ( hdr.chk != setChk( pgRes, dstOff, hdr.chk ) )
{
rtrn = FALSE;
break;
}
else
{
hotItemUpdate(pgRes, dstOff, hdr.id);
}
}
else
{
rtrn = FALSE;
break;
}
}
else
{
rtrn = FALSE;
break;
}
}
}
srcOff += sz;
}
if (rtrn == FALSE)
{
erasePage(pgRes);
}
else if (skipId == OSAL_NV_ITEM_NULL)
{
COMPACT_PAGE_CLEANUP(srcPg);
}
// else invoking function must cleanup.
return rtrn;
}
/*********************************************************************
* @fn findItem
*
* @brief Find an item Id in NV and return the page and offset to its data.
*
* @param id - Valid NV item Id.
*
* @return Offset of data corresponding to item Id, if found;
* otherwise OSAL_NV_ITEM_NULL.
*
* The page containing the item, if found;
* otherwise no valid assignment made - left equal to item Id.
*
*/
static uint16 findItem( uint16 id )
{
uint16 off;
uint8 pg;
for ( pg = OSAL_NV_PAGE_BEG; pg <= OSAL_NV_PAGE_END; pg++ )
{
if ( (off = initPage( pg, id, FALSE )) != OSAL_NV_ITEM_NULL )
{
findPg = pg;
return off;
}
}
// Now attempt to find the item as the "old" item of a failed/interrupted NV write.
if ( (id & OSAL_NV_SOURCE_ID) == 0 )
{
return findItem( id | OSAL_NV_SOURCE_ID );
}
else
{
findPg = OSAL_NV_PAGE_NULL;
return OSAL_NV_ITEM_NULL;
}
}
/*********************************************************************
* @fn initItem
*
* @brief An NV item is created and initialized with the data passed to the function, if any.
*
* @param flag - TRUE if the 'buf' parameter contains data for the call to writeItem().
* (i.e. if invoked from osal_nv_item_init() ).
* FALSE if writeItem() should just write the header and the 'buf' parameter
* is ok to use as a return value of the page number to be cleaned with
* COMPACT_PAGE_CLEANUP().
* (i.e. if invoked from osal_nv_write() ).
* @param id - Valid NV item Id.
* @param len - Item data length.
* @param *buf - Pointer to item initalization data. Set to NULL if none.
*
* @return The OSAL Nv page number if item write and read back checksums ok;
* OSAL_NV_PAGE_NULL otherwise.
*/
static uint8 initItem( uint8 flag, uint16 id, uint16 len, void *buf )
{
uint16 sz = OSAL_NV_ITEM_SIZE( len );
uint8 rtrn = OSAL_NV_PAGE_NULL;
uint8 cnt = OSAL_NV_PAGES_USED;
uint8 pg = pgRes+1; // Set to 1 after the reserve page to even wear across all available pages.
do {
if (pg >= OSAL_NV_PAGE_BEG+OSAL_NV_PAGES_USED)
{
pg = OSAL_NV_PAGE_BEG;
}
if ( pg != pgRes )
{
uint8 idx = pg - OSAL_NV_PAGE_BEG;
if ( sz <= (OSAL_NV_PAGE_SIZE - pgOff[idx] + pgLost[idx]) )
{
break;
}
}
pg++;
} while (--cnt);
if (cnt)
{
// Item fits if an old page is compacted.
if ( sz > (OSAL_NV_PAGE_SIZE - pgOff[pg - OSAL_NV_PAGE_BEG]) )
{
osalNvPgHdr_t pgHdr;
/* Prevent excessive re-writes to page header caused by numerous, rapid, & successive
* OSAL_Nv interruptions caused by resets.
*/
HalFlashRead(pg, OSAL_NV_PAGE_HDR_OFFSET, (uint8 *)(&pgHdr), OSAL_NV_PAGE_HDR_SIZE);
if ( pgHdr.xfer == OSAL_NV_ERASED_ID )
{
// Mark the old page as being in process of compaction.
sz = OSAL_NV_ZEROED_ID;
writeWordH( pg, OSAL_NV_PG_XFER, (uint8*)(&sz) );
}
/* First the old page is compacted, then the new item will be the last one written to what
* had been the reserved page.
*/
if (compactPage( pg, id ))
{
if ( writeItem( pgRes, id, len, buf, flag ) )
{
rtrn = pgRes;
}
if ( flag == FALSE )
{
/* Overload 'buf' as an OUT parameter to pass back to the calling function
* the old page to be cleaned up.
*/
*(uint8 *)buf = pg;
}
else
{
/* Safe to do the compacted page cleanup even if writeItem() above failed because the
* item does not yet exist since this call with flag==TRUE is from osal_nv_item_init().
*/
COMPACT_PAGE_CLEANUP( pg );
}
}
}
else
{
if ( writeItem( pg, id, len, buf, flag ) )
{
rtrn = pg;
}
}
}
return rtrn;
}
/*********************************************************************
* @fn setItem
*
* @brief Set an item Id or status to mark its state.
*
* @param pg - Valid NV page.
* @param offset - Valid offset into the page of the item data - the header
* offset is calculated from this.
* @param stat - Valid enum value for the item status.
*
* @return none
*/
static void setItem( uint8 pg, uint16 offset, eNvHdrEnum stat )
{
osalNvHdr_t hdr;
offset -= OSAL_NV_HDR_SIZE;
HalFlashRead(pg, offset, (uint8 *)(&hdr), OSAL_NV_HDR_SIZE);
if ( stat == eNvXfer )
{
hdr.stat = OSAL_NV_ACTIVE;
writeWord( pg, offset+OSAL_NV_HDR_CHK, (uint8*)(&(hdr.chk)) );
}
else // if ( stat == eNvZero )
{
uint16 sz = ((hdr.len + (OSAL_NV_WORD_SIZE-1)) / OSAL_NV_WORD_SIZE) * OSAL_NV_WORD_SIZE +
OSAL_NV_HDR_SIZE;
hdr.id = 0;
writeWord( pg, offset, (uint8 *)(&hdr) );
pgLost[pg-OSAL_NV_PAGE_BEG] += sz;
}
}
/*********************************************************************
* @fn setChk
*
* @brief Set the item header checksum given the data buffer offset.
*
* @param pg - Valid NV page.
* @param offset - Valid offset into the page of the item data - the header
* offset is calculated from this.
* @param chk - The checksum to set.
*
* @return The checksum read back.
*/
static uint16 setChk( uint8 pg, uint16 offset, uint16 chk )
{
offset -= OSAL_NV_WORD_SIZE;
writeWordH( pg, offset, (uint8 *)&chk );
HalFlashRead( pg, offset, (uint8 *)(&chk), sizeof( chk ) );
return chk;
}
/*********************************************************************
* @fn calcChkB
*
* @brief Calculates the data checksum over the 'buf' parameter.
*
* @param len - Byte count of the data to be checksummed.
* @param buf - Data buffer to be checksummed.
*
* @return Calculated checksum of the data bytes.
*/
static uint16 calcChkB( uint16 len, uint8 *buf )
{
uint8 fill = len % OSAL_NV_WORD_SIZE;
uint16 chk;
if ( !buf )
{
chk = len * OSAL_NV_ERASED;
}
else
{
chk = 0;
while ( len-- )
{
chk += *buf++;
}
}
// calcChkF() will calculate over OSAL_NV_WORD_SIZE alignment.
if ( fill )
{
chk += (OSAL_NV_WORD_SIZE - fill) * OSAL_NV_ERASED;
}
return chk;
}
/*********************************************************************
* @fn calcChkF
*
* @brief Calculates the data checksum by reading the data bytes from NV.
*
* @param pg - A valid NV Flash page.
* @param offset - A valid offset into the page.
* @param len - Byte count of the data to be checksummed.
*
* @return Calculated checksum of the data bytes.
*/
static uint16 calcChkF( uint8 pg, uint16 offset, uint16 len )
{
uint16 chk = 0;
len = (len + (OSAL_NV_WORD_SIZE-1)) / OSAL_NV_WORD_SIZE;
while ( len-- )
{
uint8 cnt, tmp[OSAL_NV_WORD_SIZE];
HalFlashRead(pg, offset, tmp, OSAL_NV_WORD_SIZE);
offset += OSAL_NV_WORD_SIZE;
for ( cnt = 0; cnt < OSAL_NV_WORD_SIZE; cnt++ )
{
chk += tmp[cnt];
}
}
return chk;
}
/*********************************************************************
* @fn writeWord
*
* @brief Writes a Flash-WORD to NV.
*
* @param pg - A valid NV Flash page.
* @param offset - A valid offset into the page.
* @param buf - Pointer to source buffer.
*
* @return none
*/
static void writeWord( uint8 pg, uint16 offset, uint8 *buf )
{
offset = (offset / HAL_FLASH_WORD_SIZE) +
((uint16)pg * (HAL_FLASH_PAGE_SIZE / HAL_FLASH_WORD_SIZE));
HalFlashWrite(offset, buf, 1);
}
/*********************************************************************
* @fn writeWordM
*
* @brief Writes multiple Flash-WORDs to NV.
*
* @param pg - A valid NV Flash page.
* @param offset - A valid offset into the page.
* @param buf - Pointer to source buffer.
* @param cnt - Number of 4-byte blocks to write.
*
* @return none
*/
static void writeWordM( uint8 pg, uint16 offset, uint8 *buf, uint16 cnt )
{
offset = (offset / HAL_FLASH_WORD_SIZE) +
((uint16)pg * (HAL_FLASH_PAGE_SIZE / HAL_FLASH_WORD_SIZE));
HalFlashWrite(offset, buf, cnt);
}
/*********************************************************************
* @fn writeWordH
*
* @brief Writes the 1st half of a Flash-WORD to NV (filling 2nd half with 0xffff).
*
* @param pg - A valid NV Flash page.
* @param offset - A valid offset into the page.
* @param buf - Pointer to source buffer.
*
* @return none
*/
static void writeWordH( uint8 pg, uint16 offset, uint8 *buf )
{
uint8 tmp[4];
tmp[0] = buf[0];
tmp[1] = buf[1];
tmp[2] = OSAL_NV_ERASED;
tmp[3] = OSAL_NV_ERASED;
writeWord( pg, offset, tmp );
}
/*********************************************************************
* @fn writeBuf
*
* @brief Writes a data buffer to NV.
*
* @param dstPg - A valid NV Flash page.
* @param offset - A valid offset into the page.
* @param len - Byte count of the data to write.
* @param buf - The data to write.
*
* @return TRUE if data buf checksum matches read back checksum, else FALSE.
*/
static void writeBuf( uint8 dstPg, uint16 dstOff, uint16 len, uint8 *buf )
{
uint8 rem = dstOff % OSAL_NV_WORD_SIZE;
uint8 tmp[OSAL_NV_WORD_SIZE];
if ( rem )
{
dstOff = (dstOff / OSAL_NV_WORD_SIZE) * OSAL_NV_WORD_SIZE;
HalFlashRead(dstPg, dstOff, tmp, OSAL_NV_WORD_SIZE);
while ( (rem < OSAL_NV_WORD_SIZE) && len )
{
tmp[rem++] = *buf++;
len--;
}
writeWord( dstPg, dstOff, tmp );
dstOff += OSAL_NV_WORD_SIZE;
}
rem = len % OSAL_NV_WORD_SIZE;
len /= OSAL_NV_WORD_SIZE;
if ( len )
{
writeWordM( dstPg, dstOff, buf, len );
dstOff += OSAL_NV_WORD_SIZE * len;
buf += OSAL_NV_WORD_SIZE * len;
}
if ( rem )
{
uint8 idx = 0;
HalFlashRead(dstPg, dstOff, tmp, OSAL_NV_WORD_SIZE);
while ( rem-- )
{
tmp[idx++] = *buf++;
}
writeWord( dstPg, dstOff, tmp );
}
}
/*********************************************************************
* @fn xferBuf
*
* @brief Xfers an NV buffer from one location to another, enforcing OSAL_NV_WORD_SIZE writes.
*
* @return none
*/
static void xferBuf( uint8 srcPg, uint16 srcOff, uint8 dstPg, uint16 dstOff, uint16 len )
{
uint8 rem = dstOff % OSAL_NV_WORD_SIZE;
uint8 tmp[OSAL_NV_WORD_SIZE];
if ( rem )
{
dstOff -= rem;
HalFlashRead(dstPg, dstOff, tmp, OSAL_NV_WORD_SIZE);
while ( (rem < OSAL_NV_WORD_SIZE) && len )
{
HalFlashRead(srcPg, srcOff, tmp+rem, 1);
srcOff++;
rem++;
len--;
}
writeWord( dstPg, dstOff, tmp );
dstOff += OSAL_NV_WORD_SIZE;
}
rem = len % OSAL_NV_WORD_SIZE;
len /= OSAL_NV_WORD_SIZE;
while ( len-- )
{
HalFlashRead(srcPg, srcOff, tmp, OSAL_NV_WORD_SIZE);
srcOff += OSAL_NV_WORD_SIZE;
writeWord( dstPg, dstOff, tmp );
dstOff += OSAL_NV_WORD_SIZE;
}
if ( rem )
{
uint8 idx = 0;
HalFlashRead(dstPg, dstOff, tmp, OSAL_NV_WORD_SIZE);
while ( rem-- )
{
HalFlashRead(srcPg, srcOff, tmp+idx, 1);
srcOff++;
idx++;
}
writeWord( dstPg, dstOff, tmp );
}
}
/*********************************************************************
* @fn writeItem
*
* @brief Writes an item header/data combo to the specified NV page.
*
* @param pg - Valid NV Flash page.
* @param id - Valid NV item Id.
* @param len - Byte count of the data to write.
* @param buf - The data to write. If NULL, no data/checksum write.
* @param flag - TRUE if the checksum should be written, FALSE otherwise.
*
* @return TRUE if header/data to write matches header/data read back, else FALSE.
*/
static uint8 writeItem( uint8 pg, uint16 id, uint16 len, void *buf, uint8 flag )
{
uint16 offset = pgOff[pg-OSAL_NV_PAGE_BEG];
uint8 rtrn = FALSE;
osalNvHdr_t hdr;
hdr.id = id;
hdr.len = len;
writeWord( pg, offset, (uint8 *)&hdr );
HalFlashRead(pg, offset, (uint8 *)(&hdr), OSAL_NV_HDR_SIZE);
if ( (hdr.id == id) && (hdr.len == len) )
{
if ( flag )
{
hdr.chk = calcChkB( len, buf );
offset += OSAL_NV_HDR_SIZE;
if ( buf != NULL )
{
writeBuf( pg, offset, len, buf );
}
if ( hdr.chk == calcChkF( pg, offset, len ) )
{
if ( hdr.chk == setChk( pg, offset, hdr.chk ) )
{
hotItemUpdate(pg, offset, hdr.id);
rtrn = TRUE;
}
}
}
else
{
rtrn = TRUE;
}
len = OSAL_NV_ITEM_SIZE( hdr.len );
}
else
{
len = OSAL_NV_ITEM_SIZE( hdr.len );
if (len > (OSAL_NV_PAGE_SIZE - pgOff[pg - OSAL_NV_PAGE_BEG]))
{
len = (OSAL_NV_PAGE_SIZE - pgOff[pg - OSAL_NV_PAGE_BEG]);
}
pgLost[pg - OSAL_NV_PAGE_BEG] += len;
}
pgOff[pg - OSAL_NV_PAGE_BEG] += len;
return rtrn;
}
/*********************************************************************
* @fn hotItem
*
* @brief Look for the parameter 'id' in the hot items array.
*
* @param id - A valid NV item Id.
*
* @return A valid index into the hot items if the item is hot; OSAL_NV_MAX_HOT if not.
*/
static uint8 hotItem(uint16 id)
{
uint8 hotIdx;
for (hotIdx = 0; hotIdx < OSAL_NV_MAX_HOT; hotIdx++)
{
if (hotIds[hotIdx] == id)
{
break;
}
}
return hotIdx;
}
/*********************************************************************
* @fn hotItemUpdate
*
* @brief If the parameter 'id' is a hot item, update the corresponding hot item data.
*
* @param pg - The new NV page corresponding to the hot item.
* @param off - The new NV page offset corresponding to the hot item.
* @param id - A valid NV item Id.
*
* @return none
*/
static void hotItemUpdate(uint8 pg, uint16 off, uint16 id)
{
uint8 hotIdx = hotItem(id);
if (hotIdx < OSAL_NV_MAX_HOT)
{
{
hotPg[hotIdx] = pg;
hotOff[hotIdx] = off;
}
}
}
/*********************************************************************
* @fn osal_nv_init
*
* @brief Initialize NV service.
*
* @param p - Not used.
*
* @return none
*/
void osal_nv_init( void *p )
{
(void)p; // Suppress Lint warning.
(void)initNV(); // Always returns TRUE after pages have been erased.
}
/*********************************************************************
* @fn osal_nv_item_init
*
* @brief If the NV item does not already exist, it is created and
* initialized with the data passed to the function, if any.
* This function must be called before calling osal_nv_read() or
* osal_nv_write().
*
* @param id - Valid NV item Id.
* @param len - Item length.
* @param *buf - Pointer to item initalization data. Set to NULL if none.
*
* @return NV_ITEM_UNINIT - Id did not exist and was created successfully.
* SUCCESS - Id already existed, no action taken.
* NV_OPER_FAILED - Failure to find or create Id.
*/
uint8 osal_nv_item_init( uint16 id, uint16 len, void *buf )
{
uint16 offset;
if ( !OSAL_NV_CHECK_BUS_VOLTAGE )
{
return NV_OPER_FAILED;
}
else if ((offset = findItem(id)) != OSAL_NV_ITEM_NULL)
{
// Re-populate the NV hot item data if the corresponding items are already established.
hotItemUpdate(findPg, offset, id);
return SUCCESS;
}
else if ( initItem( TRUE, id, len, buf ) != OSAL_NV_PAGE_NULL )
{
return NV_ITEM_UNINIT;
}
else
{
return NV_OPER_FAILED;
}
}
/*********************************************************************
* @fn osal_nv_item_len
*
* @brief Get the data length of the item stored in NV memory.
*
* @param id - Valid NV item Id.
*
* @return Item length, if found; zero otherwise.
*/
uint16 osal_nv_item_len( uint16 id )
{
osalNvHdr_t hdr;
uint16 offset;
uint8 hotIdx;
if ((hotIdx = hotItem(id)) < OSAL_NV_MAX_HOT)
{
findPg = hotPg[hotIdx];
offset = hotOff[hotIdx];
}
else if ((offset = findItem(id)) == OSAL_NV_ITEM_NULL)
{
return 0;
}
HalFlashRead(findPg, (offset - OSAL_NV_HDR_SIZE), (uint8 *)(&hdr), OSAL_NV_HDR_SIZE);
return hdr.len;
}
/*********************************************************************
* @fn osal_nv_write
*
* @brief Write a data item to NV. Function can write an entire item to NV or
* an element of an item by indexing into the item with an offset.
*
* @param id - Valid NV item Id.
* @param ndx - Index offset into item
* @param len - Length of data to write.
* @param *buf - Data to write.
*
* @return SUCCESS if successful, NV_ITEM_UNINIT if item did not
* exist in NV and offset is non-zero, NV_OPER_FAILED if failure.
*/
uint8 osal_nv_write( uint16 id, uint16 ndx, uint16 len, void *buf )
{
uint8 rtrn = SUCCESS;
if ( !OSAL_NV_CHECK_BUS_VOLTAGE )
{
return NV_OPER_FAILED;
}
else if ( len != 0 )
{
osalNvHdr_t hdr;
uint16 origOff, srcOff;
uint16 cnt, chk;
uint8 *ptr, srcPg;
origOff = srcOff = findItem( id );
srcPg = findPg;
if ( srcOff == OSAL_NV_ITEM_NULL )
{
return NV_ITEM_UNINIT;
}
HalFlashRead(srcPg, (srcOff - OSAL_NV_HDR_SIZE), (uint8 *)(&hdr), OSAL_NV_HDR_SIZE);
if ( hdr.len < (ndx + len) )
{
return NV_OPER_FAILED;
}
srcOff += ndx;
ptr = buf;
cnt = len;
chk = 0;
while ( cnt-- )
{
uint8 tmp;
HalFlashRead(srcPg, srcOff, &tmp, 1);
if ( tmp != *ptr )
{
chk = 1; // Mark that at least one byte is different.
// Calculate expected checksum after transferring old data and writing new data.
hdr.chk -= tmp;
hdr.chk += *ptr;
}
srcOff++;
ptr++;
}
if ( chk != 0 ) // If the buffer to write is different in one or more bytes.
{
uint8 comPg = OSAL_NV_PAGE_NULL;
uint8 dstPg = initItem( FALSE, id, hdr.len, &comPg );
if ( dstPg != OSAL_NV_PAGE_NULL )
{
uint16 tmp = OSAL_NV_DATA_SIZE( hdr.len );
uint16 dstOff = pgOff[dstPg-OSAL_NV_PAGE_BEG] - tmp;
srcOff = origOff;
/* Prevent excessive re-writes to item header caused by numerous, rapid, & successive
* OSAL_Nv interruptions caused by resets.
*/
if ( hdr.stat == OSAL_NV_ERASED_ID )
{
setItem( srcPg, srcOff, eNvXfer );
}
xferBuf( srcPg, srcOff, dstPg, dstOff, ndx );
srcOff += ndx;
dstOff += ndx;
writeBuf( dstPg, dstOff, len, buf );
srcOff += len;
dstOff += len;
xferBuf( srcPg, srcOff, dstPg, dstOff, (hdr.len-ndx-len) );
// Calculate and write the new checksum.
dstOff = pgOff[dstPg-OSAL_NV_PAGE_BEG] - tmp;
if ( hdr.chk == calcChkF( dstPg, dstOff, hdr.len ) )
{
if ( hdr.chk != setChk( dstPg, dstOff, hdr.chk ) )
{
rtrn = NV_OPER_FAILED;
}
else
{
hotItemUpdate(dstPg, dstOff, hdr.id);
}
}
else
{
rtrn = NV_OPER_FAILED;
}
}
else
{
rtrn = NV_OPER_FAILED;
}
if ( comPg != OSAL_NV_PAGE_NULL )
{
/* Even though the page compaction succeeded, if the new item is coming from the compacted
* page and writing the new value failed, then the compaction must be aborted.
*/
if ( (srcPg == comPg) && (rtrn == NV_OPER_FAILED) )
{
erasePage( pgRes );
}
else
{
COMPACT_PAGE_CLEANUP( comPg );
}
}
/* Zero of the old item must wait until after compact page cleanup has finished - if the item
* is zeroed before and cleanup is interrupted by a power-cycle, the new item can be lost.
*/
if ( (srcPg != comPg) && (rtrn != NV_OPER_FAILED) )
{
setItem( srcPg, origOff, eNvZero );
}
}
}
return rtrn;
}
/*********************************************************************
* @fn osal_nv_read
*
* @brief Read data from NV. This function can be used to read an entire item from NV or
* an element of an item by indexing into the item with an offset.
* Read data is copied into *buf.
*
* @param id - Valid NV item Id.
* @param ndx - Index offset into item
* @param len - Length of data to read.
* @param *buf - Data is read into this buffer.
*
* @return SUCCESS if NV data was copied to the parameter 'buf'.
* Otherwise, NV_OPER_FAILED for failure.
*/
uint8 osal_nv_read( uint16 id, uint16 ndx, uint16 len, void *buf )
{
uint16 offset;
uint8 hotIdx;
if ((hotIdx = hotItem(id)) < OSAL_NV_MAX_HOT)
{
HalFlashRead(hotPg[hotIdx], hotOff[hotIdx]+ndx, buf, len);
return SUCCESS;
}
if ((offset = findItem(id)) == OSAL_NV_ITEM_NULL)
{
return NV_OPER_FAILED;
}
else
{
HalFlashRead(findPg, offset+ndx, buf, len);
return SUCCESS;
}
}
/*********************************************************************
* @fn osal_nv_delete
*
* @brief Delete item from NV. This function will fail if the length
* parameter does not match the length of the item in NV.
*
* @param id - Valid NV item Id.
* @param len - Length of item to delete.
*
* @return SUCCESS if item was deleted,
* NV_ITEM_UNINIT if item did not exist in NV,
* NV_BAD_ITEM_LEN if length parameter not correct,
* NV_OPER_FAILED if attempted deletion failed.
*/
uint8 osal_nv_delete( uint16 id, uint16 len )
{
uint16 length;
uint16 offset;
offset = findItem( id );
if ( offset == OSAL_NV_ITEM_NULL )
{
// NV item does not exist
return NV_ITEM_UNINIT;
}
length = osal_nv_item_len( id );
if ( length != len )
{
// NV item has different length
return NV_BAD_ITEM_LEN;
}
// Set item header ID to zero to 'delete' the item
setItem( findPg, offset, eNvZero );
// Verify that item has been removed
offset = findItem( id );
if ( offset != OSAL_NV_ITEM_NULL )
{
// Still there
return NV_OPER_FAILED;
}
else
{
// Yes, it's gone
return SUCCESS;
}
}
/*********************************************************************
*/