Skip to content

Commit df36f0e

Browse files
author
Offir Kochalsky
committed
Fixed PR review remarks
1 parent b71db49 commit df36f0e

File tree

2 files changed

+42
-39
lines changed

2 files changed

+42
-39
lines changed

‎components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ enum spif_bd_error {
2828
SPIF_BD_ERROR_OK = 0, /*!< no error */
2929
SPIF_BD_ERROR_DEVICE_ERROR = BD_ERROR_DEVICE_ERROR, /*!< device specific error -4001 */
3030
SPIF_BD_ERROR_PARSING_FAILED = -4002, /* SFDP Parsing failed */
31-
SPIF_BD_ERROR_READY_FAILED = -4003, /* Wait for Mem Ready failed */
31+
SPIF_BD_ERROR_READY_FAILED = -4003, /* Wait for Mem Ready failed */
3232
SPIF_BD_ERROR_WREN_FAILED = -4004, /* Write Enable Failed */
3333
SPIF_BD_ERROR_INVALID_ERASE_PARAMS = -4005, /* Erase command not on sector aligned addresses or exceeds device size */
3434
};

‎components/storage/blockdevice/COMPONENT_SPIF/TESTS/block_device/spif/main.cpp

Lines changed: 41 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -41,13 +41,13 @@ static SingletonPtr<PlatformMutex> _mutex;
4141
// Mutex is protecting rand() per srand for buffer writing and verification.
4242
// Mutex is also protecting printouts for clear logs.
4343
// Mutex is NOT protecting Block Device actions: erase/program/read - which is the purpose of the multithreaded test!
44-
void basic_erase_program_read_test(SPIFBlockDevice& blockD, bd_size_t block_size, uint8_t *write_block,
44+
void basic_erase_program_read_test(SPIFBlockDevice& block_device, bd_size_t block_size, uint8_t *write_block,
4545
uint8_t *read_block, unsigned addrwidth)
4646
{
4747
int err = 0;
4848
_mutex->lock();
4949
// Find a random block
50-
bd_addr_t block = (rand() * block_size) % blockD.size();
50+
bd_addr_t block = (rand() * block_size) % block_device.size();
5151

5252
// Use next random number as temporary seed to keep
5353
// the address progressing in the pseudorandom sequence
@@ -62,13 +62,13 @@ void basic_erase_program_read_test(SPIFBlockDevice& blockD, bd_size_t block_size
6262
utest_printf("\ntest %0*llx:%llu...", addrwidth, block, block_size);
6363
_mutex->unlock();
6464

65-
err = blockD.erase(block, block_size);
65+
err = block_device.erase(block, block_size);
6666
TEST_ASSERT_EQUAL(0, err);
6767

68-
err = blockD.program(write_block, block, block_size);
68+
err = block_device.program(write_block, block, block_size);
6969
TEST_ASSERT_EQUAL(0, err);
7070

71-
err = blockD.read(read_block, block, block_size);
71+
err = block_device.read(read_block, block, block_size);
7272
TEST_ASSERT_EQUAL(0, err);
7373

7474
_mutex->lock();
@@ -91,16 +91,17 @@ void test_spif_random_program_read_erase()
9191
{
9292
utest_printf("\nTest Random Program Read Erase Starts..\n");
9393

94-
SPIFBlockDevice blockD(MBED_CONF_SPIF_DRIVER_SPI_MOSI, MBED_CONF_SPIF_DRIVER_SPI_MISO, MBED_CONF_SPIF_DRIVER_SPI_CLK,
95-
MBED_CONF_SPIF_DRIVER_SPI_CS);
94+
SPIFBlockDevice block_device(MBED_CONF_SPIF_DRIVER_SPI_MOSI, MBED_CONF_SPIF_DRIVER_SPI_MISO,
95+
MBED_CONF_SPIF_DRIVER_SPI_CLK,
96+
MBED_CONF_SPIF_DRIVER_SPI_CS);
9697

97-
int err = blockD.init();
98+
int err = block_device.init();
9899
TEST_ASSERT_EQUAL(0, err);
99100

100101
for (unsigned atr = 0; atr < sizeof(ATTRS) / sizeof(ATTRS[0]); atr++) {
101102
static const char *prefixes[] = {"", "k", "M", "G"};
102103
for (int i_ind = 3; i_ind >= 0; i_ind--) {
103-
bd_size_t size = (blockD.*ATTRS[atr].method)();
104+
bd_size_t size = (block_device.*ATTRS[atr].method)();
104105
if (size >= (1ULL << 10 * i_ind)) {
105106
utest_printf("%s: %llu%sbytes (%llubytes)\n",
106107
ATTRS[atr].name, size >> 10 * i_ind, prefixes[i_ind], size);
@@ -109,8 +110,8 @@ void test_spif_random_program_read_erase()
109110
}
110111
}
111112

112-
bd_size_t block_size = blockD.get_erase_size();
113-
unsigned addrwidth = ceil(log(float(blockD.size() - 1)) / log(float(16))) + 1;
113+
bd_size_t block_size = block_device.get_erase_size();
114+
unsigned addrwidth = ceil(log(float(block_device.size() - 1)) / log(float(16))) + 1;
114115

115116
uint8_t *write_block = new (std::nothrow) uint8_t[block_size];
116117
uint8_t *read_block = new (std::nothrow) uint8_t[block_size];
@@ -120,10 +121,10 @@ void test_spif_random_program_read_erase()
120121
}
121122

122123
for (int b = 0; b < TEST_BLOCK_COUNT; b++) {
123-
basic_erase_program_read_test(blockD, block_size, write_block, read_block, addrwidth);
124+
basic_erase_program_read_test(block_device, block_size, write_block, read_block, addrwidth);
124125
}
125126

126-
err = blockD.deinit();
127+
err = block_device.deinit();
127128
TEST_ASSERT_EQUAL(0, err);
128129

129130
end:
@@ -135,16 +136,17 @@ void test_spif_unaligned_erase()
135136
{
136137
utest_printf("\nTest Unaligned Erase Starts..\n");
137138

138-
SPIFBlockDevice blockD(MBED_CONF_SPIF_DRIVER_SPI_MOSI, MBED_CONF_SPIF_DRIVER_SPI_MISO, MBED_CONF_SPIF_DRIVER_SPI_CLK,
139-
MBED_CONF_SPIF_DRIVER_SPI_CS);
139+
SPIFBlockDevice block_device(MBED_CONF_SPIF_DRIVER_SPI_MOSI, MBED_CONF_SPIF_DRIVER_SPI_MISO,
140+
MBED_CONF_SPIF_DRIVER_SPI_CLK,
141+
MBED_CONF_SPIF_DRIVER_SPI_CS);
140142

141-
int err = blockD.init();
143+
int err = block_device.init();
142144
TEST_ASSERT_EQUAL(0, err);
143145

144146
for (unsigned atr = 0; atr < sizeof(ATTRS) / sizeof(ATTRS[0]); atr++) {
145147
static const char *prefixes[] = {"", "k", "M", "G"};
146148
for (int i_ind = 3; i_ind >= 0; i_ind--) {
147-
bd_size_t size = (blockD.*ATTRS[atr].method)();
149+
bd_size_t size = (block_device.*ATTRS[atr].method)();
148150
if (size >= (1ULL << 10 * i_ind)) {
149151
utest_printf("%s: %llu%sbytes (%llubytes)\n",
150152
ATTRS[atr].name, size >> 10 * i_ind, prefixes[i_ind], size);
@@ -154,52 +156,52 @@ void test_spif_unaligned_erase()
154156
}
155157

156158
bd_addr_t addr = 0;
157-
bd_size_t sector_erase_size = blockD.get_erase_size(addr);
158-
unsigned addrwidth = ceil(log(float(blockD.size() - 1)) / log(float(16))) + 1;
159+
bd_size_t sector_erase_size = block_device.get_erase_size(addr);
160+
unsigned addrwidth = ceil(log(float(block_device.size() - 1)) / log(float(16))) + 1;
159161

160162
utest_printf("\ntest %0*llx:%llu...", addrwidth, addr, sector_erase_size);
161163

162164
//unaligned start address
163165
addr += 1;
164-
err = blockD.erase(addr, sector_erase_size - 1);
166+
err = block_device.erase(addr, sector_erase_size - 1);
165167
TEST_ASSERT_EQUAL(SPIF_BD_ERROR_INVALID_ERASE_PARAMS, err);
166168

167-
err = blockD.erase(addr, sector_erase_size);
169+
err = block_device.erase(addr, sector_erase_size);
168170
TEST_ASSERT_EQUAL(SPIF_BD_ERROR_INVALID_ERASE_PARAMS, err);
169171

170-
err = blockD.erase(addr, 1);
172+
err = block_device.erase(addr, 1);
171173
TEST_ASSERT_EQUAL(SPIF_BD_ERROR_INVALID_ERASE_PARAMS, err);
172174

173175
//unaligned end address
174176
addr = 0;
175177

176-
err = blockD.erase(addr, 1);
178+
err = block_device.erase(addr, 1);
177179
TEST_ASSERT_EQUAL(SPIF_BD_ERROR_INVALID_ERASE_PARAMS, err);
178180

179-
err = blockD.erase(addr, sector_erase_size + 1);
181+
err = block_device.erase(addr, sector_erase_size + 1);
180182
TEST_ASSERT_EQUAL(SPIF_BD_ERROR_INVALID_ERASE_PARAMS, err);
181183

182184
//erase size exceeds flash device size
183-
err = blockD.erase(addr, blockD.size() + 1);
185+
err = block_device.erase(addr, block_device.size() + 1);
184186
TEST_ASSERT_EQUAL(SPIF_BD_ERROR_INVALID_ERASE_PARAMS, err);
185187

186188
// Valid erase
187-
err = blockD.erase(addr, sector_erase_size);
189+
err = block_device.erase(addr, sector_erase_size);
188190
TEST_ASSERT_EQUAL(SPIF_BD_ERROR_OK, err);
189191

190-
err = blockD.deinit();
192+
err = block_device.deinit();
191193
TEST_ASSERT_EQUAL(0, err);
192194
}
193195

194-
static void test_spif_thread_job(void *vBlockD/*, int thread_num*/)
196+
static void test_spif_thread_job(void *block_device_ptr/*, int thread_num*/)
195197
{
196198
static int thread_num = 0;
197199
thread_num++;
198-
SPIFBlockDevice *blockD = (SPIFBlockDevice *)vBlockD;
200+
SPIFBlockDevice *block_device = (SPIFBlockDevice *)block_device_ptr;
199201
utest_printf("\n Thread %d Started \n", thread_num);
200202

201-
bd_size_t block_size = blockD->get_erase_size();
202-
unsigned addrwidth = ceil(log(float(blockD->size() - 1)) / log(float(16))) + 1;
203+
bd_size_t block_size = block_device->get_erase_size();
204+
unsigned addrwidth = ceil(log(float(block_device->size() - 1)) / log(float(16))) + 1;
203205

204206
uint8_t *write_block = new (std::nothrow) uint8_t[block_size];
205207
uint8_t *read_block = new (std::nothrow) uint8_t[block_size];
@@ -209,7 +211,7 @@ static void test_spif_thread_job(void *vBlockD/*, int thread_num*/)
209211
}
210212

211213
for (int b = 0; b < TEST_BLOCK_COUNT; b++) {
212-
basic_erase_program_read_test((*blockD), block_size, write_block, read_block, addrwidth);
214+
basic_erase_program_read_test((*block_device), block_size, write_block, read_block, addrwidth);
213215
}
214216

215217
end:
@@ -221,16 +223,17 @@ void test_spif_multi_threads()
221223
{
222224
utest_printf("\nTest Multi Threaded Erase/Program/Read Starts..\n");
223225

224-
SPIFBlockDevice blockD(MBED_CONF_SPIF_DRIVER_SPI_MOSI, MBED_CONF_SPIF_DRIVER_SPI_MISO, MBED_CONF_SPIF_DRIVER_SPI_CLK,
225-
MBED_CONF_SPIF_DRIVER_SPI_CS);
226+
SPIFBlockDevice block_device(MBED_CONF_SPIF_DRIVER_SPI_MOSI, MBED_CONF_SPIF_DRIVER_SPI_MISO,
227+
MBED_CONF_SPIF_DRIVER_SPI_CLK,
228+
MBED_CONF_SPIF_DRIVER_SPI_CS);
226229

227-
int err = blockD.init();
230+
int err = block_device.init();
228231
TEST_ASSERT_EQUAL(0, err);
229232

230233
for (unsigned atr = 0; atr < sizeof(ATTRS) / sizeof(ATTRS[0]); atr++) {
231234
static const char *prefixes[] = {"", "k", "M", "G"};
232235
for (int i_ind = 3; i_ind >= 0; i_ind--) {
233-
bd_size_t size = (blockD.*ATTRS[atr].method)();
236+
bd_size_t size = (block_device.*ATTRS[atr].method)();
234237
if (size >= (1ULL << 10 * i_ind)) {
235238
utest_printf("%s: %llu%sbytes (%llubytes)\n",
236239
ATTRS[atr].name, size >> 10 * i_ind, prefixes[i_ind], size);
@@ -245,7 +248,7 @@ void test_spif_multi_threads()
245248
int i_ind;
246249

247250
for (i_ind = 0; i_ind < SPIF_TEST_NUM_OF_THREADS; i_ind++) {
248-
threadStatus = spif_bd_thread[i_ind].start(test_spif_thread_job, (void *)&blockD);
251+
threadStatus = spif_bd_thread[i_ind].start(test_spif_thread_job, (void *)&block_device);
249252
if (threadStatus != 0) {
250253
utest_printf("\n Thread %d Start Failed!", i_ind + 1);
251254
}
@@ -255,7 +258,7 @@ void test_spif_multi_threads()
255258
spif_bd_thread[i_ind].join();
256259
}
257260

258-
err = blockD.deinit();
261+
err = block_device.deinit();
259262
TEST_ASSERT_EQUAL(0, err);
260263
}
261264

0 commit comments

Comments
 (0)