/** * Test nvm_eeprom_erase_bytes_in_page() and * nvm_eeprom_erase_bytes_in_all_pages() * * Test procedure: * - Write two bytes into page TEST_ERASE_BYTES_PAGE_1 and * TEST_ERASE_BYTES_PAGE_2 * - Load value to page buffer in the address of the first byte * - Erase first byte of TEST_ERASE_BYTES_PAGE_1 * - Verify that first byte is deleted in TEST_ERASE_BYTES_PAGE_1 * - Load value to page buffer in the address of the first byte * - Erase first byte of all pages * - Verify that first byte is deleted in TEST_ERASE_BYTES_PAGE_2 * * \return STATUS_OK if test succeeded, otherwise ERR_BAD_DATA */ static status_code_t test_erase_bytes(void) { set_buffer(buffer, EEPROM_ERASED); buffer[0] = 0xaa; buffer[1] = 0xaf; /* Write two bytes into first page */ nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_1 * EEPROM_PAGE_SIZE + 0, buffer[0]); nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_1 * EEPROM_PAGE_SIZE + 1, buffer[1]); /* Write two bytes into second page */ nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_2 * EEPROM_PAGE_SIZE + 0, buffer[0]); nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_2 * EEPROM_PAGE_SIZE + 1, buffer[1]); /* Erase first byte of the first page */ nvm_eeprom_load_byte_to_buffer(0, 0xff); nvm_eeprom_erase_bytes_in_page(TEST_ERASE_BYTES_PAGE_1); buffer[0] = EEPROM_ERASED; if (is_eeprom_page_equal_to_buffer(TEST_ERASE_BYTES_PAGE_1, buffer)) { /* Erase first byte of all pages */ nvm_eeprom_load_byte_to_buffer(0, 0xff); nvm_eeprom_erase_bytes_in_all_pages(); if (is_eeprom_page_equal_to_buffer(TEST_ERASE_BYTES_PAGE_2, buffer)) { return STATUS_OK; } } return ERR_BAD_DATA; }
/** * Test nvm_eeprom_load_byte_to_buffer(), nvm_eeprom_flush_buffer() and * nvm_eeprom_atomic_write_page() * * Test procedure: * - Erase the TEST_ATOMIC_WRITE_PAGE page. * - Load byte and then flush the buffer at one location. * - Load two more bytes at a different location. * - Write the page. * - Verify that only two bytes are written and the rest of the page is erased. * * \return STATUS_OK if test succeeded, otherwise ERR_BAD_DATA */ static status_code_t test_atomic_write(void) { nvm_eeprom_erase_page(TEST_ATOMIC_WRITE_PAGE); /* Load a dummy byte and then flush the buffer to remove the byte from * the buffer. The byte should not be written to the EEPROM. */ nvm_eeprom_load_byte_to_buffer(0, 55); nvm_eeprom_flush_buffer(); /* Load some additional bytes */ set_buffer(buffer, EEPROM_ERASED); buffer[1] = 0xaa; buffer[2] = 0x19; nvm_eeprom_load_byte_to_buffer(1, buffer[1]); nvm_eeprom_load_byte_to_buffer(2, buffer[2]); /* Erase and then write page */ nvm_eeprom_atomic_write_page(TEST_ATOMIC_WRITE_PAGE); if (is_eeprom_page_equal_to_buffer(TEST_ATOMIC_WRITE_PAGE, buffer)) { return STATUS_OK; } return ERR_BAD_DATA; }
/** * \brief Test EEPROM read buffer * * This test erases test page \ref TEST_READ_BUFFER_PAGE then writes four bytes * to the test page and tries to read the entire page using * nvm_eeprom_read_buffer. * It then compares the read page with what's actually in the EEPROM page. * * \param test Current test case. */ static void run_eeprom_read_buffer_test(const struct test_case *test) { uint8_t buffer[EEPROM_PAGE_SIZE]; uint8_t buffer_read[EEPROM_PAGE_SIZE]; bool success; set_buffer(buffer, EEPROM_ERASED); buffer[0] = 0x11; buffer[1] = 0xaa; buffer[2] = 0xee; buffer[3] = 0x22; // Erase page nvm_eeprom_erase_bytes_in_page(TEST_READ_BUFFER_PAGE); // Write 4 bytes into page: nvm_eeprom_write_byte(TEST_READ_BUFFER_PAGE * EEPROM_PAGE_SIZE + 0, buffer[0]); nvm_eeprom_write_byte(TEST_READ_BUFFER_PAGE * EEPROM_PAGE_SIZE + 1, buffer[1]); nvm_eeprom_write_byte(TEST_READ_BUFFER_PAGE * EEPROM_PAGE_SIZE + 2, buffer[2]); nvm_eeprom_write_byte(TEST_READ_BUFFER_PAGE * EEPROM_PAGE_SIZE + 3, buffer[3]); nvm_eeprom_read_buffer(TEST_READ_BUFFER_PAGE * EEPROM_PAGE_SIZE, &buffer_read, EEPROM_PAGE_SIZE); // Check that what we have read is actually what's in EEPROM. success = is_eeprom_page_equal_to_buffer(TEST_READ_BUFFER_PAGE, buffer_read); test_assert_true(test, success, "Read buffer failed"); }
/** * \brief Test EEPROM write buffer * * This test erases test page \ref TEST_WRITE_BUFFER_PAGE then writes a buffer * to the test page, and then overwrites this with the another buffer and checks * that the last buffer written is what the page is containing. * * \param test Current test case. */ static void run_eeprom_write_buffer_test(const struct test_case *test) { uint8_t buffer[EEPROM_PAGE_SIZE]; bool success; set_buffer(buffer, EEPROM_ERASED); buffer[0] = 0x11; buffer[1] = 0xaa; buffer[2] = 0xee; buffer[3] = 0x22; // Erase page nvm_eeprom_erase_bytes_in_page(TEST_WRITE_BUFFER_PAGE); // Write buffer to EEPROM nvm_eeprom_erase_and_write_buffer(TEST_WRITE_BUFFER_PAGE * EEPROM_PAGE_SIZE, &buffer, EEPROM_PAGE_SIZE); /* Write another buffer to EEPROM to make sure EEPROM is deleted before * written to. */ buffer[0] = 0x33; buffer[1] = 0x11; buffer[2] = 0xee; buffer[3] = 0xaa; nvm_eeprom_erase_and_write_buffer(TEST_WRITE_BUFFER_PAGE * EEPROM_PAGE_SIZE, &buffer, EEPROM_PAGE_SIZE); // Check that what we have written is in EEPROM. success = is_eeprom_page_equal_to_buffer(TEST_WRITE_BUFFER_PAGE, buffer); test_assert_true(test, success, "Write buffer failed"); }
/** * \brief Test EEPROM atomic write * * This test erases test page \ref TEST_ATOMIC_WRITE_PAGE, then writes the first * byte in the page buffer before flushing it -- this byte should then not be * written to the EEPROM -- and writing different values to the two successive * bytes. An atomic write is then executed before the write of the latter two * bytes is verified. * * \param test Current test case. */ static void run_eeprom_atomic_write_test(const struct test_case *test) { uint8_t buffer[EEPROM_PAGE_SIZE]; bool success; nvm_eeprom_erase_page(TEST_ATOMIC_WRITE_PAGE); /* Load a dummy byte and then flush the buffer to remove the byte from * the buffer. The byte should not be written to the EEPROM. */ nvm_eeprom_load_byte_to_buffer(0, 55); nvm_eeprom_flush_buffer(); /* Load some additional bytes */ set_buffer(buffer, EEPROM_ERASED); buffer[1] = 0xaa; buffer[2] = 0x19; nvm_eeprom_load_byte_to_buffer(1, buffer[1]); nvm_eeprom_load_byte_to_buffer(2, buffer[2]); /* Erase and then write page */ nvm_eeprom_atomic_write_page(TEST_ATOMIC_WRITE_PAGE); success = is_eeprom_page_equal_to_buffer(TEST_ATOMIC_WRITE_PAGE, buffer); test_assert_true(test, success, "Page buffer flush, byte load or atomic write failed"); }
/** * Test nvm_eeprom_erase_all(). * * Test procedure: * - Write one byte to the TEST_ERASE_PAGE page. * - Erase all memory locations * - Verify that the EEPROM is erased by a spot test on the * TEST_ERASE_PAGE page. * * \return STATUS_OK if test succeeded, otherwise ERR_BAD_DATA */ static status_code_t test_erase(void) { nvm_eeprom_write_byte(TEST_ERASE_PAGE * EEPROM_PAGE_SIZE, 42); nvm_eeprom_erase_all(); set_buffer(buffer, EEPROM_ERASED); if (is_eeprom_page_equal_to_buffer(TEST_ERASE_PAGE, buffer)) { return STATUS_OK; } return ERR_BAD_DATA; }
/** * \brief Test EEPROM erase * * This test writes a single byte to test page \ref TEST_ERASE_PAGE, then erases * _all_ pages and checks that the test page contains only \ref EEPROM_ERASED. * * \param test Current test case. */ static void run_eeprom_erase_test(const struct test_case *test) { uint8_t buffer[EEPROM_PAGE_SIZE]; bool success; nvm_eeprom_write_byte(TEST_ERASE_PAGE * EEPROM_PAGE_SIZE, 42); nvm_eeprom_erase_all(); set_buffer(buffer, EEPROM_ERASED); success = is_eeprom_page_equal_to_buffer(TEST_ERASE_PAGE, buffer); test_assert_true(test, success, "Page was not erased"); }
/** * \brief Test EEPROM write * * This test erases test page \ref TEST_WRITE_PAGE, then writes a single byte to * it and verifies that the write succeeded. * * \param test Current test case. */ static void run_eeprom_write_test(const struct test_case *test) { uint8_t buffer[EEPROM_PAGE_SIZE]; bool success; nvm_eeprom_erase_page(TEST_WRITE_PAGE); set_buffer(buffer, EEPROM_ERASED); buffer[0] = 0xaa; nvm_eeprom_write_byte(TEST_WRITE_PAGE * EEPROM_PAGE_SIZE, buffer[0]); success = is_eeprom_page_equal_to_buffer(TEST_WRITE_PAGE, buffer); test_assert_true(test, success, "Byte write failed"); }
/** * Test nvm_eeprom_erase_page() and nvm_eeprom_write_byte(). * * Test procedure: * - Erase TEST_WRITE_PAGE * - Write one byte * - Verify that the byte is written and that all other bytes are erased. * * \return STATUS_OK if test succeeded, otherwise ERR_BAD_DATA */ static status_code_t test_write(void) { // Test write nvm_eeprom_erase_page(TEST_WRITE_PAGE); set_buffer(buffer, EEPROM_ERASED); buffer[0] = 0xaa; nvm_eeprom_write_byte(TEST_WRITE_PAGE*EEPROM_PAGE_SIZE, buffer[0]); if (is_eeprom_page_equal_to_buffer(TEST_WRITE_PAGE, buffer)) { return STATUS_OK; } return ERR_BAD_DATA; }
/** * \brief Test EEPROM byte erase * * This test writes two bytes to test pages \ref TEST_ERASE_BYTES_PAGE_1 and * \ref TEST_ERASE_BYTES_PAGE_2, then tries to erase one of them in the first * page before verifying the erase, then in all pages before verifying that the * second page was also erased. * * \param test Current test case. */ static void run_eeprom_erase_byte_test(const struct test_case *test) { uint8_t buffer[EEPROM_PAGE_SIZE]; bool success; set_buffer(buffer, EEPROM_ERASED); buffer[0] = 0xaa; buffer[1] = 0xaf; /* Write two bytes into first page */ nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_1 * EEPROM_PAGE_SIZE + 0, buffer[0]); nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_1 * EEPROM_PAGE_SIZE + 1, buffer[1]); /* Write two bytes into second page */ nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_2 * EEPROM_PAGE_SIZE + 0, buffer[0]); nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_2 * EEPROM_PAGE_SIZE + 1, buffer[1]); /* Erase first byte of the first page */ nvm_eeprom_load_byte_to_buffer(0, 0xff); nvm_eeprom_erase_bytes_in_page(TEST_ERASE_BYTES_PAGE_1); buffer[0] = EEPROM_ERASED; success = is_eeprom_page_equal_to_buffer(TEST_ERASE_BYTES_PAGE_1, buffer); test_assert_true(test, success, "Byte erase in single page failed"); /* Erase first byte of all pages */ nvm_eeprom_load_byte_to_buffer(0, 0xff); nvm_eeprom_erase_bytes_in_all_pages(); success = is_eeprom_page_equal_to_buffer(TEST_ERASE_BYTES_PAGE_2, buffer); test_assert_true(test, success, "Byte erase in all pages failed"); }
/** * Test nvm_eeprom_split_write_page() * * Test procedure: * - Erase TEST_SPLIT_WRITE_PAGE page and then write 2 bytes * to TEST_SPLIT_WRITE_PAGE by using an atomic write * - Write 1 additional byte at another location using a split write * - Verify that all 3 bytes written correctly and that the rest of the page * is erased. * * \return STATUS_OK if test succeeded, otherwise ERR_BAD_DATA */ static status_code_t test_split_write(void) { /* Erase and then program two bytes into the page */ set_buffer(buffer, EEPROM_ERASED); buffer[1] = 0xaa; buffer[2] = 0x19; nvm_eeprom_load_byte_to_buffer(1, buffer[1]); nvm_eeprom_load_byte_to_buffer(2, buffer[2]); nvm_eeprom_atomic_write_page(TEST_SPLIT_WRITE_PAGE); /* * Write another value to the EEPROM and then verify that all three bytes * are present, ie. the split write does not delete the first two bytes. */ buffer[3] = 0xa7; nvm_eeprom_load_byte_to_buffer(3, buffer[3]); nvm_eeprom_split_write_page(TEST_SPLIT_WRITE_PAGE); if (is_eeprom_page_equal_to_buffer(TEST_SPLIT_WRITE_PAGE, buffer)) { return STATUS_OK; } return ERR_BAD_DATA; }
/** * \brief Test EEPROM split write * * This test writes two bytes to test page \ref TEST_SPLIT_WRITE_PAGE with an * atomic write operation, then writes a third byte to the same page with a * split write operation before verifying that the page contains all three * bytes. * * \param test Current test case. */ static void run_eeprom_split_write_test(const struct test_case *test) { uint8_t buffer[EEPROM_PAGE_SIZE]; bool success; /* Erase and then program two bytes into the page */ set_buffer(buffer, EEPROM_ERASED); buffer[1] = 0xaa; buffer[2] = 0x19; nvm_eeprom_load_byte_to_buffer(1, buffer[1]); nvm_eeprom_load_byte_to_buffer(2, buffer[2]); nvm_eeprom_atomic_write_page(TEST_SPLIT_WRITE_PAGE); /* * Write another value to the EEPROM and then verify that all three bytes * are present, ie. the split write does not delete the first two bytes. */ buffer[3] = 0xa7; nvm_eeprom_load_byte_to_buffer(3, buffer[3]); nvm_eeprom_split_write_page(TEST_SPLIT_WRITE_PAGE); success = is_eeprom_page_equal_to_buffer(TEST_SPLIT_WRITE_PAGE, buffer); test_assert_true(test, success, "Split write failed"); }