memtest 函数

最新推荐文章于 2023-04-19 08:34:50 发布
最新推荐文章于 2023-04-19 08:34:50 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： C/C++

 

/*
**  Reorganize the test_memtest code.
**					Leon   2013.04.14
*/
/* DMA related definition */
/* Following structure used for special hardware implement */
/* DMA transmission width, bit 31:6 */
#define HAL_PACERS_DMA_TRANS_WIDTH_BIT	6
/* DMA destination address increase enable, bit 5 */
#define HAL_PACERS_DMA_DST_INC_BIT		5
/* DMA source address increase enable, bit 3 */
#define HAL_PACERS_DMA_SRC_INC_BIT		3
/* DMA destination transport disable, bit 4 */
#define HAL_PACERS_DMA_TRANS_DIS_BIT		4
/* DMA enable, bit 2 */
#define HAL_PACERS_DMA_ENABLE_BIT		2
	
#define LOG_PRINTF printf
#define debug_printf printf /*on or off debug print*/
#define ATOI atoi
#define STRCMP strcmp
#define UINT8 unsigned char
#define UINT16 unsigned short
#define UINT32 unsigned int
#define INT32  int
#define GDMA_DST_ADDR 0x85000000
#define GDMA_SRC_ADDR 0x8a000000
#define NULL 0
	
struct dma_link_node {
	UINT32 control; 				/* Channel control register value */
	UINT32 src_addr;				/* Source address */
	UINT32 dst_addr;				/* Destin address */
	UINT32 next_node;				/* Next node address */
};
inline void *hal_vaddr_to_paddr(void *vaddr)
{
	UINT8 tmp = (UINT32)vaddr >> 29;

	if (tmp >= 0x4 && tmp < 0x6) {
		return (void *)((UINT32)vaddr & ~0xE0000000);
	} else {
		return vaddr;
	}
}

void reset_gdma()/*reset  gdma.*/
{
	CPUregWrite_32(0xbf20009c, 0x00000080); 
	CPUregWrite_32(0xbf200080, 0xfffff7ff); 
	delay(50000);
	CPUregWrite_32(0xbf200080, 0xffffffff);
}
UINT32 fill_data(void *addr,UINT32 length)/*fill data at some physical addr.*/
{
	UINT32 i,data;
	UINT32 gdma_src_addr = (UINT32)addr;
	
	for (i = 0; i < length/4; i++) 
	{
		if((i%4)==0)
		{
			((volatile UINT32 *)gdma_src_addr)[i] = 0xa5a5a5a5;
			data = ((volatile UINT32 *)gdma_src_addr)[i];
			if ((UINT32)data !=0xa5a5a5a5) {
				LOG_PRINTF("0x%08x: Error! 0x%08x\n", ((int *)gdma_src_addr) + i, data);
				return 0;
			}
		}
		if((i%4)==1)
		{
			((volatile UINT32 *)gdma_src_addr)[i] = 0;
			data = ((volatile UINT32 *)gdma_src_addr)[i];
			if ((UINT32)data != 0) {
				LOG_PRINTF("0x%08x: Error! 0x%08x\n", ((int *)gdma_src_addr) + i, data);
				return 0;
			}
		}
		if((i%4)==2)
		{
			((volatile UINT32 *)gdma_src_addr)[i] = 0x5a5a5a5a;
			data = ((volatile UINT32 *)gdma_src_addr)[i];
			if ((UINT32)data !=0x5a5a5a5a) {
				LOG_PRINTF("0x%08x: Error! 0x%08x\n", ((int *)gdma_src_addr) + i, data);
				return 0;
			}
		}	
		if((i%4)==3)
		{
			((volatile UINT32 *)gdma_src_addr)[i] = 0;
			data = ((volatile UINT32 *)gdma_src_addr)[i];
			if ((UINT32)data != 0) {
				LOG_PRINTF("0x%08x: Error! 0x%08x\n", ((int *)gdma_src_addr) + i, data);
				return 0;
			}
		}
	}
	return 0;
}
UINT32 check_data(void *addr,UINT32 length)/*fill data at some physical addr.*/
{
	UINT32 i,data;
	UINT32 gdma_src_addr = (UINT32)addr;
	
	for (i = 0; i < length/4; i++) 
	{
		if((i%4)==0)
		{
			((volatile UINT32 *)gdma_src_addr)[i] = 0xa5a5a5a5;
			data = ((volatile UINT32 *)gdma_src_addr)[i];
			if ((UINT32)data !=0xa5a5a5a5) {
				LOG_PRINTF("0x%08x: Error! 0x%08x\n", ((int *)gdma_src_addr) + i, data);
//				return 0;
			}
		}
		if((i%4)==1)
		{
			((volatile UINT32 *)gdma_src_addr)[i] = 0;
			data = ((volatile UINT32 *)gdma_src_addr)[i];
			if ((UINT32)data != 0) {
				LOG_PRINTF("0x%08x: Error! 0x%08x\n", ((int *)gdma_src_addr) + i, data);
//				return 0;
			}
		}
		if((i%4)==2)
		{
			((volatile UINT32 *)gdma_src_addr)[i] = 0x5a5a5a5a;
			data = ((volatile UINT32 *)gdma_src_addr)[i];
			if ((UINT32)data !=0x5a5a5a5a) {
				LOG_PRINTF("0x%08x: Error! 0x%08x\n", ((int *)gdma_src_addr) + i, data);
//				return 0;
			}
		}	
		if((i%4)==3)
		{
			((volatile UINT32 *)gdma_src_addr)[i] = 0;
			data = ((volatile UINT32 *)gdma_src_addr)[i];
			if ((UINT32)data != 0) {
				LOG_PRINTF("0x%08x: Error! 0x%08x\n", ((int *)gdma_src_addr) + i, data);
//				return 0;
			}
		}
	}
	return 0;
}

struct item_node
{
	UINT32 control;
	UINT32 src_addr;
	UINT32 dst_addr;
	UINT32 next_node;
};

void gdma_mv_data(void *psrc,void *pdst,UINT32 length)
{
	reset_gdma();
	CPUregWrite_32(0xbf3c0804, 0x001fffff);/*need or not?*/
	
	UINT32 item_addr = (UINT32)malloc(0x100*sizeof(int));/*don't forget to free*/
	item_addr = (item_addr + 63)&0xfffffff0;/*16bytes align*/
	debug_printf("item_addr = 0x%x\n",item_addr);
	
	struct item_node *node =(struct item_node *)item_addr;
	node->control = ((length<<HAL_PACERS_DMA_TRANS_WIDTH_BIT)|(1<<HAL_PACERS_DMA_SRC_INC_BIT));
	node->src_addr = (UINT32)psrc;
	node->dst_addr = (UINT32)pdst;
	node->next_node = NULL;
	
	CPUregWrite_32(0xbf3c0010, (UINT32)hal_vaddr_to_paddr(&node));
	CPUregWrite_32(0xbf3c0000, 0x00021c01);
	CPUregWrite_32(0xbf3c00c4, 0x00000000);/*enable channel*/
	CPUregWrite_32(0xbf3c0004, 0x00000001);/*start to move data*/	

	free(node);	
}
UINT32 gdma_check_idle(UINT32 channel)
{
	int m = 0,timeout_flag = 0;
	while((~(((CPUregRead_32(0xbf3c0008))>>4)&0x1))&0x01)/*FIXME*/
	{
		delay(500000);
		m++;
		if(m == 100)/*LEON*/
		{
			timeout_flag = 1;
			break;		
		}
	};
	return timeout_flag;
}
static int test_memtest(int argc, char *argv[])
{
	UINT32 *start_addr, loop_num;
	INT32 data,i,j,k = 0,length,testmode = 0;
	UINT32 random,m;

	if (argc < 4) 
	{
		printf("Usage: %s [start_addr] [length] [loop_num] [testmode 0|1|2].\n", argv[0]);
		return -1;
	}
	if (!get_rsa ((UINT32 *)&start_addr, argv[1]))
	{
		printf("Please input the start address \n");
		return -1;
	}	
	if (!get_rsa ((UINT32 *)&length, argv[2]))
	{
		printf("Please input the length \n");
		return -1;
	}
	if (!get_rsa ((UINT32 *)&loop_num, argv[3]))
	{
		printf("Please input the loop number \n");
		return -1;
	}
	m = loop_num;

	if(argc > 4){
		get_rsa ((UINT32 *)&testmode, argv[4]);
	}
	
	if(testmode == 1)
	{
		printf("StartAddr:0x%x Length:0x%x Loop:0x%x\n",(UINT32)start_addr,length,loop_num);
		printf("TestMode = 1,In GDMA VDDR MODE.\n");		
		while(1)
		{
			printf("Loop Number = 0x%x\n",k++);
			
			int overtime_flag = 0;
			
			fill_data((void *)GDMA_SRC_ADDR,length);
			
			flushcache();
			
			gdma_mv_data(hal_vaddr_to_paddr((void *)GDMA_SRC_ADDR),((void *)start_addr),length);/*need to be fix!!!*/

			gdma_check_idle(0);
			
			gdma_mv_data(((void *)start_addr),hal_vaddr_to_paddr((void *)GDMA_DST_ADDR),length);/*need to be fix!!!*/			

			if (gdma_check_idle(0) == 1)/*check channel idle or not*/
			{
				overtime_flag = 1;
			}
			
			flushcache();
			
			check_data((void *)GDMA_DST_ADDR,length);
			
			if (overtime_flag == 1)
			{
				printf("WAIT TOO LONG FOR GDMA!\n");
				overtime_flag = 0;/*make sure*/
				return 0;
			}

			if ((loop_num != 0)&&((m--) == 0))/*deal with loop_num*/
			{
				break;/*break out of while(1)*/
			}
			printf("GDMA VDDR MEM TEST DONE.SUCCESS.\n");			
		}				
		return 0;		
	}
	else if(testmode==2)/*Test mddr.*/
	{
		printf("StartAddr:0x%x Length:0x%x Loop:0x%x\n",(UINT32)start_addr,length,loop_num);
		printf("TestMode = 2,In GDMA MDDR MODE.\n");
		while(1)
		{
			printf("Loop Number = 0x%x\n",k++);
			
			int overtime_flag = 0;
			
			fill_data((void *)GDMA_SRC_ADDR,length);
			
			flushcache();
			
			gdma_mv_data(hal_vaddr_to_paddr((void *)GDMA_SRC_ADDR),hal_vaddr_to_paddr((void *)GDMA_DST_ADDR),length);

			gdma_check_idle(0);
			
	//		gdma_mv_data(((void *)start_addr),hal_vaddr_to_paddr((void *)GDMA_DST_ADDR),length);/*need to be fix!!!*/			

			if (gdma_check_idle(0) == 1)/*check channel idle or not*/
			{
				overtime_flag = 1;
			}
			
			flushcache();
			
			check_data((void *)GDMA_DST_ADDR,length);
			
			if (overtime_flag == 1)
			{
				printf("WAIT TOO LONG FOR GDMA!\n");
				overtime_flag = 0;/*make sure*/
				return 0;
			}

			if ((loop_num != 0)&&((m--) == 0))/*deal with loop_num*/
			{
				break;
			}
			printf("GDMA VDDR MEM TEST DONE.SUCCESS.\n");			
		}
		return 0;
	}
	else
	{
		printf("StartAddr:0x%x Length:0x%x Loop:0x%x",(UINT32)start_addr,length,loop_num);
		printf("  TestMode = 0,In Normal MODE.\n");
		while(1)
		{
			LOG_PRINTF("Loop Number = 0x%x\n",k++);	
			int overtime_flag = 0;
			random = (UINT32)rand();
			
			for (i = 0; i < length; i++) {
				((volatile UINT8 *)start_addr)[i] = (UINT8)(i+random);
				data = ((volatile UINT8 *)start_addr)[i];
				if ((UINT8)data != (UINT8)(i+random)){
					LOG_PRINTF("0x%08x: Error! 0x%02x : 0x%02x\n", ((char *)start_addr) + i, (UINT8)(i+random), data);
					break;
				}
			}
			LOG_PRINTF("...");
			for (i = 0; i < length/2; i++) {
				((volatile UINT16 *)start_addr)[i] = (UINT16)(i+random);
				data = ((volatile UINT16 *)start_addr)[i];
				if ((UINT16)data != (UINT16)(i+random)){
					LOG_PRINTF("0x%08x: Error! 0x%04x : 0x%04x\n", ((short *)start_addr) + i, (UINT16)(i+random), data);
					break;
				}
			}
			LOG_PRINTF("...");
			for (i = 0; i < length/4; i++) {
				((volatile UINT32 *)start_addr)[i] = (UINT32)(i+random);
				data = ((volatile UINT32 *)start_addr)[i];
				if ((UINT32)data != (UINT32)(i+random)) {
					LOG_PRINTF("0x%08x: Error! 0x%08x : 0x%08x\n", ((int *)start_addr) + i, (UINT32)(i+random), data);
					break;
				}
			}
			for (i = length - 1; i >= 0; i--) {
				((volatile UINT8 *)start_addr)[i] = (UINT8)(i+random);
				data = ((volatile UINT8 *)start_addr)[i];
				if ((UINT8)data != (UINT8)(i+random)) {
					LOG_PRINTF("0x%08x: Error! 0x%02x : 0x%02x\n", ((char *)start_addr) + i, (UINT8)(i+random), data);
					break;
				}
			}
			LOG_PRINTF("...");
			for (i = length/2 - 1; i >= 0; i--) {
				((volatile UINT16 *)start_addr)[i] = (UINT16)(i+random);
				data = ((volatile UINT16 *)start_addr)[i];
				if ((UINT16)data != (UINT16)(i+random)) {
					LOG_PRINTF("0x%08x: Error! 0x%04x : 0x%04x\n", ((short *)start_addr) + i, (UINT16)(i+random), data);
					break;
				}
			}
			LOG_PRINTF("...");
			for (i = length/4 -1; i >= 0; i--) {
				((volatile UINT32 *)start_addr)[i] = (UINT32)(i+random);
				data = (UINT32)(((volatile UINT32 *)start_addr)[i]);
				if ((UINT32)data != (UINT32)(i+random)) {
					LOG_PRINTF("0x%08x: Error! 0x%08x : 0x%08x\n", ((int *)start_addr) + i, (UINT32)(i+random), data);
					break;
				}
			}

			if (overtime_flag == 1)
			{
				printf("WAIT TOO LONG FOR GDMA!\n");
				overtime_flag = 0;/*make sure*/
				return 0;
			}

			if ((loop_num != 0)&&((m--) == 0))/*deal with loop_num*/
			{
				break;
			}	
			
			printf("\nNormal MEM TEST DONE,SUCCESS.\n");
		}
		return 0;	
	}	
}

专注嵌入式
关注
专栏目录
memtest86+-5.31b.tar.gz
03-11
2. **内存检测模块**：此模块包含了各种内存测试算法，每个算法对应一个或多个函数，用于执行特定的内存测试。 3. **错误处理模块**：检测到错误时，该模块记录并报告错误位置和类型，帮助用户定位问题。 4. **用户...
Linux下内存压力测试工具memtest（使用心得）
热门推荐
Naidas的博客
11-29 1万+
1. 下载memtest 2. 安装 3. 交叉编译 4. 执行测试 5. 如何确认物理地址？
MemTest内存软件测试介绍说明-2
dramtest的博客
04-19 1万+
为了提高内存性能，使用了一些策略，例如通道交错（用于双通道，三通道和四通道设置），等级/库/行交错和地址刷新，以增加内存访问的并发性。根据所使用的芯片组，报告的ECC错误地址可以是系统内存地址（例如0x93801200）或DRAM列/组/行/列地址（例如0x3E0、0x5F6D，0x2、0x2）。然后，存储器控制器使用芯片组特定的地址解码方案对该存储器地址进行解码，以识别DRAM中的特定通道，DIMM，等级，DRAM芯片，存储体，行和列。在其他情况下，唯一的选择是用质量更好，速度更快的内存替换。
寄存器读写测试方法
水可马二的博客
01-18 1万+
业内人士介绍的两种寄存器读写测试方法1 测试方法1.1 九步法1、检查寄存器初值是否与表单描述一致 2、对寄存器升序写入0x5a5a5a5a，读出并check是否正确 3、对寄存器升序写入0xa5a5a5a5，读出并check是否正确，对该寄存器写入随机值，并读出检查是否正确 4、对寄存器降序写入0x5a5a5a5a，读出并check是否正确 5、对寄存器降序写入0xa5a5a5a5，读出
Memtest86 —— Modulo20 算法
weixin_44620949的博客
12-11 961
Memtest86 Modulo20 算法介绍
MEMTEST86
qq1327798176的博客
02-02 1万+
有很多测试内存的软件。但是，许多测试只是将一些模式套用到内存上，而没有对内存体系结构或如何最好地检测错误进行深入思考或了解。这对于硬盘故障很有效，但很少发现间歇性错误。基于 BIOS 的内存测试对于查找间歇性内存错误毫无用处。 存储芯片由大量紧密堆积的存储单元组成，每位数据一个。绝大多数间歇性故障是这些存储单元之间相互作用的结果。通常，写入存储单元会导致相邻单元之一被写入相同的数据。有效的内存测...
C# WPF to automate HCI MemTest.zip
最新发布
12-27
3. **MemTestAutomation.cs**: 包含自动化内存测试的逻辑，可能包括启动、停止测试，以及收集和解析测试结果的函数。 4. **HCI MemTest.exe**: 可能是被自动化调用的内存测试工具的可执行文件。 5. **App.xaml**: ...
linux ddr2 测试memtest)
10-22
`memtest.c`包含了实际的内存测试逻辑，而`memtest.h`可能包含了函数声明、数据结构定义等头文件内容，供`memtest.c`使用。开发者可以通过编译这两个文件生成可执行程序，然后在目标设备上运行以测试DDR2内存。 四...
开源项目-sethgrid-memtest.zip
09-03
对于这个记忆游戏，可能会有用于生成随机记忆卡片的类，处理用户输入的函数，以及负责显示和更新游戏界面的部分。 2. **配置文件**：项目可能包含配置文件，如设置文件或环境变量，用于自定义游戏的行为，例如难度...
redis源码日志（源码分析）
01-27
Redis是一款高性能的键值存储系统，其开源代码的解析对于深入理解其内部机制至关重要。"redis源码日志（源码分析）"是针对Redis源码进行深入剖析的学习资料，旨在帮助开发者理解如何通过源码实现Redis的高并发处理...
最棒的内存检测工具memtest (Deluxe CD版),无任何限制,可检测2G以上大内存
06-01
最棒的内存检测工具memtest (Deluxe CD版),无任何限制,可检测2G以上大内存!
pmem test code
11-30
可用于测试Android的pmem device，可以编译
MemTest（内存测试）
07-05
测试内存之软件，包含稳定程度、存储及释放能力。
内存测试算法及源码 版本号4.2.2
08-02
Memory Test 4.2.2，这是一个开源项目，主要指标有： Stuck Address Random Value Compare XOR Compare SUB Compare MUL Compare DIV Compare OR Compare AND Sequential Increment Solid Bits Block Sequential Checkerboard Bit Spread Bit Flip Walking Ones Walking Zeroes
memtest 4.20 源代码
11-26
memtest 4.20 源代码 在linux下编译。有兴趣到可以试试编译。
FreeRTOS --（1）链表
梁的愚见
02-28 775
Based On FreeRTOS Kernel V10.3.1 1、相关文件 链表结构是 OS 内部经常使用到的，FreeRTOS 自然也不例外，在深入分析各个模块的工作原理之前，首先来分析 FreeRTOS 的链表结构，和链表相关的代码被定义在： list.h list.c   2、数据结构 不得不说，FreeRTOS 另一个成功的因素，在于他的代码注释，非常的完备...
kernel中的memtest
jason的笔记
09-12 3282
在mm/Makefile中 obj-$(CONFIG_MEMTEST) += memtest.o 可以看到使能CONFIG_MEMTEST，并且传递的command line 中保护 memtest 关键字的话，则kernel会对没有使用的free memory做memtest 具体源码在mm/memtest.c中 static int __init parse_memtest(char *ar
Redis源码分析（十一）--- memtest内存检测
走在前往架构师的路上
10-17 6564
今天我们继续redis源码test测试包下的其他文件，今天看完的是memtest文件，翻译器起来，就是memory test 内存检测的意思，这个文件虽然说代码量不是很多，但是里面的提及了很多东西，也给我涨了很多见识，网上关于memtest这种类似的redis内部边缘的文件解析基本没有，所以自己从头开始学习。机器的内存检测会和机器的CPU位数有关，32位或64位会影响后面的一些宏定义参数。首先亮出
Redis源码分析之内存检测memtest
一缕阳光的博客
05-09 1341
redis的内存检测会和机器的CPU位数有关，32位或64位会影响后面的一些宏定义参数。首先给出memtest中的API： void memtest_progress_start(char *title, int pass) /* 内存检测加载开始，输出开始的一些图线显示 */ void memtest_progress_end(void) /* progress bar加载完再次清屏操作 *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值