2020-05-24 15:30:55 -05:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2022-01-31 16:59:14 -06:00
|
|
|
// Copyright (C) 2020-2022 Martin Whitaker.
|
2020-05-24 15:30:55 -05:00
|
|
|
//
|
|
|
|
// Derived from an extract of memtest86+ test.c:
|
|
|
|
//
|
|
|
|
// MemTest86+ V5 Specific code (GPL V2.0)
|
|
|
|
// By Samuel DEMEULEMEESTER, sdemeule@memtest.org
|
|
|
|
// http://www.canardpc.com - http://www.memtest.org
|
|
|
|
// Thanks to Passmark for calculate_chunk() and various comments !
|
|
|
|
// ----------------------------------------------------
|
|
|
|
// test.c - MemTest-86 Version 3.4
|
|
|
|
//
|
|
|
|
// Released under version 2 of the Gnu Public License.
|
|
|
|
// By Chris Brady
|
|
|
|
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
|
|
|
|
#include "unistd.h"
|
|
|
|
|
|
|
|
#include "display.h"
|
|
|
|
#include "error.h"
|
|
|
|
#include "test.h"
|
|
|
|
|
|
|
|
#include "test_funcs.h"
|
|
|
|
#include "test_helper.h"
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Private Functions
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
2022-01-31 16:59:14 -06:00
|
|
|
static int pattern_fill(int my_cpu, testword_t pattern)
|
2020-05-24 15:30:55 -05:00
|
|
|
{
|
|
|
|
int ticks = 0;
|
|
|
|
|
2022-01-31 16:59:14 -06:00
|
|
|
if (my_cpu == master_cpu) {
|
2020-05-24 15:30:55 -05:00
|
|
|
display_test_pattern_value(pattern);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < vm_map_size; i++) {
|
|
|
|
testword_t *start = vm_map[i].start;
|
|
|
|
testword_t *end = vm_map[i].end;
|
|
|
|
|
2022-02-19 07:01:42 -06:00
|
|
|
testword_t *p = start;
|
|
|
|
testword_t *pe = start;
|
2020-05-24 15:30:55 -05:00
|
|
|
|
|
|
|
bool at_end = false;
|
|
|
|
do {
|
|
|
|
// take care to avoid pointer overflow
|
|
|
|
if ((end - pe) >= SPIN_SIZE) {
|
|
|
|
pe += SPIN_SIZE - 1;
|
|
|
|
} else {
|
|
|
|
at_end = true;
|
|
|
|
pe = end;
|
|
|
|
}
|
|
|
|
ticks++;
|
2022-01-31 16:59:14 -06:00
|
|
|
if (my_cpu < 0) {
|
2020-05-24 15:30:55 -05:00
|
|
|
continue;
|
|
|
|
}
|
2022-01-31 16:59:14 -06:00
|
|
|
test_addr[my_cpu] = (uintptr_t)p;
|
2020-05-24 15:30:55 -05:00
|
|
|
do {
|
2021-12-23 03:46:01 -06:00
|
|
|
write_word(p, pattern);
|
2020-05-24 15:30:55 -05:00
|
|
|
} while (p++ < pe); // test before increment in case pointer overflows
|
2022-01-31 16:59:14 -06:00
|
|
|
do_tick(my_cpu);
|
2020-05-24 15:30:55 -05:00
|
|
|
BAILOUT;
|
|
|
|
} while (!at_end && ++pe); // advance pe to next start point
|
|
|
|
}
|
|
|
|
|
2022-01-31 16:59:14 -06:00
|
|
|
flush_caches(my_cpu);
|
2021-12-23 05:00:10 -06:00
|
|
|
|
2020-05-24 15:30:55 -05:00
|
|
|
return ticks;
|
|
|
|
}
|
|
|
|
|
2022-01-31 16:59:14 -06:00
|
|
|
static int pattern_check(int my_cpu, testword_t pattern)
|
2020-05-24 15:30:55 -05:00
|
|
|
{
|
|
|
|
int ticks = 0;
|
|
|
|
|
|
|
|
for (int i = 0; i < vm_map_size; i++) {
|
|
|
|
testword_t *start = vm_map[i].start;
|
|
|
|
testword_t *end = vm_map[i].end;
|
|
|
|
|
2022-02-19 07:01:42 -06:00
|
|
|
testword_t *p = start;
|
|
|
|
testword_t *pe = start;
|
2020-05-24 15:30:55 -05:00
|
|
|
|
|
|
|
bool at_end = false;
|
|
|
|
do {
|
|
|
|
// take care to avoid pointer overflow
|
|
|
|
if ((end - pe) >= SPIN_SIZE) {
|
|
|
|
pe += SPIN_SIZE - 1;
|
|
|
|
} else {
|
|
|
|
at_end = true;
|
|
|
|
pe = end;
|
|
|
|
}
|
|
|
|
ticks++;
|
2022-01-31 16:59:14 -06:00
|
|
|
if (my_cpu < 0) {
|
2020-05-24 15:30:55 -05:00
|
|
|
continue;
|
|
|
|
}
|
2022-01-31 16:59:14 -06:00
|
|
|
test_addr[my_cpu] = (uintptr_t)p;
|
2020-05-24 15:30:55 -05:00
|
|
|
do {
|
2021-12-23 03:46:01 -06:00
|
|
|
testword_t actual = read_word(p);
|
2020-05-24 15:30:55 -05:00
|
|
|
if (unlikely(actual != pattern)) {
|
|
|
|
data_error(p, pattern, actual, true);
|
|
|
|
}
|
|
|
|
} while (p++ < pe); // test before increment in case pointer overflows
|
2022-01-31 16:59:14 -06:00
|
|
|
do_tick(my_cpu);
|
2020-05-24 15:30:55 -05:00
|
|
|
BAILOUT;
|
|
|
|
} while (!at_end && ++pe); // advance pe to next start point
|
|
|
|
}
|
|
|
|
|
|
|
|
return ticks;
|
|
|
|
}
|
|
|
|
|
2022-01-31 16:59:14 -06:00
|
|
|
static int fade_delay(int my_cpu, int sleep_secs)
|
2020-05-24 15:30:55 -05:00
|
|
|
{
|
|
|
|
int ticks = 0;
|
|
|
|
|
2022-01-31 16:59:14 -06:00
|
|
|
if (my_cpu == master_cpu) {
|
2020-05-24 15:30:55 -05:00
|
|
|
display_test_stage_description("fade over %i seconds", sleep_secs);
|
|
|
|
}
|
|
|
|
while (sleep_secs > 0) {
|
|
|
|
sleep_secs--;
|
|
|
|
ticks++;
|
2022-01-31 16:59:14 -06:00
|
|
|
if (my_cpu < 0) {
|
2020-05-24 15:30:55 -05:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
sleep(1);
|
2022-01-31 16:59:14 -06:00
|
|
|
do_tick(my_cpu);
|
2020-05-24 15:30:55 -05:00
|
|
|
BAILOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ticks;
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Public Functions
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
2022-01-31 16:59:14 -06:00
|
|
|
int test_bit_fade(int my_cpu, int stage, int sleep_secs)
|
2020-05-24 15:30:55 -05:00
|
|
|
{
|
|
|
|
const testword_t all_zero = 0;
|
|
|
|
const testword_t all_ones = ~all_zero;
|
|
|
|
|
|
|
|
static int last_stage = -1;
|
|
|
|
|
|
|
|
int ticks = 0;
|
|
|
|
|
|
|
|
switch (stage) {
|
|
|
|
case 0:
|
2022-01-31 16:59:14 -06:00
|
|
|
ticks = pattern_fill(my_cpu, all_zero);
|
2020-05-24 15:30:55 -05:00
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
// Only sleep once.
|
|
|
|
if (stage != last_stage) {
|
2022-01-31 16:59:14 -06:00
|
|
|
ticks = fade_delay(my_cpu, sleep_secs);
|
2020-05-24 15:30:55 -05:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 2:
|
2022-01-31 16:59:14 -06:00
|
|
|
ticks = pattern_check(my_cpu, all_zero);
|
2020-05-24 15:30:55 -05:00
|
|
|
break;
|
|
|
|
case 3:
|
2022-01-31 16:59:14 -06:00
|
|
|
ticks = pattern_fill(my_cpu, all_ones);
|
2020-05-24 15:30:55 -05:00
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
// Only sleep once.
|
|
|
|
if (stage != last_stage) {
|
2022-01-31 16:59:14 -06:00
|
|
|
ticks = fade_delay(my_cpu, sleep_secs);
|
2020-05-24 15:30:55 -05:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 5:
|
2022-01-31 16:59:14 -06:00
|
|
|
ticks = pattern_check(my_cpu, all_ones);
|
2020-05-24 15:30:55 -05:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
last_stage = stage;
|
|
|
|
|
|
|
|
return ticks;
|
|
|
|
}
|