Improve XEBEC controller support
[SCSI2SD.git] / software / SCSI2SD / v4 / SCSI2SD.cydsn / Generated_Source / PSoC5 / cy_em_eeprom.h
1 /*******************************************************************************
2 * \file cy_em_eeprom.h
3 * \version 2.0
4 *
5 * \brief
6 *  This file provides the function prototypes and constants for the Emulated
7 *  EEPROM middleware library.
8 *
9 ********************************************************************************
10 * Copyright 2017, Cypress Semiconductor Corporation.  All rights reserved.
11 * You may use this file only in accordance with the license, terms, conditions,
12 * disclaimers, and limitations in the end user license agreement accompanying
13 * the software package with which this file was provided.
14 *******************************************************************************/
15
16 /**
17  * \mainpage Cypress Em_EEPROM Middleware Library
18  *
19  * The Emulated EEPROM provides an API that allows creating an emulated
20  * EEPROM in flash that has the ability to do wear leveling and restore
21  * corrupted data from a redundant copy. The Emulated EEPROM library is designed
22  * to be used with the Em_EEPROM component.
23  *
24  * The Cy_Em_EEPROM API is described in the following sections:
25  * - \ref group_em_eeprom_macros
26  * - \ref group_em_eeprom_data_structures
27  * - \ref group_em_eeprom_enums
28  * - \ref group_em_eeprom_functions
29  *
30  * <b>Features:</b>
31  * * EEPROM-Like Non-Volatile Storage
32  * * Easy to use Read and Write API
33  * * Optional Wear Leveling
34  * * Optional Redundant Data storage
35  *
36  * \section group_em_eeprom_configuration Configuration Considerations
37  *
38  * The Em_EEPROM operates on the top of the flash driver. The flash driver has
39  * some prerequisites for proper operation. Refer to the "Flash System 
40  * Routine (Flash)" section of the PDL API Reference Manual.
41  *
42  * <b>Initializing Emulated EEPROM in User flash</b>
43  *
44  * To initialize an Emulated EEPROM in the User flash, the EEPROM storage should
45  * be declared by the user. For the proper operation, the EEPROM storage should
46  * be aligned to the size of the flash row. An example of the EEPROM storage
47  * declaration is below (applicable for GCC and MDK compilers):
48  *
49  *      CY_ALIGN(CY_EM_EEPROM_FLASH_SIZEOF_ROW)
50  *      const uint8 emEeprom[Em_EEPROM_PHYSICAL_SIZE] = {0u};
51  *
52  * The same declaration for the IAR compiler:
53  *
54  *      #pragma data_alignment = CY_EM_EEPROM_FLASH_SIZEOF_ROW
55  *      const uint8 emEeprom[Em_EEPROM_PHYSICAL_SIZE] = {0u};
56  * 
57  * Note that the name "emEeprom" is shown for reference. Any other name can be
58  * used instead. Also, note that the Em_EEPROM_PHYSICAL_SIZE constant is 
59  * generated by the PSoC Creator Em_EEPROM component and so it is instance name
60  * dependent and its prefix should be changed when the name of the component 
61  * changes. If the The Cy_Em_EEPROM middleware library is used without the 
62  * Em_EEPROM component, the user has to provide a proper size for the EEPROM 
63  * storage instead of Em_EEPROM_PHYSICAL_SIZE. The size of the EEPROM storage 
64  * can be calculated using the following equation:
65  * 
66  *  Physical size = EEPROM data size * 2 * wear leveling * (1 + redundant copy)
67  *
68  * where, 
69  *   "EEPROM data size" - the size of data the user wants to store in the 
70  *   EEPROM. The data size must divide evenly to the half of the flash row size.
71  *   "wear leveling" - the wear leveling factor (1-10).
72  *   "redundant copy" - "zero" if a redundant copy is not used, and "one" 
73  *   otherwise.
74  *
75  * The start address of the storage should be filled to the Emulated EEPROM 
76  * configuration structure and then passed to the Cy_Em_EEPROM_Init().
77  * If the Em_EEPROM component is used, the config (Em_EEPROM_config) and 
78  * context structures (Em_EEPROM_context) are defined by the component, so the
79  * user may just use that structures otherwise both of the structures need to 
80  * be provided by the user. Note that if the "Config Data in Flash"
81  * option is selected in the component, then the configuration structure should
82  * be copied to RAM to allow EEPROM storage start address update. The following 
83  * code demonstrates utilization of "Em_EEPROM_config" and "Em_EEPROM_context"
84  * Em_EEPROM component structures for Cy_Em_EEPROM middleware library 
85  * initialization:
86  *
87  *      cy_en_em_eeprom_status_t retValue;
88  *      cy_stc_eeprom_config_t config;
89  *
90  *      memcpy((void *)&config, 
91                (void *)&Em_EEPROM_config, 
92                sizeof(cy_stc_eeprom_config_t));
93  *      config.userFlashStartAddr = (uint32)emEeprom;
94  *      retValue = Cy_Em_EEPROM_Init(&config, &Em_EEPROM_context);
95  *
96  * <b>Initializing EEPROM in Emulated EEPROM flash area</b>
97  * 
98  * Initializing of the EEPROM storage in the Emulated EEPROM flash area is 
99  * identical to initializing of the EEPROM storage in the User flash with one 
100  * difference. The location of the Emulated EEPROM storage should be specified 
101  * somewhere in the EmulatedEEPROM flash area. If the Em_EEPROM component is 
102  * utilized in the project, then the respective storage 
103  * (Em_EEPROM_em_EepromStorage[]) is automatically declared by the component 
104  * if the "Use Emulated EEPROM" option is set to "Yes". The user just needs to 
105  * fill the start address of the storage to the config structure. If the
106  * Em_EEPROM component is not used, the user needs to declare the storage
107  * in the Emulated EEPROM flash area. An example of such declaration is 
108  * following (applicable for GCC and MDK compilers):
109  *
110  *      CY_SECTION(".cy_em_eeprom") CY_ALIGN(CY_EM_EEPROM_FLASH_SIZEOF_ROW)
111  *      const uint8_t emEeprom[Em_EEPROM_PHYSICAL_SIZE] = {0u};
112  *
113  * The same declaration for the IAR compiler:
114  *
115  *      #pragma location = ".cy_em_eeprom"
116  *      #pragma data_alignment = CY_EM_EEPROM_FLASH_SIZEOF_ROW
117  *      const uint8 emEeprom[Em_EEPROM_PHYSICAL_SIZE] = {0u};
118  *
119  * where,
120  *   Em_EEPROM_PHYSICAL_SIZE - is a constant that is generated by the Em_EEPROM
121  *   component when the component is utilized in the project or it should be 
122  *   provided by the user. The equation for the calculation of the constant is 
123  *   shown above.
124  *
125  * Note that the size of the Emulated EEPROM flash area is limited. Refer to the
126  * specific device datasheet for the value of the available EEPROM Emulation 
127  * area.
128  *
129  * \section group_em_eeprom_more_information More Information
130  * See the Em_EEPROM Component datasheet.
131  *
132  *
133  * \section group_em_eeprom_MISRA MISRA-C Compliance
134  *
135  * The Cy_Em_EEPROM library has the following specific deviations:
136  *
137  * <table class="doxtable">
138  *   <tr>
139  *     <th>MISRA Rule</th>
140  *     <th>Rule Class (Required/Advisory)</th>
141  *     <th>Rule Description</th>
142  *     <th>Description of Deviation(s)</th>
143  *   </tr>
144  *   <tr>
145  *     <td>11.4</td>
146  *     <td>A</td>
147  *     <td>The cast should not be performed between a pointer to the object type
148  *         and a different pointer to the object type.</td>
149  *     <td>The cast from the object type and a different pointer to the object 
150  *         was used intentionally because of the performance reasons.</td>
151  *   </tr>
152  *   <tr>
153  *     <td>14.2</td>
154  *     <td>R</td>
155  *     <td>All non-null statements shall either have at least one side-effect,
156  *         however executed, or cause control flow to change.</td>
157  *     <td>To maintain common codebase, some variables, unused for a specific 
158  *         device, are casted to void to prevent generation of an unused variable
159  *         compiler warning.</td>
160  *   </tr>
161  *   <tr>
162  *     <td>16.7</td>
163  *     <td>A</td>
164  *     <td>The object addressed by the pointer parameter is not modified and so
165  *          the pointer could be of type 'pointer to const'.</td>
166  *     <td>The warning is generated because of the pointer dereferencing to
167  *         address which makes the MISRA checker think the data is not
168  *         modified.</td>
169  *   </tr>
170  *   <tr>
171  *     <td>17.4</td>
172  *     <td>R</td>
173  *     <td>The array indexing shall be the only allowed form of pointer 
174  *         arithmetic.</td>
175  *     <td>The pointer arithmetic used in several places on the Cy_Em_EEPROM
176  *         implementation is safe and preferred because it increases the code
177  *         flexibility.</td>
178  *   </tr>
179  *   <tr>
180  *     <td>19.7</td>
181  *     <td>A</td>
182  *     <td>A function shall be used in preference to a function-like macro.</td>
183  *     <td>Macro is used because of performance reasons.</td>
184  *   </tr>
185  * </table>
186  *
187  * \section group_em_eeprom_changelog Changelog
188  * <table class="doxtable">
189  *   <tr><th>Version</th><th>Changes</th><th>Reason for Change</th></tr>
190  *   <tr>
191  *     <td>1.0</td>
192  *     <td>Initial Version</td>
193  *     <td></td>
194  *   </tr>
195  * </table>
196  *
197  * \defgroup group_em_eeprom_macros Macros
198  * \brief
199  * This section describes the Emulated EEPROM Macros.
200  *
201  * \defgroup group_em_eeprom_functions Functions
202  * \brief
203  * This section describes the Emulated EEPROM Function Prototypes.
204  *
205  * \defgroup group_em_eeprom_data_structures Data Structures
206  * \brief
207  * Describes the data structures defined by the Emulated EEPROM.
208  *
209  * \defgroup group_em_eeprom_enums Enumerated types
210  * \brief
211  * Describes the enumeration types defined by the Emulated EEPROM.
212  *
213  */
214
215
216 #if !defined(CY_EM_EEPROM_H)
217 #define CY_EM_EEPROM_H
218
219 #include "cytypes.h"
220 #include <stddef.h>
221 #if (CYDEV_CHIP_FAMILY_USED == CYDEV_CHIP_FAMILY_PSOC6)
222     #include <cy_device_headers.h>
223     #include "syslib/cy_syslib.h"
224     #include "flash/cy_flash.h"
225 #else
226     #include "CyFlash.h"
227     #include <cyfitter.h>
228 #endif /* (CYDEV_CHIP_FAMILY_USED == CYDEV_CHIP_FAMILY_PSOC6) */
229
230 /* The C binding of definitions if building with the C++ compiler */
231 #ifdef __cplusplus
232 extern "C" {
233 #endif /* __cplusplus */
234
235
236 /***************************************
237 * Conditional Compilation Parameters
238 ***************************************/
239 #define CY_PSOC6                                    (CYDEV_CHIP_FAMILY_USED == CYDEV_CHIP_FAMILY_PSOC6)
240
241
242 /***************************************
243 * Data Structure definitions
244 ***************************************/
245 /**
246 * \addtogroup group_em_eeprom_data_structures
247 * \{
248 */
249
250 /** EEPROM configuration structure */
251 typedef struct
252 {
253     /** The number of bytes to store in EEPROM */
254     uint32 eepromSize;
255
256     /** The amount of wear leveling from 1 to 10. 1 means no wear leveling
257     * is used.
258     */
259     uint32 wearLevelingFactor;
260
261     /** If not zero, a redundant copy of the Em_EEPROM is included. */
262     uint8 redundantCopy;
263
264     /** If not zero, a blocking write to flash is used. Otherwise non-blocking
265     * write is used. This parameter is used only for PSoC 6.
266     */
267     uint8 blockingWrite;
268
269     /** The start address for the EEPROM memory in the user's flash. */
270     uint32 userFlashStartAddr;
271 } cy_stc_eeprom_config_t;
272
273 /** \} group_em_eeprom_data_structures */
274
275 /** The EEPROM context data structure. It is used to store the specific
276 * EEPROM context data.
277 */
278 typedef struct
279 {
280     /** The pointer to the end address of EEPROM including wear leveling overhead
281     * and excluding redundant copy overhead.
282     */
283     uint32 wlEndAddr;
284
285     /** The number of flash rows allocated for the EEPROM excluding the number of
286     * rows allocated for wear leveling and redundant copy overhead.
287     */
288     uint32 numberOfRows;
289
290     /** The address of the last written EEPROM row */
291     uint32 lastWrRowAddr;
292
293     /** The number of bytes to store in EEPROM */
294     uint32 eepromSize;
295
296     /** The amount of wear leveling from 1 to 10. 1 means no wear leveling
297     * is used.
298     */
299     uint32 wearLevelingFactor;
300
301     /** If not zero, a redundant copy of the Em_EEPROM is included. */
302     uint8 redundantCopy;
303
304     /** If not zero, a blocking write to flash is used. Otherwise non-blocking
305     * write is used. This parameter is used only for PSoC 6.
306     */
307     uint8 blockingWrite;
308
309     /** The start address for the EEPROM memory in the user's flash. */
310     uint32 userFlashStartAddr;
311 } cy_stc_eeprom_context_t;
312
313 #if (CY_PSOC6)
314
315     #define CY_EM_EEPROM_ID                         (CY_PDL_DRV_ID(0x1BuL))  /**< Em_EEPROM PDL ID */
316     /**
317     * \addtogroup group_em_eeprom_enums
318     * \{
319     * Specifies return values meaning.
320     */
321     /** A prefix for EEPROM function error return-values */
322     #define CY_EM_EEPROM_ID_ERROR                   (uint32_t)(CY_EM_EEPROM_ID | CY_PDL_STATUS_ERROR)
323
324 #else
325
326     /** A prefix for EEPROM function status codes. For non-PSoC6 devices,
327     * prefix is zero.
328     */
329     #define CY_EM_EEPROM_ID_ERROR                       (0uL)
330
331 #endif /* (CY_PSOC6) */
332
333
334 /***************************************
335 * Enumerated Types and Parameters
336 ***************************************/
337
338 /** EEPROM return enumeration type */
339 typedef enum
340 {
341     CY_EM_EEPROM_SUCCESS      = 0x00uL,                             /**< The function executed successfully */
342     CY_EM_EEPROM_BAD_PARAM    = (CY_EM_EEPROM_ID_ERROR + 1uL),      /**< The input parameter is invalid */
343     CY_EM_EEPROM_BAD_CHECKSUM = (CY_EM_EEPROM_ID_ERROR + 2uL),      /**< The data in EEPROM is corrupted */
344     CY_EM_EEPROM_BAD_DATA     = (CY_EM_EEPROM_ID_ERROR + 3uL),      /**< Failed to place the EEPROM in flash */
345     CY_EM_EEPROM_WRITE_FAIL   = (CY_EM_EEPROM_ID_ERROR + 4uL)       /**< Write to EEPROM failed */
346 } cy_en_em_eeprom_status_t;
347
348 /** \} group_em_eeprom_enums */
349
350
351 /***************************************
352 *        Function Prototypes
353 ***************************************/
354
355 /**
356 * \addtogroup group_em_eeprom_functions
357 * \{
358 */
359 cy_en_em_eeprom_status_t Cy_Em_EEPROM_Init(cy_stc_eeprom_config_t* config, cy_stc_eeprom_context_t * context);
360 cy_en_em_eeprom_status_t Cy_Em_EEPROM_Read(uint32 addr,
361                                         void * eepromData,
362                                         uint32 size,
363                                         cy_stc_eeprom_context_t * context);
364 cy_en_em_eeprom_status_t Cy_Em_EEPROM_Write(uint32 addr,
365                                             void * eepromData,
366                                             uint32 size,
367                                             cy_stc_eeprom_context_t * context);
368 cy_en_em_eeprom_status_t Cy_Em_EEPROM_Erase(cy_stc_eeprom_context_t * context);
369 uint32 Cy_Em_EEPROM_NumWrites(cy_stc_eeprom_context_t * context);
370 /** \} group_em_eeprom_functions */
371
372
373 /***************************************
374 * API Constants
375 ***************************************/
376 /**
377 * \addtogroup group_em_eeprom_macros
378 * \{
379 */
380 /** Library major version */
381 #define CY_EM_EEPROM_VERSION_MAJOR                  (2)
382
383 /** Library minor version */
384 #define CY_EM_EEPROM_VERSION_MINOR                  (0)
385
386 /** Defines the maximum data length that can be stored in one flash row */
387 #define CY_EM_EEPROM_EEPROM_DATA_LEN                (CY_EM_EEPROM_FLASH_SIZEOF_ROW / 2u)
388
389 /** \} group_em_eeprom_macros */
390
391
392 /***************************************
393 * Macro definitions
394 ***************************************/
395 /** \cond INTERNAL */
396
397 /* Defines the size of flash row */
398 #define CY_EM_EEPROM_FLASH_SIZEOF_ROW               (CY_FLASH_SIZEOF_ROW)
399
400 /* Device specific flash constants */
401 #if (!CY_PSOC6)
402     #define CY_EM_EEPROM_FLASH_BASE_ADDR                (CYDEV_FLASH_BASE)
403     #define CY_EM_EEPROM_FLASH_SIZE                     (CYDEV_FLASH_SIZE)
404     #define CY_EM_EEPROM_ROWS_IN_ARRAY                  (CY_FLASH_SIZEOF_ARRAY / CY_EM_EEPROM_FLASH_SIZEOF_ROW)
405     #if (CY_PSOC3)
406         #define CY_EM_EEPROM_CODE_MEM_CLASS_PREFIX          (0xff0000uL)
407         #define CY_EM_EEPROM_CODE_ADDR_END                  \
408                         (CY_EM_EEPROM_CODE_MEM_CLASS_PREFIX + (CY_EM_EEPROM_FLASH_SIZE - 1u))
409         #define CY_EM_EEPROM_CODE_ADDR_MASK                 (0xffffu)
410         /* Checks if the EEPROM is in flash range */
411         #define CY_EM_EEPROM_IS_IN_FLASH_RANGE(startAddr, endAddr) \
412                         (((startAddr) > CY_EM_EEPROM_CODE_MEM_CLASS_PREFIX) && \
413                          ((endAddr) <= CY_EM_EEPROM_CODE_ADDR_END))
414     #else
415         /* Checks is the EEPROM is in flash range */
416         #define CY_EM_EEPROM_IS_IN_FLASH_RANGE(startAddr, endAddr) \
417                         (((startAddr) > CY_EM_EEPROM_FLASH_BASE_ADDR) && ((endAddr) <= CY_EM_EEPROM_FLASH_END_ADDR))
418     #endif /* (CY_PSOC3) */
419 #else
420     #define CY_EM_EEPROM_FLASH_BASE_ADDR                (CY_FLASH_BASE)
421     #define CY_EM_EEPROM_FLASH_SIZE                     (CY_FLASH_SIZE)
422     #define CY_EM_EEPROM_EM_EEPROM_BASE_ADDR            (CY_EM_EEPROM_BASE)
423     #define CY_EM_EEPROM_EM_EEPROM_SIZE                 (CY_EM_EEPROM_SIZE)
424     #define CY_EM_EEPROM_EM_EEPROM_END_ADDR             (CY_EM_EEPROM_EM_EEPROM_BASE_ADDR + CY_EM_EEPROM_EM_EEPROM_SIZE)
425     /* Checks is the EEPROM is in flash range */
426     #define CY_EM_EEPROM_IS_IN_FLASH_RANGE(startAddr, endAddr) \
427                     (((((startAddr) > CY_EM_EEPROM_FLASH_BASE_ADDR) && ((endAddr) <= CY_EM_EEPROM_FLASH_END_ADDR)) || \
428                       (((startAddr) >= CY_EM_EEPROM_EM_EEPROM_BASE_ADDR) && \
429                                                                     ((endAddr) <= CY_EM_EEPROM_EM_EEPROM_END_ADDR))))
430 #endif /* (!CY_PSOC6) */
431
432 #define CY_EM_EEPROM_FLASH_END_ADDR                 (CY_EM_EEPROM_FLASH_BASE_ADDR + CY_EM_EEPROM_FLASH_SIZE)
433
434 /* Defines the length of EEPROM data that can be stored in Em_EEPROM header */
435 #define CY_EM_EEPROM_HEADER_DATA_LEN                ((CY_EM_EEPROM_FLASH_SIZEOF_ROW / 2u) - 16u)
436
437 #define CY_EM_EEPROM_ADDR_IN_RANGE                  (1u)
438
439 /* Return CY_EM_EEPROM_ADDR_IN_RANGE if addr exceeded the upper range of
440 * EEPROM. The wear leveling overhead is included in the range but redundant copy
441 * is excluded.
442 */
443 #define CY_EM_EEPROM_IS_ADDR_EXCEED_RANGE(addr, endEepromAddr) \
444                                     (((addr) >= (endEepromAddr)) ? (0u) : (CY_EM_EEPROM_ADDR_IN_RANGE))
445
446 /* Check to see if the specified address is present in the EEPROM */
447 #define CY_EM_EEPROM_IS_ADDR_IN_RANGE(addr, startEepromAddr, endEepromAddr) \
448                                     (((addr) > (startEepromAddr)) ? \
449                                     (((addr) < (endEepromAddr)) ? (CY_EM_EEPROM_ADDR_IN_RANGE) : (0u)) : (0u))
450
451 /* Check if the EEPROM address locations from startAddr1 to endAddr1
452 * are crossed with EEPROM address locations from startAddr2 to endAddr2.
453 */
454 #define CY_EM_EEPROM_IS_ADDRESES_CROSSING(startAddr1, endAddr1 , startAddr2, endAddr2) \
455                                     (((startAddr1) > (startAddr2)) ? (((startAddr1) >= (endAddr2)) ? (0u) : (1u) ) : \
456                                     (((startAddr2) >= (endAddr1)) ? (0u) : (1u)))
457
458 /* Return the pointer to the start of the redundant copy of the EEPROM */
459 #define CY_EM_EEPROM_GET_REDNT_COPY_ADDR_BASE(numRows, wearLeveling, eepromStartAddr) \
460                                     ((((numRows) * CY_EM_EEPROM_FLASH_SIZEOF_ROW) * (wearLeveling)) + (eepromStartAddr))
461
462 /* Return the number of the row in EM_EEPROM which contains an address defined by
463 * rowAddr.
464  */
465 #define CY_EM_EEPROM_GET_ACT_ROW_NUM_FROM_ADDR(rowAddr, maxRows, eepromStartAddr) \
466                                     ((((rowAddr) - (eepromStartAddr)) / CY_EM_EEPROM_FLASH_SIZEOF_ROW) % (maxRows))
467
468
469 /** Returns the size allocated for the EEPROM excluding wear leveling and
470 * redundant copy overhead.
471 */
472 #define CY_EM_EEPROM_GET_EEPROM_SIZE(numRows)       ((numRows) * CY_EM_EEPROM_FLASH_SIZEOF_ROW)
473
474 /* Check if the given address belongs to the EEPROM address of the row
475 * specified by rowNum.
476 */
477 #define CY_EM_EEPROM_IS_ADDR_IN_ROW_RANGE(addr, rowNum) \
478                                     (((addr) < ((rowNum) * (CY_EM_EEPROM_FLASH_SIZEOF_ROW / 2u))) ? (0u) : \
479                                     (((addr) > ((((rowNum) + 1u) * (CY_EM_EEPROM_FLASH_SIZEOF_ROW / 2u)) - 1u)) ? \
480                                     (0u) : (1u)))
481
482 /* CRC-8 constants */
483 #define CY_EM_EEPROM_CRC8_POLYNOM                   ((uint8)(0x31u))
484 #define CY_EM_EEPROM_CRC8_POLYNOM_LEN               (8u)
485 #define CY_EM_EEPROM_CRC8_SEED                      (0xFFu)
486 #define CY_EM_EEPROM_CRC8_XOR_VAL                   ((uint8) (0x80u))
487
488 #define CY_EM_EEPROM_CALCULATE_CRC8(crc)            \
489                   ((CY_EM_EEPROM_CRC8_XOR_VAL == ((crc) & CY_EM_EEPROM_CRC8_XOR_VAL)) ? \
490                   ((uint8)(((uint8)((uint8)((crc) << 1u))) ^ CY_EM_EEPROM_CRC8_POLYNOM)) : ((uint8)((crc) << 1u)))
491
492 #define CY_EM_EEPROM_GET_SEQ_NUM(addr)                (*(uint32*)(addr))
493
494 /** \endcond */
495
496 /**
497 * \addtogroup group_em_eeprom_macros
498 * \{
499 */
500
501 /** Calculate the number of flash rows required to create an Em_EEPROM of
502 * dataSize.
503 */
504 #define CY_EM_EEPROM_GET_NUM_ROWS_IN_EEPROM(dataSize) \
505                                     (((dataSize) / (CY_EM_EEPROM_EEPROM_DATA_LEN)) + \
506                                     ((((dataSize) % (CY_EM_EEPROM_EEPROM_DATA_LEN)) != 0u) ? 1U : 0U))
507
508 /** Returns the size of flash allocated for EEPROM including wear leveling and
509 * redundant copy overhead.
510 */
511 #define CY_EM_EEPROM_GET_PHYSICAL_SIZE(dataSize, wearLeveling, redundantCopy) \
512                                     (((CY_EM_EEPROM_GET_NUM_ROWS_IN_EEPROM(dataSize) * \
513                                     CY_EM_EEPROM_FLASH_SIZEOF_ROW) * \
514                                     (wearLeveling)) * (1uL + (redundantCopy)))
515
516 /** \} group_em_eeprom_macros */
517
518
519 /******************************************************************************
520 * Local definitions
521 *******************************************************************************/
522 /** \cond INTERNAL */
523
524 /* Offsets for 32-bit RAM buffer addressing */
525 #define CY_EM_EEPROM_EEPROM_DATA_OFFSET_U32         ((CY_EM_EEPROM_FLASH_SIZEOF_ROW / 2u) / 4u)
526 #define CY_EM_EEPROM_HEADER_SEQ_NUM_OFFSET_U32      (0u)
527 #define CY_EM_EEPROM_HEADER_ADDR_OFFSET_U32         (1u)
528 #define CY_EM_EEPROM_HEADER_LEN_OFFSET_U32          (2u)
529 #define CY_EM_EEPROM_HEADER_DATA_OFFSET_U32         (3u)
530 #define CY_EM_EEPROM_HEADER_CHECKSUM_OFFSET_U32     (CY_EM_EEPROM_EEPROM_DATA_OFFSET_U32 - 1u)
531
532 /* The same offsets as above used for direct memory addressing */
533 #define CY_EM_EEPROM_EEPROM_DATA_OFFSET             (CY_EM_EEPROM_FLASH_SIZEOF_ROW / 2u)
534 #define CY_EM_EEPROM_HEADER_ADDR_OFFSET             (4u)
535 #define CY_EM_EEPROM_HEADER_LEN_OFFSET              (8u)
536 #define CY_EM_EEPROM_HEADER_DATA_OFFSET             (12u)
537 #define CY_EM_EEPROM_HEADER_CHECKSUM_OFFSET         (CY_EM_EEPROM_EEPROM_DATA_OFFSET - 4u)
538
539 #define CY_EM_EEPROM_U32_DIV                        (4u)
540
541 /* Maximum wear leveling value */
542 #define CY_EM_EEPROM_MAX_WEAR_LEVELING_FACTOR       (10u)
543
544 /* Maximum allowed flash row write/erase operation duration */
545 #define CY_EM_EEPROM_MAX_WRITE_DURATION_MS          (50u)
546
547 /** \endcond */
548
549
550 #ifdef __cplusplus
551 }
552 #endif /* __cplusplus */
553 #endif /* CY_EM_EEPROM_H */
554
555
556 /* [] END OF FILE */