github-mirrors/neorv32
1
0
Fork 0
mirror of https://github.com/stnolting/neorv32.git synced 2025-04-23 13:47:33 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

[sw/example] use functions from neorv32_aux

Browse source
This commit is contained in:
stnolting 2024-06-29 17:05:18 +02:00
parent 723f339380
commit 1377399a91
13 changed files with 46 additions and 366 deletions
Download patch file Download diff file Expand all files Collapse all files

54
sw/example/atomic_test/main.c
View file

@ -30,7 +30,6 @@
// Prototypes
uint32_t xorshift32(void);
uint32_t check_result(uint32_t num, uint32_t amo_var_old, uint32_t amo_var_pre, uint32_t amo_var_new, uint32_t amo_var);
void print_report(int num_err, int num_tests);
@ -92,8 +91,8 @@ int main() {
neorv32_uart0_printf("\namoswap.w:\n");
err_cnt = 0;
for (i=0; i<num_tests; i++) {
amo_var_old = xorshift32();
amo_var_update = xorshift32();
amo_var_old = neorv32_aux_xorshift32();
amo_var_update = neorv32_aux_xorshift32();
amo_var = amo_var_old;
asm volatile ("fence");
@ -110,8 +109,8 @@ int main() {
neorv32_uart0_printf("\namoadd.w:\n");
err_cnt = 0;
for (i=0; i<num_tests; i++) {
amo_var_old = xorshift32();
amo_var_update = xorshift32();
amo_var_old = neorv32_aux_xorshift32();
amo_var_update = neorv32_aux_xorshift32();
amo_var = amo_var_old;
asm volatile ("fence");
@ -128,8 +127,8 @@ int main() {
neorv32_uart0_printf("\namoand.w:\n");
err_cnt = 0;
for (i=0; i<num_tests; i++) {
amo_var_old = xorshift32();
amo_var_update = xorshift32();
amo_var_old = neorv32_aux_xorshift32();
amo_var_update = neorv32_aux_xorshift32();
amo_var = amo_var_old;
asm volatile ("fence");
@ -146,8 +145,8 @@ int main() {
neorv32_uart0_printf("\namoor.w:\n");
err_cnt = 0;
for (i=0; i<num_tests; i++) {
amo_var_old = xorshift32();
amo_var_update = xorshift32();
amo_var_old = neorv32_aux_xorshift32();
amo_var_update = neorv32_aux_xorshift32();
amo_var = amo_var_old;
asm volatile ("fence");
@ -164,8 +163,8 @@ int main() {
neorv32_uart0_printf("\namoxor.w:\n");
err_cnt = 0;
for (i=0; i<num_tests; i++) {
amo_var_old = xorshift32();
amo_var_update = xorshift32();
amo_var_old = neorv32_aux_xorshift32();
amo_var_update = neorv32_aux_xorshift32();
amo_var = amo_var_old;
asm volatile ("fence");
@ -182,8 +181,8 @@ int main() {
neorv32_uart0_printf("\namomax.w:\n");
err_cnt = 0;
for (i=0; i<num_tests; i++) {
amo_var_old = xorshift32();
amo_var_update = xorshift32();
amo_var_old = neorv32_aux_xorshift32();
amo_var_update = neorv32_aux_xorshift32();
amo_var = amo_var_old;
asm volatile ("fence");
@ -200,8 +199,8 @@ int main() {
neorv32_uart0_printf("\namomaxu.w:\n");
err_cnt = 0;
for (i=0; i<num_tests; i++) {
amo_var_old = xorshift32();
amo_var_update = xorshift32();
amo_var_old = neorv32_aux_xorshift32();
amo_var_update = neorv32_aux_xorshift32();
amo_var = amo_var_old;
asm volatile ("fence");
@ -218,8 +217,8 @@ int main() {
neorv32_uart0_printf("\namomin.w:\n");
err_cnt = 0;
for (i=0; i<num_tests; i++) {
amo_var_old = xorshift32();
amo_var_update = xorshift32();
amo_var_old = neorv32_aux_xorshift32();
amo_var_update = neorv32_aux_xorshift32();
amo_var = amo_var_old;
asm volatile ("fence");
@ -236,8 +235,8 @@ int main() {
neorv32_uart0_printf("\namominu.w:\n");
err_cnt = 0;
for (i=0; i<num_tests; i++) {
amo_var_old = xorshift32();
amo_var_update = xorshift32();
amo_var_old = neorv32_aux_xorshift32();
amo_var_update = neorv32_aux_xorshift32();
amo_var = amo_var_old;
asm volatile ("fence");
@ -261,23 +260,6 @@ int main() {
}
/**********************************************************************//**
* Pseudo-Random Number Generator (to generate deterministic test vectors).
*
* @return Random data (32-bit).
**************************************************************************/
uint32_t xorshift32(void) {
static uint32_t x32 = 314159265;
x32 ^= x32 << 13;
x32 ^= x32 >> 17;
x32 ^= x32 << 5;
return x32;
}
/**********************************************************************//**
* Check results (reference (SW) vs actual hardware).
*

49
sw/example/bus_explorer/main.c
View file

@ -34,7 +34,6 @@ void setup_access(void);
void write_memory(uint32_t address, uint32_t data);
void dump_memory(uint32_t address);
void hexdump(uint32_t address);
uint32_t hexstr_to_uint32(char *buffer, uint8_t length);
void aux_print_hex_byte(uint8_t byte);
@ -118,7 +117,7 @@ int main() {
neorv32_uart0_printf("Insufficient arguments.\n");
}
else {
read_memory((uint32_t)hexstr_to_uint32(arg0, 8));
read_memory((uint32_t)neorv32_aux_hexstr2uint64(arg0, 8));
}
}
@ -127,7 +126,7 @@ int main() {
neorv32_uart0_printf("Insufficient arguments.\n");
}
else {
write_memory((uint32_t)hexstr_to_uint32(arg0, 8), (uint32_t)hexstr_to_uint32(arg1, 8));
write_memory((uint32_t)neorv32_aux_hexstr2uint64(arg0, 8), (uint32_t)neorv32_aux_hexstr2uint64(arg1, 8));
}
}
@ -136,7 +135,7 @@ int main() {
neorv32_uart0_printf("Insufficient arguments.\n");
}
else {
dump_memory((uint32_t)hexstr_to_uint32(arg0, 8));
dump_memory((uint32_t)neorv32_aux_hexstr2uint64(arg0, 8));
}
}
@ -145,7 +144,7 @@ int main() {
neorv32_uart0_printf("Insufficient arguments.\n");
}
else {
hexdump((uint32_t)hexstr_to_uint32(arg0, 8));
hexdump((uint32_t)neorv32_aux_hexstr2uint64(arg0, 8));
}
}
@ -395,46 +394,6 @@ void hexdump(uint32_t address) {
}
/**********************************************************************//**
* Helper function to convert N hex chars string into uint32_t
*
* @param[in,out] buffer Pointer to array of chars to convert into number.
* @param[in,out] length Length of the conversion string.
* @return Converted number.
**************************************************************************/
uint32_t hexstr_to_uint32(char *buffer, uint8_t length) {
uint32_t res = 0, d = 0;
char c = 0;
while (length--) {
c = *buffer++;
if (c == '\0') {
break;
}
if ((c >= '0') && (c <= '9')) {
d = (uint32_t)(c - '0');
}
else if ((c >= 'a') && (c <= 'f')) {
d = (uint32_t)((c - 'a') + 10);
}
else if ((c >= 'A') && (c <= 'F')) {
d = (uint32_t)((c - 'A') + 10);
}
else {
d = 0;
}
res <<= 4;
res |= d & 0xf;
}
return res;
}
/**********************************************************************//**
* Print HEX byte.
*

31
sw/example/demo_cfs/main.c
View file

@ -27,12 +27,6 @@
/**@}*/
/**********************************************************************//**
* @name Prototypes
**************************************************************************/
uint32_t xorshift32(void);
/**********************************************************************//**
* Main function
*
@ -76,28 +70,28 @@ int main() {
// function examples
neorv32_uart0_printf("\n--- CFS 'binary to gray' function ---\n");
for (i=0; i<TESTCASES; i++) {
tmp = xorshift32(); // get random test data
tmp = neorv32_aux_xorshift32(); // get random test data
NEORV32_CFS->REG[0] = tmp; // write to CFS memory-mapped register 0
neorv32_uart0_printf("%u: IN = 0x%x, OUT = 0x%x\n", i, tmp, NEORV32_CFS->REG[0]); // read from CFS memory-mapped register 0
}
neorv32_uart0_printf("\n--- CFS 'gray to binary' function ---\n");
for (i=0; i<TESTCASES; i++) {
tmp = xorshift32(); // get random test data
tmp = neorv32_aux_xorshift32(); // get random test data
NEORV32_CFS->REG[1] = tmp; // write to CFS memory-mapped register 1
neorv32_uart0_printf("%u: IN = 0x%x, OUT = 0x%x\n", i, tmp, NEORV32_CFS->REG[1]); // read from CFS memory-mapped register 1
}
neorv32_uart0_printf("\n--- CFS 'bit reversal' function ---\n");
for (i=0; i<TESTCASES; i++) {
tmp = xorshift32(); // get random test data
tmp = neorv32_aux_xorshift32(); // get random test data
NEORV32_CFS->REG[2] = tmp; // write to CFS memory-mapped register 2
neorv32_uart0_printf("%u: IN = 0x%x, OUT = 0x%x\n", i, tmp, NEORV32_CFS->REG[2]); // read from CFS memory-mapped register 2
}
neorv32_uart0_printf("\n--- CFS 'byte swap' function ---\n");
for (i=0; i<TESTCASES; i++) {
tmp = xorshift32(); // get random test data
tmp = neorv32_aux_xorshift32(); // get random test data
NEORV32_CFS->REG[3] = tmp; // write to CFS memory-mapped register 3
neorv32_uart0_printf("%u: IN = 0x%x, OUT = 0x%x\n", i, tmp, NEORV32_CFS->REG[3]); // read from CFS memory-mapped register 3
}
@ -107,20 +101,3 @@ int main() {
return 0;
}
/**********************************************************************//**
* Pseudo-Random Number Generator (to generate deterministic test vectors).
*
* @return Random data (32-bit).
**************************************************************************/
uint32_t xorshift32(void) {
static uint32_t x32 = 314159265;
x32 ^= x32 << 13;
x32 ^= x32 >> 17;
x32 ^= x32 << 5;
return x32;
}

19
sw/example/demo_cfu/main.c
View file

@ -80,23 +80,6 @@ uint32_t time_enc_sw, time_enc_hw, time_dec_sw, time_dec_hw;
/**@}*/
/**********************************************************************//**
* Pseudo-random number generator (to generate deterministic test data).
*
* @return Random data (32-bit).
**************************************************************************/
uint32_t xorshift32(void) {
static uint32_t x32 = 314159265;
x32 ^= x32 << 13;
x32 ^= x32 >> 17;
x32 ^= x32 << 5;
return x32;
}
/**********************************************************************//**
* XTEA encryption - software reference
*
@ -218,7 +201,7 @@ int main() {
// generate "random" data for the plain text
for (i=0; i<DATA_NUM; i++) {
input_data[i] = xorshift32();
input_data[i] = neorv32_aux_xorshift32();
}

4
sw/example/demo_mtime/main.c
View file

@ -62,7 +62,7 @@ int main() {
date.minutes = 47; // 0..59
date.seconds = 11; // 0..59
neorv32_mtime_set_unixtime(neorv32_mtime_date2unixtime(&date));
neorv32_mtime_set_unixtime(neorv32_aux_date2unixtime(&date));
neorv32_uart0_printf("Unix timestamp: %u\n", (uint32_t)neorv32_mtime_get_unixtime());
// clear GPIO output port
@ -103,7 +103,7 @@ void mtime_irq_handler(void) {
// show date in human-readable format
date_t date;
neorv32_mtime_unixtime2date(neorv32_mtime_get_unixtime(), &date);
neorv32_aux_unixtime2date(neorv32_mtime_get_unixtime(), &date);
neorv32_uart0_printf("%u.%u.%u (%s) ", date.day, date.month, date.year, weekdays[(date.weekday-1)%7]);
neorv32_uart0_printf("%u:%u:%u\n", date.hours, date.minutes, date.seconds);
}

43
sw/example/demo_onewire/main.c
View file

@ -36,7 +36,6 @@ void show_1wire_commands(void);
void read_byte(void);
void write_byte(void);
void scan_bus(void);
uint32_t hexstr_to_uint32(char *buffer, uint8_t length);
/**********************************************************************//**
@ -211,7 +210,7 @@ void write_byte(void) {
// enter address
neorv32_uart0_printf("Enter write data (2 hex chars): 0x");
neorv32_uart0_scan(terminal_buffer, 2+1, 1); // 2 hex chars for address plus '\0'
uint8_t wdata = (uint8_t)hexstr_to_uint32(terminal_buffer, strlen(terminal_buffer));
uint8_t wdata = (uint8_t)neorv32_aux_hexstr2uint64(terminal_buffer, strlen(terminal_buffer));
// write to bus
neorv32_uart0_printf("\nWriting 0x");
@ -262,43 +261,3 @@ void scan_bus(void) {
neorv32_uart0_printf("Devices found: %u\n", cnt);
}
/**********************************************************************//**
* Helper function to convert N hex chars string into uint32_t
*
* @param[in,out] buffer Pointer to array of chars to convert into number.
* @param[in,out] length Length of the conversion string.
* @return Converted number.
**************************************************************************/
uint32_t hexstr_to_uint32(char *buffer, uint8_t length) {
uint32_t res = 0, d = 0;
char c = 0;
while (length--) {
c = *buffer++;
if (c == '\0') {
break;
}
if ((c >= '0') && (c <= '9')) {
d = (uint32_t)(c - '0');
}
else if ((c >= 'a') && (c <= 'f')) {
d = (uint32_t)((c - 'a') + 10);
}
else if ((c >= 'A') && (c <= 'F')) {
d = (uint32_t)((c - 'A') + 10);
}
else {
d = 0;
}
res <<= 4;
res |= d & 0xf;
}
return res;
}

43
sw/example/demo_sdi/main.c
View file

@ -28,7 +28,6 @@
// Prototypes
void sdi_put(void);
void sdi_get(void);
uint32_t hexstr_to_uint32(char *buffer, uint8_t length);
/**********************************************************************//**
@ -115,7 +114,7 @@ void sdi_put(void) {
neorv32_uart0_printf("Enter TX data (2 hex chars): 0x");
neorv32_uart0_scan(terminal_buffer, sizeof(terminal_buffer), 1);
uint32_t tx_data = (uint32_t)hexstr_to_uint32(terminal_buffer, strlen(terminal_buffer));
uint32_t tx_data = (uint32_t)neorv32_aux_hexstr2uint64(terminal_buffer, strlen(terminal_buffer));
neorv32_uart0_printf("\nWriting 0x%x to SDI TX buffer... ", tx_data);
@ -142,43 +141,3 @@ void sdi_get(void) {
neorv32_uart0_printf("Read data: 0x%x\n", (uint32_t)rx_data);
}
}
/**********************************************************************//**
* Helper function to convert N hex chars string into uint32_t
*
* @param[in,out] buffer Pointer to array of chars to convert into number.
* @param[in,out] length Length of the conversion string.
* @return Converted number.
**************************************************************************/
uint32_t hexstr_to_uint32(char *buffer, uint8_t length) {
uint32_t res = 0, d = 0;
char c = 0;
while (length--) {
c = *buffer++;
if (c == '\0') {
break;
}
if ((c >= '0') && (c <= '9')) {
d = (uint32_t)(c - '0');
}
else if ((c >= 'a') && (c <= 'f')) {
d = (uint32_t)((c - 'a') + 10);
}
else if ((c >= 'A') && (c <= 'F')) {
d = (uint32_t)((c - 'A') + 10);
}
else {
d = 0;
}
res <<= 4;
res |= d & 0xf;
}
return res;
}

22
sw/example/demo_slink/main.c
View file

@ -26,7 +26,6 @@
// Prototypes
void slink_firq_handler(void);
uint32_t xorshift32(void);
/**********************************************************************//**
@ -79,7 +78,7 @@ int main() {
neorv32_uart0_printf("-------- TX Demo --------\n");
for (i=0; i<(rx_depth+tx_depth); i++) {
slink_data = xorshift32();
slink_data = neorv32_aux_xorshift32();
neorv32_uart0_printf("[%i] Sending 0x%x... ", i, slink_data);
slink_rc = neorv32_slink_tx_status();
@ -135,7 +134,7 @@ int main() {
neorv32_cpu_csr_set(CSR_MSTATUS, 1 << CSR_MSTATUS_MIE); // enable machine-mode interrupts
for (i=0; i<4; i++) {
slink_data = xorshift32();
slink_data = neorv32_aux_xorshift32();
neorv32_uart0_printf("[%i] Sending 0x%x... ", i, slink_data);
slink_rc = neorv32_slink_tx_status();
@ -161,20 +160,3 @@ void slink_firq_handler(void) {
neorv32_uart0_printf(" <<RX data: 0x%x>> ", neorv32_slink_get());
}
/**********************************************************************//**
* Simple pseudo random number generator.
*
* @return Random number.
**************************************************************************/
uint32_t xorshift32(void) {
static uint32_t x32 = 314159265;
x32 ^= x32 << 13;
x32 ^= x32 >> 17;
x32 ^= x32 << 5;
return x32;
}

51
sw/example/demo_spi/main.c
View file

@ -33,7 +33,6 @@ uint32_t spi_configured;
void spi_cs(uint32_t type);
void spi_trans(void);
void spi_setup(void);
uint32_t hexstr_to_uint32(char *buffer, uint8_t length);
void aux_print_hex_byte(uint8_t byte);
@ -142,7 +141,7 @@ void spi_cs(uint32_t type) {
neorv32_uart0_printf("Chip-select line to ENABLE (set low) [0..7]: ");
while (1) {
neorv32_uart0_scan(terminal_buffer, 2, 1); // 1 hex char plus '\0'
channel = (uint8_t)hexstr_to_uint32(terminal_buffer, strlen(terminal_buffer));
channel = (uint8_t)neorv32_aux_hexstr2uint64(terminal_buffer, strlen(terminal_buffer));
if (channel > 7) {
neorv32_uart0_printf("\nInvalid channel selection!\n");
return;
@ -175,7 +174,7 @@ void spi_trans(void) {
neorv32_uart0_printf("Enter TX data (2 hex chars): 0x");
neorv32_uart0_scan(terminal_buffer, 2+1, 1);
uint32_t tx_data = (uint32_t)hexstr_to_uint32(terminal_buffer, strlen(terminal_buffer));
uint32_t tx_data = (uint32_t)neorv32_aux_hexstr2uint64(terminal_buffer, strlen(terminal_buffer));
uint32_t rx_data = neorv32_spi_trans(tx_data);
@ -203,7 +202,7 @@ void spi_setup(void) {
while (1) {
neorv32_uart0_printf("Select SPI clock prescaler (0..7): ");
neorv32_uart0_scan(terminal_buffer, 2, 1);
tmp = (uint32_t)hexstr_to_uint32(terminal_buffer, strlen(terminal_buffer));
tmp = (uint32_t)neorv32_aux_hexstr2uint64(terminal_buffer, strlen(terminal_buffer));
if (tmp > 8) {
neorv32_uart0_printf("\nInvalid selection!\n");
}
@ -215,7 +214,7 @@ void spi_setup(void) {
neorv32_uart0_printf("\nEnter clock divider (0..15, as one hex char): ");
neorv32_uart0_scan(terminal_buffer, 2, 1);
clk_div = (uint8_t)hexstr_to_uint32(terminal_buffer, strlen(terminal_buffer));
clk_div = (uint8_t)neorv32_aux_hexstr2uint64(terminal_buffer, strlen(terminal_buffer));
uint32_t clock = NEORV32_SYSINFO->CLK / (2 * PRSC_LUT[spi_prsc] * (1 + clk_div));
neorv32_uart0_printf("\n+ New SPI clock speed = %u Hz\n", clock);
@ -225,7 +224,7 @@ void spi_setup(void) {
while (1) {
neorv32_uart0_printf("Select SPI clock mode (0..3): ");
neorv32_uart0_scan(terminal_buffer, 2, 1);
tmp = (uint32_t)hexstr_to_uint32(terminal_buffer, strlen(terminal_buffer));
tmp = (uint32_t)neorv32_aux_hexstr2uint64(terminal_buffer, strlen(terminal_buffer));
if (tmp > 4) {
neorv32_uart0_printf("\nInvalid selection!\n");
}
@ -242,46 +241,6 @@ void spi_setup(void) {
}
/**********************************************************************//**
* Helper function to convert N hex chars string into uint32_t
*
* @param[in,out] buffer Pointer to array of chars to convert into number.
* @param[in,out] length Length of the conversion string.
* @return Converted number.
**************************************************************************/
uint32_t hexstr_to_uint32(char *buffer, uint8_t length) {
uint32_t res = 0, d = 0;
char c = 0;
while (length--) {
c = *buffer++;
if (c == '\0') {
break;
}
if ((c >= '0') && (c <= '9')) {
d = (uint32_t)(c - '0');
}
else if ((c >= 'a') && (c <= 'f')) {
d = (uint32_t)((c - 'a') + 10);
}
else if ((c >= 'A') && (c <= 'F')) {
d = (uint32_t)((c - 'A') + 10);
}
else {
d = 0;
}
res <<= 4;
res |= d & 0xf;
}
return res;
}
/**********************************************************************//**
* Print HEX byte.
*

47
sw/example/demo_twi/main.c
View file

@ -30,7 +30,6 @@
void scan_twi(void);
void set_clock(void);
void send_twi(void);
uint32_t hexstr_to_uint32(char *buffer, uint8_t length);
void print_hex_byte(uint8_t data);
@ -131,7 +130,7 @@ void set_clock(void) {
// clock prescaler
neorv32_uart0_printf("Select new clock prescaler (0..7; one hex char): ");
neorv32_uart0_scan(terminal_buffer, 2, 1); // 1 hex char plus '\0'
int prsc = (int)hexstr_to_uint32(terminal_buffer, strlen(terminal_buffer));
int prsc = (int)neorv32_aux_hexstr2uint64(terminal_buffer, strlen(terminal_buffer));
if ((prsc < 0) || (prsc > 7)) { // invalid?
neorv32_uart0_printf("\nInvalid selection!\n");
@ -141,7 +140,7 @@ void set_clock(void) {
// clock divider
neorv32_uart0_printf("\nSelect new clock divider (0..15; one hex char): ");
neorv32_uart0_scan(terminal_buffer, 2, 1); // 1 hex char plus '\0'
int cdiv = (int)hexstr_to_uint32(terminal_buffer, strlen(terminal_buffer));
int cdiv = (int)neorv32_aux_hexstr2uint64(terminal_buffer, strlen(terminal_buffer));
if ((cdiv < 0) || (cdiv > 15)) { // invalid?
neorv32_uart0_printf("\nInvalid selection!\n");
@ -217,7 +216,7 @@ void send_twi(void) {
// TX data
neorv32_uart0_printf("Enter TX data (2 hex chars): ");
neorv32_uart0_scan(terminal_buffer, 3, 1); // 2 hex chars for address plus '\0'
data = (uint8_t)hexstr_to_uint32(terminal_buffer, strlen(terminal_buffer));
data = (uint8_t)neorv32_aux_hexstr2uint64(terminal_buffer, strlen(terminal_buffer));
// host ACK
neorv32_uart0_printf("\nIssue ACK by host (y/n)? ");
@ -250,46 +249,6 @@ void send_twi(void) {
}
/**********************************************************************//**
* Helper function to convert N hex chars string into uint32_t
*
* @param[in,out] buffer Pointer to array of chars to convert into number.
* @param[in,out] length Length of the conversion string.
* @return Converted number.
**************************************************************************/
uint32_t hexstr_to_uint32(char *buffer, uint8_t length) {
uint32_t res = 0, d = 0;
char c = 0;
while (length--) {
c = *buffer++;
if (c == '\0') {
break;
}
if ((c >= '0') && (c <= '9')) {
d = (uint32_t)(c - '0');
}
else if ((c >= 'a') && (c <= 'f')) {
d = (uint32_t)((c - 'a') + 10);
}
else if ((c >= 'A') && (c <= 'F')) {
d = (uint32_t)((c - 'A') + 10);
}
else {
d = 0;
}
res <<= 4;
res |= d & 0xf;
}
return res;
}
/**********************************************************************//**
* Print byte as hex chars via UART0.
*

3
sw/example/float_corner_test/main.c
View file

@ -64,7 +64,6 @@
// Prototypes
uint32_t get_test_vector(void);
uint32_t xorshift32(void);
uint32_t verify_result(uint32_t num, uint32_t opa, uint32_t opb, uint32_t ref, uint32_t res);
void print_report(uint32_t num_err);
@ -265,5 +264,3 @@ int main() {
}
}

24
sw/example/floating_point_test/main.c
View file

@ -78,7 +78,6 @@
// Prototypes
uint32_t get_test_vector(void);
uint32_t xorshift32(void);
uint32_t verify_result(uint32_t num, uint32_t opa, uint32_t opb, uint32_t ref, uint32_t res);
void print_report(uint32_t num_err);
@ -901,9 +900,9 @@ uint32_t get_test_vector(void) {
float_conv_t tmp;
// generate special value "every" ~256th time this function is called
if ((xorshift32() & 0xff) == 0xff) {
if ((neorv32_aux_xorshift32() & 0xff) == 0xff) {
switch((xorshift32() >> 10) & 0x3) { // random decision which special value we are taking
switch((neorv32_aux_xorshift32() >> 10) & 0x3) { // random decision which special value we are taking
case 0: tmp.float_value = +INFINITY; break;
case 1: tmp.float_value = -INFINITY; break;
case 2: tmp.float_value = +0.0f; break;
@ -916,30 +915,13 @@ uint32_t get_test_vector(void) {
}
}
else {
tmp.binary_value = xorshift32();
tmp.binary_value = neorv32_aux_xorshift32();
}
return tmp.binary_value;
}
/**********************************************************************//**
* PSEUDO-RANDOM number generator.
*
* @return Random data (32-bit).
**************************************************************************/
uint32_t xorshift32(void) {
static uint32_t x32 = 314159265;
x32 ^= x32 << 13;
x32 ^= x32 >> 17;
x32 ^= x32 << 5;
return x32;
}
/**********************************************************************//**
* Verify results (software reference vs. actual hardware).
*

22
sw/example/game_of_life/main.c
View file

@ -48,7 +48,6 @@ int get_cell(int u, int x, int y);
int get_neighborhood(int u, int x, int y);
void print_universe(int u);
int pop_count(int u);
uint32_t xorshift32(void);
/**********************************************************************//**
@ -105,7 +104,7 @@ int main(void) {
// randomize until key pressed
while (neorv32_uart0_char_received() == 0) {
xorshift32();
neorv32_aux_xorshift32();
}
neorv32_uart0_char_received_get(); // discard received char
@ -125,7 +124,7 @@ int main(void) {
universe[0][x][y] = trng_data; // use data from TRNG
}
else {
universe[0][x][y] = (uint8_t)xorshift32(); // use data from PRNG
universe[0][x][y] = (uint8_t)neorv32_aux_xorshift32(); // use data from PRNG
}
}
}
@ -334,20 +333,3 @@ int pop_count(int u) {
return cnt;
}
/**********************************************************************//**
* Simple pseudo random number generator.
*
* @return Random number.
**************************************************************************/
uint32_t xorshift32(void) {
static uint32_t x32 = 314159265;
x32 ^= x32 << 13;
x32 ^= x32 >> 17;
x32 ^= x32 << 5;
return x32;
}