mirror of https://github.com/ARMmbed/mbed-os.git
Merge pull request #9370 from ARMmbed/release-candidate
Release candidate for mbed-os-5.11.2pull/9634/head mbed-os-5.11.2
Cruz Monrreal
GitHub
commit
a8f0c33eaa
49
.travis.yml
49
.travis.yml
|
|
@ -46,6 +46,8 @@ before_install:
|
|||
# Setup ppa to make sure arm-none-eabi-gcc is correct version
|
||||
- sudo add-apt-repository -y ppa:team-gcc-arm-embedded/ppa
|
||||
- sudo add-apt-repository -y ppa:deadsnakes/ppa
|
||||
# workaround for https://travis-ci.community/t/then-sudo-apt-get-update-failed-public-key-is-not-available-no-pubkey-6b05f25d762e3157-in-ubuntu-xenial/1728
|
||||
- sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 762E3157
|
||||
# Loop until update succeeds (timeouts can occur)
|
||||
- travis_retry $(! sudo apt-get update 2>&1 |grep Failed)
|
||||
|
||||
|
|
@ -105,7 +107,7 @@ matrix:
|
|||
# Install dependencies
|
||||
- sudo apt-get install gcc-arm-embedded
|
||||
- pip install -r requirements.txt
|
||||
- pip install pytest pylint hypothesis mock coverage coveralls
|
||||
- pip install pytest pylint hypothesis==3.88.3 mock coverage coveralls
|
||||
# Print versions we use
|
||||
|
||||
- arm-none-eabi-gcc --version
|
||||
|
|
@ -134,43 +136,25 @@ matrix:
|
|||
- env:
|
||||
- NAME=astyle
|
||||
install:
|
||||
- curl -L0 https://mbed-os.s3-eu-west-1.amazonaws.com/builds/deps/astyle_3.1_linux.tar.gz --output astyle.tar.gz;
|
||||
- >-
|
||||
curl -L0 https://mbed-os.s3-eu-west-1.amazonaws.com/builds/deps/astyle_3.1_linux.tar.gz --output astyle.tar.gz;
|
||||
mkdir -p BUILD && tar xf astyle.tar.gz -C BUILD;
|
||||
pushd BUILD/astyle/build/gcc;
|
||||
cd BUILD/astyle/build/gcc;
|
||||
make;
|
||||
export PATH=$PWD/bin:$PATH;
|
||||
popd;
|
||||
cd -
|
||||
- astyle --version
|
||||
# Fetch remaining information needed for branch comparison
|
||||
- git fetch --all --unshallow --tags
|
||||
- git fetch origin "${TRAVIS_BRANCH}"
|
||||
script:
|
||||
# only changed files this time
|
||||
git diff --name-only --diff-filter=d $TRAVIS_BRANCH | grep '.*\.\(h\|c\|hpp\|cpp\)$' | fgrep -v -f .astyleignore | xargs -n 100 -I {} bash -c "astyle -n --options=.astylerc \"{}\"" > astyle-files-changed.out;
|
||||
if [ $(cat astyle-files-changed.out | grep Formatted | wc -l) -ne 0 ]; then
|
||||
git --no-pager diff;
|
||||
echo "";
|
||||
echo "AStyle check failed, please fix style issues as shown above";
|
||||
(exit 1);
|
||||
else
|
||||
echo "Coding style check OK";
|
||||
fi
|
||||
after_success:
|
||||
# run astyle for all files on the branch
|
||||
- git checkout -- .
|
||||
- find -regex '.*\.\(h\|c\|hpp\|cpp\)$' -type f | fgrep -v -f .astyleignore | xargs -n 100 -I {} bash -c "astyle -n --options=.astylerc \"{}\"" > astyle-branch.out;
|
||||
# update status if we succeeded, compare with master if possible
|
||||
- |
|
||||
CURR=$(cat astyle-branch.out | grep Formatted | wc -l)
|
||||
PREV=$(curl -u "$MBED_BOT" https://api.github.com/repos/$TRAVIS_REPO_SLUG/status/master \
|
||||
| jq -re "select(.sha != \"$TRAVIS_COMMIT\")
|
||||
| .statuses[] | select(.context == \"travis-ci/$NAME\").description
|
||||
| capture(\", (?<files>[0-9]+) files\").files" \
|
||||
|| echo 0)
|
||||
- >-
|
||||
git diff --name-only --diff-filter=d FETCH_HEAD..HEAD \
|
||||
| ( grep '.\(c\|cpp\|h\|hpp\)$' || true ) \
|
||||
| ( fgrep -v -f .astyleignore || true ) \
|
||||
| while read file; do astyle -n --options=.astylerc "${file}"; done
|
||||
- git diff --exit-code --diff-filter=d --color
|
||||
|
||||
STATUSM="Passed, ${CURR} files"
|
||||
if [ "$PREV" -ne 0 ]
|
||||
then
|
||||
STATUSM="$STATUSM ($(python -c "print '%+d' % ($CURR-$PREV)") files)"
|
||||
fi
|
||||
- bash -c "$STATUS" success "$STATUSM"
|
||||
- env:
|
||||
- NAME=events
|
||||
- EVENTS=events
|
||||
|
|
@ -294,6 +278,7 @@ matrix:
|
|||
- echo 'Checking that there is no GPL licence text in code'
|
||||
- ! git grep -q --ignore-case "gnu general public";
|
||||
- ! git grep -q --ignore-case "gnu library general public";
|
||||
|
||||
- env:
|
||||
- NAME=psa-autogen
|
||||
script:
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ class RTC_time_calc_test(BaseHostTest):
|
|||
self.send_kv("passed", str(response))
|
||||
else:
|
||||
self.send_kv("failed", 0)
|
||||
print "expected = %d, result = %d" % (expected_timestamp , actual_timestamp)
|
||||
print("expected = %d, result = %d" % (expected_timestamp , actual_timestamp))
|
||||
|
||||
# calculate next date
|
||||
if (self.first):
|
||||
|
|
|
|||
|
|
@ -40,6 +40,9 @@ using namespace utest::v1;
|
|||
//#define QSPI_TEST_LOG_FLASH_STATUS
|
||||
|
||||
|
||||
|
||||
#define QSPI_MIN_FREQUENCY 1000000
|
||||
|
||||
// max write size is usually page size
|
||||
#define DATA_SIZE_256 (QSPI_PAGE_SIZE)
|
||||
#define DATA_SIZE_1024 (QSPI_PAGE_SIZE * 4)
|
||||
|
|
@ -93,11 +96,11 @@ static void log_data(const char *str, uint8_t *data, uint32_t size)
|
|||
|
||||
static void _qspi_write_read_test(Qspi &qspi, qspi_bus_width_t write_inst_width, qspi_bus_width_t write_addr_width,
|
||||
qspi_bus_width_t write_data_width, qspi_bus_width_t write_alt_width, uint32_t write_cmd,
|
||||
qspi_address_size_t write_addr_size, qspi_alt_size_t write_alt_size, int write_frequency,
|
||||
qspi_address_size_t write_addr_size, qspi_alt_size_t write_alt_size,
|
||||
uint32_t write_count, qspi_bus_width_t read_inst_width, qspi_bus_width_t read_addr_width,
|
||||
qspi_bus_width_t read_data_width, qspi_bus_width_t read_alt_width, uint32_t read_cmd,
|
||||
int read_dummy_cycles, qspi_address_size_t read_addr_size, qspi_alt_size_t read_alt_size,
|
||||
int read_frequency, uint32_t read_count, uint32_t test_count, uint32_t data_size,
|
||||
uint32_t read_count, uint32_t test_count, uint32_t data_size,
|
||||
uint32_t flash_addr)
|
||||
{
|
||||
qspi_status_t ret = QSPI_STATUS_OK;
|
||||
|
|
@ -126,11 +129,6 @@ static void _qspi_write_read_test(Qspi &qspi, qspi_bus_width_t write_inst_width,
|
|||
timer.stop();
|
||||
erase_time = timer.read_us();
|
||||
|
||||
if (write_frequency != QSPI_NONE) {
|
||||
qspi_frequency(&qspi.handle, write_frequency);
|
||||
WAIT_FOR(WAIT_MAX_TIME, qspi);
|
||||
}
|
||||
|
||||
// switching to extended-SPI/DPI/QPI mode here for write operation
|
||||
// for DPI/QPI qspi.cmd is automatically switched to 2_2_2/4_4_4 mode
|
||||
ret = mode_enable(qspi, write_inst_width, write_addr_width, write_data_width);
|
||||
|
|
@ -167,11 +165,6 @@ static void _qspi_write_read_test(Qspi &qspi, qspi_bus_width_t write_inst_width,
|
|||
ret = mode_disable(qspi, write_inst_width, write_addr_width, write_data_width);
|
||||
TEST_ASSERT_EQUAL(QSPI_STATUS_OK, ret);
|
||||
|
||||
if (read_frequency != QSPI_NONE) {
|
||||
qspi_frequency(&qspi.handle, read_frequency);
|
||||
WAIT_FOR(WAIT_MAX_TIME, qspi);
|
||||
}
|
||||
|
||||
// switching to extended-SPI/DPI/QPI mode here for read operation
|
||||
// for DPI/QPI qspi.cmd is automatically switched to 2_2_2/4_4_4 mode
|
||||
ret = mode_enable(qspi, read_inst_width, read_addr_width, read_data_width);
|
||||
|
|
@ -234,7 +227,6 @@ template < qspi_bus_width_t write_inst_width,
|
|||
unsigned int write_cmd,
|
||||
qspi_address_size_t write_addr_size,
|
||||
qspi_alt_size_t write_alt_size,
|
||||
int write_frequency,
|
||||
uint32_t write_count,
|
||||
qspi_bus_width_t read_inst_width,
|
||||
qspi_bus_width_t read_addr_width,
|
||||
|
|
@ -244,7 +236,7 @@ template < qspi_bus_width_t write_inst_width,
|
|||
int read_dummy_cycles,
|
||||
qspi_address_size_t read_addr_size,
|
||||
qspi_alt_size_t read_alt_size,
|
||||
int read_frequency,
|
||||
int frequency,
|
||||
uint32_t read_count,
|
||||
uint32_t test_count,
|
||||
uint32_t data_size,
|
||||
|
|
@ -262,6 +254,9 @@ void qspi_write_read_test(void)
|
|||
|
||||
qspi_init(&qspi.handle, QPIN_0, QPIN_1, QPIN_2, QPIN_3, QSCK, QCSN, QSPI_COMMON_MAX_FREQUENCY, 0);
|
||||
|
||||
ret = qspi_frequency(&qspi.handle, frequency);
|
||||
TEST_ASSERT_EQUAL(QSPI_STATUS_OK, ret);
|
||||
|
||||
qspi.cmd.configure(MODE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8);
|
||||
flash_init(qspi);
|
||||
|
||||
|
|
@ -281,9 +276,9 @@ void qspi_write_read_test(void)
|
|||
#endif
|
||||
|
||||
_qspi_write_read_test(qspi, write_inst_width, write_addr_width, write_data_width, write_alt_width, write_cmd,
|
||||
write_addr_size, write_alt_size, write_frequency, write_count, read_inst_width,
|
||||
write_addr_size, write_alt_size, write_count, read_inst_width,
|
||||
read_addr_width, read_data_width, read_alt_width, read_cmd, read_dummy_cycles,
|
||||
read_addr_size, read_alt_size, read_frequency, read_count, test_count,
|
||||
read_addr_size, read_alt_size, read_count, test_count,
|
||||
data_size, addr);
|
||||
|
||||
ret = fast_mode_disable(qspi);
|
||||
|
|
@ -334,7 +329,7 @@ void qspi_init_free_test(void)
|
|||
#endif
|
||||
#endif
|
||||
|
||||
_qspi_write_read_test(qspi, WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS);
|
||||
_qspi_write_read_test(qspi, WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS);
|
||||
qspi_free(&qspi.handle);
|
||||
}
|
||||
|
||||
|
|
@ -348,28 +343,18 @@ void qspi_frequency_test(void)
|
|||
ret = qspi_init(&qspi.handle, QPIN_0, QPIN_1, QPIN_2, QPIN_3, QSCK, QCSN, freq, 0);
|
||||
TEST_ASSERT_EQUAL(QSPI_STATUS_OK, ret);
|
||||
|
||||
do {
|
||||
// check if the memory is working properly
|
||||
qspi.cmd.configure(MODE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8);
|
||||
|
||||
flash_init(qspi);
|
||||
_qspi_write_read_test(qspi, WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, freq, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, freq, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS);
|
||||
_qspi_write_read_test(qspi, WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS);
|
||||
|
||||
utest_printf("frequency setting %d [Hz] - OK\r\n", freq);
|
||||
|
||||
freq /= 2;
|
||||
// check if the memory is working properly
|
||||
qspi.cmd.configure(MODE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8);
|
||||
flash_init(qspi);
|
||||
_qspi_write_read_test(qspi, WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, freq, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, freq, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS);
|
||||
|
||||
freq /= 2;
|
||||
// check if the memory is working properly
|
||||
qspi.cmd.configure(MODE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8);
|
||||
flash_init(qspi);
|
||||
_qspi_write_read_test(qspi, WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, freq, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, freq, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS);
|
||||
|
||||
freq /= 2;
|
||||
// check if the memory is working properly
|
||||
qspi.cmd.configure(MODE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8);
|
||||
flash_init(qspi);
|
||||
_qspi_write_read_test(qspi, WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, freq, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, freq, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS);
|
||||
ret = qspi_frequency(&qspi.handle, freq);
|
||||
} while (ret == QSPI_STATUS_OK && freq >= QSPI_MIN_FREQUENCY);
|
||||
|
||||
qspi_free(&qspi.handle);
|
||||
}
|
||||
|
|
@ -395,176 +380,176 @@ Case cases[] = {
|
|||
// 1-4-4 - Quad I/O (extended SPI)
|
||||
// 2-2-2 - DPI (multi-channel SPI)
|
||||
// 4-4-4 - QPI (multi-channel SPI)
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-1)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-1)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-1)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-1)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#ifdef READ_2_2_2
|
||||
Case("qspi write(1-1-1)/x1 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(2-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(2-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(2-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(2-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#endif
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-1-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(1-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#ifdef READ_4_4_4
|
||||
Case("qspi write(1-1-1)/x1 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(4-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(4-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x4 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(4-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-1-1)/x1 read(4-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#endif
|
||||
|
||||
#ifdef WRITE_1_2_2
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-1)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-1)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-1)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-1)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#ifdef READ_2_2_2
|
||||
Case("qspi write(1-2-2)/x1 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(2-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(2-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(2-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(2-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#endif
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-1-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(1-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#ifdef READ_4_4_4
|
||||
Case("qspi write(1-2-2)/x1 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(4-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(4-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x4 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(4-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-2-2)/x1 read(4-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef WRITE_2_2_2
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-1)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-1)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-1)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-1)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#ifdef READ_2_2_2
|
||||
Case("qspi write(2-2-2)/x1 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(2-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(2-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(2-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(2-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#endif
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-1-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(1-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#ifdef READ_4_4_4
|
||||
Case("qspi write(2-2-2)/x1 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(4-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(4-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x4 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(4-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(2-2-2)/x1 read(4-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef WRITE_1_4_4
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-1)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-1)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-1)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-1)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#ifdef READ_2_2_2
|
||||
Case("qspi write(1-4-4)/x1 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(2-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(2-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(2-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(2-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#endif
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-1-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(1-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#ifdef READ_4_4_4
|
||||
Case("qspi write(1-4-4)/x1 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(4-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(4-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x4 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(4-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(1-4-4)/x1 read(4-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef WRITE_4_4_4
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-1)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-1)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(1-1-1)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-1)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-1)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_1, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(1-1-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(1-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#ifdef READ_2_2_2
|
||||
Case("qspi write(4-4-4)/x1 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(2-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(2-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(2-2-2)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(2-2-2)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(2-2-2)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_2_2_2, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#endif
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(1-1-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-1-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_1_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(1-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(1-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_1_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#ifdef READ_4_4_4
|
||||
Case("qspi write(4-4-4)/x1 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_MULTIPLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(4-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(4-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x4 read(4-4-4)/x1 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_MULTIPLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_SINGLE, DATA_SIZE_1024, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(4-4-4)/x4 repeat/x1 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_MULTIPLE, TEST_REPEAT_SINGLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
Case("qspi write(4-4-4)/x1 read(4-4-4)/x1 repeat/x4 test", qspi_write_read_test<WRITE_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, WRITE_SINGLE, READ_4_4_4, ADDR_SIZE_24, ALT_SIZE_8, QSPI_COMMON_MAX_FREQUENCY, READ_SINGLE, TEST_REPEAT_MULTIPLE, DATA_SIZE_256, TEST_FLASH_ADDRESS>),
|
||||
#endif
|
||||
#endif
|
||||
};
|
||||
|
|
|
|||
|
|
@ -77,7 +77,6 @@ template < qspi_bus_width_t write_inst_width,
|
|||
unsigned int write_cmd,
|
||||
qspi_address_size_t write_addr_size,
|
||||
qspi_alt_size_t write_alt_size,
|
||||
int write_frequency,
|
||||
uint32_t write_count,
|
||||
qspi_bus_width_t read_inst_width,
|
||||
qspi_bus_width_t read_addr_width,
|
||||
|
|
@ -87,7 +86,7 @@ template < qspi_bus_width_t write_inst_width,
|
|||
int read_dummy_cycles,
|
||||
qspi_address_size_t read_addr_size,
|
||||
qspi_alt_size_t read_alt_size,
|
||||
int read_frequency,
|
||||
int frequency,
|
||||
uint32_t read_count,
|
||||
uint32_t test_count,
|
||||
uint32_t data_size,
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ __attribute__((naked)) void call_mem(uint32_t addr)
|
|||
// since exception will be generated for invalid memory access.
|
||||
// Other instructions are for calling do_nothing function according to AAPCS.
|
||||
__ASM(
|
||||
"LDR r1, [r0]\n"
|
||||
"LDR r3, [r0]\n"
|
||||
"BX lr\n"
|
||||
);
|
||||
}
|
||||
|
|
@ -138,10 +138,10 @@ utest::v1::status_t fault_override_teardown(const Case *const source, const size
|
|||
}
|
||||
|
||||
Case cases[] = {
|
||||
Case("SPM - Access secure RAM", fault_override_setup, secure_ram_fault_test, fault_override_teardown),
|
||||
Case("SPM - Access secure Flash", fault_override_setup, secure_flash_fault_test, fault_override_teardown),
|
||||
Case("SPM - Access non-secure RAM", fault_override_setup, non_secure_ram_fault_test, fault_override_teardown),
|
||||
Case("SPM - Access non-secure Flash", fault_override_setup, non_secure_flash_fault_test, fault_override_teardown),
|
||||
Case("SPM - Access secure RAM", fault_override_setup, secure_ram_fault_test, fault_override_teardown),
|
||||
Case("SPM - Access secure Flash", fault_override_setup, secure_flash_fault_test, fault_override_teardown)
|
||||
};
|
||||
|
||||
utest::v1::status_t greentea_test_setup(const size_t number_of_cases)
|
||||
|
|
|
|||
|
|
@ -39,7 +39,12 @@ void TCPSOCKET_BIND_ADDRESS()
|
|||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
SocketAddress sockAddr = SocketAddress(get_interface()->get_ip_address(), 80);
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->bind(sockAddr));
|
||||
nsapi_error_t bind_result = sock->bind(sockAddr);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,12 @@ void TCPSOCKET_BIND_ADDRESS_INVALID()
|
|||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_PARAMETER, sock->bind("190.2.3.4", 1024));
|
||||
nsapi_error_t bind_result = sock->bind("190.2.3.4", 1024);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_PARAMETER, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,12 @@ void TCPSOCKET_BIND_ADDRESS_NULL()
|
|||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->bind(NULL, 1024));
|
||||
nsapi_error_t bind_result = sock->bind(NULL, 1024);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,12 @@ void TCPSOCKET_BIND_ADDRESS_PORT()
|
|||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->bind(get_interface()->get_ip_address(), 80));
|
||||
nsapi_error_t bind_result = sock->bind(get_interface()->get_ip_address(), 80);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,12 @@ void TCPSOCKET_BIND_PORT()
|
|||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->bind(1024));
|
||||
nsapi_error_t bind_result = sock->bind(1024);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,14 @@ void TCPSOCKET_BIND_PORT_FAIL()
|
|||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->bind(1024));
|
||||
nsapi_error_t bind_result = sock->bind(1024);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
delete sock;
|
||||
return;
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, bind_result);
|
||||
}
|
||||
|
||||
TCPSocket *sock2 = new TCPSocket;
|
||||
if (!sock2) {
|
||||
|
|
|
|||
|
|
@ -37,7 +37,12 @@ void TCPSOCKET_BIND_UNOPENED()
|
|||
if (!sock) {
|
||||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_SOCKET, sock->bind(1024));
|
||||
nsapi_error_t bind_result = sock->bind(1024);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_SOCKET, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -40,7 +40,12 @@ void TCPSOCKET_BIND_WRONG_TYPE()
|
|||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
char addr_bytes[16] = {0xfe, 0x80, 0xff, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
SocketAddress sockAddr = SocketAddress(addr_bytes, NSAPI_IPv4, 80);
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_PARAMETER, sock->bind(sockAddr));
|
||||
nsapi_error_t bind_result = sock->bind(sockAddr);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_PARAMETER, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -39,7 +39,12 @@ void UDPSOCKET_BIND_ADDRESS()
|
|||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
SocketAddress sockAddr = SocketAddress(get_interface()->get_ip_address(), 80);
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->bind(sockAddr));
|
||||
nsapi_error_t bind_result = sock->bind(sockAddr);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,12 @@ void UDPSOCKET_BIND_ADDRESS_INVALID()
|
|||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_PARAMETER, sock->bind("190.2.3.4", 1024));
|
||||
nsapi_error_t bind_result = sock->bind("190.2.3.4", 1024);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_PARAMETER, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,12 @@ void UDPSOCKET_BIND_ADDRESS_NULL()
|
|||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->bind(NULL, 1024));
|
||||
nsapi_error_t bind_result = sock->bind(NULL, 1024);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,12 @@ void UDPSOCKET_BIND_ADDRESS_PORT()
|
|||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->bind(get_interface()->get_ip_address(), 80));
|
||||
nsapi_error_t bind_result = sock->bind(get_interface()->get_ip_address(), 80);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,12 @@ void UDPSOCKET_BIND_PORT()
|
|||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->bind(1024));
|
||||
nsapi_error_t bind_result = sock->bind(1024);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,14 @@ void UDPSOCKET_BIND_PORT_FAIL()
|
|||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->bind(1024));
|
||||
nsapi_error_t bind_result = sock->bind(1024);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
delete sock;
|
||||
return;
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, bind_result);
|
||||
}
|
||||
|
||||
UDPSocket *sock2 = new UDPSocket;
|
||||
if (!sock2) {
|
||||
|
|
|
|||
|
|
@ -37,7 +37,12 @@ void UDPSOCKET_BIND_UNOPENED()
|
|||
if (!sock) {
|
||||
TEST_FAIL();
|
||||
}
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_SOCKET, sock->bind(1024));
|
||||
nsapi_error_t bind_result = sock->bind(1024);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_SOCKET, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -40,7 +40,12 @@ void UDPSOCKET_BIND_WRONG_TYPE()
|
|||
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock->open(get_interface()));
|
||||
char addr_bytes[16] = {0xfe, 0x80, 0xff, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
SocketAddress sockAddr = SocketAddress(addr_bytes, NSAPI_IPv4, 80);
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_PARAMETER, sock->bind(sockAddr));
|
||||
nsapi_error_t bind_result = sock->bind(sockAddr);
|
||||
if (bind_result == NSAPI_ERROR_UNSUPPORTED) {
|
||||
TEST_IGNORE_MESSAGE("bind() not supported");
|
||||
} else {
|
||||
TEST_ASSERT_EQUAL(NSAPI_ERROR_PARAMETER, bind_result);
|
||||
}
|
||||
|
||||
delete sock;
|
||||
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ psa_its_status_t test_psa_its_reset_impl(void)
|
|||
}
|
||||
|
||||
KVMap &kv_map = KVMap::get_instance();
|
||||
KVStore *kvstore = kv_map.get_main_kv_instance(STR_EXPAND(MBED_CONF_STORAGE_DEFAULT_KV));
|
||||
KVStore *kvstore = kv_map.get_internal_kv_instance(STR_EXPAND(MBED_CONF_STORAGE_DEFAULT_KV));
|
||||
if (!kvstore) {
|
||||
return PSA_ITS_ERROR_STORAGE_FAILURE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ psa_its_status_t test_psa_its_reset_impl(void)
|
|||
}
|
||||
|
||||
KVMap &kv_map = KVMap::get_instance();
|
||||
KVStore *kvstore = kv_map.get_main_kv_instance(STR_EXPAND(MBED_CONF_STORAGE_DEFAULT_KV));
|
||||
KVStore *kvstore = kv_map.get_internal_kv_instance(STR_EXPAND(MBED_CONF_STORAGE_DEFAULT_KV));
|
||||
if (!kvstore) {
|
||||
return PSA_ITS_ERROR_STORAGE_FAILURE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ psa_its_status_t test_psa_its_reset_impl(void)
|
|||
}
|
||||
|
||||
KVMap &kv_map = KVMap::get_instance();
|
||||
KVStore *kvstore = kv_map.get_main_kv_instance(STR_EXPAND(MBED_CONF_STORAGE_DEFAULT_KV));
|
||||
KVStore *kvstore = kv_map.get_internal_kv_instance(STR_EXPAND(MBED_CONF_STORAGE_DEFAULT_KV));
|
||||
if (!kvstore) {
|
||||
return PSA_ITS_ERROR_STORAGE_FAILURE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ psa_its_status_t test_psa_its_reset_impl(void)
|
|||
}
|
||||
|
||||
KVMap &kv_map = KVMap::get_instance();
|
||||
KVStore *kvstore = kv_map.get_main_kv_instance(STR_EXPAND(MBED_CONF_STORAGE_DEFAULT_KV));
|
||||
KVStore *kvstore = kv_map.get_internal_kv_instance(STR_EXPAND(MBED_CONF_STORAGE_DEFAULT_KV));
|
||||
if (!kvstore) {
|
||||
return PSA_ITS_ERROR_STORAGE_FAILURE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -121,7 +121,11 @@ class Testcase(Bench):
|
|||
except TestStepFail:
|
||||
self.logger.info("Warning, iteration failed #" + str(loop+1))
|
||||
loop = loop + 1
|
||||
if (loop < 5):
|
||||
self.stop_event.set()
|
||||
self.th.join()
|
||||
self.delay(5)
|
||||
|
||||
else:
|
||||
raise TestStepFail("Too many failed iterations!")
|
||||
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@ void EventQueue::background(Callback<void(int)> update)
|
|||
{
|
||||
}
|
||||
|
||||
void EventQueue::chain(EventQueue *target)
|
||||
int EventQueue::chain(EventQueue *target)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ void equeue_background(equeue_t *queue,
|
|||
|
||||
}
|
||||
|
||||
void equeue_chain(equeue_t *queue, equeue_t *target)
|
||||
int equeue_chain(equeue_t *queue, equeue_t *target)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,101 @@
|
|||
/**************************************************
|
||||
*
|
||||
* Part two of the system initialization code, contains C-level
|
||||
* initialization, thumb-2 only variant.
|
||||
*
|
||||
* $Revision: 59783 $
|
||||
*
|
||||
**************************************************/
|
||||
/* Copyright 2008-2017, IAR Systems AB.
|
||||
This source code is the property of IAR Systems. The source code may only
|
||||
be used together with the IAR Embedded Workbench. Redistribution and use
|
||||
in source and binary forms, with or without modification, is permitted
|
||||
provided that the following conditions are met:
|
||||
- Redistributions of source code, in whole or in part, must retain the
|
||||
above copyright notice, this list of conditions and the disclaimer below.
|
||||
- IAR Systems name may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
; --------------------------------------------------
|
||||
; Module ?cmain, C-level initialization.
|
||||
;
|
||||
|
||||
|
||||
SECTION SHT$$PREINIT_ARRAY:CONST:NOROOT(2)
|
||||
SECTION SHT$$INIT_ARRAY:CONST:NOROOT(2)
|
||||
|
||||
SECTION .text:CODE:NOROOT(2)
|
||||
|
||||
PUBLIC __cmain
|
||||
;; Keep ?main for legacy reasons, it is accessed in countless instances of cstartup.s around the world...
|
||||
PUBLIC ?main
|
||||
EXTWEAK __iar_data_init3
|
||||
EXTWEAK __iar_argc_argv
|
||||
EXTERN __low_level_init
|
||||
EXTERN __call_ctors
|
||||
EXTERN main
|
||||
EXTERN exit
|
||||
EXTERN __iar_dynamic_initialization
|
||||
EXTERN mbed_sdk_init
|
||||
EXTERN mbed_main
|
||||
EXTERN SystemInit
|
||||
|
||||
THUMB
|
||||
__cmain:
|
||||
?main:
|
||||
|
||||
; Initialize segments.
|
||||
; __segment_init and __low_level_init are assumed to use the same
|
||||
; instruction set and to be reachable by BL from the ICODE segment
|
||||
; (it is safest to link them in segment ICODE).
|
||||
|
||||
FUNCALL __cmain, __low_level_init
|
||||
bl __low_level_init
|
||||
cmp r0,#0
|
||||
beq ?l1
|
||||
FUNCALL __cmain, __iar_data_init3
|
||||
bl __iar_data_init3
|
||||
MOVS r0,#0 ; No parameters
|
||||
FUNCALL __cmain, mbed_sdk_init
|
||||
BL mbed_sdk_init
|
||||
MOVS r0,#0 ; No parameters
|
||||
FUNCALL __cmain, __iar_dynamic_initialization
|
||||
BL __iar_dynamic_initialization ; C++ dynamic initialization
|
||||
|
||||
?l1:
|
||||
REQUIRE ?l3
|
||||
|
||||
SECTION .text:CODE:NOROOT(2)
|
||||
|
||||
PUBLIC _main
|
||||
PUBLIC _call_main
|
||||
THUMB
|
||||
|
||||
__iar_init$$done: ; Copy initialization is done
|
||||
|
||||
?l3:
|
||||
_call_main:
|
||||
MOVS r0,#0 ; No parameters
|
||||
FUNCALL __cmain, __iar_argc_argv
|
||||
BL __iar_argc_argv ; Maybe setup command line
|
||||
|
||||
MOVS r0,#0 ; No parameters
|
||||
FUNCALL __cmain, mbed_main
|
||||
BL mbed_main
|
||||
|
||||
FUNCALL __cmain, main
|
||||
BL main
|
||||
_main:
|
||||
FUNCALL __cmain, exit
|
||||
BL exit
|
||||
|
||||
END
|
||||
|
|
@ -22,6 +22,8 @@
|
|||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#if !TARGET_TFM
|
||||
|
||||
#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
|
||||
|
||||
#include "RTE_Components.h"
|
||||
|
|
@ -201,3 +203,5 @@ uint32_t TZ_StoreContext_S (TZ_MemoryId_t id) {
|
|||
return 1U; // Success
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // !TARGET_TFM
|
||||
|
|
|
|||
|
|
@ -26,6 +26,12 @@
|
|||
#include "nanostack/platform/arm_hal_phy.h"
|
||||
#include "mbed_trace.h"
|
||||
#include "mbed_toolchain.h"
|
||||
#include "DigitalIn.h"
|
||||
#include "DigitalOut.h"
|
||||
#include "InterruptIn.h"
|
||||
#include "SPI.h"
|
||||
#include "inttypes.h"
|
||||
#include "Timeout.h"
|
||||
|
||||
#define TRACE_GROUP "AtRF"
|
||||
|
||||
|
|
@ -219,8 +225,9 @@ static inline rf_trx_states_t rf_if_trx_status_from_full(uint8_t full_trx_status
|
|||
}
|
||||
|
||||
#ifdef MBED_CONF_RTOS_PRESENT
|
||||
#include "mbed.h"
|
||||
|
||||
#include "rtos.h"
|
||||
|
||||
using namespace mbed;
|
||||
using namespace rtos;
|
||||
|
||||
|
|
|
|||
|
|
@ -18,8 +18,13 @@
|
|||
#define NANOSTACK_PHY_MCR20A_H_
|
||||
|
||||
#if defined(MBED_CONF_NANOSTACK_CONFIGURATION) && DEVICE_SPI && defined(MBED_CONF_RTOS_PRESENT)
|
||||
#include "mbed.h"
|
||||
#include "inttypes.h"
|
||||
#include "NanostackRfPhy.h"
|
||||
#include "DigitalIn.h"
|
||||
#include "DigitalOut.h"
|
||||
#include "InterruptIn.h"
|
||||
#include "SPI.h"
|
||||
#include "rtos.h"
|
||||
|
||||
// Arduino pin defaults for convenience
|
||||
#if !defined(MCR20A_SPI_MOSI)
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@
|
|||
#include "nanostack/platform/arm_hal_phy.h"
|
||||
#include <string.h>
|
||||
#include "rtos.h"
|
||||
#include "mbed_interface.h"
|
||||
|
||||
using namespace mbed;
|
||||
using namespace rtos;
|
||||
|
|
|
|||
|
|
@ -26,6 +26,12 @@
|
|||
#include "mbed_toolchain.h"
|
||||
#include "common_functions.h"
|
||||
#include <Timer.h>
|
||||
#include "Timeout.h"
|
||||
#include "Thread.h"
|
||||
#include "mbed_wait_api.h"
|
||||
|
||||
using namespace mbed;
|
||||
using namespace rtos;
|
||||
|
||||
#define TRACE_GROUP "s2lp"
|
||||
|
||||
|
|
@ -216,7 +222,7 @@ static const phy_device_channel_page_s phy_channel_pages[] = {
|
|||
};
|
||||
|
||||
#ifdef MBED_CONF_RTOS_PRESENT
|
||||
#include "mbed.h"
|
||||
|
||||
#include "rtos.h"
|
||||
|
||||
static void rf_irq_task_process_irq();
|
||||
|
|
|
|||
|
|
@ -18,8 +18,12 @@
|
|||
#define NANOSTACK_PHY_S2LP_H_
|
||||
|
||||
#if defined(MBED_CONF_NANOSTACK_CONFIGURATION) && DEVICE_SPI && defined(MBED_CONF_RTOS_PRESENT)
|
||||
#include "mbed.h"
|
||||
#include "inttypes.h"
|
||||
#include "NanostackRfPhy.h"
|
||||
#include "DigitalIn.h"
|
||||
#include "DigitalOut.h"
|
||||
#include "InterruptIn.h"
|
||||
#include "SPI.h"
|
||||
|
||||
// Uncomment to use testing gpios attached to TX/RX processes
|
||||
//#define TEST_GPIOS_ENABLED
|
||||
|
|
|
|||
|
|
@ -527,6 +527,11 @@ bd_size_t DataFlashBlockDevice::size() const
|
|||
return device_size;
|
||||
}
|
||||
|
||||
const char *DataFlashBlockDevice::get_type() const
|
||||
{
|
||||
return "DATAFLASH";
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Function for reading a specific register.
|
||||
* @details Used for reading either the Status Register or Manufacture and ID Register.
|
||||
|
|
|
|||
|
|
@ -153,6 +153,12 @@ public:
|
|||
*/
|
||||
virtual mbed::bd_size_t size() const;
|
||||
|
||||
/** Get the BlockDevice class type.
|
||||
*
|
||||
* @return A string represent the BlockDevice class type.
|
||||
*/
|
||||
virtual const char *get_type() const;
|
||||
|
||||
private:
|
||||
// Master side hardware
|
||||
mbed::SPI _spi;
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@
|
|||
#include "FlashIAPBlockDevice.h"
|
||||
#include "mbed_critical.h"
|
||||
|
||||
#include "mbed.h"
|
||||
using namespace mbed;
|
||||
#include <inttypes.h>
|
||||
|
||||
|
|
@ -248,4 +247,9 @@ bd_size_t FlashIAPBlockDevice::size() const
|
|||
return _size;
|
||||
}
|
||||
|
||||
const char *FlashIAPBlockDevice::get_type() const
|
||||
{
|
||||
return "FLASHIAP";
|
||||
}
|
||||
|
||||
#endif /* DEVICE_FLASH */
|
||||
|
|
|
|||
|
|
@ -121,6 +121,12 @@ public:
|
|||
*/
|
||||
virtual mbed::bd_size_t size() const;
|
||||
|
||||
/** Get the BlockDevice class type.
|
||||
*
|
||||
* @return A string represent the BlockDevice class type.
|
||||
*/
|
||||
virtual const char *get_type() const;
|
||||
|
||||
private:
|
||||
// Device configuration
|
||||
mbed::FlashIAP _flash;
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@
|
|||
*/
|
||||
|
||||
//#include "mbed.h"
|
||||
#include "FlashIAP.h"
|
||||
#include "LittleFileSystem.h"
|
||||
#include "fslittle_debug.h"
|
||||
#include "fslittle_test.h"
|
||||
|
|
@ -48,6 +49,15 @@ using namespace utest::v1;
|
|||
#endif
|
||||
/// @endcond
|
||||
|
||||
// Align a value to a specified size.
|
||||
// Parameters :
|
||||
// val - [IN] Value.
|
||||
// size - [IN] Size.
|
||||
// Return : Aligned value.
|
||||
static inline uint32_t align_up(uint32_t val, uint32_t size)
|
||||
{
|
||||
return (((val - 1) / size) + 1) * size;
|
||||
}
|
||||
|
||||
/* DEVICE_SPI
|
||||
* This symbol is defined in targets.json if the target has a SPI interface, which is required for SDCard support.
|
||||
|
|
@ -734,7 +744,6 @@ control_t fslittle_fopen_test_06(const size_t call_count)
|
|||
control_t fslittle_fopen_test_07(const size_t call_count)
|
||||
{
|
||||
FILE *f = NULL;
|
||||
int ret = -1;
|
||||
int errno_val = 0;
|
||||
const char *filename = sd_badfile_path;
|
||||
|
||||
|
|
@ -1016,7 +1025,7 @@ control_t fslittle_fopen_test_11(const size_t call_count)
|
|||
return CaseNext;
|
||||
}
|
||||
|
||||
|
||||
#if ! defined(__ARMCC_VERSION) && defined(__GNUC__)
|
||||
/* file data for test_12 */
|
||||
static fslittle_kv_data_t fslittle_fopen_test_12_kv_data[] = {
|
||||
{ "/sd/test_12/subdir/testfil1.txt", "testfil1.txt"},
|
||||
|
|
@ -1026,6 +1035,7 @@ static fslittle_kv_data_t fslittle_fopen_test_12_kv_data[] = {
|
|||
{ "/sd/test_12/testfil5.txt", "testfil5.txt"},
|
||||
{ NULL, NULL},
|
||||
};
|
||||
#endif
|
||||
|
||||
/** @brief test for operation of readdir().
|
||||
*
|
||||
|
|
@ -1036,6 +1046,7 @@ static fslittle_kv_data_t fslittle_fopen_test_12_kv_data[] = {
|
|||
*/
|
||||
control_t fslittle_fopen_test_12(const size_t call_count)
|
||||
{
|
||||
#if ! defined(__ARMCC_VERSION) && defined(__GNUC__)
|
||||
char buf[FSLITTLE_FOPEN_TEST_WORK_BUF_SIZE_1];
|
||||
char *pos = NULL;
|
||||
int32_t count = 0;
|
||||
|
|
@ -1048,8 +1059,6 @@ control_t fslittle_fopen_test_12(const size_t call_count)
|
|||
FSLITTLE_FENTRYLOG("%s:entered\n", __func__);
|
||||
(void) call_count;
|
||||
|
||||
#if ! defined(__ARMCC_VERSION) && defined(__GNUC__)
|
||||
|
||||
/* start from a known state i.e. directory to be created in not present */
|
||||
while (node->filename != NULL) {
|
||||
fslittle_filepath_remove_all((char *) node->filename);
|
||||
|
|
@ -1156,6 +1165,7 @@ control_t fslittle_fopen_test_13(const size_t call_count)
|
|||
return CaseNext;
|
||||
}
|
||||
|
||||
#if ! defined(__ARMCC_VERSION) && defined(__GNUC__)
|
||||
/* file data for test_14 */
|
||||
static fslittle_kv_data_t fslittle_fopen_test_14_kv_data[] = {
|
||||
/* a file is included in the filepath even though its not created by the test,
|
||||
|
|
@ -1163,6 +1173,7 @@ static fslittle_kv_data_t fslittle_fopen_test_14_kv_data[] = {
|
|||
{ "/sd/test_14/testfile.txt", "testdata"},
|
||||
{ NULL, NULL},
|
||||
};
|
||||
#endif
|
||||
|
||||
/** @brief test for operation of stat()
|
||||
*
|
||||
|
|
@ -1246,7 +1257,29 @@ control_t fslittle_fopen_test_00(const size_t call_count)
|
|||
(void) call_count;
|
||||
int32_t ret = -1;
|
||||
|
||||
#if (MBED_CONF_FLASHIAP_BLOCK_DEVICE_SIZE == 0) && (MBED_CONF_FLASHIAP_BLOCK_DEVICE_BASE_ADDRESS == 0xFFFFFFFF)
|
||||
|
||||
size_t flash_size;
|
||||
uint32_t start_address;
|
||||
uint32_t bottom_address;
|
||||
mbed::FlashIAP flash_driver;
|
||||
|
||||
ret = flash_driver.init();
|
||||
TEST_ASSERT_EQUAL(0, ret);
|
||||
|
||||
//Find the start of first sector after text area
|
||||
bottom_address = align_up(FLASHIAP_APP_ROM_END_ADDR, flash_driver.get_sector_size(FLASHIAP_APP_ROM_END_ADDR));
|
||||
start_address = flash_driver.get_flash_start();
|
||||
flash_size = flash_driver.get_flash_size();
|
||||
ret = flash_driver.deinit();
|
||||
flash = new FlashIAPBlockDevice(bottom_address, start_address + flash_size - bottom_address);
|
||||
|
||||
#else
|
||||
|
||||
flash = new FlashIAPBlockDevice();
|
||||
|
||||
#endif
|
||||
|
||||
ret = flash->init();
|
||||
TEST_ASSERT_EQUAL(0, ret);
|
||||
|
||||
|
|
|
|||
|
|
@ -119,7 +119,7 @@ QSPIFBlockDevice::QSPIFBlockDevice(PinName io0, PinName io1, PinName io2, PinNam
|
|||
_unique_device_status = add_new_csel_instance(csel);
|
||||
|
||||
if (_unique_device_status == 0) {
|
||||
tr_info("Adding a new QSPIFBlockDevice csel: %d\n", (int)csel);
|
||||
tr_debug("Adding a new QSPIFBlockDevice csel: %d\n", (int)csel);
|
||||
} else if (_unique_device_status == -1) {
|
||||
tr_error("QSPIFBlockDevice with the same csel(%d) already exists\n", (int)csel);
|
||||
} else {
|
||||
|
|
@ -187,7 +187,7 @@ int QSPIFBlockDevice::init()
|
|||
status = QSPIF_BD_ERROR_DEVICE_ERROR;
|
||||
goto exit_point;
|
||||
} else {
|
||||
tr_info("Initialize flash memory OK");
|
||||
tr_debug("Initialize flash memory OK");
|
||||
}
|
||||
|
||||
/* Read Manufacturer ID (1byte), and Device ID (2bytes)*/
|
||||
|
|
@ -237,7 +237,7 @@ int QSPIFBlockDevice::init()
|
|||
_region_high_boundary[0] = _device_size_bytes - 1;
|
||||
|
||||
if ((sector_map_table_addr != 0) && (0 != sector_map_table_size)) {
|
||||
tr_info("Init - Parsing Sector Map Table - addr: 0x%lxh, Size: %d", sector_map_table_addr,
|
||||
tr_debug("Init - Parsing Sector Map Table - addr: 0x%lxh, Size: %d", sector_map_table_addr,
|
||||
sector_map_table_size);
|
||||
if (0 != _sfdp_parse_sector_map_table(sector_map_table_addr, sector_map_table_size)) {
|
||||
tr_error("Init - Parse Sector Map Table Failed");
|
||||
|
|
@ -298,7 +298,7 @@ int QSPIFBlockDevice::deinit()
|
|||
int QSPIFBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
|
||||
{
|
||||
int status = QSPIF_BD_ERROR_OK;
|
||||
tr_info("Read Inst: 0x%xh", _read_instruction);
|
||||
tr_debug("Read Inst: 0x%xh", _read_instruction);
|
||||
|
||||
_mutex.lock();
|
||||
|
||||
|
|
@ -477,6 +477,11 @@ bd_size_t QSPIFBlockDevice::get_erase_size() const
|
|||
return _min_common_erase_size;
|
||||
}
|
||||
|
||||
const char *QSPIFBlockDevice::get_type() const
|
||||
{
|
||||
return "QSPIF";
|
||||
}
|
||||
|
||||
// Find minimal erase size supported by the region to which the address belongs to
|
||||
bd_size_t QSPIFBlockDevice::get_erase_size(bd_addr_t addr)
|
||||
{
|
||||
|
|
@ -691,13 +696,13 @@ int QSPIFBlockDevice::_sfdp_parse_basic_param_table(uint32_t basic_table_addr, s
|
|||
if (true == shouldSetQuadEnable) {
|
||||
_enable_fast_mdoe();
|
||||
// Set Quad Enable and QPI Bus modes if Supported
|
||||
tr_info("Init - Setting Quad Enable");
|
||||
tr_debug("Init - Setting Quad Enable");
|
||||
if (0 != _sfdp_set_quad_enabled(param_table)) {
|
||||
tr_error("Device supports Quad bus, but Quad Enable Failed");
|
||||
return -1;
|
||||
}
|
||||
if (true == is_qpi_mode) {
|
||||
tr_info("Init - Setting QPI mode");
|
||||
tr_debug("Init - Setting QPI mode");
|
||||
_sfdp_set_qpi_enabled(param_table);
|
||||
}
|
||||
}
|
||||
|
|
@ -728,7 +733,7 @@ int QSPIFBlockDevice::_sfdp_parse_sfdp_headers(uint32_t &basic_table_addr, size_
|
|||
tr_error("Init - _verify SFDP signature and version Failed");
|
||||
return -1;
|
||||
} else {
|
||||
tr_info("Init - verified SFDP Signature and version Successfully");
|
||||
tr_debug("Init - verified SFDP Signature and version Successfully");
|
||||
}
|
||||
|
||||
// Discover Number of Parameter Headers
|
||||
|
|
@ -964,7 +969,7 @@ int QSPIFBlockDevice::_sfdp_detect_erase_types_inst_and_size(uint8_t *basic_para
|
|||
erase_type_inst_arr[i_ind] = 0xff; //0xFF default for unsupported type
|
||||
erase_type_size_arr[i_ind] = local_math_power(2,
|
||||
basic_param_table_ptr[QSPIF_BASIC_PARAM_ERASE_TYPE_1_SIZE_BYTE + 2 * i_ind]); // Size given as 2^N
|
||||
tr_info("Erase Type(A) %d - Inst: 0x%xh, Size: %d", (i_ind + 1), erase_type_inst_arr[i_ind],
|
||||
tr_debug("Erase Type(A) %d - Inst: 0x%xh, Size: %d", (i_ind + 1), erase_type_inst_arr[i_ind],
|
||||
erase_type_size_arr[i_ind]);
|
||||
if (erase_type_size_arr[i_ind] > 1) {
|
||||
// if size==1 type is not supported
|
||||
|
|
@ -988,7 +993,7 @@ int QSPIFBlockDevice::_sfdp_detect_erase_types_inst_and_size(uint8_t *basic_para
|
|||
_region_erase_types_bitfield[0] |= bitfield; // If there's no region map, set region "0" types bitfield as defualt;
|
||||
}
|
||||
|
||||
tr_info("Erase Type %d - Inst: 0x%xh, Size: %d", (i_ind + 1), erase_type_inst_arr[i_ind],
|
||||
tr_debug("Erase Type %d - Inst: 0x%xh, Size: %d", (i_ind + 1), erase_type_inst_arr[i_ind],
|
||||
erase_type_size_arr[i_ind]);
|
||||
bitfield = bitfield << 1;
|
||||
}
|
||||
|
|
@ -1059,7 +1064,7 @@ int QSPIFBlockDevice::_sfdp_detect_best_bus_read_mode(uint8_t *basic_param_table
|
|||
+ (basic_param_table_ptr[QSPIF_BASIC_PARAM_TABLE_222_READ_INST_BYTE - 1] & 0x1F);
|
||||
_address_width = QSPI_CFG_BUS_DUAL;
|
||||
_data_width = QSPI_CFG_BUS_DUAL;
|
||||
tr_info("Read Bus Mode set to 2-2-2, Instruction: 0x%xh", _read_instruction);
|
||||
tr_debug("Read Bus Mode set to 2-2-2, Instruction: 0x%xh", _read_instruction);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -1094,7 +1099,7 @@ int QSPIFBlockDevice::_reset_flash_mem()
|
|||
// Perform Soft Reset of the Device prior to initialization
|
||||
int status = 0;
|
||||
char status_value[QSPI_MAX_STATUS_REGISTER_SIZE] = {0};
|
||||
tr_info("_reset_flash_mem:");
|
||||
tr_debug("_reset_flash_mem:");
|
||||
//Read the Status Register from device
|
||||
if (QSPI_STATUS_OK == _qspi_send_general_command(QSPIF_RDSR, QSPI_NO_ADDRESS_COMMAND, NULL, 0, status_value,
|
||||
QSPI_MAX_STATUS_REGISTER_SIZE)) { // store received values in status_value
|
||||
|
|
@ -1345,7 +1350,7 @@ qspi_status_t QSPIFBlockDevice::_qspi_send_erase_command(unsigned int erase_inst
|
|||
// Send Erase Instruction command to driver
|
||||
qspi_status_t result = QSPI_STATUS_OK;
|
||||
|
||||
tr_info("Inst: 0x%xh, addr: %llu, size: %llu", erase_inst, addr, size);
|
||||
tr_debug("Inst: 0x%xh, addr: %llu, size: %llu", erase_inst, addr, size);
|
||||
|
||||
result = _qspi.command_transfer(erase_inst, // command to send
|
||||
(((int)addr) & 0x00FFF000), // Align addr to 4096
|
||||
|
|
|
|||
|
|
@ -211,6 +211,12 @@ public:
|
|||
*/
|
||||
virtual mbed::bd_size_t size() const;
|
||||
|
||||
/** Get the BlockDevice class type.
|
||||
*
|
||||
* @return A string represent the BlockDevice class type.
|
||||
*/
|
||||
virtual const char *get_type() const;
|
||||
|
||||
private:
|
||||
// Internal functions
|
||||
|
||||
|
|
@ -307,8 +313,6 @@ private:
|
|||
int _utils_iterate_next_largest_erase_type(uint8_t &bitfield, int size, int offset, int boundry);
|
||||
|
||||
private:
|
||||
// Internal Members
|
||||
|
||||
// QSPI Driver Object
|
||||
mbed::QSPI _qspi;
|
||||
|
||||
|
|
|
|||
|
|
@ -48,7 +48,6 @@ enum ops {
|
|||
#define SPIF_WEL 0x2
|
||||
#define SPIF_WIP 0x1
|
||||
|
||||
|
||||
SPIFReducedBlockDevice::SPIFReducedBlockDevice(
|
||||
PinName mosi, PinName miso, PinName sclk, PinName cs, int freq)
|
||||
: _spi(mosi, miso, sclk), _cs(cs), _size(0)
|
||||
|
|
@ -344,3 +343,9 @@ bd_size_t SPIFReducedBlockDevice::size() const
|
|||
{
|
||||
return _size;
|
||||
}
|
||||
|
||||
const char *SPIFReducedBlockDevice::get_type() const
|
||||
{
|
||||
return "SPIFR";
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -155,6 +155,12 @@ public:
|
|||
*/
|
||||
virtual mbed::bd_size_t size() const;
|
||||
|
||||
/** Get the BlockDevice class type.
|
||||
*
|
||||
* @return A string represent the BlockDevice class type.
|
||||
*/
|
||||
virtual const char *get_type() const;
|
||||
|
||||
private:
|
||||
// Master side hardware
|
||||
mbed::SPI _spi;
|
||||
|
|
|
|||
|
|
@ -632,6 +632,11 @@ bd_size_t SDBlockDevice::size() const
|
|||
return _block_size * _sectors;
|
||||
}
|
||||
|
||||
const char *SDBlockDevice::get_type() const
|
||||
{
|
||||
return "SD";
|
||||
}
|
||||
|
||||
void SDBlockDevice::debug(bool dbg)
|
||||
{
|
||||
_dbg = dbg;
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
#ifndef MBED_SD_BLOCK_DEVICE_H
|
||||
#define MBED_SD_BLOCK_DEVICE_H
|
||||
|
||||
/* If the target has no SPI support then SDCard is not supported */
|
||||
/* If the target has no SPI support, then SD Card is not supported. */
|
||||
#if DEVICE_SPI
|
||||
|
||||
#include "BlockDevice.h"
|
||||
|
|
@ -30,24 +30,35 @@
|
|||
|
||||
/** SDBlockDevice class
|
||||
*
|
||||
* Access an SD Card using SPI
|
||||
* Access an SD Card using SPI bus
|
||||
*/
|
||||
class SDBlockDevice : public mbed::BlockDevice {
|
||||
public:
|
||||
/** Lifetime of an SD card
|
||||
/** Creates an SDBlockDevice on a SPI bus specified by pins
|
||||
*
|
||||
* @param mosi SPI master out, slave in pin
|
||||
* @param miso SPI master in, slave out pin
|
||||
* @param sclk SPI clock pin
|
||||
* @param cs SPI chip select pin
|
||||
* @param hz Clock speed of the SPI bus (defaults to 1MHz)
|
||||
* @param crc_on Enable cyclic redundancy check (defaults to disabled)
|
||||
*/
|
||||
SDBlockDevice(PinName mosi, PinName miso, PinName sclk, PinName cs, uint64_t hz = 1000000, bool crc_on = 0);
|
||||
virtual ~SDBlockDevice();
|
||||
|
||||
/** Initialize a block device
|
||||
*
|
||||
* @return 0 on success or a negative error code on failure
|
||||
* @return BD_ERROR_OK(0) - success
|
||||
* BD_ERROR_DEVICE_ERROR - device driver transaction failed
|
||||
* SD_BLOCK_DEVICE_ERROR_NO_DEVICE - device (SD card) is missing or not connected
|
||||
* SD_BLOCK_DEVICE_ERROR_UNUSABLE - unusable card
|
||||
* SD_BLOCK_DEVICE_ERROR_CRC - crc error
|
||||
*/
|
||||
virtual int init();
|
||||
|
||||
/** Deinitialize a block device
|
||||
*
|
||||
* @return 0 on success or a negative error code on failure
|
||||
* @return BD_ERROR_OK(0) - success
|
||||
*/
|
||||
virtual int deinit();
|
||||
|
||||
|
|
@ -56,18 +67,30 @@ public:
|
|||
* @param buffer Buffer to write blocks to
|
||||
* @param addr Address of block to begin reading from
|
||||
* @param size Size to read in bytes, must be a multiple of read block size
|
||||
* @return 0 on success, negative error code on failure
|
||||
* @return BD_ERROR_OK(0) - success
|
||||
* SD_BLOCK_DEVICE_ERROR_NO_DEVICE - device (SD card) is missing or not connected
|
||||
* SD_BLOCK_DEVICE_ERROR_CRC - crc error
|
||||
* SD_BLOCK_DEVICE_ERROR_PARAMETER - invalid parameter
|
||||
* SD_BLOCK_DEVICE_ERROR_NO_RESPONSE - no response from device
|
||||
* SD_BLOCK_DEVICE_ERROR_UNSUPPORTED - unsupported command
|
||||
*/
|
||||
virtual int read(void *buffer, mbed::bd_addr_t addr, mbed::bd_size_t size);
|
||||
|
||||
/** Program blocks to a block device
|
||||
*
|
||||
* The blocks must have been erased prior to being programmed
|
||||
* @note The blocks must be erased prior to programming
|
||||
*
|
||||
* @param buffer Buffer of data to write to blocks
|
||||
* @param addr Address of block to begin writing to
|
||||
* @param size Size to write in bytes, must be a multiple of program block size
|
||||
* @return 0 on success, negative error code on failure
|
||||
* @param size Size to write in bytes. Must be a multiple of program block size
|
||||
* @return BD_ERROR_OK(0) - success
|
||||
* SD_BLOCK_DEVICE_ERROR_NO_DEVICE - device (SD card) is missing or not connected
|
||||
* SD_BLOCK_DEVICE_ERROR_CRC - crc error
|
||||
* SD_BLOCK_DEVICE_ERROR_PARAMETER - invalid parameter
|
||||
* SD_BLOCK_DEVICE_ERROR_UNSUPPORTED - unsupported command
|
||||
* SD_BLOCK_DEVICE_ERROR_NO_INIT - device is not initialized
|
||||
* SD_BLOCK_DEVICE_ERROR_WRITE - SPI write error
|
||||
* SD_BLOCK_DEVICE_ERROR_ERASE - erase error
|
||||
*/
|
||||
virtual int program(const void *buffer, mbed::bd_addr_t addr, mbed::bd_size_t size);
|
||||
|
||||
|
|
@ -80,7 +103,13 @@ public:
|
|||
*
|
||||
* @param addr Address of block to mark as unused
|
||||
* @param size Size to mark as unused in bytes, must be a multiple of erase block size
|
||||
* @return 0 on success, negative error code on failure
|
||||
* @return BD_ERROR_OK(0) - success
|
||||
* SD_BLOCK_DEVICE_ERROR_NO_DEVICE - device (SD card) is missing or not connected
|
||||
* SD_BLOCK_DEVICE_ERROR_CRC - crc error
|
||||
* SD_BLOCK_DEVICE_ERROR_PARAMETER - invalid parameter
|
||||
* SD_BLOCK_DEVICE_ERROR_UNSUPPORTED - unsupported command
|
||||
* SD_BLOCK_DEVICE_ERROR_NO_INIT - device is not initialized
|
||||
* SD_BLOCK_DEVICE_ERROR_ERASE - erase error
|
||||
*/
|
||||
virtual int trim(mbed::bd_addr_t addr, mbed::bd_size_t size);
|
||||
|
||||
|
|
@ -90,9 +119,9 @@ public:
|
|||
*/
|
||||
virtual mbed::bd_size_t get_read_size() const;
|
||||
|
||||
/** Get the size of a programable block
|
||||
/** Get the size of a programmable block
|
||||
*
|
||||
* @return Size of a programable block in bytes
|
||||
* @return Size of a programmable block in bytes
|
||||
* @note Must be a multiple of the read size
|
||||
*/
|
||||
virtual mbed::bd_size_t get_program_size() const;
|
||||
|
|
@ -116,6 +145,11 @@ public:
|
|||
*/
|
||||
virtual int frequency(uint64_t freq);
|
||||
|
||||
/** Get the BlockDevice class type.
|
||||
*
|
||||
* @return A string representation of the BlockDevice class type.
|
||||
*/
|
||||
virtual const char *get_type() const;
|
||||
|
||||
private:
|
||||
/* Commands : Listed below are commands supported
|
||||
|
|
@ -182,7 +216,7 @@ private:
|
|||
|
||||
/* SPI functions */
|
||||
mbed::Timer _spi_timer; /**< Timer Class object used for busy wait */
|
||||
uint32_t _init_sck; /**< Intial SPI frequency */
|
||||
uint32_t _init_sck; /**< Initial SPI frequency */
|
||||
uint32_t _transfer_sck; /**< SPI frequency during data transfer/after initialization */
|
||||
mbed::SPI _spi; /**< SPI Class object */
|
||||
|
||||
|
|
|
|||
|
|
@ -75,7 +75,6 @@ DIR *dd[MBED_TEST_DIRS];
|
|||
FILE *fd[MBED_TEST_FILES];
|
||||
struct dirent ent;
|
||||
struct dirent *ed;
|
||||
size_t size;
|
||||
uint8_t buffer[MBED_TEST_BUFFER];
|
||||
uint8_t rbuffer[MBED_TEST_BUFFER];
|
||||
uint8_t wbuffer[MBED_TEST_BUFFER];
|
||||
|
|
@ -107,6 +106,7 @@ void test_simple_file_test()
|
|||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
{
|
||||
size_t size;
|
||||
res = fs.mount(&bd);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
res = file[0].open(&fs, "hello", O_WRONLY | O_CREAT);
|
||||
|
|
|
|||
|
|
@ -75,7 +75,6 @@ DIR *dd[MBED_TEST_DIRS];
|
|||
FILE *fd[MBED_TEST_FILES];
|
||||
struct dirent ent;
|
||||
struct dirent *ed;
|
||||
size_t size;
|
||||
uint8_t buffer[MBED_TEST_BUFFER];
|
||||
uint8_t rbuffer[MBED_TEST_BUFFER];
|
||||
uint8_t wbuffer[MBED_TEST_BUFFER];
|
||||
|
|
@ -89,6 +88,7 @@ void test_seek_tests()
|
|||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
{
|
||||
size_t size;
|
||||
res = MBED_TEST_FILESYSTEM::format(&bd);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
res = fs.mount(&bd);
|
||||
|
|
@ -271,6 +271,7 @@ void test_simple_file_seek()
|
|||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
{
|
||||
size_t size;
|
||||
res = fs.mount(&bd);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
res = file[0].open(&fs, "hello/kitty42", O_RDONLY);
|
||||
|
|
@ -318,7 +319,7 @@ void test_simple_file_seek()
|
|||
res = memcmp(buffer, "kittycatcat", size);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
size_t size = file[0].size();
|
||||
size = file[0].size();
|
||||
res = file[0].seek(0, SEEK_CUR);
|
||||
TEST_ASSERT_EQUAL(size, res);
|
||||
res = file[0].close();
|
||||
|
|
@ -337,6 +338,7 @@ void test_large_file_seek()
|
|||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
{
|
||||
size_t size;
|
||||
res = fs.mount(&bd);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
res = file[0].open(&fs, "hello/kitty42", O_RDONLY);
|
||||
|
|
@ -384,7 +386,7 @@ void test_large_file_seek()
|
|||
res = memcmp(buffer, "kittycatcat", size);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
size_t size = file[0].size();
|
||||
size = file[0].size();
|
||||
res = file[0].seek(0, SEEK_CUR);
|
||||
TEST_ASSERT_EQUAL(size, res);
|
||||
res = file[0].close();
|
||||
|
|
@ -403,6 +405,7 @@ void test_simple_file_seek_and_write()
|
|||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
{
|
||||
size_t size;
|
||||
res = fs.mount(&bd);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
res = file[0].open(&fs, "hello/kitty42", O_RDWR);
|
||||
|
|
@ -450,7 +453,7 @@ void test_simple_file_seek_and_write()
|
|||
res = memcmp(buffer, "kittycatcat", size);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
size_t size = file[0].size();
|
||||
size = file[0].size();
|
||||
res = file[0].seek(0, SEEK_CUR);
|
||||
TEST_ASSERT_EQUAL(size, res);
|
||||
res = file[0].close();
|
||||
|
|
@ -469,6 +472,7 @@ void test_large_file_seek_and_write()
|
|||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
{
|
||||
size_t size;
|
||||
res = fs.mount(&bd);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
res = file[0].open(&fs, "hello/kitty42", O_RDWR);
|
||||
|
|
@ -518,7 +522,7 @@ void test_large_file_seek_and_write()
|
|||
res = memcmp(buffer, "kittycatcat", size);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
size_t size = file[0].size();
|
||||
size = file[0].size();
|
||||
res = file[0].seek(0, SEEK_CUR);
|
||||
TEST_ASSERT_EQUAL(size, res);
|
||||
res = file[0].close();
|
||||
|
|
@ -537,6 +541,7 @@ void test_boundary_seek_and_write()
|
|||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
{
|
||||
size_t size;
|
||||
res = fs.mount(&bd);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
res = file[0].open(&fs, "hello/kitty42", O_RDWR);
|
||||
|
|
@ -583,6 +588,7 @@ void test_out_of_bounds_seek()
|
|||
TEST_ASSERT_EQUAL(0, res);
|
||||
|
||||
{
|
||||
size_t size;
|
||||
res = fs.mount(&bd);
|
||||
TEST_ASSERT_EQUAL(0, res);
|
||||
res = file[0].open(&fs, "hello/kitty42", O_RDWR);
|
||||
|
|
|
|||
|
|
@ -472,6 +472,11 @@ int SPIFBlockDevice::get_erase_value() const
|
|||
return 0xFF;
|
||||
}
|
||||
|
||||
const char *SPIFBlockDevice::get_type() const
|
||||
{
|
||||
return "SPIF";
|
||||
}
|
||||
|
||||
/***************************************************/
|
||||
/*********** SPI Driver API Functions **************/
|
||||
/***************************************************/
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ enum spif_bd_error {
|
|||
SPIF_BD_ERROR_OK = 0, /*!< no error */
|
||||
SPIF_BD_ERROR_DEVICE_ERROR = BD_ERROR_DEVICE_ERROR, /*!< device specific error -4001 */
|
||||
SPIF_BD_ERROR_PARSING_FAILED = -4002, /* SFDP Parsing failed */
|
||||
SPIF_BD_ERROR_READY_FAILED = -4003, /* Wait for Mem Ready failed */
|
||||
SPIF_BD_ERROR_READY_FAILED = -4003, /* Wait for Memory Ready failed */
|
||||
SPIF_BD_ERROR_WREN_FAILED = -4004, /* Write Enable Failed */
|
||||
SPIF_BD_ERROR_INVALID_ERASE_PARAMS = -4005, /* Erase command not on sector aligned addresses or exceeds device size */
|
||||
};
|
||||
|
|
@ -40,7 +40,7 @@ enum spif_bd_error {
|
|||
/** BlockDevice for SFDP based flash devices over SPI bus
|
||||
*
|
||||
* @code
|
||||
* // Here's an example using SPI flash device on K82F target
|
||||
* // An example using SPI flash device on K82F target
|
||||
* #include "mbed.h"
|
||||
* #include "SPIFBlockDevice.h"
|
||||
*
|
||||
|
|
@ -99,7 +99,7 @@ public:
|
|||
*/
|
||||
virtual int deinit();
|
||||
|
||||
/** Desctruct SPIFBlockDevie
|
||||
/** Desctruct SPIFBlockDevice
|
||||
*/
|
||||
~SPIFBlockDevice()
|
||||
{
|
||||
|
|
@ -118,7 +118,7 @@ public:
|
|||
|
||||
/** Program blocks to a block device
|
||||
*
|
||||
* The blocks must have been erased prior to being programmed
|
||||
* @note The blocks must have been erased prior to being programmed
|
||||
*
|
||||
* @param buffer Buffer of data to write to blocks
|
||||
* @param addr Address of block to begin writing to
|
||||
|
|
@ -132,14 +132,13 @@ public:
|
|||
|
||||
/** Erase blocks on a block device
|
||||
*
|
||||
* The state of an erased block is undefined until it has been programmed
|
||||
* @note The state of an erased block is undefined until it has been programmed
|
||||
*
|
||||
* @param addr Address of block to begin erasing
|
||||
* @param size Size to erase in bytes, must be a multiple of erase block size
|
||||
* @return SPIF_BD_ERROR_OK(0) - success
|
||||
* SPIF_BD_ERROR_DEVICE_ERROR - device driver transaction failed
|
||||
* SPIF_BD_ERROR_READY_FAILED - Waiting for Memory ready failed or timed out
|
||||
* SPIF_BD_ERROR_WREN_FAILED - Write Enable failed
|
||||
* SPIF_BD_ERROR_INVALID_ERASE_PARAMS - Trying to erase unaligned address or size
|
||||
*/
|
||||
virtual int erase(mbed::bd_addr_t addr, mbed::bd_size_t size);
|
||||
|
|
@ -157,14 +156,14 @@ public:
|
|||
*/
|
||||
virtual mbed::bd_size_t get_program_size() const;
|
||||
|
||||
/** Get the size of a eraseable block
|
||||
/** Get the size of an erasable block
|
||||
*
|
||||
* @return Size of a eraseable block in bytes
|
||||
* @return Size of an erasable block in bytes
|
||||
* @note Must be a multiple of the program size
|
||||
*/
|
||||
virtual mbed::bd_size_t get_erase_size() const;
|
||||
|
||||
/** Get the size of minimal eraseable sector size of given address
|
||||
/** Get the size of minimal erasable sector size of given address
|
||||
*
|
||||
* @param addr Any address within block queried for erase sector size (can be any address within flash size offset)
|
||||
* @return Size of minimal erase sector size, in given address region, in bytes
|
||||
|
|
@ -189,6 +188,12 @@ public:
|
|||
*/
|
||||
virtual mbed::bd_size_t size() const;
|
||||
|
||||
/** Get the BlockDevice class type.
|
||||
*
|
||||
* @return A string representation of the BlockDevice class type.
|
||||
*/
|
||||
virtual const char *get_type() const;
|
||||
|
||||
private:
|
||||
|
||||
// Internal functions
|
||||
|
|
@ -203,7 +208,7 @@ private:
|
|||
// Parse and Detect required Basic Parameters from Table
|
||||
int _sfdp_parse_basic_param_table(uint32_t basic_table_addr, size_t basic_table_size);
|
||||
|
||||
// Parse and read information required by Regions Secotr Map
|
||||
// Parse and read information required by Regions Sector Map
|
||||
int _sfdp_parse_sector_map_table(uint32_t sector_map_table_addr, size_t sector_map_table_size);
|
||||
|
||||
// Detect fastest read Bus mode supported by device
|
||||
|
|
@ -220,10 +225,10 @@ private:
|
|||
/***********************/
|
||||
/* Utilities Functions */
|
||||
/***********************/
|
||||
// Find the region to which the given offset belong to
|
||||
// Find the region to which the given offset belongs to
|
||||
int _utils_find_addr_region(bd_size_t offset);
|
||||
|
||||
// Iterate on all supported Erase Types of the Region to which the offset belong to.
|
||||
// Iterate on all supported Erase Types of the Region to which the offset belongs to.
|
||||
// Iterates from highest type to lowest
|
||||
int _utils_iterate_next_largest_erase_type(uint8_t &bitfield, int size, int offset, int boundry);
|
||||
|
||||
|
|
@ -260,7 +265,7 @@ private:
|
|||
private:
|
||||
// Master side hardware
|
||||
mbed::SPI _spi;
|
||||
// Enable CS control (low/high) for SPI driver operatios
|
||||
// Enable CS control (low/high) for SPI driver operations
|
||||
mbed::DigitalOut _cs;
|
||||
|
||||
// Mutex is used to protect Flash device for some SPI Driver commands that must be done sequentially with no other commands in between
|
||||
|
|
|
|||
|
|
@ -472,8 +472,7 @@ nsapi_error_t ESP8266::open_udp(int id, const char *addr, int port, int local_po
|
|||
_sock_already = false; // To be raised again by OOB msg
|
||||
done = close(id);
|
||||
if (!done) {
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_DRIVER, MBED_ERROR_CLOSE_FAILED), \
|
||||
"ESP8266::_open_udp: device refused to close socket");
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (_error) {
|
||||
|
|
@ -491,9 +490,7 @@ nsapi_error_t ESP8266::open_udp(int id, const char *addr, int port, int local_po
|
|||
|
||||
_smutex.unlock();
|
||||
|
||||
if (done) {
|
||||
tr_debug("UDP socket %d opened", id);
|
||||
}
|
||||
tr_debug("UDP socket %d opened: %s", id, (_sock_i[id].open ? "true" : "false"));
|
||||
|
||||
return done ? NSAPI_ERROR_OK : NSAPI_ERROR_DEVICE_ERROR;
|
||||
}
|
||||
|
|
@ -526,8 +523,7 @@ nsapi_error_t ESP8266::open_tcp(int id, const char *addr, int port, int keepaliv
|
|||
_sock_already = false; // To be raised again by OOB msg
|
||||
done = close(id);
|
||||
if (!done) {
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_DRIVER, MBED_ERROR_CLOSE_FAILED), \
|
||||
"ESP8266::_open_tcp: device refused to close socket");
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (_error) {
|
||||
|
|
@ -545,9 +541,7 @@ nsapi_error_t ESP8266::open_tcp(int id, const char *addr, int port, int keepaliv
|
|||
|
||||
_smutex.unlock();
|
||||
|
||||
if (done) {
|
||||
tr_debug("TCP socket %d opened", id);
|
||||
}
|
||||
tr_debug("TCP socket %d opened: %s", id, (_sock_i[id].open ? "true" : "false"));
|
||||
|
||||
return done ? NSAPI_ERROR_OK : NSAPI_ERROR_DEVICE_ERROR;
|
||||
}
|
||||
|
|
@ -563,6 +557,7 @@ bool ESP8266::dns_lookup(const char *name, char *ip)
|
|||
|
||||
nsapi_error_t ESP8266::send(int id, const void *data, uint32_t amount)
|
||||
{
|
||||
nsapi_error_t ret = NSAPI_ERROR_DEVICE_ERROR;
|
||||
// +CIPSEND supports up to 2048 bytes at a time
|
||||
// Data stream can be truncated
|
||||
if (amount > 2048 && _sock_i[id].proto == NSAPI_TCP) {
|
||||
|
|
@ -576,31 +571,50 @@ nsapi_error_t ESP8266::send(int id, const void *data, uint32_t amount)
|
|||
_smutex.lock();
|
||||
set_timeout(ESP8266_SEND_TIMEOUT);
|
||||
_busy = false;
|
||||
if (_parser.send("AT+CIPSEND=%d,%lu", id, amount)
|
||||
&& _parser.recv(">")
|
||||
&& _parser.write((char *)data, (int)amount) >= 0
|
||||
&& _parser.recv("SEND OK")) {
|
||||
// No flow control, data overrun is possible
|
||||
if (_serial_rts == NC) {
|
||||
while (_parser.process_oob()); // Drain USART receive register
|
||||
}
|
||||
_smutex.unlock();
|
||||
return NSAPI_ERROR_OK;
|
||||
}
|
||||
if (_error) {
|
||||
_error = false;
|
||||
if (!_parser.send("AT+CIPSEND=%d,%lu", id, amount)) {
|
||||
tr_debug("ESP8266::send(): AT+CIPSEND failed");
|
||||
goto END;
|
||||
}
|
||||
|
||||
if(!_parser.recv(">")) {
|
||||
tr_debug("ESP8266::send(): didn't get \">\"");
|
||||
ret = NSAPI_ERROR_WOULD_BLOCK;
|
||||
goto END;
|
||||
}
|
||||
|
||||
if (_parser.write((char *)data, (int)amount) >= 0 && _parser.recv("SEND OK")) {
|
||||
ret = NSAPI_ERROR_OK;
|
||||
}
|
||||
|
||||
END:
|
||||
_process_oob(ESP8266_RECV_TIMEOUT, true); // Drain USART receive register to avoid data overrun
|
||||
|
||||
// error hierarchy, from low to high
|
||||
if (_busy) {
|
||||
set_timeout();
|
||||
_smutex.unlock();
|
||||
tr_debug("returning WOULD_BLOCK");
|
||||
return NSAPI_ERROR_WOULD_BLOCK;
|
||||
ret = NSAPI_ERROR_WOULD_BLOCK;
|
||||
tr_debug("ESP8266::send(): modem busy");
|
||||
}
|
||||
|
||||
if (ret == NSAPI_ERROR_DEVICE_ERROR) {
|
||||
ret = NSAPI_ERROR_WOULD_BLOCK;
|
||||
tr_debug("ESP8266::send(): send failed");
|
||||
}
|
||||
|
||||
if (_error) {
|
||||
ret = NSAPI_ERROR_CONNECTION_LOST;
|
||||
tr_debug("ESP8266::send(): connection disrupted");
|
||||
}
|
||||
|
||||
if (!_sock_i[id].open && ret != NSAPI_ERROR_OK) {
|
||||
ret = NSAPI_ERROR_CONNECTION_LOST;
|
||||
tr_debug("ESP8266::send(): socket closed abruptly");
|
||||
}
|
||||
|
||||
set_timeout();
|
||||
_smutex.unlock();
|
||||
|
||||
return NSAPI_ERROR_DEVICE_ERROR;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void ESP8266::_oob_packet_hdlr()
|
||||
|
|
@ -1100,6 +1114,13 @@ int8_t ESP8266::default_wifi_mode()
|
|||
return 0;
|
||||
}
|
||||
|
||||
void ESP8266::flush()
|
||||
{
|
||||
_smutex.lock();
|
||||
_parser.flush();
|
||||
_smutex.unlock();
|
||||
}
|
||||
|
||||
bool ESP8266::set_default_wifi_mode(const int8_t mode)
|
||||
{
|
||||
_smutex.lock();
|
||||
|
|
|
|||
|
|
@ -367,6 +367,15 @@ public:
|
|||
*/
|
||||
void bg_process_oob(uint32_t timeout, bool all);
|
||||
|
||||
/**
|
||||
* Flush the serial port input buffers.
|
||||
*
|
||||
* If you do HW reset for ESP module, you should
|
||||
* flush the input buffers from existing responses
|
||||
* from the device.
|
||||
*/
|
||||
void flush();
|
||||
|
||||
static const int8_t WIFIMODE_STATION = 1;
|
||||
static const int8_t WIFIMODE_SOFTAP = 2;
|
||||
static const int8_t WIFIMODE_STATION_SOFTAP = 3;
|
||||
|
|
|
|||
|
|
@ -339,9 +339,6 @@ nsapi_error_t ESP8266Interface::_init(void)
|
|||
if (!_esp.at_available()) {
|
||||
return NSAPI_ERROR_DEVICE_ERROR;
|
||||
}
|
||||
if (!_esp.stop_uart_hw_flow_ctrl()) {
|
||||
return NSAPI_ERROR_DEVICE_ERROR;
|
||||
}
|
||||
if (!_esp.reset()) {
|
||||
return NSAPI_ERROR_DEVICE_ERROR;
|
||||
}
|
||||
|
|
@ -371,12 +368,15 @@ nsapi_error_t ESP8266Interface::_init(void)
|
|||
|
||||
void ESP8266Interface::_hw_reset()
|
||||
{
|
||||
if (_rst_pin.is_connected()) {
|
||||
_rst_pin.rst_assert();
|
||||
// If you happen to use Pin7 CH_EN as reset pin, not needed otherwise
|
||||
// https://www.espressif.com/sites/default/files/documentation/esp8266_hardware_design_guidelines_en.pdf
|
||||
wait_us(200);
|
||||
wait_ms(2); // Documentation says 200 us should have been enough, but experimentation shows that 1ms was not enough
|
||||
_esp.flush();
|
||||
_rst_pin.rst_deassert();
|
||||
}
|
||||
}
|
||||
|
||||
struct esp8266_socket {
|
||||
int id;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,81 @@
|
|||
# Get type method addon to block devices class
|
||||
|
||||
### Revision history
|
||||
| Revision | Date | Authors | Mbed OS version | Comments |
|
||||
|---------- |-----------------|-------------------------------------------------------------|------------------------|------------------|
|
||||
| 1.0 | 04/12/2018 | Yossi Levy ([@yossi2le](https://github.com/yossi2le/)) | 5.11+ | Initial revision |
|
||||
|
||||
## Introduction
|
||||
|
||||
Most storage solutions use block devices, whether it is Filesystems, KVStore or any other solution
|
||||
most of them will have some BlockDevice class underneath. However, sometimes a storage type or an application needs to know the physical
|
||||
BlockDevice type in order to work smoothly or the BlockDevice type in order to decide what is
|
||||
the best storage configuration to use.
|
||||
To address this an add-on method of getting type is proposed for BlockDevice interface class.
|
||||
|
||||
## The Motivation
|
||||
|
||||
Below there is a list of some examples to explain the motivation and the need for the adding of get_type to BlockDevice interface.
|
||||
|
||||
examples:
|
||||
- TDBStore needs to know if there are flash characteristics for the block device and if there aren<65>t it should use
|
||||
FlashSimBlockDevice to simulate a flash BlockDevice.
|
||||
- TDBStore should not co-exists with NVStore, but this is true only if TDBStore is running on internal memory. Therefore if TDBStore running on
|
||||
internal memory and NVStore is also there an error should be raised.
|
||||
- When creating a file system you would prefer working with FAT on top of SD while LITTLEFS on top of any flash block device.
|
||||
Those preference in favor of better performance.
|
||||
|
||||
To summarize the above, it may be very useful when using block device to know the type of the instance and especially, but not only,
|
||||
when using get_default_instace. Sometimes applications and tests would like to behave differently depending on the instance that has been created
|
||||
or provided to them.
|
||||
|
||||
In fact it might be worth to consider adding the get_type to any interface with get_default_instance at mbed-os.
|
||||
|
||||
## Dive into details
|
||||
we should add the following method to BlockDevice interface class.
|
||||
|
||||
```virtual const char * get_type() const = 0;```
|
||||
|
||||
then every physical BlockDevice class which implements the interface should also implement this method and return a string
|
||||
representing its type. Furthermore, a nonphysical BlockDevice like SlicingBlockDevice should return the underlying physical
|
||||
BlockDevice type.
|
||||
|
||||
### Physical BlockDevice:
|
||||
```
|
||||
const char * HeapBlockDevice::get_type() const
|
||||
{
|
||||
return "HEAP";
|
||||
}
|
||||
```
|
||||
|
||||
### Logical BlockDevice:
|
||||
```
|
||||
const char * SlicingBlockDevice::get_type() const
|
||||
{
|
||||
if (_bd != NULL) {
|
||||
return _bd->get_type();
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
```
|
||||
|
||||
### Open issue
|
||||
The ChainingBlockDevice which chains different type of physical block devices into one block device is unable
|
||||
to return the underneath physical as it contains two or more types. Therefore it will return CHAINING as its
|
||||
identity and its left for the user to decide how the application will treat this information.
|
||||
|
||||
|
||||
The below table describes physical BlockDevice and its tyep names
|
||||
|
||||
|
||||
| BlockDevice class | String description |
|
||||
|-----------------------------|--------------------|
|
||||
| HeapBlockDevice | "HEAP" |
|
||||
| SPIFBlockDevice | "SPIF" |
|
||||
| SPIFReducedBlockDevice | "SPIFR" |
|
||||
| QSPIFBlockDevice | "QSPIF" |
|
||||
| SDBlockDevice | "SD" |
|
||||
| FlashIAPBlockDevice | "FLASHIAP" |
|
||||
| DataFlashBlockDevice | "DATAFLASH" |
|
||||
| ChainingBlockDevice | "CHAINING" |
|
||||
|
|
@ -62,6 +62,8 @@ The following is a list of all storage parameters available and their descriptio
|
|||
* `TDB_EXTERNAL_NO_RBP`.
|
||||
* `FILESYSTEM`.
|
||||
* `FILESYSTEM_NO_RBP`.
|
||||
* `default`
|
||||
If default is set, the system will choose the type of storage base on the block device component set in target.json. For QSPIF, SPIF and DATAFLASH block devices TDB_EXTERNAL will be used. If SD is set a FILESYSTEM storage is set and if only FLASHIAP exists as the only block device component, a TDB_INTERNAL will be used.
|
||||
* `default_kv` - This is a string representing the path for the default KVStore instantiation. Applications can pass an empty path (only the key name) or pass the generated name for this parameter (`MBED_CONF_STORAGE_DEFAULT_KV`) as the path to use this configuration.
|
||||
* `internal_size` - The size in bytes for the internal FlashIAP block device. This, together with the `internal_base_address`, adjusts exactly the size and location where the block device resides on memory. If not defined, the block device will try to get the maximum size available.
|
||||
* `internal_base_address` - The address where the internal FlashIAP blockDevice starts. This helps to prevent collisions with other needs, such as firmware updates. If not defined, the start address will be set to the first sector after the application code ends in `TDB_internal`. In any external configurations with rollback protection support, it will be set to end of flash - `rbp_internal_size`.
|
||||
|
|
@ -83,7 +85,7 @@ Below is the main storage configuration `mbed_lib.json` file:
|
|||
"name": "storage",
|
||||
"config": {
|
||||
"storage_type": {
|
||||
"help": "Options are TDB_INTERNAL, TDB_EXTERNAL, TDB_EXTERNAL_NO_RBP, FILESYSTEM or FILESYSTEM_NO_RBP.",
|
||||
"help": "Options are TDB_INTERNAL, TDB_EXTERNAL, TDB_EXTERNAL_NO_RBP, FILESYSTEM, FILESYSTEM_NO_RBP or default. If default, the storage type will be chosen according to the component defined in targets.json",
|
||||
"value": "NULL"
|
||||
},
|
||||
"default_kv": {
|
||||
|
|
|
|||
|
|
@ -71,12 +71,12 @@ void EventQueue::background(Callback<void(int)> update)
|
|||
}
|
||||
}
|
||||
|
||||
void EventQueue::chain(EventQueue *target)
|
||||
int EventQueue::chain(EventQueue *target)
|
||||
{
|
||||
if (target) {
|
||||
equeue_chain(&_equeue, &target->_equeue);
|
||||
return equeue_chain(&_equeue, &target->_equeue);
|
||||
} else {
|
||||
equeue_chain(&_equeue, 0);
|
||||
return equeue_chain(&_equeue, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -181,8 +181,11 @@ public:
|
|||
*
|
||||
* @param target Queue that will dispatch this queue's events as a
|
||||
* part of its dispatch loop
|
||||
*
|
||||
* @return Zero on success and negative error code value if chaining fails
|
||||
*
|
||||
*/
|
||||
void chain(EventQueue *target);
|
||||
int chain(EventQueue *target);
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
## The mbed-events library ##
|
||||
## The `mbed-events` library ##
|
||||
|
||||
The mbed-events library provides a flexible queue for scheduling events.
|
||||
The `mbed-events` library provides a flexible queue for scheduling events.
|
||||
|
||||
``` cpp
|
||||
#include "mbed_events.h"
|
||||
|
|
@ -20,18 +20,18 @@ int main() {
|
|||
}
|
||||
```
|
||||
|
||||
The mbed-events library can be used as a normal event loop, or it can be
|
||||
backgrounded on a single hardware timer or even another event loop. It is
|
||||
both thread and irq safe, and provides functions for easily composing
|
||||
You can use the `mbed-events library` as a normal event loop, or you can
|
||||
background it on a single hardware timer or even another event loop. It is
|
||||
both thread and IRQ safe and provides functions for easily composing
|
||||
independent event queues.
|
||||
|
||||
The mbed-events library can act as a drop-in scheduler, provide synchronization
|
||||
between multiple threads, or just act as a mechanism for moving events out of
|
||||
The `mbed-events` library can act as a drop-in scheduler, provide synchronization
|
||||
between multiple threads or act as a mechanism for moving events out of
|
||||
interrupt contexts.
|
||||
|
||||
### Usage ###
|
||||
|
||||
The core of the mbed-events library is the [EventQueue](EventQueue.h) class,
|
||||
The core of the `mbed-events library` is the [EventQueue](EventQueue.h) class,
|
||||
which represents a single event queue. The `EventQueue::dispatch` function
|
||||
runs the queue, providing the context for executing events.
|
||||
|
||||
|
|
@ -53,8 +53,8 @@ queue.dispatch();
|
|||
```
|
||||
|
||||
The EventQueue class provides several call functions for posting events
|
||||
to the underlying event queue. The call functions are thread and irq safe,
|
||||
don't need the underlying loop to be running, and provide an easy mechanism
|
||||
to the underlying event queue. The call functions are thread and IRQ safe,
|
||||
don't need the underlying loop to be running and provide a mechanism
|
||||
for moving events out of interrupt contexts.
|
||||
|
||||
``` cpp
|
||||
|
|
@ -73,8 +73,8 @@ queue.call_every(2000, doit_every_two_seconds);
|
|||
queue.call_every(400, printf, "called every 0.4 seconds\n");
|
||||
```
|
||||
|
||||
The call functions return an id that uniquely represents the event in the
|
||||
the event queue. This id can be passed to `EventQueue::cancel` to cancel
|
||||
The call functions return an ID that uniquely represents the event in the
|
||||
the event queue. You can pass this ID to `EventQueue::cancel` to cancel
|
||||
an in-flight event.
|
||||
|
||||
``` cpp
|
||||
|
|
@ -92,9 +92,9 @@ if (id) {
|
|||
queue.cancel(id);
|
||||
```
|
||||
|
||||
For a more fine-grain control of event dispatch, the `Event` class can be
|
||||
manually instantiated and configured. An `Event` represents an event as
|
||||
a C++ style function object and can be directly passed to other APIs that
|
||||
For a more detailed control of event dispatch, you can manually instantiate
|
||||
and configure the `Event` class. An `Event` represents an event as
|
||||
a C++ style function object, and you can directly pass it to other APIs that
|
||||
expect a callback.
|
||||
|
||||
``` cpp
|
||||
|
|
@ -126,7 +126,7 @@ queue.dispatch();
|
|||
|
||||
Event queues easily align with module boundaries, where internal state can
|
||||
be implicitly synchronized through event dispatch. Multiple modules can
|
||||
use independent event queues, but still be composed through the
|
||||
use independent event queues but still be composed through the
|
||||
`EventQueue::chain` function.
|
||||
|
||||
``` cpp
|
||||
|
|
|
|||
|
|
@ -603,23 +603,27 @@ static void equeue_chain_update(void *p, int ms)
|
|||
if (ms >= 0) {
|
||||
c->id = equeue_call_in(c->target, ms, equeue_chain_dispatch, c->q);
|
||||
} else {
|
||||
equeue_dealloc(c->target, c);
|
||||
equeue_dealloc(c->q, c);
|
||||
}
|
||||
}
|
||||
|
||||
void equeue_chain(equeue_t *q, equeue_t *target)
|
||||
int equeue_chain(equeue_t *q, equeue_t *target)
|
||||
{
|
||||
if (!target) {
|
||||
equeue_background(q, 0, 0);
|
||||
return;
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct equeue_chain_context *c = equeue_alloc(q,
|
||||
sizeof(struct equeue_chain_context));
|
||||
if (!c) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
c->q = q;
|
||||
c->target = target;
|
||||
c->id = 0;
|
||||
|
||||
equeue_background(q, equeue_chain_update, c);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -220,7 +220,10 @@ void equeue_background(equeue_t *queue,
|
|||
//
|
||||
// The equeue_chain function allows multiple equeues to be composed, sharing
|
||||
// the context of a dispatch loop while still being managed independently.
|
||||
void equeue_chain(equeue_t *queue, equeue_t *target);
|
||||
//
|
||||
// If the event queue chaining fails, equeue_chain returns a negative,
|
||||
// platform-specific error code.
|
||||
int equeue_chain(equeue_t *queue, equeue_t *target);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
"present": 1,
|
||||
"shared-stacksize": {
|
||||
"help": "Stack size (bytes) for shared event queue thread",
|
||||
"value": 1024
|
||||
"value": 2048
|
||||
},
|
||||
"shared-eventsize": {
|
||||
"help": "Event buffer size (bytes) for shared event queue",
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ class BLEInstanceBase;
|
|||
* Next, the signal handling/process mechanism should be set up. By design,
|
||||
* Mbed BLE does not impose to the user an event handling/processing mechanism;
|
||||
* however, it exposes APIs, which allows an application to compose its own:
|
||||
* - onEventsToProcess(), whichs register a callback that
|
||||
* - onEventsToProcess(), which registers a callback that
|
||||
* the BLE subsystem will call when there is an event ready to be processed.
|
||||
* - processEvents(), which processes all the events present in the BLE subsystem.
|
||||
*
|
||||
|
|
@ -84,7 +84,7 @@ class BLEInstanceBase;
|
|||
* static EventQueue event_queue(4 * EVENTS_EVENT_SIZE);
|
||||
*
|
||||
* // Function invoked when there is a BLE event available.
|
||||
* // It put into the event queue the processing of the event(s)
|
||||
* // Event processing is put into the event queue.
|
||||
* void schedule_ble_processing(BLE::OnEventsToProcessCallbackContext* context) {
|
||||
* event_queue.call(callback(&(context->ble), &BLE::processEvents));
|
||||
* }
|
||||
|
|
@ -424,6 +424,8 @@ public:
|
|||
* are thin wrappers around a transport object (that is, ptr. to
|
||||
* BLEInstanceBase).
|
||||
*
|
||||
* @param[in] instanceID BLE Instance ID to get.
|
||||
*
|
||||
* It is better to create BLE objects as singletons accessed through the
|
||||
* Instance() method. If multiple BLE handles are constructed for the same
|
||||
* interface (using this constructor), they share the same underlying
|
||||
|
|
@ -442,7 +444,7 @@ public:
|
|||
* MCU might wake up several times to service the stack before returning
|
||||
* control to the caller.
|
||||
*
|
||||
* @deprecated This function block the CPU prefer to use the pair
|
||||
* @deprecated This function blocks the CPU. Use the pair
|
||||
* onEventsToProcess() and processEvents().
|
||||
*/
|
||||
MBED_DEPRECATED("Use BLE::processEvents() and BLE::onEventsToProcess().")
|
||||
|
|
@ -451,6 +453,10 @@ public:
|
|||
/**
|
||||
* Set the BTLE MAC address and type.
|
||||
*
|
||||
* @param[in] type Type of the address to set.
|
||||
* @param[in] address Value of the address to set. It is ordered in
|
||||
* little endian.
|
||||
*
|
||||
* @return BLE_ERROR_NONE on success.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly, refer to
|
||||
|
|
@ -466,6 +472,9 @@ public:
|
|||
/**
|
||||
* Fetch the Bluetooth Low Energy MAC address and type.
|
||||
*
|
||||
* @param[out] typeP Type of the current address set.
|
||||
* @param[out] address Value of the current address.
|
||||
*
|
||||
* @return BLE_ERROR_NONE on success.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
|
|
@ -483,6 +492,8 @@ public:
|
|||
/**
|
||||
* Set the GAP advertising mode to use for this device.
|
||||
*
|
||||
* @param[in] advType New type of advertising to use.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::setAdvertisingType(). A former call to
|
||||
* ble.setAdvertisingType(...) should be replaced with
|
||||
|
|
@ -492,6 +503,8 @@ public:
|
|||
void setAdvertisingType(GapAdvertisingParams::AdvertisingType advType);
|
||||
|
||||
/**
|
||||
* Set the advertising interval.
|
||||
*
|
||||
* @param[in] interval
|
||||
* Advertising interval in units of milliseconds. Advertising
|
||||
* is disabled if interval is 0. If interval is smaller than
|
||||
|
|
@ -521,6 +534,9 @@ public:
|
|||
void setAdvertisingInterval(uint16_t interval);
|
||||
|
||||
/**
|
||||
* Get the minimum advertising interval in milliseconds, which can be used
|
||||
* for connectable advertising types.
|
||||
*
|
||||
* @return Minimum Advertising interval in milliseconds.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly, refer to
|
||||
|
|
@ -535,6 +551,9 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* Get the minimum advertising interval in milliseconds, which can be
|
||||
* used for nonconnectable advertising type.
|
||||
*
|
||||
* @return Minimum Advertising interval in milliseconds for nonconnectible mode.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly, refer to
|
||||
|
|
@ -549,6 +568,8 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* Get the maximum advertising interval in milliseconds.
|
||||
*
|
||||
* @return Maximum Advertising interval in milliseconds.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly, refer to
|
||||
|
|
@ -563,6 +584,10 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* Set the advertising duration.
|
||||
*
|
||||
* A timeout event is genenerated once the advertising period expired.
|
||||
*
|
||||
* @param[in] timeout
|
||||
* Advertising timeout (in seconds) between 0x1 and 0x3FFF (1
|
||||
* and 16383). Use 0 to disable the advertising timeout.
|
||||
|
|
@ -581,6 +606,8 @@ public:
|
|||
* directly; there are other APIs to tweak advertisement parameters
|
||||
* individually (see above).
|
||||
*
|
||||
* @param[in] advParams The new advertising parameters.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::setAdvertisingParams(). A former call to
|
||||
* ble.setAdvertisingParams(...) should be replaced with
|
||||
|
|
@ -590,6 +617,8 @@ public:
|
|||
void setAdvertisingParams(const GapAdvertisingParams &advParams);
|
||||
|
||||
/**
|
||||
* Get the current advertising parameters.
|
||||
*
|
||||
* @return Read back advertising parameters. Useful for storing and
|
||||
* restoring parameters rapidly.
|
||||
*
|
||||
|
|
@ -612,6 +641,9 @@ public:
|
|||
* GapAdvertisingData::Flags for valid flags. Multiple
|
||||
* flags may be specified in combination.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the data was successfully added to the
|
||||
* advertising payload.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly, refer to
|
||||
* Gap::accumulateAdvertisingPayload(uint8_t). A former call to
|
||||
* ble.accumulateAdvertisingPayload(flags) should be replaced with
|
||||
|
|
@ -629,6 +661,9 @@ public:
|
|||
* @param[in] app
|
||||
* The appearance of the peripheral.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the data was successfully added to the
|
||||
* advertising payload.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::accumulateAdvertisingPayload(GapAdvertisingData::Appearance).
|
||||
* A former call to ble.accumulateAdvertisingPayload(appearance)
|
||||
|
|
@ -648,6 +683,9 @@ public:
|
|||
* The max transmit power to be used by the controller. This
|
||||
* is only a hint.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the data was successfully added to the
|
||||
* advertising payload.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::accumulateAdvertisingPayloadTxPower(). A former call to
|
||||
* ble.accumulateAdvertisingPayloadTxPower(txPower) should be replaced with
|
||||
|
|
@ -666,6 +704,9 @@ public:
|
|||
* @param data Data bytes.
|
||||
* @param len Data length.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the advertisement payload was updated based on
|
||||
* matching AD type; otherwise, an appropriate error.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly, refer to
|
||||
* Gap::accumulateAdvertisingPayload(GapAdvertisingData::DataType, const uint8_t, uint8_t).
|
||||
* A former call to ble.accumulateAdvertisingPayload(...) should
|
||||
|
|
@ -679,6 +720,10 @@ public:
|
|||
* underlying stack. It would be uncommon for this API to be used directly;
|
||||
* there are other APIs to build an advertisement payload (see above).
|
||||
*
|
||||
* @param[in] advData Advertising data to set.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the advertising data was set successfully.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly, refer to
|
||||
* Gap::setAdvertisingData(). A former call to
|
||||
* ble.setAdvertisingData(...) should be replaced with
|
||||
|
|
@ -688,6 +733,8 @@ public:
|
|||
ble_error_t setAdvertisingData(const GapAdvertisingData &advData);
|
||||
|
||||
/**
|
||||
* Get a reference to the current advertising payload.
|
||||
*
|
||||
* @return Read back advertising data. Useful for storing and
|
||||
* restoring payload.
|
||||
*
|
||||
|
|
@ -737,6 +784,9 @@ public:
|
|||
* @param[in] data Data bytes.
|
||||
* @param[in] len Data length.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the data was successfully added to the scan
|
||||
* response payload.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::accumulateScanResponse(). A former call to
|
||||
* ble.accumulateScanResponse(...) should be replaced with
|
||||
|
|
@ -760,6 +810,9 @@ public:
|
|||
/**
|
||||
* Start advertising.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the advertising procedure successfully
|
||||
* started.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::startAdvertising(). A former call to
|
||||
* ble.startAdvertising(...) should be replaced with
|
||||
|
|
@ -771,6 +824,9 @@ public:
|
|||
/**
|
||||
* Stop advertising.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the advertising procedure has been successfully
|
||||
* stopped.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::stopAdvertising(). A former call to
|
||||
* ble.stopAdvertising(...) should be replaced with
|
||||
|
|
@ -781,6 +837,7 @@ public:
|
|||
|
||||
/**
|
||||
* Set up parameters for GAP scanning (observer mode).
|
||||
*
|
||||
* @param[in] interval
|
||||
* Scan interval (in milliseconds) [valid values lie between 2.5ms and 10.24s].
|
||||
* @param[in] window
|
||||
|
|
@ -791,6 +848,8 @@ public:
|
|||
* Set to True if active-scanning is required. This is used to fetch the
|
||||
* scan response from a peer if possible.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the scan parameters were correctly set.
|
||||
*
|
||||
* The scanning window divided by the interval determines the duty cycle for
|
||||
* scanning. For example, if the interval is 100ms and the window is 10ms,
|
||||
* then the controller will scan for 10 percent of the time. It is possible
|
||||
|
|
@ -818,9 +877,12 @@ public:
|
|||
|
||||
/**
|
||||
* Set up the scanInterval parameter for GAP scanning (observer mode).
|
||||
*
|
||||
* @param[in] interval
|
||||
* Scan interval (in milliseconds) [valid values lie between 2.5ms and 10.24s].
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the scan interval was correctly set.
|
||||
*
|
||||
* The scanning window divided by the interval determines the duty cycle for
|
||||
* scanning. For example, if the interval is 100ms and the window is 10ms,
|
||||
* then the controller will scan for 10 percent of the time. It is possible
|
||||
|
|
@ -841,9 +903,12 @@ public:
|
|||
|
||||
/**
|
||||
* Set up the scanWindow parameter for GAP scanning (observer mode).
|
||||
*
|
||||
* @param[in] window
|
||||
* Scan Window (in milliseconds) [valid values lie between 2.5ms and 10.24s].
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the scan window was correctly set.
|
||||
*
|
||||
* The scanning window divided by the interval determines the duty cycle for
|
||||
* scanning. For example, if the interval is 100ms and the window is 10ms,
|
||||
* then the controller will scan for 10 percent of the time. It is possible
|
||||
|
|
@ -864,9 +929,12 @@ public:
|
|||
|
||||
/**
|
||||
* Set up parameters for GAP scanning (observer mode).
|
||||
*
|
||||
* @param[in] timeout
|
||||
* Scan timeout (in seconds) between 0x0001 and 0xFFFF; 0x0000 disables timeout.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the scan timeout was correctly set.
|
||||
*
|
||||
* The scanning window divided by the interval determines the duty cycle for
|
||||
* scanning. For example, if the interval is 100ms and the window is 10ms,
|
||||
* then the controller will scan for 10 percent of the time. It is possible
|
||||
|
|
@ -889,6 +957,7 @@ public:
|
|||
|
||||
/**
|
||||
* Set up parameters for GAP scanning (observer mode).
|
||||
*
|
||||
* @param[in] activeScanning
|
||||
* Set to True if active-scanning is required. This is used to fetch the
|
||||
* scan response from a peer if possible.
|
||||
|
|
@ -913,6 +982,9 @@ public:
|
|||
* receiving every advertisement report. This can be passed in
|
||||
* as NULL, in which case scanning may not be enabled at all.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the device successfully started the scan
|
||||
* procedure.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly, refer to
|
||||
* Gap::startScan(). A former call to
|
||||
* ble.startScan(callback) should be replaced with
|
||||
|
|
@ -922,7 +994,19 @@ public:
|
|||
ble_error_t startScan(void (*callback)(const Gap::AdvertisementCallbackParams_t *params));
|
||||
|
||||
/**
|
||||
* Same as above, but this takes an (object, method) pair for a callback.
|
||||
* Start the scanning procedure.
|
||||
*
|
||||
* Packets received during the scan procedure are forwarded to the
|
||||
* scan packet handler passed as argument to this function.
|
||||
*
|
||||
* @param[in] object Instance used to invoke @p callbackMember.
|
||||
*
|
||||
* @param[in] memberCallback Advertisement packet event handler. Upon
|
||||
* reception of an advertising packet, the packet is forwarded to @p
|
||||
* callback invoked from @p object.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the device successfully started the scan
|
||||
* procedure.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly, refer to
|
||||
* Gap::startScan(). A former call to
|
||||
|
|
@ -936,7 +1020,7 @@ public:
|
|||
/**
|
||||
* Stop scanning. The current scanning parameters remain in effect.
|
||||
*
|
||||
* @retval BLE_ERROR_NONE if successfully stopped scanning procedure.
|
||||
* @return BLE_ERROR_NONE if successfully stopped scanning procedure.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::stopScan(). A former call to
|
||||
|
|
@ -951,6 +1035,7 @@ public:
|
|||
|
||||
/**
|
||||
* Create a connection (GAP Link Establishment).
|
||||
*
|
||||
* @param peerAddr
|
||||
* 48-bit address, LSB format.
|
||||
* @param peerAddrType
|
||||
|
|
@ -959,6 +1044,7 @@ public:
|
|||
* Connection parameters.
|
||||
* @param scanParams
|
||||
* Parameters to use while scanning for the peer.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if connection establishment procedure is started
|
||||
* successfully. The onConnection callback (if set) is invoked upon
|
||||
* a connection event.
|
||||
|
|
@ -984,6 +1070,14 @@ public:
|
|||
* @param[in] connectionHandle
|
||||
* @param[in] reason
|
||||
* The reason for disconnection; sent back to the peer.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the disconnection procedure successfully
|
||||
* started.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* GAP::disconnect(). A former call to
|
||||
* ble.disconnect(...) should be replaced with
|
||||
* ble.gap().disconnect(...).
|
||||
*/
|
||||
MBED_DEPRECATED("Use ble.gap().disconnect(...)")
|
||||
ble_error_t disconnect(Gap::Handle_t connectionHandle, Gap::DisconnectionReason_t reason);
|
||||
|
|
@ -996,6 +1090,9 @@ public:
|
|||
* @param reason
|
||||
* The reason for disconnection; sent back to the peer.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the disconnection procedure successfully
|
||||
* started.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::disconnect(). A former call to
|
||||
* ble.disconnect(reason) should be replaced with
|
||||
|
|
@ -1012,12 +1109,14 @@ public:
|
|||
* Returns the current Gap state of the device using a bitmask that
|
||||
* describes whether the device is advertising or connected.
|
||||
*
|
||||
* @return The current GAP state of the device.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::getState(). A former call to
|
||||
* ble.getGapState() should be replaced with
|
||||
* ble.gap().getState().
|
||||
*/
|
||||
MBED_DEPRECATED("Use ble.gap().getGapState(...)")
|
||||
MBED_DEPRECATED("Use ble.gap().getState()")
|
||||
Gap::GapState_t getGapState(void) const;
|
||||
|
||||
/**
|
||||
|
|
@ -1051,6 +1150,9 @@ public:
|
|||
* @param[in] params
|
||||
* The structure containing the desired parameters.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the preferred connection parameters were set
|
||||
* correctly.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::setPreferredConnectionParams(). A former call to
|
||||
* ble.setPreferredConnectionParams() should be replaced with
|
||||
|
|
@ -1064,14 +1166,18 @@ public:
|
|||
|
||||
/**
|
||||
* Update connection parameters while in the peripheral role.
|
||||
*
|
||||
* @details In the peripheral role, this will send the corresponding L2CAP request to the connected peer and wait for
|
||||
* the central to perform the procedure.
|
||||
*
|
||||
* @param[in] handle
|
||||
* Connection Handle
|
||||
* @param[in] params
|
||||
* Pointer to desired connection parameters. If NULL is provided on a peripheral role,
|
||||
* the parameters in the PPCP characteristic of the GAP service will be used instead.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the connection parameters were updated correctly.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::updateConnectionParams(). A former call to
|
||||
* ble.updateConnectionParams() should be replaced with
|
||||
|
|
@ -1082,9 +1188,12 @@ public:
|
|||
|
||||
/**
|
||||
* Set the device name characteristic in the Gap service.
|
||||
*
|
||||
* @param[in] deviceName
|
||||
* The new value for the device-name. This is a UTF-8 encoded, <b>NULL-terminated</b> string.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the device name was set correctly.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::setDeviceName(). A former call to
|
||||
* ble.setDeviceName() should be replaced with
|
||||
|
|
@ -1098,6 +1207,7 @@ public:
|
|||
|
||||
/**
|
||||
* Get the value of the device name characteristic in the Gap service.
|
||||
*
|
||||
* @param[out] deviceName
|
||||
* Pointer to an empty buffer where the UTF-8 *non NULL-
|
||||
* terminated* string will be placed. Set this
|
||||
|
|
@ -1109,6 +1219,9 @@ public:
|
|||
* (on output) the complete device name length (without the
|
||||
* null terminator).
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the device name was fetched correctly from the
|
||||
* underlying BLE stack.
|
||||
*
|
||||
* @note If the device name is longer than the size of the supplied buffer,
|
||||
* the length will return the complete device name length and not the
|
||||
* number of bytes actually returned in deviceName. The application may
|
||||
|
|
@ -1127,9 +1240,12 @@ public:
|
|||
|
||||
/**
|
||||
* Set the appearance characteristic in the Gap service.
|
||||
*
|
||||
* @param[in] appearance
|
||||
* The new value for the device-appearance.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the new appearance was set correctly.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::setAppearance(). A former call to
|
||||
* ble.setAppearance() should be replaced with
|
||||
|
|
@ -1143,9 +1259,13 @@ public:
|
|||
|
||||
/**
|
||||
* Get the appearance characteristic in the Gap service.
|
||||
*
|
||||
* @param[out] appearanceP
|
||||
* The new value for the device-appearance.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the device-appearance was fetched correctly
|
||||
* from the underlying BLE stack.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly, refer to
|
||||
* Gap::getAppearance(). A former call to
|
||||
* ble.getAppearance() should be replaced with
|
||||
|
|
@ -1159,8 +1279,12 @@ public:
|
|||
|
||||
/**
|
||||
* Set the radio's transmit power.
|
||||
*
|
||||
* @param[in] txPower Radio transmit power in dBm.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the new radio's transmit power was set
|
||||
* correctly.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::setTxPower(). A former call to
|
||||
* ble.setTxPower() should be replaced with
|
||||
|
|
@ -1189,6 +1313,12 @@ public:
|
|||
* Add a service declaration to the local server ATT table. Also add the
|
||||
* characteristics contained within.
|
||||
*
|
||||
* @param[in] service The service to be added; attribute handle of services,
|
||||
* characteristic and characteristic descriptors are updated by the
|
||||
* process.
|
||||
*
|
||||
* @return BLE_ERROR_NONE if the service was successfully added.
|
||||
*
|
||||
* @deprecated You should use the parallel API from GattServer directly, refer to
|
||||
* GattServer::addService(). A former call
|
||||
* to ble.addService() should be replaced with
|
||||
|
|
@ -1202,6 +1332,7 @@ public:
|
|||
|
||||
/**
|
||||
* Read the value of a characteristic from the local GattServer.
|
||||
*
|
||||
* @param[in] attributeHandle
|
||||
* Attribute handle for the value attribute of the characteristic.
|
||||
* @param[out] buffer
|
||||
|
|
@ -1228,6 +1359,7 @@ public:
|
|||
|
||||
/**
|
||||
* Read the value of a characteristic from the local GattServer.
|
||||
*
|
||||
* @param[in] connectionHandle
|
||||
* Connection Handle.
|
||||
* @param[in] attributeHandle
|
||||
|
|
@ -1356,7 +1488,7 @@ public:
|
|||
* call to ble.initializeSecurity(...) should be replaced with
|
||||
* ble.securityManager().init(...).
|
||||
*/
|
||||
MBED_DEPRECATED("Use ble.gattServer().write(...)")
|
||||
MBED_DEPRECATED("Use ble.securityManager().init(...)")
|
||||
ble_error_t initializeSecurity(
|
||||
bool enableBonding = true,
|
||||
bool requireMITM = true,
|
||||
|
|
@ -1409,6 +1541,8 @@ public:
|
|||
* Set up a callback for timeout events. Refer to Gap::TimeoutSource_t for
|
||||
* possible event types.
|
||||
*
|
||||
* @param[in] timeoutCallback Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::onTimeout(). A former call
|
||||
* to ble.onTimeout(callback) should be replaced with
|
||||
|
|
@ -1420,6 +1554,8 @@ public:
|
|||
/**
|
||||
* Set up a callback for connection events. Refer to Gap::ConnectionEventCallback_t.
|
||||
*
|
||||
* @param[in] connectionCallback Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly, refer to
|
||||
* Gap::onConnection(). A former call
|
||||
* to ble.onConnection(callback) should be replaced with
|
||||
|
|
@ -1431,6 +1567,8 @@ public:
|
|||
/**
|
||||
* Append to a chain of callbacks to be invoked upon GAP disconnection.
|
||||
*
|
||||
* @param[in] disconnectionCallback Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::onDisconnection(). A former call
|
||||
* to ble.onDisconnection(callback) should be replaced with
|
||||
|
|
@ -1443,6 +1581,9 @@ public:
|
|||
* The same as onDisconnection() but allows an object reference and member function
|
||||
* to be added to the chain of callbacks.
|
||||
*
|
||||
* @param[in] tptr Instance used to invoke mptr.
|
||||
* @param[in] mptr Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from Gap directly and refer to
|
||||
* Gap::onDisconnection(). A former call
|
||||
* to ble.onDisconnection(callback) should be replaced with
|
||||
|
|
@ -1483,6 +1624,8 @@ public:
|
|||
* Add a callback for the GATT event DATA_SENT (which is triggered when
|
||||
* updates are sent out by GATT in the form of notifications).
|
||||
*
|
||||
* @param[in] callback Event handler being registered.
|
||||
*
|
||||
* @note It is possible to chain together multiple onDataSent callbacks
|
||||
* (potentially from different modules of an application) to receive updates
|
||||
* to characteristics.
|
||||
|
|
@ -1505,6 +1648,11 @@ public:
|
|||
* The same as onDataSent() but allows an object reference and member function
|
||||
* to be added to the chain of callbacks.
|
||||
*
|
||||
* @param[in] objPtr Pointer to the instance that is used to invoke the
|
||||
* event handler.
|
||||
* @param[in] memberPtr Event handler being registered. It is a member
|
||||
* function.
|
||||
*
|
||||
* @deprecated You should use the parallel API from GattServer directly and refer to
|
||||
* GattServer::onDataSent(). A former call
|
||||
* to ble.onDataSent(...) should be replaced with
|
||||
|
|
@ -1524,6 +1672,8 @@ public:
|
|||
* For a Central, this callback is triggered when a response is received for
|
||||
* a write request.
|
||||
*
|
||||
* @param[in] callback The event handler being registered.
|
||||
*
|
||||
* @note It is possible to chain together multiple onDataWritten callbacks
|
||||
* (potentially from different modules of an application) to receive updates
|
||||
* to characteristics. Many services, such as DFU and UART, add their own
|
||||
|
|
@ -1547,6 +1697,12 @@ public:
|
|||
* The same as onDataWritten() but allows an object reference and member function
|
||||
* to be added to the chain of callbacks.
|
||||
*
|
||||
* @param[in] objPtr Pointer to the instance that is used to invoke the
|
||||
* event handler (@p memberPtr).
|
||||
* @param[in] memberPtr Event handler being registered. It is a member
|
||||
* function.
|
||||
*
|
||||
*
|
||||
* @deprecated You should use the parallel API from GattServer directly, refer to
|
||||
* GattServer::onDataWritten(). A former call
|
||||
* to ble.onDataWritten(...) should be replaced with
|
||||
|
|
@ -1575,6 +1731,8 @@ public:
|
|||
* @note It is also possible to set up a callback into a member function of
|
||||
* some object.
|
||||
*
|
||||
* @param[in] callback Event handler being registered.
|
||||
*
|
||||
* @return BLE_ERROR_NOT_IMPLEMENTED if this functionality isn't available;
|
||||
* else BLE_ERROR_NONE.
|
||||
*
|
||||
|
|
@ -1593,6 +1751,14 @@ public:
|
|||
* The same as onDataRead() but allows an object reference and member function
|
||||
* to be added to the chain of callbacks.
|
||||
*
|
||||
* @param[in] objPtr Pointer to the instance that is used to invoke the
|
||||
* event handler (@p memberPtr).
|
||||
* @param[in] memberPtr Event handler being registered. It is a member
|
||||
* function.
|
||||
*
|
||||
* @return BLE_ERROR_NOT_IMPLEMENTED if this functionality isn't available;
|
||||
* else BLE_ERROR_NONE.
|
||||
*
|
||||
* @deprecated You should use the parallel API from GattServer directly and refer to
|
||||
* GattServer::onDataRead(). A former call
|
||||
* to ble.onDataRead(...) should be replaced with
|
||||
|
|
@ -1609,6 +1775,8 @@ public:
|
|||
* Set up a callback for when notifications or indications are enabled for a
|
||||
* characteristic on the local GattServer.
|
||||
*
|
||||
* @param[in] callback Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from GattServer directly and refer to
|
||||
* GattServer::onUpdatesEnabled(). A former call
|
||||
* to ble.onUpdatesEnabled(callback) should be replaced with
|
||||
|
|
@ -1624,6 +1792,8 @@ public:
|
|||
* Set up a callback for when notifications or indications are disabled for a
|
||||
* characteristic on the local GattServer.
|
||||
*
|
||||
* @param[in] callback Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from GattServer directly and refer to
|
||||
* GattServer::onUpdatesDisabled(). A former call
|
||||
* to ble.onUpdatesDisabled(callback) should be replaced with
|
||||
|
|
@ -1639,6 +1809,8 @@ public:
|
|||
* Set up a callback for when the GATT server receives a response for an
|
||||
* indication event sent previously.
|
||||
*
|
||||
* @param[in] callback Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from GattServer directly and refer to
|
||||
* GattServer::onConfirmationReceived(). A former call
|
||||
* to ble.onConfirmationReceived(callback) should be replaced with
|
||||
|
|
@ -1657,6 +1829,8 @@ public:
|
|||
* security request: bool allowBonding, bool requireMITM and
|
||||
* SecurityIOCapabilities_t.
|
||||
*
|
||||
* @param[in] callback Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from SecurityManager directly and refer to
|
||||
* SecurityManager::onSecuritySetupInitiated(). A former
|
||||
* call to ble.onSecuritySetupInitiated(callback) should be replaced with
|
||||
|
|
@ -1674,6 +1848,8 @@ public:
|
|||
* devices. The callback is passed in the success/failure status of the
|
||||
* security setup procedure.
|
||||
*
|
||||
* @param[in] callback Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from SecurityManager directly and refer to
|
||||
* SecurityManager::onSecuritySetupCompleted(). A former
|
||||
* call to ble.onSecuritySetupCompleted(callback) should be replaced with
|
||||
|
|
@ -1693,6 +1869,8 @@ public:
|
|||
* or both sides. The callback is passed in a SecurityManager::SecurityMode_t according
|
||||
* to the level of security in effect for the secured link.
|
||||
*
|
||||
* @param[in] callback Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from SecurityManager directly and refer to
|
||||
* SecurityManager::onLinkSecured(). A former
|
||||
* call to ble.onLinkSecured(callback) should be replaced with
|
||||
|
|
@ -1708,6 +1886,8 @@ public:
|
|||
* Set up a callback for successful bonding, meaning that link-specific security
|
||||
* context is stored persistently for a peer device.
|
||||
*
|
||||
* @param[in] callback Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from SecurityManager directly and refer to
|
||||
* SecurityManager::onSecurityContextStored(). A former
|
||||
* call to ble.onSecurityContextStored(callback) should be replaced with
|
||||
|
|
@ -1726,6 +1906,8 @@ public:
|
|||
* a passkey (or PIN) to authenticate the connection
|
||||
* attempt.
|
||||
*
|
||||
* @param[in] callback Event handler being registered.
|
||||
*
|
||||
* @deprecated You should use the parallel API from SecurityManager directly and refer to
|
||||
* SecurityManager::onPasskeyDisplay(). A former
|
||||
* call to ble.onPasskeyDisplay(callback) should be replaced with
|
||||
|
|
|
|||
|
|
@ -726,6 +726,7 @@ private:
|
|||
ble::address_t _random_static_identity_address;
|
||||
bool _random_address_rotating;
|
||||
|
||||
bool _scan_enabled;
|
||||
mbed::Timeout _advertising_timeout;
|
||||
mbed::Timeout _scan_timeout;
|
||||
mbed::Ticker _address_rotation_ticker;
|
||||
|
|
|
|||
|
|
@ -19,9 +19,10 @@
|
|||
|
||||
#warning ble/services/EddystoneConfigService.h is deprecated. Please use the example in 'github.com/ARMmbed/ble-examples/tree/master/BLE_EddystoneService'.
|
||||
|
||||
#include "mbed.h"
|
||||
#include "ble/BLE.h"
|
||||
#include "ble/services/EddystoneService.h"
|
||||
#include "Timer.h"
|
||||
#include "Ticker.h"
|
||||
|
||||
#define UUID_URI_BEACON(FIRST, SECOND) { \
|
||||
0xee, 0x0c, FIRST, SECOND, 0x87, 0x86, 0x40, 0xba, \
|
||||
|
|
@ -497,8 +498,8 @@ private:
|
|||
|
||||
BLEDevice &ble;
|
||||
Params_t ¶ms;
|
||||
Ticker timeSinceBootTick;
|
||||
Timeout switchFrame;
|
||||
mbed::Ticker timeSinceBootTick;
|
||||
mbed::Timeout switchFrame;
|
||||
// Default value that is restored on reset.
|
||||
PowerLevels_t &defaultAdvPowerLevels; // This goes into the advertising frames (radio power measured at 1m from device).
|
||||
PowerLevels_t &radioPowerLevels; // This configures the power levels of the radio.
|
||||
|
|
|
|||
|
|
@ -20,8 +20,11 @@
|
|||
#warning ble/services/EddystoneService.h is deprecated. Please use the example in 'github.com/ARMmbed/ble-examples/tree/master/BLE_EddystoneService'.
|
||||
|
||||
#include "ble/BLE.h"
|
||||
#include "mbed.h"
|
||||
#include "CircularBuffer.h"
|
||||
#include "Timer.h"
|
||||
#include "Ticker.h"
|
||||
#include "Timeout.h"
|
||||
|
||||
static const uint8_t BEACON_EDDYSTONE[] = {0xAA, 0xFE};
|
||||
|
||||
//Debug is disabled by default
|
||||
|
|
@ -76,7 +79,7 @@ public:
|
|||
void (*frames[EDDYSTONE_MAX_FRAMETYPE])(uint8_t *, uint32_t);
|
||||
static const int URI_DATA_MAX = 18;
|
||||
typedef uint8_t UriData_t[URI_DATA_MAX];
|
||||
CircularBuffer<FrameTypes, EDDYSTONE_MAX_FRAMETYPE> overflow;
|
||||
mbed::CircularBuffer<FrameTypes, EDDYSTONE_MAX_FRAMETYPE> overflow;
|
||||
|
||||
// UID Frame Type subfields
|
||||
static const int UID_NAMESPACEID_SIZE = 10;
|
||||
|
|
@ -543,11 +546,11 @@ private:
|
|||
BLEDevice &ble;
|
||||
uint16_t advPeriodus;
|
||||
uint8_t txPower;
|
||||
Timer timeSinceBootTimer;
|
||||
mbed::Timer timeSinceBootTimer;
|
||||
volatile uint32_t lastBootTimerRead;
|
||||
volatile bool advLock;
|
||||
volatile FrameTypes frameIndex;
|
||||
Timeout stopAdv;
|
||||
mbed::Timeout stopAdv;
|
||||
|
||||
|
||||
// URI Frame Variables
|
||||
|
|
@ -556,7 +559,7 @@ private:
|
|||
int8_t defaultUrlPower;
|
||||
bool urlIsSet; // flag that enables / disable URI Frames
|
||||
float urlAdvPeriod; // how long the url frame will be advertised for
|
||||
Ticker urlTicker;
|
||||
mbed::Ticker urlTicker;
|
||||
|
||||
// UID Frame Variables
|
||||
UIDNamespaceID_t defaultUidNamespaceID;
|
||||
|
|
@ -565,7 +568,7 @@ private:
|
|||
uint16_t uidRFU;
|
||||
bool uidIsSet; // flag that enables / disable UID Frames
|
||||
float uidAdvPeriod; // how long the uid frame will be advertised for
|
||||
Ticker uidTicker;
|
||||
mbed::Ticker uidTicker;
|
||||
|
||||
// TLM Frame Variables
|
||||
uint8_t TlmVersion;
|
||||
|
|
@ -575,7 +578,7 @@ private:
|
|||
volatile uint32_t TlmTimeSinceBoot;
|
||||
bool tlmIsSet; // flag that enables / disables TLM frames
|
||||
float TlmAdvPeriod; // number of minutes between adv frames
|
||||
Ticker tlmTicker;
|
||||
mbed::Ticker tlmTicker;
|
||||
|
||||
public:
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@
|
|||
#include "mbed-drivers/mbed.h"
|
||||
#include "mbed-drivers/Stream.h"
|
||||
#else
|
||||
#include "mbed.h"
|
||||
#include "Stream.h"
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@
|
|||
#ifdef YOTTA_CFG_MBED_OS
|
||||
#include "mbed-drivers/mbed.h"
|
||||
#else
|
||||
#include "mbed.h"
|
||||
|
||||
#endif
|
||||
|
||||
extern const uint8_t UUID_URI_BEACON_SERVICE[UUID::LENGTH_OF_LONG_UUID];
|
||||
|
|
|
|||
|
|
@ -435,6 +435,7 @@ GenericGap::GenericGap(
|
|||
_peripheral_privacy_configuration(default_peripheral_privacy_configuration),
|
||||
_central_privacy_configuration(default_central_privacy_configuration),
|
||||
_random_address_rotating(false),
|
||||
_scan_enabled(false),
|
||||
_advertising_timeout(),
|
||||
_scan_timeout(),
|
||||
_connection_event_handler(NULL),
|
||||
|
|
@ -564,15 +565,27 @@ ble_error_t GenericGap::stopAdvertising()
|
|||
ble_error_t GenericGap::stopScan()
|
||||
{
|
||||
ble_error_t err;
|
||||
|
||||
if (is_extended_advertising_available()) {
|
||||
if (!_scan_enabled) {
|
||||
return BLE_ERROR_NONE;
|
||||
}
|
||||
|
||||
_scan_enabled = false;
|
||||
|
||||
err = _pal_gap.extended_scan_enable(false, pal::duplicates_filter_t::DISABLE, 0, 0);
|
||||
|
||||
if (err) {
|
||||
_scan_enabled = true;
|
||||
return err;
|
||||
}
|
||||
} else {
|
||||
err = _pal_gap.scan_enable(false, false);
|
||||
}
|
||||
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
}
|
||||
|
||||
// Stop address rotation if required
|
||||
set_random_address_rotation(false);
|
||||
|
|
@ -1465,6 +1478,12 @@ BLE_DEPRECATED_API_USE_END()
|
|||
|
||||
void GenericGap::on_scan_timeout()
|
||||
{
|
||||
if (!_scan_enabled) {
|
||||
return;
|
||||
}
|
||||
|
||||
_scan_enabled = false;
|
||||
|
||||
if (!_eventHandler) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -2875,12 +2894,19 @@ ble_error_t GenericGap::startScan(
|
|||
}
|
||||
|
||||
if (is_extended_advertising_available()) {
|
||||
return _pal_gap.extended_scan_enable(
|
||||
_scan_enabled = true;
|
||||
|
||||
ble_error_t err = _pal_gap.extended_scan_enable(
|
||||
/* enable */true,
|
||||
filtering,
|
||||
duration.value(),
|
||||
period.value()
|
||||
);
|
||||
|
||||
if (err) {
|
||||
_scan_enabled = false;
|
||||
return err;
|
||||
}
|
||||
} else {
|
||||
if (period.value() != 0) {
|
||||
return BLE_ERROR_INVALID_PARAM;
|
||||
|
|
@ -2902,10 +2928,10 @@ ble_error_t GenericGap::startScan(
|
|||
microsecond_t(duration).value()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return BLE_ERROR_NONE;
|
||||
}
|
||||
}
|
||||
|
||||
ble_error_t GenericGap::createSync(
|
||||
peer_address_type_t peerAddressType,
|
||||
|
|
|
|||
|
|
@ -115,6 +115,23 @@ peer_address_type_t convert_identity_address(advertising_peer_address_type_t add
|
|||
}
|
||||
}
|
||||
|
||||
ble::phy_t convert_phy(uint8_t nordic_phy)
|
||||
{
|
||||
switch(nordic_phy) {
|
||||
case BLE_GAP_PHY_1MBPS:
|
||||
return ble::phy_t::LE_1M;
|
||||
|
||||
case BLE_GAP_PHY_2MBPS:
|
||||
return ble::phy_t::LE_2M;
|
||||
|
||||
case BLE_GAP_PHY_CODED:
|
||||
return ble::phy_t::LE_CODED;
|
||||
|
||||
default:
|
||||
return ble::phy_t::NONE;
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME: update when SD 5 (not alpha!) or more is used for 52840.
|
||||
#ifndef BLE_GAP_PHY_AUTO
|
||||
#define BLE_GAP_PHY_AUTO 0
|
||||
|
|
@ -1630,8 +1647,8 @@ void nRF5xGap::on_phy_update(
|
|||
_eventHandler->onPhyUpdateComplete(
|
||||
status,
|
||||
connection,
|
||||
Phy_t::LE_1M,
|
||||
Phy_t::LE_1M
|
||||
convert_phy(evt.tx_phy),
|
||||
convert_phy(evt.rx_phy)
|
||||
);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,49 @@
|
|||
Permissive Binary License
|
||||
|
||||
Version 1.0, September 2015
|
||||
|
||||
Redistribution. Redistribution and use in binary form, without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
1) Redistributions must reproduce the above copyright notice and the
|
||||
following disclaimer in the documentation and/or other materials
|
||||
provided with the distribution.
|
||||
|
||||
2) Unless to the extent explicitly permitted by law, no reverse
|
||||
engineering, decompilation, or disassembly of this software is
|
||||
permitted.
|
||||
|
||||
3) Redistribution as part of a software development kit must include the
|
||||
accompanying file named "DEPENDENCIES" and any dependencies listed in
|
||||
that file.
|
||||
|
||||
4) Neither the name of the copyright holder nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
Limited patent license. The copyright holders (and contributors) grant a
|
||||
worldwide, non-exclusive, no-charge, royalty-free patent license to
|
||||
make, have made, use, offer to sell, sell, import, and otherwise
|
||||
transfer this software, where such license applies only to those patent
|
||||
claims licensable by the copyright holders (and contributors) that are
|
||||
necessarily infringed by this software. This patent license shall not
|
||||
apply to any combinations that include this software. No hardware is
|
||||
licensed hereunder.
|
||||
|
||||
If you institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the software
|
||||
itself infringes your patent(s), then your rights granted under this
|
||||
license shall terminate as of the date such litigation is filed.
|
||||
|
||||
DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
||||
CONTRIBUTORS "AS IS." ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
|
||||
NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
|
||||
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
Binary file not shown.
|
|
@ -0,0 +1,10 @@
|
|||
{
|
||||
"name": "bootloader_SDT64B",
|
||||
"target_overrides": {
|
||||
"*": {
|
||||
"target.app_offset": "0xa400",
|
||||
"target.header_offset": "0xa000",
|
||||
"target.bootloader_img": "mbed-bootloader-sdt64b-block_device-sotp-v3_3_0.bin"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -40,6 +40,8 @@
|
|||
#define RETRY_COUNT_DEFAULT 3
|
||||
|
||||
const int STM_STOPPED = -99;
|
||||
const int ACTIVE_PDP_CONTEXT = 0x01;
|
||||
const int ATTACHED_TO_NETWORK = 0x02;
|
||||
|
||||
namespace mbed {
|
||||
|
||||
|
|
@ -48,7 +50,7 @@ CellularStateMachine::CellularStateMachine(CellularDevice &device, events::Event
|
|||
_event_status_cb(0), _network(0), _power(0), _sim(0), _queue(queue), _queue_thread(0), _sim_pin(0),
|
||||
_retry_count(0), _event_timeout(-1), _event_id(-1), _plmn(0), _command_success(false),
|
||||
_plmn_network_found(false), _is_retry(false), _cb_data(), _current_event(NSAPI_EVENT_CONNECTION_STATUS_CHANGE),
|
||||
_active_context(false)
|
||||
_network_status(0)
|
||||
{
|
||||
#if MBED_CONF_CELLULAR_RANDOM_MAX_START_DELAY == 0
|
||||
_start_time = 0;
|
||||
|
|
@ -83,7 +85,7 @@ void CellularStateMachine::reset()
|
|||
_event_id = -1;
|
||||
_plmn_network_found = false;
|
||||
_is_retry = false;
|
||||
_active_context = false;
|
||||
_network_status = 0;
|
||||
enter_to_state(STATE_INIT);
|
||||
}
|
||||
|
||||
|
|
@ -193,7 +195,7 @@ bool CellularStateMachine::is_registered()
|
|||
}
|
||||
|
||||
_cb_data.status_data = status;
|
||||
return is_registered || _active_context;
|
||||
return is_registered || _network_status;
|
||||
}
|
||||
|
||||
bool CellularStateMachine::get_network_registration(CellularNetwork::RegistrationType type,
|
||||
|
|
@ -440,8 +442,15 @@ void CellularStateMachine::state_sim_pin()
|
|||
return;
|
||||
}
|
||||
|
||||
_active_context = false;
|
||||
_active_context = _network->is_active_context(); // check if context was already activated
|
||||
if (_network->is_active_context()) { // check if context was already activated
|
||||
tr_debug("ACTIVE CONTEXT FOUND, skip registering.");
|
||||
_network_status |= ACTIVE_PDP_CONTEXT;
|
||||
}
|
||||
CellularNetwork::AttachStatus status; // check if modem is already attached to a network
|
||||
if (_network->get_attach(status) == NSAPI_ERROR_OK && status == CellularNetwork::Attached) {
|
||||
_network_status |= ATTACHED_TO_NETWORK;
|
||||
tr_debug("DEVICE IS ALREADY ATTACHED TO NETWORK, skip registering and attach.");
|
||||
}
|
||||
if (_plmn) {
|
||||
enter_to_state(STATE_MANUAL_REGISTERING_NETWORK);
|
||||
} else {
|
||||
|
|
@ -499,7 +508,9 @@ void CellularStateMachine::state_attaching()
|
|||
{
|
||||
_cellularDevice.set_timeout(TIMEOUT_CONNECT);
|
||||
tr_info("Attaching network (timeout %d s)", TIMEOUT_CONNECT / 1000);
|
||||
if (_network_status != ATTACHED_TO_NETWORK) {
|
||||
_cb_data.error = _network->set_attach();
|
||||
}
|
||||
if (_cb_data.error == NSAPI_ERROR_OK) {
|
||||
_cellularDevice.close_sim();
|
||||
_sim = NULL;
|
||||
|
|
|
|||
|
|
@ -185,7 +185,7 @@ private:
|
|||
bool _is_retry;
|
||||
cell_callback_data_t _cb_data;
|
||||
nsapi_event_t _current_event;
|
||||
bool _active_context; // Is there any active context?
|
||||
int _network_status; // Is there any active context or is modem attached to a network?
|
||||
PlatformMutex _mutex;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -27,15 +27,10 @@
|
|||
#include "crys_ecpki_domain.h"
|
||||
#include "crys_ec_mont_api.h"
|
||||
#include "mbedtls/platform.h"
|
||||
#include "mbedtls/platform_util.h"
|
||||
#include "cc_internal.h"
|
||||
|
||||
|
||||
/* Implementation that should never be optimized out by the compiler */
|
||||
static void mbedtls_zeroize( void *v, size_t n ) {
|
||||
volatile unsigned char *p = (unsigned char*)v;
|
||||
while( n-- ) *p++ = 0;
|
||||
}
|
||||
|
||||
#if defined (MBEDTLS_ECDH_GEN_PUBLIC_ALT)
|
||||
int mbedtls_ecdh_gen_public( mbedtls_ecp_group *grp, mbedtls_mpi *d, mbedtls_ecp_point *Q,
|
||||
int ( *f_rng )( void *, unsigned char *, size_t ),
|
||||
|
|
@ -84,12 +79,12 @@ int mbedtls_ecdh_gen_public( mbedtls_ecp_group *grp, mbedtls_mpi *d, mbedtls_ecp
|
|||
4*((((grp->nbits+7)/8)+3)/4) ) );
|
||||
if( ret != 0 )
|
||||
{
|
||||
mbedtls_zeroize( temp_buf, sizeof( temp_buf ) );
|
||||
mbedtls_platform_zeroize( temp_buf, sizeof( temp_buf ) );
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary( d, temp_buf, (grp->nbits+7)/8 ) );
|
||||
mbedtls_zeroize( temp_buf, sizeof( temp_buf ) );
|
||||
mbedtls_platform_zeroize( temp_buf, sizeof( temp_buf ) );
|
||||
}
|
||||
|
||||
/* if CRYS_ECPKI_GetEcDomain returns NULL, then the given curve is either Montgomery 25519
|
||||
|
|
@ -124,7 +119,7 @@ cleanup:
|
|||
|
||||
if ( pHeap )
|
||||
{
|
||||
mbedtls_zeroize( pHeap, heapSize );
|
||||
mbedtls_platform_zeroize( pHeap, heapSize );
|
||||
mbedtls_free( pHeap );
|
||||
}
|
||||
|
||||
|
|
@ -190,7 +185,7 @@ int mbedtls_ecdh_compute_shared( mbedtls_ecp_group *grp, mbedtls_mpi *z,
|
|||
temp_buf,
|
||||
mbedtls_mpi_size( d ),
|
||||
&ecdhParams->privKey ) );
|
||||
mbedtls_zeroize( temp_buf, sizeof( temp_buf ) );
|
||||
mbedtls_platform_zeroize( temp_buf, sizeof( temp_buf ) );
|
||||
if ( ret != 0 )
|
||||
{
|
||||
goto cleanup;
|
||||
|
|
@ -241,13 +236,13 @@ cleanup:
|
|||
|
||||
if ( pHeap )
|
||||
{
|
||||
mbedtls_zeroize( pHeap, heapSize );
|
||||
mbedtls_platform_zeroize( pHeap, heapSize );
|
||||
mbedtls_free ( pHeap );
|
||||
}
|
||||
|
||||
if ( secret )
|
||||
{
|
||||
mbedtls_zeroize( secret, secret_size_in_heap );
|
||||
mbedtls_platform_zeroize( secret, secret_size_in_heap );
|
||||
mbedtls_free ( secret );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -27,14 +27,9 @@
|
|||
#include "crys_ecpki_domain.h"
|
||||
#include "crys_ec_edw_api.h"
|
||||
#include "mbedtls/platform.h"
|
||||
#include "mbedtls/platform_util.h"
|
||||
#include "cc_internal.h"
|
||||
|
||||
/* Implementation that should never be optimized out by the compiler */
|
||||
static void mbedtls_zeroize( void *v, size_t n ) {
|
||||
volatile unsigned char *p = (unsigned char*)v;
|
||||
while( n-- ) *p++ = 0;
|
||||
}
|
||||
|
||||
static CRYS_ECPKI_HASH_OpMode_t message_size_to_hash_mode( size_t blen )
|
||||
{
|
||||
CRYS_ECPKI_HASH_OpMode_t hash_mode;
|
||||
|
|
@ -110,7 +105,7 @@ int mbedtls_ecdsa_sign( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s,
|
|||
if( CrysRet != CRYS_OK )
|
||||
{
|
||||
ret = convert_CrysError_to_mbedtls_err( CrysRet );
|
||||
mbedtls_zeroize( temp_buf, sizeof(temp_buf) );
|
||||
mbedtls_platform_zeroize( temp_buf, sizeof(temp_buf) );
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
|
|
@ -123,7 +118,7 @@ int mbedtls_ecdsa_sign( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s,
|
|||
blen,
|
||||
pSignature,
|
||||
&signature_size );
|
||||
mbedtls_zeroize( temp_buf, sizeof(temp_buf) );
|
||||
mbedtls_platform_zeroize( temp_buf, sizeof(temp_buf) );
|
||||
if( CrysRet != CRYS_OK )
|
||||
{
|
||||
ret = convert_CrysError_to_mbedtls_err( CrysRet );
|
||||
|
|
@ -145,13 +140,13 @@ cleanup:
|
|||
|
||||
if ( pHeap )
|
||||
{
|
||||
mbedtls_zeroize( pHeap, heapSize );
|
||||
mbedtls_platform_zeroize( pHeap, heapSize );
|
||||
mbedtls_free( pHeap );
|
||||
}
|
||||
|
||||
if( pSignature )
|
||||
{
|
||||
mbedtls_zeroize( pSignature, signature_size_for_heap );
|
||||
mbedtls_platform_zeroize( pSignature, signature_size_for_heap );
|
||||
mbedtls_free( pSignature );
|
||||
|
||||
}
|
||||
|
|
@ -232,13 +227,13 @@ cleanup:
|
|||
|
||||
if( pHeap )
|
||||
{
|
||||
mbedtls_zeroize( pHeap, heapSize );
|
||||
mbedtls_platform_zeroize( pHeap, heapSize );
|
||||
mbedtls_free( pHeap );
|
||||
}
|
||||
|
||||
if( pSignature )
|
||||
{
|
||||
mbedtls_zeroize( pSignature, signature_size );
|
||||
mbedtls_platform_zeroize( pSignature, signature_size );
|
||||
mbedtls_free( pSignature );
|
||||
|
||||
}
|
||||
|
|
@ -301,12 +296,12 @@ int mbedtls_ecdsa_genkey( mbedtls_ecdsa_context *ctx, mbedtls_ecp_group_id gid,
|
|||
if ( CrysRet != CRYS_OK )
|
||||
{
|
||||
ret = convert_CrysError_to_mbedtls_err( CrysRet );
|
||||
mbedtls_zeroize( temp_buf, sizeof(temp_buf) );
|
||||
mbedtls_platform_zeroize( temp_buf, sizeof(temp_buf) );
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
ret = mbedtls_mpi_read_binary( &ctx->d, temp_buf, (ctx->grp.nbits+7)/8 );
|
||||
mbedtls_zeroize( temp_buf, sizeof(temp_buf) );
|
||||
mbedtls_platform_zeroize( temp_buf, sizeof(temp_buf) );
|
||||
if ( ret != 0 )
|
||||
{
|
||||
goto cleanup;
|
||||
|
|
@ -319,7 +314,7 @@ int mbedtls_ecdsa_genkey( mbedtls_ecdsa_context *ctx, mbedtls_ecp_group_id gid,
|
|||
cleanup:
|
||||
if ( pHeap )
|
||||
{
|
||||
mbedtls_zeroize( pHeap, heapSize );
|
||||
mbedtls_platform_zeroize( pHeap, heapSize );
|
||||
mbedtls_free ( pHeap );
|
||||
}
|
||||
return ( ret );
|
||||
|
|
|
|||
|
|
@ -267,11 +267,12 @@ int DeviceKey::generate_key_by_random(uint32_t *output, size_t size)
|
|||
ret = mbedtls_entropy_func(entropy, (unsigned char *)output, size);
|
||||
if (ret != MBED_SUCCESS) {
|
||||
ret = DEVICEKEY_GENERATE_RANDOM_ERROR;
|
||||
} else {
|
||||
ret = DEVICEKEY_SUCCESS;
|
||||
}
|
||||
|
||||
mbedtls_entropy_free(entropy);
|
||||
delete entropy;
|
||||
ret = DEVICEKEY_SUCCESS;
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
|
|
|
|||
|
|
@ -18,129 +18,382 @@
|
|||
#ifndef LORARADIO_H_
|
||||
#define LORARADIO_H_
|
||||
|
||||
/** @addtogroup LoRaWAN
|
||||
* Parent class for a LoRa radio driver
|
||||
* @{
|
||||
*/
|
||||
|
||||
#include "platform/Callback.h"
|
||||
#include "PinNames.h"
|
||||
|
||||
/**
|
||||
* Structure to hold RF controls for LoRa Radio.
|
||||
* SX1276 have an extra control for the crystal (used in DOSCO-L072CZ)
|
||||
* SX1276 have an extra control for the crystal (used in DISCO-L072CZ).
|
||||
* A subset of these pins may be used by the driver in accordance with the physical
|
||||
* implementation.
|
||||
*/
|
||||
typedef struct {
|
||||
/** TX latch switch pin.
|
||||
* Exact operation is implementation specific.
|
||||
*/
|
||||
PinName rf_switch_ctl1;
|
||||
|
||||
/** RX latch switch pin.
|
||||
* Exact operation is implementation specific.
|
||||
*/
|
||||
PinName rf_switch_ctl2;
|
||||
|
||||
/** TX control pin for transceiver packaged as a module.
|
||||
* Exact operation is implementation specific.
|
||||
*/
|
||||
PinName txctl;
|
||||
|
||||
/** RX control pin for transceiver packaged as a module.
|
||||
* Exact operation is implementation specific.
|
||||
*/
|
||||
PinName rxctl;
|
||||
|
||||
/** Transceiver switch pin.
|
||||
* Exact operation is implementation specific. One of the polarities of the
|
||||
* pin may drive the transceiver in either TX or RX mode.
|
||||
*/
|
||||
PinName ant_switch;
|
||||
|
||||
/** Power amplifier control pin.
|
||||
* Exact operation is implementation specific. If defined,
|
||||
* controls the operation of an external power amplifier.
|
||||
*/
|
||||
PinName pwr_amp_ctl;
|
||||
|
||||
/** TCXO crystal control pin.
|
||||
* Exact operation is implementation specific.
|
||||
*/
|
||||
PinName tcxo;
|
||||
} rf_ctrls;
|
||||
|
||||
/** Radio driver internal state.
|
||||
* State machine states definition.
|
||||
* Helps identify current state of the transceiver.
|
||||
*/
|
||||
typedef enum radio_state {
|
||||
/** IDLE state.
|
||||
* Radio is in idle state.
|
||||
*/
|
||||
RF_IDLE = 0,
|
||||
|
||||
/** RX state.
|
||||
* Radio is receiving.
|
||||
*/
|
||||
RF_RX_RUNNING,
|
||||
|
||||
/** TX state.
|
||||
* Radio is transmitting.
|
||||
*/
|
||||
RF_TX_RUNNING,
|
||||
|
||||
/** CAD state.
|
||||
* Radio is detecting channel activity.
|
||||
*/
|
||||
RF_CAD,
|
||||
} radio_state_t;
|
||||
|
||||
/** Type of the modem.
|
||||
/** Type of modem.
|
||||
* [LORA/FSK]
|
||||
*/
|
||||
typedef enum modem_type {
|
||||
/** FSK operation mode.
|
||||
* Radio is using FSK modulation.
|
||||
*/
|
||||
MODEM_FSK = 0,
|
||||
|
||||
/** LoRa operation mode.
|
||||
* Radio is using LoRa modulation.
|
||||
*/
|
||||
MODEM_LORA
|
||||
} radio_modems_t;
|
||||
|
||||
/** Radio FSK modem parameters.
|
||||
*
|
||||
/** FSK modem parameters.
|
||||
* Parameters encompassing FSK modulation.
|
||||
*/
|
||||
typedef struct radio_fsk_settings {
|
||||
/**
|
||||
* Transmit power.
|
||||
*/
|
||||
int8_t power;
|
||||
|
||||
/**
|
||||
* Frequency deviation.
|
||||
*/
|
||||
uint32_t f_dev;
|
||||
|
||||
/**
|
||||
* Modulation bandwidth.
|
||||
*/
|
||||
uint32_t bandwidth;
|
||||
|
||||
/**
|
||||
* Automated frequency correction bandwidth.
|
||||
*/
|
||||
uint32_t bandwidth_afc;
|
||||
|
||||
/**
|
||||
* Data rate (SF).
|
||||
*/
|
||||
uint32_t datarate;
|
||||
|
||||
/**
|
||||
* Expected preamble length.
|
||||
*/
|
||||
uint16_t preamble_len;
|
||||
|
||||
/**
|
||||
* This flag turns on if the TX data size is fixed.
|
||||
*/
|
||||
bool fix_len;
|
||||
|
||||
/**
|
||||
* Size of outgoing data.
|
||||
*/
|
||||
uint8_t payload_len;
|
||||
|
||||
/**
|
||||
* Turn CRC on/off.
|
||||
*/
|
||||
bool crc_on;
|
||||
|
||||
/** @deprecated
|
||||
* Does not apply to FSK. Will be removed.
|
||||
*/
|
||||
bool iq_inverted;
|
||||
|
||||
/**
|
||||
* Turn continuous reception mode (such as Class C mode) on/off.
|
||||
*/
|
||||
bool rx_continuous;
|
||||
|
||||
/**
|
||||
* Timeout value in milliseconds (ms) after which the radio driver reports
|
||||
* a timeout if the radio was unable to transmit.
|
||||
*/
|
||||
uint32_t tx_timeout;
|
||||
|
||||
/**
|
||||
* Timeout value in symbols (symb) after which the radio driver reports a timeout
|
||||
* if the radio did not receive a Preamble.
|
||||
*/
|
||||
uint32_t rx_single_timeout;
|
||||
} radio_fsk_settings_t;
|
||||
|
||||
/** Radio FSK packet handler state.
|
||||
*
|
||||
/** FSK packet handle.
|
||||
* Contains information about an FSK packet and various metadata.
|
||||
*/
|
||||
typedef struct radio_fsk_packet_handler {
|
||||
/**
|
||||
* Set to true (1) when a Preamble is detected, otherwise false (0).
|
||||
*/
|
||||
uint8_t preamble_detected;
|
||||
|
||||
/**
|
||||
* Set to true (1) when a SyncWord is detected, otherwise false (0).
|
||||
*/
|
||||
uint8_t sync_word_detected;
|
||||
|
||||
/**
|
||||
* Storage for RSSI value of the received signal.
|
||||
*/
|
||||
int8_t rssi_value;
|
||||
|
||||
/**
|
||||
* Automated frequency correction value.
|
||||
*/
|
||||
int32_t afc_value;
|
||||
|
||||
/**
|
||||
* LNA gain value (dbm).
|
||||
*/
|
||||
uint8_t rx_gain;
|
||||
|
||||
/**
|
||||
* Size of the received data in bytes.
|
||||
*/
|
||||
uint16_t size;
|
||||
|
||||
/**
|
||||
* Keeps track of number of bytes already read from the RX FIFO.
|
||||
*/
|
||||
uint16_t nb_bytes;
|
||||
|
||||
/**
|
||||
* Stores the FIFO threshold value.
|
||||
*/
|
||||
uint8_t fifo_thresh;
|
||||
|
||||
/**
|
||||
* Defines the size of a chunk of outgoing buffer written to
|
||||
* the FIFO at a unit time. For example, if the size of the data exceeds the FIFO
|
||||
* limit, a certain sized chunk is written to the FIFO. Later, a FIFO-level
|
||||
* interrupt enables writing of the remaining data to the FIFO chunk by chunk until
|
||||
* transmission is complete.
|
||||
*/
|
||||
uint8_t chunk_size;
|
||||
} radio_fsk_packet_handler_t;
|
||||
|
||||
/** Radio LoRa modem parameters.
|
||||
*
|
||||
/** LoRa modem parameters.
|
||||
* Parameters encompassing LoRa modulation.
|
||||
*/
|
||||
typedef struct radio_lora_settings {
|
||||
/**
|
||||
* Transmit power.
|
||||
*/
|
||||
int8_t power;
|
||||
|
||||
/**
|
||||
* Modulation bandwidth.
|
||||
*/
|
||||
uint32_t bandwidth;
|
||||
|
||||
/**
|
||||
* Data rate (SF).
|
||||
*/
|
||||
uint32_t datarate;
|
||||
|
||||
/**
|
||||
* Turn low data rate optimization on/off.
|
||||
*/
|
||||
bool low_datarate_optimize;
|
||||
|
||||
/**
|
||||
* Error correction code rate.
|
||||
*/
|
||||
uint8_t coderate;
|
||||
|
||||
/**
|
||||
* Preamble length in symbols.
|
||||
*/
|
||||
uint16_t preamble_len;
|
||||
|
||||
/**
|
||||
* Set to true if the outgoing payload length is fixed.
|
||||
*/
|
||||
bool fix_len;
|
||||
|
||||
/**
|
||||
* Size of outgoing payload.
|
||||
*/
|
||||
uint8_t payload_len;
|
||||
|
||||
/**
|
||||
* Turn CRC on/off.
|
||||
*/
|
||||
bool crc_on;
|
||||
|
||||
/**
|
||||
* Turn frequency hopping on/off.
|
||||
*/
|
||||
bool freq_hop_on;
|
||||
|
||||
/**
|
||||
* Number of symbols between two frequency hops.
|
||||
*/
|
||||
uint8_t hop_period;
|
||||
|
||||
/**
|
||||
* Turn IQ inversion on/off. Usually, the end device sends an IQ inverted
|
||||
* signal, and the base stations do not invert. We recommended sending an
|
||||
* IQ inverted signal from the device side, so any transmissions from the
|
||||
* base stations do not interfere with end device transmission.
|
||||
*/
|
||||
bool iq_inverted;
|
||||
|
||||
/**
|
||||
* Turn continuous reception mode (such as in Class C) on/off.
|
||||
*/
|
||||
bool rx_continuous;
|
||||
|
||||
/**
|
||||
* Timeout in milliseconds (ms) after which the radio driver reports an error
|
||||
* if the radio was unable to transmit.
|
||||
*/
|
||||
uint32_t tx_timeout;
|
||||
|
||||
/**
|
||||
* Change the network mode to Public or Private.
|
||||
*/
|
||||
bool public_network;
|
||||
} radio_lora_settings_t;
|
||||
|
||||
/** Radio LoRa packet handler state.
|
||||
*
|
||||
/** LoRa packet
|
||||
* Contains information about a LoRa packet.
|
||||
*/
|
||||
typedef struct radio_lora_packet_handler {
|
||||
/**
|
||||
* Signal-to-noise ratio of a received packet.
|
||||
*/
|
||||
int8_t snr_value;
|
||||
|
||||
/**
|
||||
* RSSI value in dBm for the received packet.
|
||||
*/
|
||||
int8_t rssi_value;
|
||||
|
||||
/**
|
||||
* Size of the transmitted or received packet.
|
||||
*/
|
||||
uint8_t size;
|
||||
} radio_lora_packet_handler_t;
|
||||
|
||||
/** Radio settings.
|
||||
*
|
||||
/** Global radio settings.
|
||||
* Contains settings for the overall transceiver operation.
|
||||
*/
|
||||
typedef struct radio_settings {
|
||||
/**
|
||||
* Current state of the radio, such as RF_IDLE.
|
||||
*/
|
||||
uint8_t state;
|
||||
|
||||
/**
|
||||
* Current modem operation, such as MODEM_LORA.
|
||||
*/
|
||||
uint8_t modem;
|
||||
|
||||
/**
|
||||
* Current channel of operation.
|
||||
*/
|
||||
uint32_t channel;
|
||||
|
||||
/**
|
||||
* Settings for FSK modem part.
|
||||
*/
|
||||
radio_fsk_settings_t fsk;
|
||||
|
||||
/**
|
||||
* FSK packet and meta data.
|
||||
*/
|
||||
radio_fsk_packet_handler_t fsk_packet_handler;
|
||||
|
||||
/**
|
||||
* Settings for LoRa modem part.
|
||||
*/
|
||||
radio_lora_settings_t lora;
|
||||
|
||||
/**
|
||||
* LoRa packet and metadata.
|
||||
*/
|
||||
radio_lora_packet_handler_t lora_packet_handler;
|
||||
} radio_settings_t;
|
||||
|
||||
/** Radio driver callback functions.
|
||||
*
|
||||
/** Reporting functions for upper layers.
|
||||
* The radio driver reports various vital events to the upper controlling layers
|
||||
* using callback functions provided by the upper layers at the initialization
|
||||
* phase.
|
||||
*/
|
||||
typedef struct radio_events {
|
||||
/**
|
||||
* Callback when Transmission is done
|
||||
* Callback when Transmission is done.
|
||||
*/
|
||||
mbed::Callback<void()> tx_done;
|
||||
|
||||
/**
|
||||
* Callback when Transmission is timed out
|
||||
* Callback when Transmission is timed out.
|
||||
*/
|
||||
mbed::Callback<void()> tx_timeout;
|
||||
|
||||
|
|
@ -157,12 +410,12 @@ typedef struct radio_events {
|
|||
mbed::Callback<void(const uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr)> rx_done;
|
||||
|
||||
/**
|
||||
* Callback when Reception is timed out
|
||||
* Callback when Reception is timed out.
|
||||
*/
|
||||
mbed::Callback<void()> rx_timeout;
|
||||
|
||||
/**
|
||||
* Callback when Reception ends up in error
|
||||
* Callback when Reception ends up in error.
|
||||
*/
|
||||
mbed::Callback<void()> rx_error;
|
||||
|
||||
|
|
@ -182,16 +435,16 @@ typedef struct radio_events {
|
|||
} radio_events_t;
|
||||
|
||||
/**
|
||||
* Interface for the radios, contains the main functions that a radio needs, and five callback functions.
|
||||
* Interface for the radios, containing the main functions that a radio needs, and five callback functions.
|
||||
*/
|
||||
class LoRaRadio {
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
* Registers radio events with the Mbed LoRaWAN stack and undergoes the initialization steps if any.
|
||||
* Registers radio events with the Mbed LoRaWAN stack and undergoes initialization steps, if any.
|
||||
*
|
||||
* @param events The structure containing the driver callback functions.
|
||||
* @param events Contains driver callback functions.
|
||||
*/
|
||||
virtual void init_radio(radio_events_t *events) = 0;
|
||||
|
||||
|
|
@ -201,19 +454,19 @@ public:
|
|||
virtual void radio_reset() = 0;
|
||||
|
||||
/**
|
||||
* Put the RF module in the sleep mode.
|
||||
* Put the RF module in sleep mode.
|
||||
*/
|
||||
virtual void sleep(void) = 0;
|
||||
|
||||
/**
|
||||
* Sets the radio in the standby mode.
|
||||
* Sets the radio to standby mode.
|
||||
*/
|
||||
virtual void standby(void) = 0;
|
||||
|
||||
/**
|
||||
* Sets the reception parameters.
|
||||
* Sets reception parameters.
|
||||
*
|
||||
* @param modem The radio modem to be used [0: FSK, 1: LoRa].
|
||||
* @param modem The radio modem [0: FSK, 1: LoRa].
|
||||
* @param bandwidth Sets the bandwidth.
|
||||
* FSK : >= 2600 and <= 250000 Hz
|
||||
* LoRa: [0: 125 kHz, 1: 250 kHz,
|
||||
|
|
@ -236,13 +489,13 @@ public:
|
|||
* LoRa: Timeout in symbols
|
||||
* @param fix_len Fixed length packets [0: variable, 1: fixed].
|
||||
* @param payload_len Sets the payload length when fixed length is used.
|
||||
* @param crc_on Enables/disables the CRC [0: OFF, 1: ON].
|
||||
* @param freq_hop_on Enables/disables the intra-packet frequency hopping [0: OFF, 1: ON] (LoRa only).
|
||||
* @param crc_on Enables/disables CRC [0: OFF, 1: ON].
|
||||
* @param freq_hop_on Enables/disables intra-packet frequency hopping [0: OFF, 1: ON] (LoRa only).
|
||||
* @param hop_period The number of symbols bewteen each hop (LoRa only).
|
||||
* @param iq_inverted Inverts the IQ signals (LoRa only).
|
||||
* FSK : N/A (set to 0)
|
||||
* LoRa: [0: not inverted, 1: inverted]
|
||||
* @param rx_continuous Sets the reception in continuous mode.
|
||||
* @param rx_continuous Sets the reception to continuous mode.
|
||||
* [false: single mode, true: continuous mode]
|
||||
*/
|
||||
virtual void set_rx_config(radio_modems_t modem, uint32_t bandwidth,
|
||||
|
|
@ -256,7 +509,7 @@ public:
|
|||
/**
|
||||
* Sets the transmission parameters.
|
||||
*
|
||||
* @param modem The radio modem to be used [0: FSK, 1: LoRa].
|
||||
* @param modem The radio modem [0: FSK, 1: LoRa].
|
||||
* @param power Sets the output power [dBm].
|
||||
* @param fdev Sets the frequency deviation (FSK only).
|
||||
* FSK : [Hz]
|
||||
|
|
@ -274,8 +527,8 @@ public:
|
|||
* LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
|
||||
* @param preamble_len Sets the preamble length.
|
||||
* @param fix_len Fixed length packets [0: variable, 1: fixed].
|
||||
* @param crc_on Enables/disables the CRC [0: OFF, 1: ON].
|
||||
* @param freq_hop_on Enables/disables the intra-packet frequency hopping [0: OFF, 1: ON] (LoRa only).
|
||||
* @param crc_on Enables/disables CRC [0: OFF, 1: ON].
|
||||
* @param freq_hop_on Enables/disables intra-packet frequency hopping [0: OFF, 1: ON] (LoRa only).
|
||||
* @param hop_period The number of symbols between each hop (LoRa only).
|
||||
* @param iq_inverted Inverts IQ signals (LoRa only)
|
||||
* FSK : N/A (set to 0).
|
||||
|
|
@ -289,9 +542,9 @@ public:
|
|||
uint8_t hop_period, bool iq_inverted, uint32_t timeout) = 0;
|
||||
|
||||
/**
|
||||
* Sends the buffer of size
|
||||
* Sends the packet.
|
||||
*
|
||||
* Prepares the packet to be sent and sets the radio in transmission.
|
||||
* Prepares the packet to be sent and sets the radio to transmission mode.
|
||||
*
|
||||
* @param buffer A pointer to the buffer.
|
||||
* @param size The buffer size.
|
||||
|
|
@ -299,21 +552,21 @@ public:
|
|||
virtual void send(uint8_t *buffer, uint8_t size) = 0;
|
||||
|
||||
/**
|
||||
* Sets the radio in reception mode.
|
||||
* Sets the radio to reception mode.
|
||||
*
|
||||
* For configuration of the receiver use the `set_rx_config()` API.
|
||||
* To configure the receiver, use the `set_rx_config()` API.
|
||||
*/
|
||||
virtual void receive(void) = 0;
|
||||
|
||||
/**
|
||||
* Sets the carrier frequency
|
||||
* Sets the carrier frequency.
|
||||
*
|
||||
* @param freq Channel RF frequency.
|
||||
*/
|
||||
virtual void set_channel(uint32_t freq) = 0;
|
||||
|
||||
/**
|
||||
* Generates a 32 bit random value based on the RSSI readings.
|
||||
* Generates a 32 bit random value based on RSSI readings.
|
||||
*
|
||||
* \remark This function sets the radio in LoRa modem mode and disables all interrupts.
|
||||
* After calling this function, either `Radio.SetRxConfig` or
|
||||
|
|
@ -333,7 +586,7 @@ public:
|
|||
/**
|
||||
* Sets the maximum payload length.
|
||||
*
|
||||
* @param modem The radio modem to be used [0: FSK, 1: LoRa].
|
||||
* @param modem The radio modem [0: FSK, 1: LoRa].
|
||||
* @param max The maximum payload length in bytes.
|
||||
*/
|
||||
virtual void set_max_payload_length(radio_modems_t modem, uint8_t max) = 0;
|
||||
|
|
@ -343,16 +596,16 @@ public:
|
|||
*
|
||||
* Updates the sync byte. Applies to LoRa modem only.
|
||||
*
|
||||
* @param enable If true, it enables a public network.
|
||||
* @param enable If true, enables a public network.
|
||||
*/
|
||||
virtual void set_public_network(bool enable) = 0;
|
||||
|
||||
/**
|
||||
* Computes the packet time on air for the given payload.
|
||||
*
|
||||
* \remark This can only be called once `SetRxConfig` or `SetTxConfig` have been called.
|
||||
* \remark This can only be called after `SetRxConfig` or `SetTxConfig`.
|
||||
*
|
||||
* @param modem The radio modem to be used [0: FSK, 1: LoRa].
|
||||
* @param modem The radio modem [0: FSK, 1: LoRa].
|
||||
* @param pkt_len The packet payload length.
|
||||
* @return The computed `airTime` for the given packet payload length.
|
||||
*/
|
||||
|
|
@ -362,10 +615,10 @@ public:
|
|||
* Performs carrier sensing.
|
||||
*
|
||||
* Checks for a certain time if the RSSI is above a given threshold.
|
||||
* This threshold determines whether or not there is a transmission going on
|
||||
* in the channel already.
|
||||
* This threshold determines whether or not there is a transmission on
|
||||
* the channel already.
|
||||
*
|
||||
* @param modem The type of the radio modem.
|
||||
* @param modem The type of radio modem.
|
||||
* @param freq The carrier frequency.
|
||||
* @param rssi_threshold The threshold value of RSSI.
|
||||
* @param max_carrier_sense_time The time set for sensing the channel (ms).
|
||||
|
|
@ -379,7 +632,7 @@ public:
|
|||
uint32_t max_carrier_sense_time) = 0;
|
||||
|
||||
/**
|
||||
* Sets the radio in CAD mode.
|
||||
* Sets the radio to CAD mode.
|
||||
*
|
||||
*/
|
||||
virtual void start_cad(void) = 0;
|
||||
|
|
@ -387,11 +640,11 @@ public:
|
|||
/**
|
||||
* Checks whether the given RF is in range.
|
||||
*
|
||||
* @param frequency The frequency to be checked.
|
||||
* @param frequency The frequency to check.
|
||||
*/
|
||||
virtual bool check_rf_frequency(uint32_t frequency) = 0;
|
||||
|
||||
/** Sets the radio in continuous wave transmission mode.
|
||||
/** Sets the radio to continuous wave transmission mode.
|
||||
*
|
||||
* @param freq The RF frequency of the channel.
|
||||
* @param power The output power [dBm].
|
||||
|
|
@ -405,9 +658,10 @@ public:
|
|||
virtual void lock(void) = 0;
|
||||
|
||||
/**
|
||||
* Releases the exclusive access to this radio.
|
||||
* Releases exclusive access to this radio.
|
||||
*/
|
||||
virtual void unlock(void) = 0;
|
||||
};
|
||||
|
||||
#endif // LORARADIO_H_
|
||||
/** @}*/
|
||||
|
|
|
|||
|
|
@ -282,6 +282,8 @@ lorawan_time_t LoRaPHY::update_band_timeoff(bool joined, bool duty_cycle,
|
|||
|
||||
if (bands[i].off_time != 0) {
|
||||
next_tx_delay = MIN(bands[i].off_time - txDoneTime, next_tx_delay);
|
||||
// add a random delay from 200ms to a 1000ms
|
||||
next_tx_delay += (rand() % 800 + 200);
|
||||
}
|
||||
} else {
|
||||
// if network has been joined
|
||||
|
|
|
|||
|
|
@ -159,6 +159,14 @@
|
|||
#define TCP_WND MBED_CONF_LWIP_TCP_WND
|
||||
#endif
|
||||
|
||||
#ifdef MBED_CONF_LWIP_TCP_MAXRTX
|
||||
#define TCP_MAXRTX MBED_CONF_LWIP_TCP_MAXRTX
|
||||
#endif
|
||||
|
||||
#ifdef MBED_CONF_LWIP_TCP_SYNMAXRTX
|
||||
#define TCP_SYNMAXRTX MBED_CONF_LWIP_TCP_SYNMAXRTX
|
||||
#endif
|
||||
|
||||
// Number of pool pbufs.
|
||||
// Each requires 684 bytes of RAM (if MSS=536 and PBUF_POOL_BUFSIZE defaulting to be based on MSS)
|
||||
#ifdef MBED_CONF_LWIP_PBUF_POOL_SIZE
|
||||
|
|
|
|||
|
|
@ -88,6 +88,14 @@
|
|||
"help": "TCP sender buffer space (bytes). Current default (used if null here) is set to (4 * TCP_MSS) in opt.h, unless overridden by target Ethernet drivers.",
|
||||
"value": null
|
||||
},
|
||||
"tcp-maxrtx": {
|
||||
"help": "Maximum number of retransmissions of data segments.",
|
||||
"value": 6
|
||||
},
|
||||
"tcp-synmaxrtx": {
|
||||
"help": "Maximum number of retransmissions of SYN segments. Current default (used if null here) is set to 6 in opt.h",
|
||||
"value": null
|
||||
},
|
||||
"pbuf-pool-size": {
|
||||
"help": "Number of pbufs in pool - usually used for received packets, so this determines how much data can be buffered between reception and the application reading. If a driver uses PBUF_RAM for reception, less pool may be needed. Current default (used if null here) is set to 5 in lwipopts.h, unless overridden by target Ethernet drivers.",
|
||||
"value": null
|
||||
|
|
@ -125,7 +133,7 @@
|
|||
"mem-size": 25600
|
||||
},
|
||||
"Freescale": {
|
||||
"mem-size": 36560
|
||||
"mem-size": 16384
|
||||
},
|
||||
"LPC1768": {
|
||||
"mem-size": 16362
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
|
||||
# Set the mbed TLS release to import (this can/should be edited before import)
|
||||
MBED_TLS_RELEASE ?= mbedtls-2.15.1
|
||||
MBED_TLS_REPO_URL ?= git@github.com:ARMmbed/mbedtls-restricted.git
|
||||
|
||||
# Translate between mbed TLS namespace and mbed namespace
|
||||
TARGET_PREFIX:=../
|
||||
|
|
@ -51,7 +52,6 @@ TARGET_PSA_DRIVERS:=$(TARGET_PREFIX_CRYPTO)/targets
|
|||
TARGET_NSPE:=$(TARGET_SRV_IMPL)/COMPONENT_NSPE
|
||||
|
||||
# mbed TLS source directory - hidden from mbed via TARGET_IGNORE
|
||||
MBED_TLS_URL:=git@github.com:ARMmbed/mbedtls-restricted.git
|
||||
MBED_TLS_DIR:=TARGET_IGNORE/mbedtls
|
||||
MBED_TLS_API:=$(MBED_TLS_DIR)/include/mbedtls
|
||||
MBED_TLS_GIT_CFG=$(MBED_TLS_DIR)/.git/config
|
||||
|
|
@ -139,7 +139,7 @@ update: $(MBED_TLS_GIT_CFG) $(MBED_TLS_HA_GIT_CFG)
|
|||
|
||||
$(MBED_TLS_GIT_CFG):
|
||||
rm -rf $(MBED_TLS_DIR)
|
||||
git clone $(MBED_TLS_URL) $(MBED_TLS_DIR)
|
||||
git clone $(MBED_TLS_REPO_URL) $(MBED_TLS_DIR)
|
||||
|
||||
clean:
|
||||
rm -f $(TARGET_PREFIX)LICENSE
|
||||
|
|
|
|||
|
|
@ -16,7 +16,6 @@
|
|||
|
||||
#ifndef MESHINTERFACENANOSTACK_H
|
||||
#define MESHINTERFACENANOSTACK_H
|
||||
#include "mbed.h"
|
||||
|
||||
#include "MeshInterface.h"
|
||||
#include "NanostackRfPhy.h"
|
||||
|
|
|
|||
|
|
@ -184,7 +184,7 @@ MBED_WEAK MeshInterface *MeshInterface::get_target_default_instance()
|
|||
if (!inited) {
|
||||
nsapi_error_t result = interface.initialize(&NanostackRfPhy::get_default_instance());
|
||||
if (result != 0) {
|
||||
tr_error("LoWPANND initialize failed: %d", error);
|
||||
tr_error("LoWPANND initialize failed: %d", result);
|
||||
singleton_unlock();
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@
|
|||
#include "nanostack/net_interface.h"
|
||||
#include "thread_management_if.h"
|
||||
#include "ip6string.h"
|
||||
#include "mbed_error.h"
|
||||
|
||||
char *Nanostack::Interface::get_ip_address(char *buf, nsapi_size_t buflen)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#include "arm_hal_phy.h"
|
||||
#include "EMAC.h"
|
||||
#include "enet_tasklet.h"
|
||||
#include "mbed_interface.h"
|
||||
|
||||
class EMACPhy : public NanostackEthernetPhy {
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -278,7 +278,7 @@ MBED_WEAK MeshInterface *MeshInterface::get_target_default_instance()
|
|||
if (!inited) {
|
||||
nsapi_error_t result = interface.initialize(&NanostackRfPhy::get_default_instance());
|
||||
if (result != 0) {
|
||||
tr_error("Thread initialize failed: %d", error);
|
||||
tr_error("Thread initialize failed: %d", result);
|
||||
singleton_unlock();
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ Nanostack::WisunInterface *WisunInterface::get_interface() const
|
|||
nsapi_error_t WisunInterface::do_initialize()
|
||||
{
|
||||
if (!_interface) {
|
||||
_interface = new (nothrow) Nanostack::WisunInterface(*_phy);
|
||||
_interface = new (std::nothrow) Nanostack::WisunInterface(*_phy);
|
||||
if (!_interface) {
|
||||
return NSAPI_ERROR_NO_MEMORY;
|
||||
}
|
||||
|
|
@ -184,7 +184,7 @@ MBED_WEAK MeshInterface *MeshInterface::get_target_default_instance()
|
|||
if (!inited) {
|
||||
nsapi_error_t result = interface.initialize(&NanostackRfPhy::get_default_instance());
|
||||
if (result != 0) {
|
||||
tr_error("Wi-SUN initialize failed: %d", error);
|
||||
tr_error("Wi-SUN initialize failed: %d", result);
|
||||
singleton_unlock();
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,6 @@
|
|||
#ifndef __INCLUDE_CALLBACK_HANDLER_H__
|
||||
#define __INCLUDE_CALLBACK_HANDLER_H__
|
||||
|
||||
#include "mbed.h"
|
||||
#include "mesh_interface_types.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -16,10 +16,13 @@
|
|||
#include "ns_types.h"
|
||||
#include "fhss_api.h"
|
||||
#include "fhss_config.h"
|
||||
#include "mbed.h"
|
||||
#include "mbed_trace.h"
|
||||
#include "platform/arm_hal_interrupt.h"
|
||||
#include <Timer.h>
|
||||
#include "equeue.h"
|
||||
#include "EventQueue.h"
|
||||
#include "mbed_shared_queues.h"
|
||||
#include "Timeout.h"
|
||||
|
||||
#define TRACE_GROUP "fhdr"
|
||||
#ifndef NUMBER_OF_SIMULTANEOUS_TIMEOUTS
|
||||
|
|
|
|||
|
|
@ -18,7 +18,6 @@
|
|||
#ifndef NANOSTACK_INTERFACE_H_
|
||||
#define NANOSTACK_INTERFACE_H_
|
||||
|
||||
#include "mbed.h"
|
||||
#include "MeshInterface.h"
|
||||
// Include here for backward compatibility
|
||||
#include "LoWPANNDInterface.h"
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "mbed.h"
|
||||
|
||||
#include "ns_types.h"
|
||||
#include <string.h>
|
||||
#include "common_functions.h"
|
||||
|
|
@ -33,6 +33,10 @@ extern "C" {
|
|||
|
||||
#define SIGNAL_COUNT_RADIO 1
|
||||
|
||||
#include "Thread.h"
|
||||
#include "ThisThread.h"
|
||||
#include "mbed_error.h"
|
||||
using namespace rtos;
|
||||
static void rf_thread_loop();
|
||||
Thread rf_thread(osPriorityRealtime, RF_THREAD_STACK_SIZE);
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,6 @@
|
|||
#ifndef NANOSTACK_PHY_NCS36510_H_
|
||||
#define NANOSTACK_PHY_NCS36510_H_
|
||||
|
||||
#include "mbed.h"
|
||||
#include "NanostackRfPhy.h"
|
||||
|
||||
class NanostackRfPhyNcs36510 : public NanostackRfPhy {
|
||||
|
|
|
|||
|
|
@ -16,9 +16,10 @@
|
|||
|
||||
#include "NetworkStack.h"
|
||||
#include "nsapi_dns.h"
|
||||
#include "mbed.h"
|
||||
#include "stddef.h"
|
||||
#include <new>
|
||||
#include "EventQueue.h"
|
||||
#include "mbed_shared_queues.h"
|
||||
|
||||
// Default NetworkStack operations
|
||||
const char *NetworkStack::get_ip_address()
|
||||
|
|
|
|||
|
|
@ -24,6 +24,10 @@
|
|||
#include "mbed_trace.h"
|
||||
#define TRACE_GROUP "UCID"
|
||||
|
||||
#include "mbed_wait_api.h"
|
||||
|
||||
using namespace mbed;
|
||||
|
||||
/**
|
||||
* PDP (packet data profile) Context
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -18,7 +18,9 @@
|
|||
|
||||
#include "CellularBase.h"
|
||||
#include "platform/ATCmdParser.h"
|
||||
#include "mbed.h"
|
||||
#include "ATCmdParser.h"
|
||||
#include "FileHandle.h"
|
||||
#include "Callback.h"
|
||||
|
||||
#if NSAPI_PPP_AVAILABLE
|
||||
|
||||
|
|
@ -114,7 +116,7 @@ public:
|
|||
* use - this permits a derived class to pass a pointer to a not-yet-constructed member object.
|
||||
*/
|
||||
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
|
||||
PPPCellularInterface(FileHandle *fh, bool debug = false);
|
||||
PPPCellularInterface(mbed::FileHandle *fh, bool debug = false);
|
||||
|
||||
/** Destructor
|
||||
*
|
||||
|
|
@ -286,7 +288,7 @@ public:
|
|||
* @param status_cb The callback for status changes
|
||||
*/
|
||||
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
|
||||
virtual void attach(Callback<void(nsapi_event_t, intptr_t)> status_cb);
|
||||
virtual void attach(mbed::Callback<void(nsapi_event_t, intptr_t)> status_cb);
|
||||
|
||||
/** Get the connection status
|
||||
*
|
||||
|
|
@ -308,8 +310,8 @@ public:
|
|||
virtual nsapi_error_t set_blocking(bool blocking);
|
||||
|
||||
private:
|
||||
FileHandle *_fh;
|
||||
ATCmdParser *_at;
|
||||
mbed::FileHandle *_fh;
|
||||
mbed::ATCmdParser *_at;
|
||||
const char *_new_pin;
|
||||
const char *_pin;
|
||||
const char *_apn;
|
||||
|
|
@ -317,7 +319,7 @@ private:
|
|||
const char *_pwd;
|
||||
bool _debug_trace_on;
|
||||
nsapi_ip_stack_t _stack;
|
||||
Callback<void(nsapi_event_t, intptr_t)> _connection_status_cb;
|
||||
mbed::Callback<void(nsapi_event_t, intptr_t)> _connection_status_cb;
|
||||
nsapi_connection_status_t _connect_status;
|
||||
bool _connect_is_blocking;
|
||||
void base_initialization();
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ public:
|
|||
virtual ~UARTCellularInterface();
|
||||
|
||||
private:
|
||||
UARTSerial _serial;
|
||||
mbed::UARTSerial _serial;
|
||||
PinName _dcd_pin;
|
||||
bool _active_high;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
{
|
||||
"name": "kinetis-emac",
|
||||
"config": {
|
||||
"rx-ring-len": 16,
|
||||
"tx-ring-len": 8
|
||||
"rx-ring-len": 2,
|
||||
"tx-ring-len": 1
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,102 @@
|
|||
/* mbed Microcontroller Library
|
||||
* Copyright (c) 2018 GigaDevice Semiconductor Inc.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include "gd32f4xx.h"
|
||||
|
||||
/**
|
||||
* Initializes the HW pin for enet
|
||||
*
|
||||
*/
|
||||
void enet_bsp_init(void)
|
||||
{
|
||||
/* enable GPIOs clocks */
|
||||
rcu_periph_clock_enable(RCU_GPIOA);
|
||||
rcu_periph_clock_enable(RCU_GPIOB);
|
||||
rcu_periph_clock_enable(RCU_GPIOC);
|
||||
|
||||
/* enable SYSCFG clock */
|
||||
rcu_periph_clock_enable(RCU_SYSCFG);
|
||||
syscfg_enet_phy_interface_config(SYSCFG_ENET_PHY_RMII);
|
||||
/** ETH GPIO Configuration
|
||||
RMII_REF_CLK ----------------------> PA1
|
||||
RMII_MDIO -------------------------> PA2
|
||||
RMII_MDC --------------------------> PC1
|
||||
RMII_MII_CRS_DV -------------------> PA7
|
||||
RMII_MII_RXD0 ---------------------> PC4
|
||||
RMII_MII_RXD1 ---------------------> PC5
|
||||
RMII_MII_TX_EN --------------------> PB11
|
||||
RMII_MII_TXD0 ---------------------> PB12
|
||||
RMII_MII_TXD1 ---------------------> PB13
|
||||
*/
|
||||
|
||||
/* PA1: ETH_RMII_REF_CLK */
|
||||
gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_1);
|
||||
gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_200MHZ, GPIO_PIN_1);
|
||||
|
||||
/* PA2: ETH_MDIO */
|
||||
gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_2);
|
||||
gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_200MHZ, GPIO_PIN_2);
|
||||
|
||||
/* PA7: ETH_RMII_CRS_DV */
|
||||
gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_7);
|
||||
gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_200MHZ, GPIO_PIN_7);
|
||||
|
||||
gpio_af_set(GPIOA, GPIO_AF_11, GPIO_PIN_1);
|
||||
gpio_af_set(GPIOA, GPIO_AF_11, GPIO_PIN_2);
|
||||
gpio_af_set(GPIOA, GPIO_AF_11, GPIO_PIN_7);
|
||||
|
||||
/* PB11: ETH_RMII_TX_EN */
|
||||
gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_11);
|
||||
gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_200MHZ, GPIO_PIN_11);
|
||||
|
||||
/* PB12: ETH_RMII_TXD0 */
|
||||
gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_12);
|
||||
gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_200MHZ, GPIO_PIN_12);
|
||||
|
||||
/* PB13: ETH_RMII_TXD1 */
|
||||
gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_13);
|
||||
gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_200MHZ, GPIO_PIN_13);
|
||||
|
||||
gpio_af_set(GPIOB, GPIO_AF_11, GPIO_PIN_11);
|
||||
gpio_af_set(GPIOB, GPIO_AF_11, GPIO_PIN_12);
|
||||
gpio_af_set(GPIOB, GPIO_AF_11, GPIO_PIN_13);
|
||||
|
||||
/* PC1: ETH_MDC */
|
||||
gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_1);
|
||||
gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_200MHZ, GPIO_PIN_1);
|
||||
|
||||
/* PC4: ETH_RMII_RXD0 */
|
||||
gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_4);
|
||||
gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_200MHZ, GPIO_PIN_4);
|
||||
|
||||
/* PC5: ETH_RMII_RXD1 */
|
||||
gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_5);
|
||||
gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_200MHZ, GPIO_PIN_5);
|
||||
|
||||
gpio_af_set(GPIOC, GPIO_AF_11, GPIO_PIN_1);
|
||||
gpio_af_set(GPIOC, GPIO_AF_11, GPIO_PIN_4);
|
||||
gpio_af_set(GPIOC, GPIO_AF_11, GPIO_PIN_5);
|
||||
|
||||
/* enable the ETHERNET global interrupt */
|
||||
nvic_irq_enable(ENET_IRQn, 0x7, 0);
|
||||
|
||||
/* enable ETHERNET clock */
|
||||
rcu_periph_clock_enable(RCU_ENET);
|
||||
rcu_periph_clock_enable(RCU_ENETTX);
|
||||
rcu_periph_clock_enable(RCU_ENETRX);
|
||||
}
|
||||
|
|
@ -65,7 +65,7 @@ void basic_erase_program_read_test(BlockDevice *block_device, bd_size_t block_si
|
|||
write_block[i_ind] = 0xff & rand();
|
||||
}
|
||||
// Write, sync, and read the block
|
||||
utest_printf("\ntest %0*llx:%llu...", addrwidth, block, block_size);
|
||||
utest_printf("test %0*llx:%llu...\n", addrwidth, block, block_size);
|
||||
_mutex->unlock();
|
||||
|
||||
err = block_device->erase(block, block_size);
|
||||
|
|
@ -100,7 +100,7 @@ void test_random_program_read_erase()
|
|||
|
||||
BlockDevice *block_device = BlockDevice::get_default_instance();
|
||||
|
||||
TEST_SKIP_UNLESS_MESSAGE(block_device != NULL, "\nno block device found.\n");
|
||||
TEST_SKIP_UNLESS_MESSAGE(block_device != NULL, "no block device found.");
|
||||
|
||||
int err = block_device->init();
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
|
@ -123,7 +123,7 @@ void test_random_program_read_erase()
|
|||
uint8_t *write_block = new (std::nothrow) uint8_t[block_size];
|
||||
uint8_t *read_block = new (std::nothrow) uint8_t[block_size];
|
||||
if (!write_block || !read_block) {
|
||||
utest_printf("\n Not enough memory for test");
|
||||
utest_printf("Not enough memory for test\n");
|
||||
goto end;
|
||||
}
|
||||
|
||||
|
|
@ -152,7 +152,7 @@ static void test_thread_job(void *block_device_ptr)
|
|||
uint8_t *read_block = new (std::nothrow) uint8_t[block_size];
|
||||
|
||||
if (!write_block || !read_block) {
|
||||
utest_printf("\n Not enough memory for test");
|
||||
utest_printf("Not enough memory for test\n");
|
||||
goto end;
|
||||
}
|
||||
|
||||
|
|
@ -173,6 +173,10 @@ void test_multi_threads()
|
|||
|
||||
TEST_SKIP_UNLESS_MESSAGE(block_device != NULL, "\nno block device found.\n");
|
||||
|
||||
char *dummy = new (std::nothrow) char[TEST_NUM_OF_THREADS * OS_STACK_SIZE];
|
||||
TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory for test.\n");
|
||||
delete[] dummy;
|
||||
|
||||
int err = block_device->init();
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
||||
|
|
@ -196,7 +200,7 @@ void test_multi_threads()
|
|||
for (i_ind = 0; i_ind < TEST_NUM_OF_THREADS; i_ind++) {
|
||||
threadStatus = bd_thread[i_ind].start(callback(test_thread_job, (void *)block_device));
|
||||
if (threadStatus != 0) {
|
||||
utest_printf("\n Thread %d Start Failed!", i_ind + 1);
|
||||
utest_printf("Thread %d Start Failed!\n", i_ind + 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -219,15 +223,15 @@ void test_get_erase_value()
|
|||
// 3. Read erased region and compare with get_erase_value()
|
||||
|
||||
BlockDevice *block_device = BlockDevice::get_default_instance();
|
||||
TEST_SKIP_UNLESS_MESSAGE(block_device != NULL, "\nno block device found.\n");
|
||||
TEST_SKIP_UNLESS_MESSAGE(block_device != NULL, "no block device found.");
|
||||
|
||||
int err = block_device->init();
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
||||
// Check erase value
|
||||
int erase_value_int = block_device->get_erase_value();
|
||||
utest_printf("\nblock_device->get_erase_value()=%d", erase_value_int);
|
||||
TEST_SKIP_UNLESS_MESSAGE(erase_value_int >= 0, "\nerase value is negative which means the erase value is unknown\n");
|
||||
utest_printf("block_device->get_erase_value()=%d\n", erase_value_int);
|
||||
TEST_SKIP_UNLESS_MESSAGE(erase_value_int >= 0, "Erase not supported in this block device. Test skipped.");
|
||||
|
||||
// Assuming that get_erase_value() returns byte value as documentation mentions
|
||||
// "If get_erase_value() returns a non-negative byte value" for unknown case.
|
||||
|
|
@ -245,33 +249,33 @@ void test_get_erase_value()
|
|||
start_address %= block_device->size() - data_buf_size - erase_size; // fit all data + alignment reserve
|
||||
start_address += erase_size; // add alignment reserve
|
||||
start_address -= start_address % erase_size; // align with erase_block
|
||||
utest_printf("\nstart_address=0x%016" PRIx64, start_address);
|
||||
utest_printf("start_address=0x%016" PRIx64 "\n", start_address);
|
||||
|
||||
// Allocate buffer for read test data
|
||||
uint8_t *data_buf = (uint8_t *)malloc(data_buf_size);
|
||||
TEST_ASSERT_NOT_NULL(data_buf);
|
||||
TEST_SKIP_UNLESS_MESSAGE(data_buf, "Not enough memory for test.\n");
|
||||
|
||||
// Write random data to selected region to make sure data is not accidentally set to "erased" value.
|
||||
// With this pre-write, the test case will fail even if block_device->erase() is broken.
|
||||
for (bd_size_t i = 0; i < data_buf_size; i++) {
|
||||
data_buf[i] = (uint8_t) rand();
|
||||
}
|
||||
utest_printf("\nwriting given memory region");
|
||||
utest_printf("writing given memory region\n");
|
||||
err = block_device->program((const void *)data_buf, start_address, data_buf_size);
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
||||
// Erase given memory region
|
||||
utest_printf("\nerasing given memory region");
|
||||
utest_printf("erasing given memory region\n");
|
||||
err = block_device->erase(start_address, data_buf_size);
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
||||
// Read erased memory region
|
||||
utest_printf("\nreading erased memory region");
|
||||
utest_printf("reading erased memory region\n");
|
||||
err = block_device->read((void *)data_buf, start_address, data_buf_size);
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
||||
// Verify erased memory region
|
||||
utest_printf("\nverifying erased memory region");
|
||||
utest_printf("verifying erased memory region\n");
|
||||
for (bd_size_t i = 0; i < data_buf_size; i++) {
|
||||
TEST_ASSERT_EQUAL(erase_value, data_buf[i]);
|
||||
}
|
||||
|
|
@ -295,7 +299,7 @@ void test_contiguous_erase_write_read()
|
|||
// 3. Return step 2 for whole erase region
|
||||
|
||||
BlockDevice *block_device = BlockDevice::get_default_instance();
|
||||
TEST_SKIP_UNLESS_MESSAGE(block_device != NULL, "\nno block device found.\n");
|
||||
TEST_SKIP_UNLESS_MESSAGE(block_device != NULL, "no block device found.");
|
||||
|
||||
// Initialize BlockDevice
|
||||
int err = block_device->init();
|
||||
|
|
@ -306,9 +310,9 @@ void test_contiguous_erase_write_read()
|
|||
TEST_ASSERT(erase_size > 0);
|
||||
bd_size_t program_size = block_device->get_program_size();
|
||||
TEST_ASSERT(program_size > 0);
|
||||
utest_printf("\nerase_size=%d", erase_size);
|
||||
utest_printf("\nprogram_size=%d", program_size);
|
||||
utest_printf("\nblock_device->size()=%" PRId64, block_device->size());
|
||||
utest_printf("erase_size=%" PRId64 "\n", erase_size);
|
||||
utest_printf("program_size=%" PRId64 "\n", program_size);
|
||||
utest_printf("block_device->size()=%" PRId64 "\n", block_device->size());
|
||||
|
||||
// Determine write/read buffer size
|
||||
// start write_read_buf_size from 1% block_device->size()
|
||||
|
|
@ -324,18 +328,18 @@ void test_contiguous_erase_write_read()
|
|||
bd_size_t contiguous_write_read_blocks_per_region = write_read_buf_size /
|
||||
program_size; // 2 is minimum to test contiguous write
|
||||
write_read_buf_size = contiguous_write_read_blocks_per_region * program_size;
|
||||
utest_printf("\ncontiguous_write_read_blocks_per_region=%" PRIu64, contiguous_write_read_blocks_per_region);
|
||||
utest_printf("\nwrite_read_buf_size=%" PRIu64, write_read_buf_size);
|
||||
utest_printf("contiguous_write_read_blocks_per_region=%" PRIu64 "\n", contiguous_write_read_blocks_per_region);
|
||||
utest_printf("write_read_buf_size=%" PRIu64 "\n", write_read_buf_size);
|
||||
|
||||
// Determine test region count
|
||||
int contiguous_write_read_regions = TEST_BLOCK_COUNT;
|
||||
utest_printf("\ncontiguous_write_read_regions=%d", contiguous_write_read_regions);
|
||||
utest_printf("contiguous_write_read_regions=%d\n", contiguous_write_read_regions);
|
||||
|
||||
// Determine whole erase size
|
||||
bd_size_t contiguous_erase_size = write_read_buf_size * contiguous_write_read_regions;
|
||||
contiguous_erase_size -= contiguous_erase_size % erase_size; // aligned to erase_size
|
||||
contiguous_erase_size += erase_size; // but larger than write/read size * regions
|
||||
utest_printf("\ncontiguous_erase_size=%" PRIu64, contiguous_erase_size);
|
||||
utest_printf("contiguous_erase_size=%" PRIu64 "\n", contiguous_erase_size);
|
||||
|
||||
// Determine starting address
|
||||
bd_addr_t start_address = rand(); // low 32 bytes
|
||||
|
|
@ -344,16 +348,16 @@ void test_contiguous_erase_write_read()
|
|||
start_address += erase_size; // add alignment reserve
|
||||
start_address -= start_address % erase_size; // align with erase_block
|
||||
bd_addr_t stop_address = start_address + write_read_buf_size * contiguous_write_read_regions;
|
||||
utest_printf("\nstart_address=0x%016" PRIx64, start_address);
|
||||
utest_printf("\nstop_address=0x%016" PRIx64, stop_address);
|
||||
utest_printf("start_address=0x%016" PRIx64 "\n", start_address);
|
||||
utest_printf("stop_address=0x%016" PRIx64 "\n", stop_address);
|
||||
|
||||
// Allocate write/read buffer
|
||||
uint8_t *write_read_buf = (uint8_t *)malloc(write_read_buf_size);
|
||||
if (write_read_buf == NULL) {
|
||||
block_device->deinit();
|
||||
TEST_SKIP_MESSAGE("\nnot enough memory for test");
|
||||
TEST_SKIP_MESSAGE("not enough memory for test");
|
||||
}
|
||||
utest_printf("\nwrite_read_buf_size=%" PRIu64 "", (uint64_t)write_read_buf_size);
|
||||
utest_printf("write_read_buf_size=%" PRIu64 "\n", (uint64_t)write_read_buf_size);
|
||||
|
||||
// Pre-fill the to-be-erased region. By pre-filling the region,
|
||||
// we can be sure the test will not pass if the erase doesn't work.
|
||||
|
|
@ -361,53 +365,53 @@ void test_contiguous_erase_write_read()
|
|||
for (size_t i = 0; i < write_read_buf_size; i++) {
|
||||
write_read_buf[i] = (uint8_t)rand();
|
||||
}
|
||||
utest_printf("\npre-filling memory, from 0x%" PRIx64 " of size 0x%" PRIx64, start_address + offset,
|
||||
utest_printf("pre-filling memory, from 0x%" PRIx64 " of size 0x%" PRIx64 "\n", start_address + offset,
|
||||
write_read_buf_size);
|
||||
err = block_device->program((const void *)write_read_buf, start_address + offset, write_read_buf_size);
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
}
|
||||
|
||||
// Erase the whole region first
|
||||
utest_printf("\nerasing memory, from 0x%" PRIx64 " of size 0x%" PRIx64, start_address, contiguous_erase_size);
|
||||
utest_printf("erasing memory, from 0x%" PRIx64 " of size 0x%" PRIx64 "\n", start_address, contiguous_erase_size);
|
||||
err = block_device->erase(start_address, contiguous_erase_size);
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
||||
// Loop through all write/read regions
|
||||
int region = 0;
|
||||
for (; start_address < stop_address; start_address += write_read_buf_size) {
|
||||
utest_printf("\n\nregion #%d start_address=0x%016" PRIx64, region++, start_address);
|
||||
utest_printf("\nregion #%d start_address=0x%016" PRIx64 "\n", region++, start_address);
|
||||
|
||||
// Generate test data
|
||||
unsigned int seed = rand();
|
||||
utest_printf("\ngenerating test data, seed=%u", seed);
|
||||
utest_printf("generating test data, seed=%u\n", seed);
|
||||
srand(seed);
|
||||
for (size_t i = 0; i < write_read_buf_size; i++) {
|
||||
write_read_buf[i] = (uint8_t)rand();
|
||||
}
|
||||
|
||||
// Write test data
|
||||
utest_printf("\nwriting test data");
|
||||
utest_printf("writing test data\n");
|
||||
err = block_device->program((const void *)write_read_buf, start_address, write_read_buf_size);
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
||||
// Read test data
|
||||
memset(write_read_buf, 0, (size_t)write_read_buf_size);
|
||||
utest_printf("\nreading test data");
|
||||
utest_printf("reading test data\n");
|
||||
err = block_device->read(write_read_buf, start_address, write_read_buf_size);
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
||||
// Verify read data
|
||||
utest_printf("\nverifying test data");
|
||||
utest_printf("verifying test data\n");
|
||||
srand(seed);
|
||||
for (size_t i = 0; i < write_read_buf_size; i++) {
|
||||
uint8_t expected_value = (uint8_t)rand();
|
||||
if (write_read_buf[i] != expected_value) {
|
||||
utest_printf("\ndata verify failed, write_read_buf[%d]=%" PRIu8 " and not %" PRIu8 "\n",
|
||||
utest_printf("data verify failed, write_read_buf[%d]=%" PRIu8 " and not %" PRIu8 "\n",
|
||||
i, write_read_buf[i], expected_value);
|
||||
}
|
||||
TEST_ASSERT_EQUAL(write_read_buf[i], expected_value);
|
||||
}
|
||||
utest_printf("\nverify OK");
|
||||
utest_printf("verify OK\n");
|
||||
}
|
||||
|
||||
free(write_read_buf);
|
||||
|
|
@ -423,22 +427,34 @@ void test_program_read_small_data_sizes()
|
|||
|
||||
BlockDevice *bd = BlockDevice::get_default_instance();
|
||||
|
||||
TEST_SKIP_UNLESS_MESSAGE(bd != NULL, "\nno block device found.\n");
|
||||
TEST_SKIP_UNLESS_MESSAGE(bd != NULL, "no block device found.");
|
||||
|
||||
int err = bd->init();
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
||||
bd_size_t erase_size = bd->get_erase_size();
|
||||
bd_size_t program_size = bd->get_program_size();
|
||||
bd_size_t read_size = bd->get_read_size();
|
||||
TEST_ASSERT(program_size > 0);
|
||||
|
||||
err = bd->deinit();
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
||||
// See that we have enough memory for buffered block device
|
||||
char *dummy = new (std::nothrow) char[program_size + read_size];
|
||||
TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory for test.\n");
|
||||
delete[] dummy;
|
||||
|
||||
// use BufferedBlockDevice for better handling of block devices program and read
|
||||
BufferedBlockDevice *block_device = new BufferedBlockDevice(bd);
|
||||
|
||||
// BlockDevice initialization
|
||||
int err = block_device->init();
|
||||
err = block_device->init();
|
||||
TEST_ASSERT_EQUAL(0, err);
|
||||
|
||||
const char write_buffer[] = "1234567";
|
||||
char read_buffer[7] = {};
|
||||
|
||||
bd_size_t erase_size = block_device->get_erase_size();
|
||||
bd_size_t program_size = block_device->get_program_size();
|
||||
TEST_ASSERT(program_size > 0);
|
||||
|
||||
// Determine starting address
|
||||
bd_addr_t start_address = 0;
|
||||
|
||||
|
|
@ -466,6 +482,27 @@ void test_program_read_small_data_sizes()
|
|||
delete block_device;
|
||||
}
|
||||
|
||||
void test_get_type_functionality()
|
||||
{
|
||||
BlockDevice *block_device = BlockDevice::get_default_instance();
|
||||
TEST_SKIP_UNLESS_MESSAGE(block_device, "No block device component is defined for this target");
|
||||
const char *bd_type = block_device->get_type();
|
||||
TEST_ASSERT_NOT_EQUAL(0, bd_type);
|
||||
|
||||
#if COMPONENT_QSPIF
|
||||
TEST_ASSERT_EQUAL(0, strcmp(bd_type, "QSPIF"));
|
||||
#elif COMPONENT_SPIF
|
||||
TEST_ASSERT_EQUAL(0, strcmp(bd_type, "SPIF"));
|
||||
#elif COMPONENT_DATAFLASH
|
||||
TEST_ASSERT_EQUAL(0, strcmp(bd_type, "DATAFLASH"));
|
||||
#elif COMPONENT_SD
|
||||
TEST_ASSERT_EQUAL(0, strcmp(bd_type, "SD"));
|
||||
#elif COMPONET_FLASHIAP
|
||||
TEST_ASSERT_EQUAL(0, strcmp(bd_type, "FLASHIAP"));
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason)
|
||||
{
|
||||
greentea_case_failure_abort_handler(source, reason);
|
||||
|
|
@ -484,7 +521,8 @@ Case cases[] = {
|
|||
Case("Testing multi threads erase program read", test_multi_threads, greentea_failure_handler),
|
||||
Case("Testing contiguous erase, write and read", test_contiguous_erase_write_read, greentea_failure_handler),
|
||||
Case("Testing BlockDevice::get_erase_value()", test_get_erase_value, greentea_failure_handler),
|
||||
Case("Testing program read small data sizes", test_program_read_small_data_sizes, greentea_failure_handler)
|
||||
Case("Testing program read small data sizes", test_program_read_small_data_sizes, greentea_failure_handler),
|
||||
Case("Testing get type functionality", test_get_type_functionality, greentea_failure_handler)
|
||||
};
|
||||
|
||||
Specification specification(test_setup, cases);
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue