blob: ea98e1593c5f518f1859fc29d7074c42c4b41a73 [file] [log] [blame]
/*
* (C) Copyright 2013 Marvell company.
*/
#include <common.h>
#include "ddr_tests.h"
#define MTSP_MSG_WRITING_OFFSET 13
uint32_t exit_when_error = 1;
uint32_t mtsp_total_error;
uint32_t smtd_stat;
uint32_t smtd_pat = 0x55555555;
static uint32_t bit_byte_check;
static uint32_t byte_err_sta[4];
static uint32_t bit_err_sta[32];
#ifdef LOG_SILENT
static enum print_mode logout_mode = SILENT_MODE;
#else
static enum print_mode logout_mode = FULL_MODE;
#endif
static const struct pattern_dword pattern_list[] = {
{0x00000000, 0xFFFFFFFF},
{0x55AA55AA, 0xAA55AA55},
{0x7FFF7FFF, 0x80008000},
{0xFFFFFFFF, 0xFFFFFFFF},/*+decrement*/
{0x55555555, 0xAAAAAAAA},
{0x7F7F7F7F, 0x80808080},/*+rotate*/
{0x7FFF7FFF, 0x80008000},/*+rotate*/
{0x7FFFFFFF, 0x80000000},/*+rotate*/
{0x01010101, 0xFEFEFEFE},/*+rotate left*/
{0x00010001, 0xFFFEFFFE},/*+rotate left*/
{0x00000001, 0xFFFFFFFE},/*+rotate left*/
{0x7F7F7F7F, 0x7F7F7F7F},/*+rotate + without second pattern*/
{0x7FFF7FFF, 0x7FFF7FFF},/*+rotate + without second pattern*/
{0x7FFFFFFF, 0x7FFFFFFF},/*+rotate + without second pattern*/
{0x01010101, 0x01010101},/*+rotate left*/
{0x00010001, 0x00010001},/*+rotate left*/
{0x00000001, 0x00000001},/*+rotate left*/
{0x01010101, 0xFFFFFFFF},/*+rotate left*/
{0x00010001, 0xFFFFFFFF},/*+rotate left*/
{0x00000001, 0xFFFFFFFF},/*+rotate left*/
{0xFEFEFEFE, 0x00000000},/*+rotate left*/
{0xFFFEFFFE, 0x00000000},/*+rotate left*/
{0xFFFFFFFE, 0x00000000},/*+rotate left*/
{0x00000000, 0x00000001},/*+32 bytes+rotate left*/
{0x00000001, 0x00000001},/*+32 bytes+rotate left*/
{0x00000000, 0x00000001},/*+32 bytes+rotate left*/
{0x00000000, 0x00000001},/*+32 bytes+rotate left*/
{0x00000000, 0xFFFFFFFF},/*FREQ*/
{0x00000000, 0x00000000},/*increment*/
{0x00000001, 0x00000000},/*special test*/
{0x00000001, 0xFFFFFFFF},/*special test*/
{0x00000001, 0x00000000},/*special test*/
};
#ifndef LOG_SILENT
const char mtsp_msg_read[7] = {"Reading"};
const char mtsp_msg_write[7] = {"Writing"};
char mtsp_test_msg[32][85] = {
{"0x00000001 - Writing Analog data pattern - Start\n"},
{"0x00000002 - Writing Constant data pattern - Start\n"},
{"0x00000004 - Writing Complement data pattern - Start\n"},
{"0x00000008 - Writing Decrement data pattern - Start\n"},
{"0x00000010 - Writing Miller Effect data pattern - Start\n"},
{"0x00000020 - Writing Zero Rotate Right & Invert Byte data "
"pattern - Start\n"},
{"0x00000040 - Writing Zero Rotate Right & Invert Word data "
"pattern - Start\n"},
{"0x00000080 - Writing Zero Rotate Right & Invert DoubleWord data "
"pattern - Start\n"},
{"0x00000100 - Writing One Rotate left & Invert Byte data "
"pattern - Start\n"},
{"0x00000200 - Writing One Rotate left & Invert Word data "
"pattern - Start\n"},
{"0x00000400 - Writing One Rotate left & Invert DoubleWord data "
"pattern - Start\n"},
{"0x00000800 - Writing Zero Rotate Right Byte data "
"pattern - Start\n"},
{"0x00001000 - Writing Zero Rotate Right Word data pattern - Start\n"},
{"0x00002000 - Writing Zero Rotate Right DoubleWord data "
"pattern - Start\n"},
{"0x00004000 - Writing One Rotate left Byte data pattern - Start\n"},
{"0x00008000 - Writing One Rotate left Word data pattern - Start\n"},
{"0x00010000 - Writing One Rotate left DoubleWord data "
"pattern - Start\n"},
{"0x00020000 - Writing Walking 1 Byte data pattern - Start\n"},
{"0x00040000 - Writing Walking 1 Word data pattern - Start\n"},
{"0x00080000 - Writing Walking 1 DoubleWord data pattern - Start\n"},
{"0x00100000 - Writing Walking Zero Byte data pattern - Start\n"},
{"0x00200000 - Writing Walking Zero Word data pattern - Start\n"},
{"0x00400000 - Writing Walking Zero DoubleWord data "
"pattern - Start\n"},
{"0x00800000 - Writing Single Signal Tailgating 0101_0000 data "
"pattern - Start\n"},
{"0x01000000 - Writing Single Signal Tailgating 0101_1111 data "
"pattern - Start\n"},
{"0x02000000 - Writing Single Signal Tailgating 0101_1010 data "
"pattern - Start\n"},
{"0x04000000 - Writing Multiple Signal Tailgating data "
"pattern - Start\n"},
{"0x08000000 - Writing Frequency Sweep data pattern - Start\n"},
{"0x10000000 - Writing Vertical increment data pattern - Start\n"},
{"0x20000000 - Writing Horzontal increment data pattern - Start\n"},
{"0x40000000 - Writing fixed 2nd pattern 0xFFFFFFFF - Start\n"},
{"0x80000000 - Writing fixed 2nd pattern 0x00000000 - Start\n"},
};
#endif
/**
* print_error - This function prints an error message to the user
* @addr - where data failed
* @access - BYTE,HWORD or WORD
* @data - the current read
* @expected - expected data
*/
void print_error(uint32_t addr, enum access_type access,
uint32_t data, uint32_t expected)
{
int bit, byte;
if (bit_byte_check) {
for (bit = 0; bit < 32; bit++) {
if ((data & (1 << bit)) != (expected & (1 << bit)))
bit_err_sta[bit % 32]++;
}
for (byte = 0; byte < 4; byte++) {
if ((data & (0xFF << (byte * 8))) !=
(expected & (0xFF << (byte * 8))))
byte_err_sta[byte % 4]++;
}
}
if (logout_mode == FULL_MODE) {
printf("\nERROR: Expecting ");
switch (access) {
case ACCESS_TYPE_BYTE:
printb((uint8_t)expected & 0xFF);
break;
case ACCESS_TYPE_HWORD:
printh((uint16_t)expected & 0xFFFF);
break;
case ACCESS_TYPE_WORD:
printw(expected);
break;
default:
break;
}
printf(" at address ");
printw(addr);
printf(". Actual = ");
switch (access) {
case ACCESS_TYPE_BYTE:
printb((uint8_t)data & 0xFF);
break;
case ACCESS_TYPE_HWORD:
printh((uint16_t)data & 0xFFFF);
break;
case ACCESS_TYPE_WORD:
printw(data);
break;
default:
break;
}
printf("\n");
}
}
/**
* memory_test_type1 - This function tests the wanted memory
* according to parameters
* @addr - start address for memory to be tested
* @size - size of memory to be tested
* @first_pattern - pattern to test the memory
* @second_pattern - pattern to test the memory
* @pattern - kind of pattern to test the memory
* if test pass, returen 0;if test failed - see error value
*/
uint32_t memory_test_type1(uint32_t addr, uint32_t size,
uint32_t first_pattern,
uint32_t second_pattern, uint32_t pattern)
{
uint32_t i = 0, j = 0, error = 0;
uint32_t *temp = (uint32_t *)addr;
uint32_t first_pattern_restore = first_pattern;
uint32_t second_pattern_restore = second_pattern;
while (j < size) {
/*Write the data*/
temp[i++] = (uint32_t)(first_pattern);
temp[i++] = (uint32_t)(second_pattern);
j += 8;
}
printf("write pass\n");
#ifndef LOG_SILENT
/*Inform user that test has continue - read sequence*/
for (i = 0; i < 7; i++) {
mtsp_test_msg[pattern][MTSP_MSG_WRITING_OFFSET + i] =
mtsp_msg_read[i];
}
if (logout_mode == FULL_MODE)
printf("%s", (char *)mtsp_test_msg[pattern]);
#endif
j = 0;
i = 0;
/*Restore patterns*/
first_pattern = first_pattern_restore;
second_pattern = second_pattern_restore;
while (j < size) {
/*Read the data and compare it to the pattern*/
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail\n");
print_error((uint32_t)temp + j, ACCESS_TYPE_WORD,
temp[i-1], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != (uint32_t)(second_pattern)) {
if (!error)
printf("\n Read Fail\n");
print_error((uint32_t)temp + j + 4, ACCESS_TYPE_WORD,
temp[i-1], second_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 8;
}
if (error == 0)
printf("read pass");
return MTSP_OPERATION_OK;
}
/**
* memory_test_type2 - This function tests the wanted memory
* according to parameters
* @addr - start address for memory to be tested
* @size - size of memory to be tested
* @first_pattern - pattern to test the memory
* @pattern - kind of pattern to test the memory
* @increment - if its increment or decrement
* if test pass, returen 0;if test failed - see error value
*/
uint32_t memory_test_type2(uint32_t addr, uint32_t size,
uint32_t first_pattern,
uint32_t pattern, uint8_t increment)
{
uint32_t i = 0, j = 0, error = 0;
uint32_t *temp = (uint32_t *)addr;
uint32_t first_pattern_restore = first_pattern;
int inc;
if (increment)
inc = 1;
else
inc = -1;
while (j < size) {
/*Write the data*/
temp[i++] = (uint32_t)(first_pattern);
j += 4;
first_pattern = first_pattern + inc;
}
printf("write pass\n");
#ifndef LOG_SILENT
/*Inform user that test has continue - read sequence*/
for (i = 0; i < 7; i++) {
mtsp_test_msg[pattern][MTSP_MSG_WRITING_OFFSET + i] =
mtsp_msg_read[i];
}
if (logout_mode == FULL_MODE)
printf("%s", (char *)mtsp_test_msg[pattern]);
#endif
/*Perform activities between write to read*/
j = 0;
i = 0;
/*Restore patterns*/
first_pattern = first_pattern_restore;
while (j < size) {
/*Read the data and compare it to the pattern*/
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail\n");
print_error((uint32_t)temp + j, ACCESS_TYPE_WORD,
temp[i-1], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 4;
first_pattern = first_pattern + inc;
}
if (error == 0)
printf("read pass");
return MTSP_OPERATION_OK;
}
/**
* memory_test_type3 - This function tests the wanted memory
* according to parameters
* @addr - start address for memory to be tested
* @size - size of memory to be tested
* @first_pattern - pattern to test the memory
* @second_pattern - pattern to test the memory
* @pattern - kind of pattern to test the memory
* @left - it the rotation is left or right
* if test pass, returen 0;if test failed - see error value
*/
uint32_t memory_test_type3(uint32_t addr, uint32_t size,
uint32_t first_pattern,
uint32_t second_pattern,
uint32_t pattern, uint8_t left)
{
uint32_t i = 0, j = 0, error = 0;
uint32_t *temp = (uint32_t *)addr;
uint32_t first_pattern_restore = first_pattern;
uint32_t second_pattern_restore = second_pattern;
uint32_t rotate_number;
if (left)
rotate_number = 31;
else
rotate_number = 1;
while (j < size) {
/*Write the data*/
temp[i++] = (uint32_t)(first_pattern);
temp[i++] = (uint32_t)(second_pattern);
j += 8;
rotate(first_pattern, rotate_number);
rotate(second_pattern, rotate_number);
}
printf("write pass\n");
#ifndef LOG_SILENT
/*Inform user that test has continue - read sequence*/
for (i = 0; i < 7; i++) {
mtsp_test_msg[pattern][MTSP_MSG_WRITING_OFFSET + i] =
mtsp_msg_read[i];
}
if (logout_mode == FULL_MODE)
printf("%s", (char *)mtsp_test_msg[pattern]);
#endif
j = 0;
i = 0;
/*Restore patterns*/
first_pattern = first_pattern_restore;
second_pattern = second_pattern_restore;
while (j < size) {
/*Read the data and compare it to the pattern*/
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail\n");
print_error((uint32_t)temp + j, ACCESS_TYPE_WORD,
temp[i-1], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != (uint32_t)(second_pattern)) {
if (!error)
printf("\n Read Fail\n");
print_error((uint32_t)temp + j + 4, ACCESS_TYPE_WORD,
temp[i-1], second_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 8;
rotate(first_pattern, rotate_number);
rotate(second_pattern, rotate_number);
}
if (error == 0)
printf("read pass");
return MTSP_OPERATION_OK;
}
/**
* memory_test_type4 - This function tests the wanted memory
* according to parameters
* @addr - start address for memory to be tested
* @size - size of memory to be tested
* @first_pattern - pattern to test the memory
* @pattern - kind of pattern to test the memory
* @left - it the rotation is left or right
* if test pass, returen 0;if test failed - see error value
*/
uint32_t memory_test_type4(uint32_t addr, uint32_t size,
uint32_t first_pattern,
uint32_t pattern, uint8_t left)
{
uint32_t i = 0, j = 0, error = 0;
uint32_t *temp = (uint32_t *)addr;
uint32_t first_pattern_restore = first_pattern;
uint32_t rotate_number;
if (left)
rotate_number = 31;
else
rotate_number = 1;
while (j < size) {
/*Write the data*/
temp[i++] = (uint32_t)(first_pattern);
j += 4;
rotate(first_pattern, rotate_number);
}
printf("write pass\n");
#ifndef LOG_SILENT
/*Inform user that test has continue - read sequence*/
for (i = 0; i < 7; i++) {
mtsp_test_msg[pattern][MTSP_MSG_WRITING_OFFSET + i] =
mtsp_msg_read[i];
}
if (logout_mode == FULL_MODE)
printf("%s", (char *)mtsp_test_msg[pattern]);
#endif
j = 0;
i = 0;
/*Restore patterns*/
first_pattern = first_pattern_restore;
while (j < size) {
/*Read the data and compare it to the pattern*/
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail\n");
print_error((uint32_t)temp + j, ACCESS_TYPE_WORD,
temp[i-1], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 4;
rotate(first_pattern, rotate_number);
}
if (error == 0)
printf("read pass");
return MTSP_OPERATION_OK;
}
/**
* memory_test_type5 - This function tests the wanted memory
* according to parameters
* @addr - start address for memory to be tested
* @size - size of memory to be tested
* @first_pattern - pattern to test the memory
* @second_pattern - pattern to test the memory
* @pattern - kind of pattern to test the memory
* if test pass, returen 0;if test failed - see error value
*/
uint32_t memory_test_type5(uint32_t addr, uint32_t size,
uint32_t first_pattern,
uint32_t second_pattern, uint32_t pattern)
{
uint32_t i = 0, j = 0, error = 0;
uint32_t *temp = (uint32_t *)addr;
uint32_t first_pattern_restore = first_pattern;
uint32_t second_pattern_restore = second_pattern;
while (j < size) {
/*Write the data*/
temp[i++] = (uint32_t)(first_pattern);
temp[i++] = (uint32_t)(second_pattern);
j += 8;
rotate(first_pattern, 31);
}
printf("write pass\n");
#ifndef LOG_SILENT
/*Inform user that test has continue - read sequence*/
for (i = 0; i < 7; i++) {
mtsp_test_msg[pattern][MTSP_MSG_WRITING_OFFSET + i] =
mtsp_msg_read[i];
}
if (logout_mode == FULL_MODE)
printf("%s", (char *)mtsp_test_msg[pattern]);
#endif
j = 0;
i = 0;
/*Restore patterns*/
first_pattern = first_pattern_restore;
second_pattern = second_pattern_restore;
while (j < size) {
/*Read the data and compare it to the pattern*/
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail\n");
print_error((uint32_t)temp + j, ACCESS_TYPE_WORD,
temp[i-1], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != (uint32_t)(second_pattern)) {
if (!error)
printf("\n Read Fail\n");
print_error((uint32_t)temp + j + 4, ACCESS_TYPE_WORD,
temp[i-1], second_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 8;
rotate(first_pattern, 31);
}
if (error == 0)
printf("read pass");
return MTSP_OPERATION_OK;
}
/**
* memory_test_type6 - This function tests the wanted memory
* according to parameters
* @addr - start address for memory to be tested
* @size - size of memory to be tested
* @first_pattern - pattern to test the memory
* @second_pattern - pattern to test the memory
* @pattern - kind of pattern to test the memory
* if test pass, returen 0;if test failed - see error value
*/
uint32_t memory_test_type6(uint32_t addr, uint32_t size,
uint32_t first_pattern,
uint32_t second_pattern, uint32_t pattern)
{
uint32_t i = 0, j = 0, error = 0;
uint32_t temp_val;
uint32_t *temp = (uint32_t *)addr;
uint32_t first_pattern_restore = first_pattern;
uint32_t second_pattern_restore = second_pattern;
while (j < size) {
/*Write the data*/
temp[i++] = 0x0;
temp_val = (uint32_t)(first_pattern | second_pattern);
temp[i++] = temp_val;
temp[i++] = 0x0;
temp[i++] = temp_val;
temp[i++] = (uint32_t)(first_pattern);
temp[i++] = (uint32_t)(first_pattern);
temp[i++] = (uint32_t)(first_pattern);
temp[i++] = (uint32_t)(first_pattern);
j += 32;
rotate(first_pattern, 31);
rotate(second_pattern, 31);
}
printf("write pass\n");
#ifndef LOG_SILENT
/*Inform user that test has continue - read sequence*/
for (i = 0; i < 7; i++) {
mtsp_test_msg[pattern][MTSP_MSG_WRITING_OFFSET + i] =
mtsp_msg_read[i];
}
if (logout_mode == FULL_MODE)
printf("%s", (char *)mtsp_test_msg[pattern]);
#endif
j = 0;
i = 0;
/*Restore patterns*/
first_pattern = first_pattern_restore;
second_pattern = second_pattern_restore;
while (j < size) {
/*Read the data and compare it to the pattern*/
if (temp[i++] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j, ACCESS_TYPE_WORD,
temp[i-1], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
temp_val = (uint32_t)(first_pattern | second_pattern);
if (temp[i++] != temp_val) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 4, ACCESS_TYPE_WORD,
temp[i-1], temp_val);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 8, ACCESS_TYPE_WORD,
temp[i-1], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != temp_val) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 12, ACCESS_TYPE_WORD,
temp[i-1], temp_val);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 16, ACCESS_TYPE_WORD,
temp[i-1], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 20, ACCESS_TYPE_WORD,
temp[i-1], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 24, ACCESS_TYPE_WORD,
temp[i-1], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 28, ACCESS_TYPE_WORD,
temp[i-1], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 32;
rotate(first_pattern, 31);
rotate(second_pattern, 31);
}
if (error == 0)
printf("read pass");
return MTSP_OPERATION_OK;
}
/**
* memory_test_type7 - This function tests the wanted memory
* according to parameters
* @addr - start address for memory to be tested
* @size - size of memory to be tested
* @first_pattern - pattern to test the memory
* @second_pattern - pattern to test the memory
* @pattern - kind of pattern to test the memory
* if test pass, returen 0;if test failed - see error value
*/
uint32_t memory_test_type7(uint32_t addr, uint32_t size,
uint32_t first_pattern,
uint32_t second_pattern, uint32_t pattern)
{
uint32_t i = 0, j = 0, error = 0;
uint32_t temp_val;
uint32_t *temp = (uint32_t *)addr;
uint32_t first_pattern_restore = first_pattern;
uint32_t second_pattern_restore = second_pattern;
while (j < size) {
/*Write the data*/
temp[i++] = 0x0;
temp_val = (uint32_t)(first_pattern | second_pattern);
temp[i++] = temp_val;
temp[i++] = 0x0;
temp[i++] = temp_val;
temp[i++] = (uint32_t)(first_pattern);
temp[i++] = 0x0;
temp[i++] = (uint32_t)(first_pattern);
temp[i++] = 0x0;
j += 32;
rotate(first_pattern, 31);
rotate(second_pattern, 31);
}
printf("write pass\n");
#ifndef LOG_SILENT
/*Inform user that test has continue - read sequence*/
for (i = 0; i < 7; i++) {
mtsp_test_msg[pattern][MTSP_MSG_WRITING_OFFSET + i] =
mtsp_msg_read[i];
}
if (logout_mode == FULL_MODE)
printf("%s", (char *)mtsp_test_msg[pattern]);
#endif
j = 0;
i = 0;
/*Restore patterns*/
first_pattern = first_pattern_restore;
second_pattern = second_pattern_restore;
while (j < size) {
/*Read the data and compare it to the pattern*/
if (temp[i++] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j, ACCESS_TYPE_WORD,
temp[i-1], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
temp_val = (uint32_t)(first_pattern | second_pattern);
if (temp[i++] != temp_val) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 4, ACCESS_TYPE_WORD,
temp[i-1], temp_val);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 8, ACCESS_TYPE_WORD,
temp[i-1], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != temp_val) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 12, ACCESS_TYPE_WORD,
temp[i-1], temp_val);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 16, ACCESS_TYPE_WORD,
temp[i-1], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 20, ACCESS_TYPE_WORD,
temp[i-1], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 24, ACCESS_TYPE_WORD,
temp[i-1], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i++] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 28, ACCESS_TYPE_WORD,
temp[i-1], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 32;
rotate(first_pattern, 31);
rotate(second_pattern, 31);
}
if (error == 0)
printf("read pass");
return MTSP_OPERATION_OK;
}
/**
* memory_test_type8 - This function tests the wanted memory
* according to parameters
* @addr - start address for memory to be tested
* @size - size of memory to be tested
* @first_pattern - pattern to test the memory
* @second_pattern - pattern to test the memory
* @pattern - kind of pattern to test the memory
* if test pass, returen 0;if test failed - see error value
*/
uint32_t memory_test_type8(uint32_t addr, uint32_t size,
uint32_t first_pattern,
uint32_t second_pattern, uint32_t pattern)
{
uint32_t i = 0, j = 0, error = 0;
int loop = 1, freq;
int end_test = 0;
uint32_t *temp = (uint32_t *)addr;
uint32_t first_pattern_restore = first_pattern;
uint32_t second_pattern_restore = second_pattern;
/*Infinite loop - if J=>size break the loop*/
for (;;) {
/*Write the data*/
freq = loop;
while (freq) {
temp[i++] = (uint32_t)(first_pattern);
j += 4;
if (j >= size) {
end_test = 1;
freq = 1;
break;
}
freq--;
}
if (end_test)
break;
freq = loop;
while (freq) {
temp[i++] = (uint32_t)(second_pattern);
j += 4;
if (j >= size) {
end_test = 1;
freq = 1;
break;
}
freq--;
}
if (end_test)
break;
loop++;
if (loop == 0x100)
loop = 1;
}
printf("write pass\n");
#ifndef LOG_SILENT
/*Inform user that test has continue - read sequence*/
for (i = 0; i < 7; i++) {
mtsp_test_msg[pattern][MTSP_MSG_WRITING_OFFSET + i] =
mtsp_msg_read[i];
}
if (logout_mode == FULL_MODE)
printf("%s", (char *)mtsp_test_msg[pattern]);
#endif
j = 0;
i = 0;
loop = 1;
/*Restore patterns*/
first_pattern = first_pattern_restore;
second_pattern = second_pattern_restore;
/*Infinite loop - if J=>size break the loop*/
for (;;) {
/*Write the data*/
freq = loop;
while (freq) {
if (temp[i++] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j,
ACCESS_TYPE_WORD, temp[i-1],
first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 4;
if (j >= size) {
end_test = 1;
freq = 1;
break;
}
freq--;
}
if (end_test)
break;
freq = loop;
while (freq) {
if (temp[i++] != (uint32_t)(second_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j,
ACCESS_TYPE_WORD, temp[i-1],
second_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 4;
if (j >= size) {
end_test = 1;
freq = 1;
break;
}
freq--;
}
if (end_test)
break;
loop++;
if (loop == 0x100)
loop = 1;
}
if (error == 0)
printf("read pass");
return MTSP_OPERATION_OK;
}
/**
* memory_test_type9 - This function tests the wanted memory
* according to parameters
* @addr - start address for memory to be tested
* @size - size of memory to be tested
* @first_pattern - pattern to test the memory
* @second_pattern - pattern to test the memory
* @pattern - kind of pattern to test the memory
* if test pass, returen 0;if test failed - see error value
*/
uint32_t memory_test_type9(uint32_t addr, uint32_t size,
uint32_t first_pattern,
uint32_t second_pattern, uint32_t pattern)
{
uint32_t i = 0, j = 0, error = 0;
uint32_t *temp = (uint32_t *)addr;
uint32_t first_pattern_restore = first_pattern;
uint32_t second_pattern_restore = second_pattern;
uint32_t addr_restore = addr;
while (j < size) {
/*Write the data*/
if (addr & 0x20) {
temp[i] = (uint32_t)(first_pattern);
temp[i + 1] = (uint32_t)(second_pattern);
} else {
temp[i] = 0x0;
temp[i + 1] = 0x0;
}
if (addr & 0x40) {
temp[i + 2] = (uint32_t)(first_pattern);
temp[i + 3] = (uint32_t)(second_pattern);
} else {
temp[i + 2] = 0x0;
temp[i + 3] = 0x0;
}
if (addr&0x80) {
temp[i + 4] = (uint32_t)(first_pattern);
temp[i + 5] = (uint32_t)(second_pattern);
} else {
temp[i + 4] = 0x0;
temp[i + 5] = 0x0;
}
if (addr&0x100) {
temp[i + 6] = (uint32_t)(first_pattern);
temp[i + 7] = (uint32_t)(second_pattern);
} else {
temp[i + 6] = 0x0;
temp[i + 7] = 0x0;
}
i += 8;
j += 32;
addr += 32;
if (!(addr & 0x1E0)) {
if (((uint32_t)(first_pattern)) == 0x80000000) {
second_pattern = 0x1;
first_pattern = 0x0;
} else if (((uint32_t)(second_pattern)) == 0x80000000) {
second_pattern = 0x0;
first_pattern = 0x1;
} else {
second_pattern = second_pattern << 1;
first_pattern = first_pattern << 1;
}
}
}
printf("write pass\n");
#ifndef LOG_SILENT
/*Inform user that test has continue - read sequence*/
for (i = 0; i < 7; i++) {
mtsp_test_msg[pattern][MTSP_MSG_WRITING_OFFSET + i] =
mtsp_msg_read[i];
}
if (logout_mode == FULL_MODE)
printf("%s", (char *)mtsp_test_msg[pattern]);
#endif
j = 0;
i = 0;
/*Restore patterns*/
first_pattern = first_pattern_restore;
second_pattern = second_pattern_restore;
addr = addr_restore;
while (j < size) {
/*Write the data*/
if (addr & 0x20) {
if (temp[i] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j,
ACCESS_TYPE_WORD,
temp[i], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i + 1] != (uint32_t)(second_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 4,
ACCESS_TYPE_WORD,
temp[i + 1], second_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
} else {
if (temp[i] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j,
ACCESS_TYPE_WORD,
temp[i], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i + 1] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 4,
ACCESS_TYPE_WORD,
temp[i + 1], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
}
if (addr&0x40) {
if (temp[i + 2] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 8,
ACCESS_TYPE_WORD,
temp[i + 2], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i + 3] != (uint32_t)(second_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 12,
ACCESS_TYPE_WORD,
temp[i + 3], second_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
} else {
if (temp[i + 2] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 8,
ACCESS_TYPE_WORD,
temp[i + 2], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i + 3] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 12,
ACCESS_TYPE_WORD,
temp[i + 3], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
}
if (addr&0x80) {
if (temp[i + 4] != (uint32_t)(first_pattern)) {
printf("\n Read Fail");
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 16,
ACCESS_TYPE_WORD,
temp[i + 4], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i + 5] != (uint32_t)(second_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 20,
ACCESS_TYPE_WORD,
temp[i + 5], second_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
} else {
if (temp[i + 4] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 16,
ACCESS_TYPE_WORD,
temp[i + 4], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i + 5] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 20,
ACCESS_TYPE_WORD,
temp[i + 5], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
}
if (addr&0x100) {
if (temp[i + 6] != (uint32_t)(first_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 24,
ACCESS_TYPE_WORD,
temp[i + 6], first_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i + 7] != (uint32_t)(second_pattern)) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 28,
ACCESS_TYPE_WORD,
temp[i + 7], second_pattern);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
} else {
if (temp[i + 6] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 24,
ACCESS_TYPE_WORD,
temp[i + 6], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
if (temp[i + 7] != 0x0) {
if (!error)
printf("\n Read Fail");
print_error((uint32_t)temp + j + 28,
ACCESS_TYPE_WORD,
temp[i + 7], 0x0);
mtsp_total_error++;
error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
}
i += 8;
j += 32;
addr += 32;
if (!(addr & 0x1E0)) {
if (((uint32_t)(first_pattern)) == 0x80000000) {
second_pattern = 0x1;
first_pattern = 0x0;
} else if (((uint32_t)(second_pattern)) == 0x80000000) {
second_pattern = 0x0;
first_pattern = 0x1;
} else {
second_pattern = second_pattern << 1;
first_pattern = first_pattern << 1;
}
}
}
if (error == 0)
printf("read pass");
return MTSP_OPERATION_OK;
}
/**
* memory_test - This function tests the wanted memory
* according to parameters
* @addr - start address for memory to be tested
* @size - size of memory to be tested
* @pattern - kind of pattern to test the memory
* @access - BYTE,WORD or DWORD
* @mtsp - to define if the test is MTSP type
* if test pass, returen 0;if test failed - see error value
*/
uint32_t memory_test(uint32_t addr, uint32_t size,
enum pattern_number pattern, uint8_t access, uint8_t mtsp)
{
uint32_t i = 0, j = 0;
uint8_t mtsp_rc = MTSP_OPERATION_OK;
uint32_t first_pattern = 0, second_pattern = 0;
uint8_t *t_addr8 = (uint8_t *)addr;
uint16_t *t_addr16 = (uint16_t *)addr;
uint32_t *temp = (uint32_t *)addr;
#ifndef LOG_SILENT
char SUCCESS_SIGN = '.';
#endif
/*Get the desired pattern but only for WORD patterns*/
if (mtsp) {
if (smtd_stat&0x1) {
first_pattern = smtd_pat;
second_pattern = ~smtd_pat;
} else {
first_pattern = pattern_list[pattern].first_pattern;
second_pattern = pattern_list[pattern].second_pattern;
}
#ifndef LOG_SILENT
if (logout_mode == FULL_MODE) {
/*Inform user that test has begun - write sequence*/
printf("%s", (char *)mtsp_test_msg[pattern]);
} else if (logout_mode == SIGN_MODE)
putc(SUCCESS_SIGN);
#endif
/*Call test functions*/
switch (pattern) {
case PATTERN_NUMBER_ONE:
case PATTERN_NUMBER_TWO:
case PATTERN_NUMBER_THREE:
case PATTERN_NUMBER_FIVE:
mtsp_rc = memory_test_type1(addr, size, first_pattern,
second_pattern, pattern);
break;
case PATTERN_NUMBER_FOUR:
mtsp_rc = memory_test_type2(addr, size, first_pattern,
pattern, 0);
break;
case PATTERN_NUMBER_SIX:
case PATTERN_NUMBER_SEVEN:
case PATTERN_NUMBER_EIGHT:
mtsp_rc = memory_test_type3(addr, size, first_pattern,
second_pattern, pattern, 0);
break;
case PATTERN_NUMBER_NINE:
case PATTERN_NUMBER_TEN:
case PATTERN_NUMBER_ELEVEN:
mtsp_rc = memory_test_type3(addr, size, first_pattern,
second_pattern, pattern, 1);
break;
case PATTERN_NUMBER_TWELVE:
case PATTERN_NUMBER_THIRTEEN:
case PATTERN_NUMBER_FOURTEEN:
mtsp_rc = memory_test_type4(addr, size, first_pattern,
pattern, 0);
break;
case PATTERN_NUMBER_FIFTEEN:
case PATTERN_NUMBER_SIXTEEN:
case PATTERN_NUMBER_SEVENTEEN:
mtsp_rc = memory_test_type4(addr, size,
first_pattern, pattern, 1);
break;
case PATTERN_NUMBER_EIGHTEEN:
case PATTERN_NUMBER_NINETEEN:
case PATTERN_NUMBER_TWENTY:
case PATTERN_NUMBER_TWENTYONE:
case PATTERN_NUMBER_TWENTYTWO:
case PATTERN_NUMBER_TWENTYTHREE:
mtsp_rc = memory_test_type5(addr, size, first_pattern,
second_pattern, pattern);
break;
case PATTERN_NUMBER_TWENTYFOUR:
case PATTERN_NUMBER_TWENTYFIVE:
case PATTERN_NUMBER_TWENTYSEVEN:
mtsp_rc = memory_test_type6(addr, size, first_pattern,
second_pattern, pattern);
break;
case PATTERN_NUMBER_TWENTYSIX:
mtsp_rc = memory_test_type7(addr, size, first_pattern,
second_pattern, pattern);
break;
case PATTERN_NUMBER_TWENTYEIGHT:
mtsp_rc = memory_test_type8(addr, size, first_pattern,
second_pattern, pattern);
break;
case PATTERN_NUMBER_TWENTYNINE:
mtsp_rc = memory_test_type2(addr, size, first_pattern,
pattern, 1);
break;
case PATTERN_NUMBER_THIRTY:
mtsp_rc = memory_test_type9(addr, size, first_pattern,
second_pattern, pattern);
break;
case PATTERN_NUMBER_THIRTYONE:
mtsp_rc = memory_test_type1(addr, size, first_pattern,
0xFFFFFFFF, pattern);
break;
case PATTERN_NUMBER_THIRTYTWO:
mtsp_rc = memory_test_type1(addr, size, first_pattern,
0x00000000, pattern);
break;
default:
break;
}
#ifndef LOG_SILENT
if (logout_mode == FULL_MODE)
printf("\n");
/*Change back the string to write*/
for (i = 0; i < 7; i++) {
mtsp_test_msg[pattern][MTSP_MSG_WRITING_OFFSET + i]
= mtsp_msg_write[i];
}
#endif
} else {
#ifndef LOG_SILENT
/*Inform user for regular memory test on the desired memory*/
if (logout_mode == FULL_MODE)
printf("Regular memory test begins.\n");
#endif
while (j < size) {
switch (access) {
case ACCESS_TYPE_BYTE:
t_addr8[i] = (uint8_t)(pattern&0xFF);
if (t_addr8[i++] != (uint8_t)(pattern&0xFF)) {
print_error((uint32_t)t_addr8+j, access,
t_addr8[i-1], pattern);
mtsp_total_error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 1;
break;
case ACCESS_TYPE_HWORD:
t_addr16[i] = (uint16_t)(pattern&0xFFFF);
if (t_addr16[i++] !=
(uint16_t)(pattern&0xFFFF)) {
print_error((uint32_t)t_addr16+j,
access, t_addr16[i-1],
pattern);
mtsp_total_error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 2;
break;
case ACCESS_TYPE_WORD:
temp[i] = (uint32_t)(pattern);
if (temp[i++] != (uint32_t)(pattern)) {
print_error((uint32_t)temp + j, access,
temp[i-1], pattern);
mtsp_total_error++;
if (exit_when_error)
return MTSP_READ_FAIL;
}
j += 4;
break;
default:
return MTSP_WRONG_PARAMETER;
}
}
mtsp_rc = MTSP_OPERATION_OK;
}
return mtsp_rc;
}
uint32_t mtsp_test(uint32_t addr, uint32_t size, uint32_t pattern,
uint32_t pre_read)
{
uint32_t cur_pattern = 0;
uint32_t index = 0x1;
size_t i;
uint8_t mtsp_rc = MTSP_OPERATION_OK;
uint32_t tmsec = 0;
mtsp_total_error = 0;
if (bit_byte_check) {
for (i = 0; i < sizeof(byte_err_sta)/sizeof(uint32_t); i++)
byte_err_sta[i] = 0;
for (i = 0; i < sizeof(bit_err_sta)/sizeof(uint32_t); i++)
bit_err_sta[i] = 0;
}
if (logout_mode == FULL_MODE) {
/*Need to add many prints to the user - OR*/
printf("MTSP test starts from:");
printw(addr);
printf(" to :");
printw(addr + size);
printf("\n");
tmsec = get_timer(0);
}
for (i = 0; i < 32; i++) {
cur_pattern = pattern & (index << i);
if (cur_pattern) {
mtsp_rc = memory_test(addr, size, i,
ACCESS_TYPE_WORD, 1);
if (mtsp_rc)
break;
}
}
if (logout_mode == FULL_MODE) {
tmsec = get_timer(0) - tmsec;
printf("Elapsed time: %d msec\n", tmsec);
if (mtsp_total_error)
printf("mtsp mem test finished and %d errors occur\n",
mtsp_total_error);
else
printf("mtsp memory test finished successfully.\n");
} else if (logout_mode == SIGN_MODE)
printf("\n");
if (logout_mode >= MINIMAL_MODE && logout_mode < FULL_MODE &&
mtsp_total_error)
printf("mstp--> Test failed\n");
if (mtsp_total_error) {
if (bit_byte_check) {
printf("*** MTSP BYTE & BIT error statistics ***\n");
for (i = 0; i < sizeof(byte_err_sta)/sizeof(uint32_t);
i++)
printf("BYTE %d error: %d\n",
i, byte_err_sta[i]);
printf("----------\n");
for (i = 0; i < sizeof(bit_err_sta)/sizeof(uint32_t);
i++)
printf("BIT %d error: %d\n",
i, bit_err_sta[i]);
}
return MTSP_READ_FAIL;
}
return mtsp_rc;
}
int mtsp(int argc, uint8_t **argv)
{
uint32_t mem_test_size, patterns_to_activate;
uint32_t startAddr, test_times, i;
logout_mode = FULL_MODE;
test_times = 1;
switch (argc) {
case 1:
printf("mtsp--> Enter the start addr to be tested\n");
break;
case 2:
printf("mtsp--> Enter number of byte to be tested\n");
break;
case 3:
printf("mtsp--> Set bits of the test to be run\n");
break;
case 5:
test_times = conv_dec((char *)argv[4]);
case 4:
mem_test_size = conv_hex((char *)argv[2]);
startAddr = conv_hex((char *)argv[1]);
patterns_to_activate = conv_hex((char *)argv[3]);
for (i = 0; i < test_times; i++) {
printf("\n**** MTSP TEST LOOP: %d *****\n", i + 1);
if (mtsp_test(startAddr, mem_test_size,
patterns_to_activate, 0))
return -1;
}
break;
default:
break;
}
return 0;
}
void bbu_smtd_help(void)
{
printf("smtd - Set Memory Test Defaults.\n");
printf("The SMTD command is used to set the memory test\n");
printf("Usage:smtd [<pattern>]\n");
printf("pattern = The first pattern for mtsp test\n");
printf("Note: 1. Use 'smtd ena' to enable/disable default pattern\n");
printf("2. Use 'smtd mode' to switch the mtsp test mode:\n");
printf(" continue or terminate the test when error occurs\n");
printf("3. Use 'smtd check' to enable/disable byte&bit check\n");
printf("If no argument entered, will display current defaults\n");
}
int smtd(int argc, uint8_t **argv)
{
switch (argc) {
case 1:
if (smtd_stat == 0)
printf("\nsmtd--> The default pattern is enabled\n");
else
printf("\nsmtd--> The default pattern is disabled\n");
if (exit_when_error == 0)
printf(" --> continue test when error happens\n");
else
printf(" --> exit test when error happens\n");
if (bit_byte_check == 0)
printf(" --> Byte and bit check is disabled\n");
else
printf(" --> Byte and bit check is enabled\n");
break;
case 2:
if (!strcmp((const char *)argv[1], "ena")) {
if (smtd_stat == 0) {
smtd_stat = 1;
printf("smtd--> default pattern is disabled\n");
} else {
smtd_stat = 0;
printf("smtd--> default pattern is enabled\n");
}
} else if (!strcmp((const char *)argv[1], "mode")) {
if (exit_when_error) {
exit_when_error = 0;
printf("smtd--> error occurs, test continue\n");
} else {
exit_when_error = 1;
printf("smtd--> error occurs, test exit\n");
}
} else if (!strcmp((const char *)argv[1], "check")) {
if (bit_byte_check) {
bit_byte_check = 0;
printf("smtd--> byte&bit check is disabled\n");
} else {
bit_byte_check = 1;
printf("smtd--> byte&bit check is enabled\n");
}
} else
smtd_pat = conv_hex((char *)argv[1]);
break;
default:
bbu_smtd_help();
break;
}
return 1;
}
int do_mtsp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return mtsp(argc, argv);
}
U_BOOT_CMD(
mtsp, 5, 1, do_mtsp,
"Switch UART to another cpu",
"Usage:\nuartsw [cpu id]"
);
int do_smtd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return smtd(argc, argv);
}
U_BOOT_CMD(
smtd, 5, 1, do_smtd,
"Switch UART to another cpu",
"Usage:\nuartsw [cpu id]"
);