The EEPROM_GetValidBank() function provides functionality for finding the current EEPROM bank and page. This function is called by both the EEPROM_Write() and EEPROM_Read() functions. GetValidBank Flow shows the overall flow required to search for current EEPROM bank and page.

When entering this function, the EEPROM bank and page pointers are set to the beginning of the first sector specified in FIRST_AND_LAST_SECTOR:

RESET_BANK_POINTER;
RESET_PAGE_POINTER;     

The addresses for these pointers are defined the EEPROM_Config.h file for the specific device and EEPROM configuration being used.

Next, the current EEPROM bank is found. As GetValidBank Flow shows, there are three different states that an EEPROM bank can have: Empty, Current, and Used.

An Empty EEPROM Bank is signified by the 128 status bits all being 1s (0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF). A Current EEPROM Bank is signified by the most significant 64 bits being set to 0x5A5A5A5A5A5A5A5A, with the remaining 64 bits set to 1 (0x5A5A5A5A5A5A5A5AFFFFFFFFFFFFFFFF. A Used EERPOM Bank is signified by all 128 bits being set to 0x5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A. These values can be changed if desired.

An Empty EEPROM Bank is tested first. If this status is encountered, the EEPROM bank has not been used and no further searching is needed.

if(Bank_Status[0] == EMPTY_BANK)        // Check for Unused EEPROM Bank
{
    Bank_Counter = i;  // Set EEPROM Bank Counter to number of current page
    return;            // If EEPROM Bank is Unused, return as EEPROM is empty
}

If an Empty EEPROM Bank is not encountered, Current EEPROM Bank is tested next. If the EEPROM bank is the current EEPROM bank, the EEPROM bank counter is updated and the page pointer is set to the first page of the EEPROM bank to enable testing for the current page. The loop is then exited as no further EEPROM bank searching is needed.

if(Bank_Status[0] == CURRENT_BANK && Bank_Status[4] != CURRENT_BANK)      // Check for Current Bank
{
    Bank_Counter = i;      // Set Bank Counter to number of current bank
    // Set Page Pointer to first page in current bank    
    Page_Pointer = Bank_Pointer + 8; 
    break;      // Break from loop as current bank has been found
}

Lastly, Used EEPROM Bank is tested. In this case the EEPROM bank has been used and the EEPROM bank pointer is updated to the next EEPROM bank to test its status.

// Check for Used Bank
if(Bank_Status[0] == CURRENT_BANK && Bank_Status[4] == CURRENT_BANK)         
// If Bank has been used, set pointer to next bank
    Bank_Pointer += Bank_Size;          

After the current EEPROM bank has been found, the current page needs to be found. there are three different states that a page can have: Empty, Current, and Used.

An Empty Page is signified by the 128 status bits all being 1s (0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF). A Current Page is signified by the most significant 64 bits being set to 0x5F5F5F5F5F5F5F5F, with the remaining 64 bits set to 1 ( 0x5F5F5F5F5F5F5F5FFFFFFFFFFFFFFFFF). A Used Page is signified by all 128 bits being set to 0x5F5F5F5F5F5F5F5F5F5F5F5F5F5F5F5F. These values can be changed if desired.

The Blank and Current Pages are tested first. If either of these are the current state of the page, the correct page is found and the loop is exited as further searching is not needed.

// Check for Blank Page or Current Page
if(Page_Status[0] == BLANK_PAGE)
{
        Page_Counter = i;  // Set Page Counter to number of current page
        break;  // Break from loop as current page has been found
}

if (Page_Status[0] == CURRENT_PAGE && Page_Status[4] != CURRENT_PAGE)
{
       Page_Counter = i + 1;//Increment Page Counter as one has been used
       break; // Break from loop as current page has been found
}

If the page status is neither of these, the only other possibility is a Used Page. In this case, the page pointer is updated to the next page to test its status.

// Check for Used Page
if(Page_Status[0] == CURRENT_PAGE && Page_Status[4] == CURRENT_PAGE)
{
// If page has been used, set pointer to next page
        Page_Pointer += EEPROM_PAGE_DATA_SIZE + 8;
}

At this point, the current EEPROM bank and page is found and the calling function can continue. As a final step, this function will check if all EEPROM banks and pages have been used. In this case, the sector needs to be erased. The active units will be switched, Write/Erase Protection masks are reconfigured, and the Erase_Inactive_Unit flag is set.

if (!ReadFlag)
{
    if (Bank_Counter == NUM_EEPROM_BANKS - 1 && 
            Page_Counter == NUM_EEPROM_PAGES)     
    {

        EEPROM_ACTIVE_UNIT ^= 1;


        uint64 WE_Protection_AB_Mask = Configure_Protection_Masks(
                                             FIRST_AND_LAST_SECTOR[EEPROM_ACTIVE_UNIT], 
                                                NUM_EEPROM_SECTORS);


        WE_Protection_A_Mask = 0xFFFFFFFF ^(uint32)WE_Protection_AB_Mask;
        WE_Protection_B_Mask = 0x00000FFF ^ WE_Protection_AB_Mask >> 32;

        Erase_Inactive_Unit = 1;  
        RESET_BANK_POINTER;   
        RESET_PAGE_POINTER;                     
    }
}

This check is performed by testing the EEPROM bank and page counters. The amount of EEPROM banks and pages indicating a full EEPROM depends on the application. These counters are set when testing for the current EEPROM banks and pages as shown in the code snippets above. However, this check is not made when the Read_Flag is set. This is to prevent premature erasing of the inactive EEPROM unit when reading from a full EEPROM unit.