//----------------------------------------------------
/**
	\file		ctk/inc/paramstore.h
	\ingroup	old
	\ingroup	all

	\brief		???

	\author		ConTeK s.r.o.
	\version	01.00
	\date		00.00.0000
*/
//----------------------------------------------------

#ifndef _PARAMSTORE_H_
#define _PARAMSTORE_H_		//!< Definice pritomnosti knihovny

#include <libsets.h>
#include <ctktypes.h>
#include <datadef.h>
#include <nvmem.h>
#include <sync.h>
#include <stmachine.h>
#include <ucrc16.h>
#include <misc.h>

//----------------------------------------------------
/**
	\brief	Zamky pro FRAM
*/
//----------------------------------------------------
//@{
#ifndef NO_PST_TICK
 #define	pstlock_t		flock_t
 #define	PstLock()		FastLock()
 #define	PstUnlock(lock)	FastUnlock(lock)
#endif // NO_PST_TICK
//@}


// libsets
#define PST_CALCCRC_BLOCK_SIZE			64
#define CONF_QUEUE_SIZE					5

static const uint8_t PST_READ_RETRY_COUNT	= 2;
static const uint8_t PST_WRITE_RETRY_COUNT	= 2;
static const ticks_t PST_READ_RETRY_TIMEOUT	= 100;
static const ticks_t PST_WRITE_RETRY_TIMEOUT	= 100;


//----------------------------------------------------
//!	Stavy automatu periodicky ukladanych parametru

typedef enum _PSTSTATE
{
	PSST_WAITCMD = STM_FIRST_USER_STATE,
	PSST_CHECK_CONSISTENCE,
	PSST_CHECK_READ_HEADER,
	PSST_CHECK_READ_HEADER_VERIFY,
	PSST_CHECK_READ_SELECTOR,
	PSST_CHECK_CONSISTENCE_READ,
	PSST_CHECK_CONSISTENCE_READDATA,
	PSST_CHECK_CONSISTENCE_READCRC,
	PSST_CHECK_CONSISTENCE_CALCCRC,

	PSST_SET_DEFAULT,
	PSST_INVALIDATE,
	PSST_INVALIDATE_WAIT,
	PSST_INVALIDATE_VERIFY,
	PSST_SET_DEFAULT_DATA_0,
	PSST_SET_DEFAULT_DATA_1,
	PSST_SET_DEFAULT_HEADER,
	PSST_SET_DEFAULT_HEADER_WAIT,
	PSST_SET_DEFAULT_HEADER_VERIFY,

	PSST_WRITE_TIMEOUT_WAIT,
	PSST_WRITE_LOCKMEM,
	PSST_WRITE,
	PSST_WRITE_SELECTOR,
	PSST_WRITE_SELECTOR_WAIT,

	PSST_WRITE_BEGIN,
	PSST_WRITE_DATA,
	PSST_WRITE_CRC,
	PSST_WRITE_CRC_WAIT,
	PSST_WRITE_DATA_VERIFY,
	PSST_WRITE_CRC_VERIFY,

	PSST_CALCCRC
} PSTSTATE;


//----------------------------------------------------
//!		Chybove stavy automatu periodicky ukladanych parametru

typedef enum _PST_ERROR
{
	PSERR_NONE = 0,					//!< Bez chyby
	PSERR_UNKNOWN_CMD,				//!< Zadan neznamy prikaz, nebude vykonan
	PSERR_SET_DEFAULT,				//!< Nekonzistentni data, nahravam default
	PSERR_INVALIDATE,				//!< Nepodarilo se zneplatnit hlavicku ve FRAM
	PSERR_SETDEFAULT_BANK0,			//!< Chyba pri zapisu banky 0
	PSERR_SETDEFAULT_BANK1,			//!< Chyba pri zapisu banky 1
	PSERR_SETDEFAULT_HEADER,		//!< Chyba pri zapisu hlavicky
	PSERR_WRITE_SELECTOR,			//!< Chyba pri zapisu selektoru
	PSERR_WRITE_DATA				//!< Chyba pri zapisu dat
} PST_ERROR;

//----------------------------------------------------
//!	Stavy automatu neperiodicky ukladanych parametru

typedef enum _PARAMSTATE
{
	PRST_READ = STM_FIRST_USER_STATE,
	PRST_WAITLOAD,
	PRST_WRITE,
	PRST_WAITSAVE,
	PRST_READALL
} PARAMSTATE;


//----------------------------------------------------
//!	Stavy automatu prvotniho nacteni

typedef enum _LOADSTATE
{
	PLST_READVERSION = STM_FIRST_USER_STATE,
	PLST_CHECKHEADER,
	PLST_READ,
	PLST_LOAD,
	PLST_FIX_PARAM,
	PLST_FIX_PAGE,
	PLST_WRITE_WAIT,
	PLST_NEXT_PARAM,
	PLST_SAVE_DEFAULTS,
	PLST_WRITE_DEFAULTS,
	PLST_SAVE_HEADER,
	PLST_SAVE_HEADER_CHUNK,
	PLST_SAVE_HEADER_DONE,
	PLST_FSCK

#ifdef PARAMSTORE_FLASHFS
	,PLST_FSCK_DONE
#endif // PARAMSTORE_FLASHFS
} LOADSTATE;


//----------------------------------------------------
//!	Kody prikazu neperiodicky ukladanych parametru

typedef enum _PARAM_CMD
{
	PCMD_NONE = 0,
	PCMD_LOAD,
	PCMD_INITLOAD
} PARAM_CMD;


//----------------------------------------------------
//!	Kody prikazy periodicky ukladanych parametru

typedef enum _PST_CMD
{
	PSCMD_NONE = 0,
	PSCMD_CHECK,
	PSCMD_DEFAULT,
	PSCMD_START,
	PSCMD_STOP,
	PSCMD_WRITENOW
} PST_CMD;

//
// Zahlavi dat ulozenych ve FRAM
// Po resetu se kontroluje toto zahlavi ulozene
// na adrese DATA_TREE_HEADER_ADDR. Pokud neni platne, pak
// se provede inicializace FRAM
//

#ifdef MSVC
#pragma pack(push,1)
#endif // MSVC

typedef struct
{
	uint16_t				Magic;			//!< Cislo PST_MAGIC
	uint16_t				Version;		//!< Verze dat
	crc16_t					Crc;			//!< CRC hlavicky
#ifndef MSVC
} __attribute__((packed)) PST_HEADER;
#else
} PST_HEADER;

#pragma pack(pop)
#endif // MSVC


struct _PARAMSTORE_CTX;

//----------------------------------------------------
/**
	\brief	Metoda ziska verzi neperiodicky ukladanych parametru

	\return	Verze conf parametru
*/
//----------------------------------------------------

typedef uint16_t (*pmGetConfVersion_t) (const struct _PARAMSTORE_CTX * const _ctx);


//----------------------------------------------------
/**
	\brief	Metoda pro kontrolu verze neperiodicky ukladanych parametru

	\param	_ctx	Kontext paramstore

	\return	TRUE, pokud si verze v RAM a default odpovidaji
*/
//----------------------------------------------------

typedef bool_t (*pmCheckConfVersion_t) (const struct _PARAMSTORE_CTX * const _ctx, const uint16_t _version);


//----------------------------------------------------
/**
	\brief	Metoda ziska verzi periodicky ukladanych parametru

	\return	Verze pst parametru
*/
//----------------------------------------------------

typedef uint16_t (*pmGetPstVersion_t) (const struct _PARAMSTORE_CTX * const _ctx);


//----------------------------------------------------
/**
	\brief	Metoda kontroluje verze periodicky ukladanych parametru

	\param	_version	Verze ulozena v nv pameti

	\return	TRUE, pokud jsou verze v souladu
*/
//----------------------------------------------------

typedef bool_t (*pmCheckPstVersion_t) (const struct _PARAMSTORE_CTX * const _ctx, const uint16_t _version);


//----------------------------------------------------
/**
	\brief	Typ callbacku pro oznamovani chyb pst

	\param	_ctx		Kontext automatu, ve kterem doslo k chybe
	\param	_errCode	Chybovy kod
	\param	_userData	Uzivatelska data
*/
//----------------------------------------------------

typedef void (*pmPstErrorCb_t) (const struct _PARAMSTORE_CTX * const _ctx, const PST_ERROR _errCode, void * _userData);



//----------------------------------------------------
/**
	\brief	Metoda provadi zapis parametru do RAM

	\param	_code		Kod parametru
	\param	_value		Hodnota parametru
	\param	_userData	Uzivatelska data zadana pri inicializaci

	Metoda umoznuje aplikaci synchronizovat zapis novych hodnot do RAM
	a tak lepe spravovat zamykani struktury parametru, pripadne se mu vyvarovat.
*/
//----------------------------------------------------

typedef void (*pmWriteParamToRAM_t) (paramcode_t _code, const datavalue_t * _value, void * _userData, const dtacbDone _done, void * const _cbUserData);


//----------------------------------------------------
//! Struktura ukladajici vysledky pocatecniho nacitani

typedef struct _PARAMSTORE_LOAD_STATS
{
	bool_t		DefaultsStored;		//!< TRUE, pokud byly ulozeny vychozi hodnoty, zbyle udaje pak nemaji vyznam
	uint8_t		FixedPages;			//!< Pocet stranek pameti zrekonstruovanych z vychozich hodnot
	uint16_t	ParamUnderRange;	//!< Pocet parametru, jejichz ulozena hodnota byla pod povolenym rozsahem
	uint16_t	ParamOverRange;		//!< Pocet parametru, jejichz ulozena hodnota byla nad povolenym rozsahem
} PARAMSTORE_LOAD_STATS;


//----------------------------------------------------
//! Struktura pro rizeni periodickeho ukladani

typedef struct _PARAMSTORE_PST_CTX
{
	STMACHINE	Stm;
	NVMEMDESC	* Mem;			//!< Pamet pro parametry
	void		* DataPtr;		//!< Ukazatel na ukladana data v RAM
	void		* DataBuf;		//!< Pomocny buffer
	ptr_t		DataSize;		//!< Velikost ukladanych dat
	PST_HEADER	HdrBuf;			//!< Hlavicka dat v pameti
	uint8_t		Selector;		//!< Selector
	PST_ERROR	Error;			//!< Priznak chyby
	PST_CMD		Cmd;			//!< Pozadovana akce
	PST_CMD		PrevCmd;		//!< Predchozi prikaz v pripade prioritniho prikazu
	ticks_t		Timer;			//!< Casovac
	ticks_t		Period;			//!< Perioda ukladani
	crc16_t		MemCrc;			//!< CRC nactene z pameti
	crc16_t		CalcCrc;		//!< Vypoctene CRC
	ptr_t		DataIndex;
	nvptr_t		Addr;			//!< Adresa nacitanych dat
	uint8_t		Counter;
	pmPstErrorCb_t	cbPstError;			//!< Callback volany pri chybe
	void *		cbPstErrorUserData;		//!< Data predavana callbacku pri chybe
	uint8_t		CrcBuffer[PST_CALCCRC_BLOCK_SIZE];
} PARAMSTORE_PST_CTX;


// Zahlavi conf dat
// Po resetu se kontroluje toto zahlavi ulozene
// na pocatku oblasti pro ulozeni parametru (zadano v inicializaci)
// Pokud nesouhlasi, provede se nahrani vychozich hodnot
//

#ifdef MSVC
#pragma pack(push,1)
#endif // MSVC

typedef struct
{
	uint16_t				Magic;			//!< Cislo CONF_MAGIC
	uint16_t				Version;		//!< Verze dat
	uint16_t				Reserved;		//!< Rezervovano
	crc16_t					Crc;			//!< CRC hlavicky
#ifndef MSVC
} __attribute__((packed)) CONF_HEADER;
#else
} CONF_HEADER;

#pragma pack(pop)
#endif // MSVC


//----------------------------------------------------
//! Struktura polozky fronty zapisovanych parametru

typedef struct _CONF_QUEUE_ITEM
{
	paramcode_t		Code;
	datavalue_t		Value;
	dtacbDone		Callback;
	void 			* UserData;
} CONF_QUEUE_ITEM;

//----------------------------------------------------
//! Struktura pro rizeni neperiodickeho ukladani

typedef struct _PARAMSTORE_CONF_CTX
{
	STMACHINE		Stm;			//!< Stav automatu
	NVMEMDESC		* Mem;			//!< Pamet pro parametry
	param_t			Min;			//!< Kod pocatku ukladane oblasti
	param_t			Max;			//!< kod konce ukladane oblasti
	PARAM_CMD		Cmd;			//!< Pozadovana akce
	paramcode_t		Code;			//!< Ukladany kod
	const void		* Data;			//!< Pomocny ukazatel na ukladana data
	PARAM_ERROR		Error;			//!< Chybovy kod posledni operace
	dtacbDone		cbDone;			//!< Callback volany pri dokonceni ukladani
	void			* UserData;		//!< Data predana callbacku
	uint8_t			DataVersion;	//!< Verze dat
	datavalue_t		SavedBuf;		//!< Pomocny buffer pro ukladani

	// fronta zapisovanych parametru
	CONF_QUEUE_ITEM		ActQItem;
	CONF_QUEUE_ITEM		Queue[CONF_QUEUE_SIZE];
	uint8_t				QFront, QTail;
} PARAMSTORE_CONF_CTX;


//----------------------------------------------------
//! Struktura pro rizeni prvotniho nacteni

typedef struct _PARAMSTORE_LOAD_CTX
{
	STMACHINE		Stm;			//!< Stav automatu
	paramcode_t		Code;			//!< Aktualne nacitany kod
	PARAMETER_ITEM	Desc;			//!< Deskriptor aktualne nacitaneho parametru
	datavalue_t		DataBuf;		//!< Pomocny buffer
	CONF_HEADER		Header;			//!< Hlavicka s verzi
	const uint8_t	*DataPtr;		//!< Ukazatel uzivany pri ukladani dat
	nvptr_t			StartAddr;		//!< Pocatecni adresa zapisu
	nvptr_t			Size;			//!< Velikost zapisovane oblasti
	PARAMSTORE_LOAD_STATS	Stats;	//!< Statistiky nahravani
	bool_t			FirstPass;		//!< Prvni pokus o prvotni nacteni
} PARAMSTORE_LOAD_CTX;


//----------------------------------------------------
//!	Kontext paramstore

typedef struct _PARAMSTORE_CTX
{
	DATADEF_CTX	Parent;

	volatile bool_t		flRunning;			//!< Priznak uspesne inicializace

	//! struktura pro rizeni periodickeho ukladani
#ifndef NO_PST_TICK
	PARAMSTORE_PST_CTX		Pst;
#endif // NO_PST_TICK

	//! struktura pro rizeni prvotniho nacteni
	PARAMSTORE_LOAD_CTX		Load;

	//! struktura pro rizeni neperiodickeho ukladani
	PARAMSTORE_CONF_CTX		Conf;

	pmCheckConfVersion_t	CheckConfVersion;	//!< Metoda kontroly verze neperiodickych parametru
#ifndef NO_PST_TICK
	pmCheckPstVersion_t		CheckPstVersion;	//!< Metoda kontroly verze periodickych parametru
#endif // NO_PST_TICK
	pmGetConfVersion_t		GetConfVersion;		//!< Metoda ziska verzi neperiodickych parametru
#ifndef NO_PST_TICK
	pmGetPstVersion_t		GetPstVersion;		//!< Metoda ziska verzi periodickych parametru
#endif // NO_PST_TICK
	pmWriteParamToRAM_t		WriteParamToRAM	;	//!< Metoda pro zapis ukladaneho parametru do RAM
	void					*WriteParamToRAMUserData;	//!< Uzivatelska data pro callback

} PARAMSTORE_CTX;


//----------------------------------------------------
/**
	\brief	Zjisti stav automatu periodickeho ukladani

	\param	_ctx	Kontext

	\return		TRUE, pokud automat prijima prikazy
*/
//----------------------------------------------------

static inline bool_t pstReady(const PARAMSTORE_CTX * const _ctx)
{
#ifndef NO_PST_TICK
	return ((_ctx->Pst.Stm.State == PSST_WAITCMD) && (_ctx->Pst.Cmd == PSCMD_NONE));
#else
    UNUSED_ALWAYS(_ctx);
	static bool_t firstPass = TRUE;

	if(firstPass)
	{
		firstPass = FALSE;
		return FALSE;
	}
	else
	{
		return TRUE;
	}
#endif // NO_PST_TICK
}


//----------------------------------------------------
/**
	\brief	Zjisti, zda doslo k chybe v automatu periodickeho ukladani

	\param	_ctx	Kontext

	\return		TRUE - doslo k chybe
*/
//----------------------------------------------------
#ifndef NO_PST_TICK
static inline PST_ERROR pstGetError(const PARAMSTORE_CTX * const _ctx)
{
	return _ctx->Pst.Error;
}
#endif // NO_PST_TICK

//----------------------------------------------------
/**
	\brief	Zjisti stav automatu neperiodickeho ukladani

	\param	_ctx	Kontext

	\return		TRUE, pokud automat prijima prikazy
*/
//----------------------------------------------------

static inline bool_t confReady(PARAMSTORE_CTX * const _ctx)
{
	return stmFinished(&_ctx->Conf.Stm);
}


//----------------------------------------------------
/**
	\brief	Zjisti, zda prave probiha nacitani kompletni datove struktury

	\param	_ctx	Kontext

	\return		TRUE, pokud nacitani probiha
*/
//----------------------------------------------------
static inline bool_t confInitLoading(const PARAMSTORE_CTX * const _ctx)
{
	return (_ctx->Conf.Cmd == PCMD_INITLOAD);
}


//----------------------------------------------------
/**
	\brief	Zjisti chybu neperiodickeho ukladani

	\param	_ctx	Kontext

	\return		Kod chyby
*/
//----------------------------------------------------

static inline PARAM_ERROR confGetError(const PARAMSTORE_CTX * const _ctx)
{
	return _ctx->Conf.Error;
}


//----------------------------------------------------
/**
	\brief	Zjisti, zda je parametr neperiodicky ukladany

	\param	_ctx	Kontext
	\param	_par	Cast kodu parametru

	\return		TRUE, pokud je parametr trvale ukladan
*/
//----------------------------------------------------

static inline bool_t confNvStored(const PARAMSTORE_CTX * const _ctx, const param_t _par)
{
	return ((_par >= _ctx->Conf.Min) && (_par <= _ctx->Conf.Max));
}


//----------------------------------------------------
/**
	\brief	Registrace funkce ziskani verze neperiodicky ukladanych parametru

	\param	_ctx	Kontext
	\param	_pmi	Metoda
*/
//----------------------------------------------------

static inline void confRegisterGetVersion(PARAMSTORE_CTX * const _ctx, const pmGetConfVersion_t _method)
{
	_ctx->GetConfVersion = _method;
}


//----------------------------------------------------
/**
	\brief	Registrace funkce kontroly verzi neperiodicky ukladanych parametru

	\param	_ctx	Kontext
	\param	_pmi	Metoda
*/
//----------------------------------------------------

static inline void confRegisterCheckVersion(PARAMSTORE_CTX * const _ctx, const pmCheckConfVersion_t _method)
{
	_ctx->CheckConfVersion = _method;
}


//----------------------------------------------------
/**
	\brief	Registrace funkce pro ukladani parametru do RAM

	\param	_ctx		Kontext
	\param	_pmi		Metoda
	\param	_userData	Data, ktera budou predavana callbacku
*/
//----------------------------------------------------

static inline void confRegisterWriteParamToRAM(PARAMSTORE_CTX * const _ctx, const pmWriteParamToRAM_t _method, void * const _userData)
{
	_ctx->WriteParamToRAMUserData = _userData;
	_ctx->WriteParamToRAM = _method;
}


//----------------------------------------------------
/**
	\brief	Funkce provadi zapis parametru do RAM
*/
//----------------------------------------------------

void confWriteParamToRAM(const paramcode_t _code, const datavalue_t * const _value, void * const _userData, const dtacbDone _done, void * const _cbUserData);


//----------------------------------------------------
/**
	\brief	Funkce provadi finalizaci zapisu parametru - oznameni o dokonceni
*/
//----------------------------------------------------

void confSavingDone(const paramcode_t _code, const datavalue_t * const _value, PARAM_ERROR _error, const dtacbDone _done, void * const _cbUserData);


//----------------------------------------------------
/**
	\brief	Prikaz pro zahajeni nacitani ulozenych dat

	\param	_ctx	Kontext

	\return	FALSE v pripade chyby
*/
//----------------------------------------------------

bool_t confInitLoad(PARAMSTORE_CTX * const _ctx);


//----------------------------------------------------
/**
	\brief	Prikaz pro spusteni inicializace periodicky ukladanych dat

	\param	_ctx	Kontext

	\return		FALSE, pokud prikaz nelze v tuto chvili vykonat
*/
//----------------------------------------------------
#ifndef NO_PST_TICK
bool_t pstInit(PARAMSTORE_CTX * const _ctx);


//----------------------------------------------------
/**
	\brief	Prikaz pro ulozeni vychozich hodnot do periodicky ukladanych dat

	\param	_ctx	Kontext

	\return		FALSE, pokud prikaz nelze v tuto chvili vykonat
*/
//----------------------------------------------------

bool_t pstSetDefault(PARAMSTORE_CTX * const _ctx);


//----------------------------------------------------
/**
	\brief	Prikaz pro spusteni periodickeho ukladani

	\param	_ctx	Kontext

	\return		FALSE, pokud prikaz nelze v tuto chvili vykonat
*/
//----------------------------------------------------

bool_t pstStart(PARAMSTORE_CTX * const _ctx);


//----------------------------------------------------
/**
	\brief	Prikaz pro zastaveni periodickeho ukladani

	\param	_ctx	Kontext

	\return		FALSE, pokud prikaz nelze v tuto chvili vykonat
*/
//----------------------------------------------------

bool_t pstStop(PARAMSTORE_CTX * const _ctx);


//----------------------------------------------------
/**
	\brief	Vraci informace o oblasti periodicky ukladanych dat

	\param	_minCode	Pocatecni parametr oblasti
	\param	_maxCode	Koncovy parametr oblasti
	\param	[out] _size		Vypoctena velikost oblasti

	\return			Ukazatel na pocatek oblasti, nebo NULL
*/
//----------------------------------------------------

void * pstGetInfo(const param_t _minParam, const param_t _maxParam, uint32_t * const _size);


//----------------------------------------------------
/**
	\brief	Prikaz provede okamzity zapis dat

	\param	_ctx	Kontext

	\return		FALSE, pokud prikaz nelze v tuto chvili vykonat
*/
//----------------------------------------------------

bool_t pstWriteNow(PARAMSTORE_CTX * const _ctx);


//----------------------------------------------------
/**
	\brief	Registrace kontrolni funkce verzi pro periodicky ukladane parametry

	\param	_ctx	Kontext
	\param	_pmi	Metoda
*/
//----------------------------------------------------

static inline void pstRegisterCheckVersion(PARAMSTORE_CTX * const _ctx, const pmCheckPstVersion_t _method)
{
	_ctx->CheckPstVersion = _method;
}


//----------------------------------------------------
/**
	\brief	Registrace funkce ziskani verze periodicky ukladanych parametru

	\param	_ctx	Kontext
	\param	_pmi	Metoda
*/
//----------------------------------------------------

static inline void pstRegisterGetVersion(PARAMSTORE_CTX * const _ctx, const pmGetPstVersion_t _method)
{
	_ctx->GetPstVersion = _method;
}


//----------------------------------------------------
/**
	\brief	Registrace funkce volane pri chybe automatu pst

	\param	_ctx		Kontext
	\param	_callback	Volany callback
	\param	_userData	Data predana pri volani callbacku
*/
//----------------------------------------------------

static inline void pstRegisterErrorCb(PARAMSTORE_CTX * const _ctx, const pmPstErrorCb_t _callback, void * _userData)
{
	_ctx->Pst.cbPstError = _callback;
	_ctx->Pst.cbPstErrorUserData = _userData;
}


//----------------------------------------------------
/**
	\brief	Zruseni registrace funkce volane pri chybe automatu pst

	\param	_ctx		Kontext
*/
//----------------------------------------------------

static inline void pstUnregisterErrorCb(PARAMSTORE_CTX * const _ctx)
{
	_ctx->Pst.cbPstError = NULL;
}


//----------------------------------------------------
/**
	\brief	Tik periodickeho ukladani

	\param	_ctx	Kontext
*/
//----------------------------------------------------

void PstTick(PARAMSTORE_CTX * const _ctx);

#endif // NO_PST_TICK

//----------------------------------------------------
/**
	\brief	Tik neperiodicky ukladanych nv parametru

	\param	_ctx	Kontext
*/
//----------------------------------------------------

void ConfTick(PARAMSTORE_CTX * const _ctx);


//----------------------------------------------------
/**
	\brief	Zjisti pripravenost pst a conf subsystemu

	\param	_ctx	Kontext
*/
//----------------------------------------------------

static inline bool_t ParamStoreReady(PARAMSTORE_CTX * const _ctx)
{
	return (pstReady(_ctx) && confReady(_ctx));
}


//----------------------------------------------------
/**
	\brief	Tik nv parametru (periodickych i neperiodickych)

	\param	_ctx	Kontext
*/
//----------------------------------------------------

void ParamStoreTick(PARAMSTORE_CTX * const _ctx);


//----------------------------------------------------
/**
	\brief	Inicializace framstore

	\param	_ctx			Kontext
	\param	_pstMem			Pamet pro ulozeni periodicky ukladanych parametru
	\param	_pstPeriod		Perioda ukladani periodicky ukladanych parametru
	\param	_pstBuf			Buffer pro docasne ulozeni periodicky ukladanych parametru (vsech)
	\param	_pstPtr			Ukazatel na periodicky ukladana data v RAM
	\param	_pstSize		Velikost periodicky ukladanych dat
*/
//----------------------------------------------------
#ifndef NO_PST_TICK
bool_t PstStoreInitialize(PARAMSTORE_CTX * const _ctx,
						  NVMEMDESC * const _pstMem,
						  const ticks_t _pstPeriod,
						  void * const _pstBuf,
						  void * const _pstPtr,
						  const uint32_t _pstSize);
#endif // NO_PST_TICK

//----------------------------------------------------
/**
	\brief	Inicializace flashstore

	\param	_ctx			Kontext
	\param	_paramMem		Pamet pro ulozeni neperiodicky ukladanych parametru
	\param	_minParam		Prvni neperiodicky ukladany parametr
	\param	_maxParam		Posledni neperiodicky ukladany parametr
	\param	_versionInfoSize	Velikost oblasti nactene predem pro vyhodnoceni verzi
*/
//----------------------------------------------------

bool_t ConfStoreInitialize(PARAMSTORE_CTX * const _ctx,
						  NVMEMDESC * const _confMem,
						  const param_t _minParam,
						  const param_t _maxParam);


//----------------------------------------------------
/**
	\brief	Inicializace paramstore

	\param	_ctx			Kontext
	\param	_paramMem		Pamet pro ulozeni neperiodicky ukladanych parametru
	\param	_minParam		Prvni neperiodicky ukladany parametr
	\param	_maxParam		Posledni neperiodicky ukladany parametr
	\param	_versionInfoSize	Velikost oblasti nactene predem pro vyhodnoceni verzi
	\param	_pstMem			Pamet pro ulozeni periodicky ukladanych parametru
	\param	_pstPeriod		Perioda ukladani periodicky ukladanych parametru
	\param	_pstBuf			Buffer pro docasne ulozeni periodicky ukladanych parametru (vsech)
	\param	_pstPtr			Ukazatel na periodicky ukladana data v RAM
	\param	_pstSize		Velikost periodicky ukladanych dat

	\return	FALSE pri chybe inicializace
*/
//----------------------------------------------------

bool_t ParamStoreInitialize(PARAMSTORE_CTX * const _ctx,
						  NVMEMDESC * const _confMem,
						  const param_t _minParam,
						  const param_t _maxParam
#ifndef NO_PST_TICK
						  ,
						  NVMEMDESC * const _pstMem,
						  const ticks_t _pstTimeout,
						  void * const _pstBuf,
						  void * const _pstPtr,
						  const uint32_t _pstSize
#endif // NO_PST_TICK
						  );


//----------------------------------------------------
/**
	\brief	Finalizace pststore

	\param	_ctx		Kontext
*/
//----------------------------------------------------
#ifndef NO_PST_TICK
void PstStoreFinalize(PARAMSTORE_CTX * const _ctx);
#endif // NO_PST_TICK

//----------------------------------------------------
/**
	\brief	Finalizace confstore

	\param	_ctx		Kontext
*/
//----------------------------------------------------

void ConfStoreFinalize(PARAMSTORE_CTX * const _ctx);


//----------------------------------------------------
/**
	\brief	Finalizace paramstore

	\param	_ctx		Kontext
*/
//----------------------------------------------------

void ParamStoreFinalize(PARAMSTORE_CTX * const _ctx);

#endif // _PARAMSTORE_H_
