Описание библиотеки микросхемы 5023ВС016 процессора "Спутник"
mem_test.c
См. документацию.
1 
30 #include "mem_test.h"
31 uint8_t* reg = (uint8_t*)0x20004;
32 uint32_t err_numbers[31];
33 
34 uint32_t a;
35 
36 unsigned int Memtest_Addr_inner(unsigned int addr_start,unsigned int addr_stop, unsigned int mask)
37 {
38  unsigned int addr;
39  unsigned int errors = 0;
40  volatile uint32_t i=0;
41  // *reg = mask; ///< Переключили страницу
42 
43  for (addr = addr_start; addr < addr_stop; addr += 4)
44  {
45  {
46 
47  *(unsigned int*)addr = mask;
48 
49  }
50 
51  i+=1;
52  }
53 
54 
55 uint32_t j=0;
56  for (addr = addr_start; addr < addr_stop; addr += 4)
57  {
58  a = *(uint32_t*)addr;
59 
60 
61  if (a!=mask)//(j*mask+10)*0x12345678)//|0xFFFFF000))
62  {
63  PRINT("Address (0x%x) read: 0x%x wr:0x%x",addr,*(unsigned int*)addr,mask);
64  /* if (a!=0xDFFFFFFF)
65  {
66  int a =10;
67  }*/
68 
69  errors++;
70  // *(uint32_t*)0x20001000 = 0x12345678;
71  }
72  j+=1;
73 
74  }
75 
76  if (errors>0)
77  {
78  err_numbers[1] = 1;
79  }
80  else
81  {
82  err_numbers[1] = 0;
83  }
84  return errors;
85 }
86 
87 unsigned int Memtest_Addr( unsigned int mask)
88 {
89  unsigned int addr;
90  unsigned int errors = 0;
91  volatile uint32_t i=0;
92  *reg = mask;
93 
94  for (addr = 0x10000; addr < 0x20000; addr += 4)
95  {
96  {
97 
98  *(unsigned int*)addr = (i)*0x12345678;
99 
100  }
101 
102  i+=1;
103  }
104 
105 
106 uint32_t j=0;
107  for (addr = 0x10000; addr < 0x20000; addr += 4)
108  {
109  a = *(uint32_t*)addr;
110  if (mask>27)
111  {
112 
113  for (int k = 0; k < 100; k += 1);
114  }
115 
116  // int val = (j);
117  if ((a!=(j*0x12345678))&&(addr!=0x4))//(j*mask+10)*0x12345678)//|0xFFFFF000))
118  {
119  // PRINT("Address (0x%x) read: 0x%x wr:0x%x",addr,*(unsigned int*)addr,val);
120 
121 
122  errors++;
123  }
124  j+=1;
125 
126  }
127 
128  if (errors>0)
129  {
130  err_numbers[mask] = mask;
131  }
132  else
133  {
134  err_numbers[mask] = 0;
135  }
136  return errors;
137 }
138 
139 //=============================================================
140 uint32_t Test_inner(uint32_t* err,
141  uint32_t* err2,
142  uint32_t* err3,
143  uint32_t* err4,
144  uint32_t* err5,
145  uint32_t* err6,
146  uint32_t* err7,Answer* common_out )
147 {
148 
149  PRINT("Тестирование IN_Memmory");
150  common_out->ErrorFlag=0;
151  *err+= Memtest_Addr_inner(0x20000000,0x2001ffff,0xFFFFFFFF); // Запись 0xFFFFFFFF
152  *err+= Memtest_Addr_inner(0x20000000,0x2001ffff,0);
153 
154  *err2+= Memtest_Addr_inner(0x60000000,0x6000ffff,0xFFFFFFFF); // Запись 0xFFFFFFFF
155  *err2+= Memtest_Addr_inner(0x60000000,0x6000ffff,0);
156 
157  *err3+= Memtest_Addr_inner(0x60100000,0x6010ffff,0x1F1F1F1F); //Тестовый доступ к памяти блок 1, биты ECC (доступно 20 бит)
158  *err3+= Memtest_Addr_inner(0x60100000,0x6010ffff,0);
159 
160  *err4+= Memtest_Addr_inner(0x61000000,0x61003fff,0xFFFFFFFF); //Тестовый доступ к памяти кэша way1 данные
161  *err4+= Memtest_Addr_inner(0x61000000,0x61003fff,0);
162 
163  *err5+= Memtest_Addr_inner(0x61100000,0x61103fff,0x001FFFFF); //Тестовый доступ к памяти кэша way1 таг и crc (доступно 18 бит)
164  *err5+= Memtest_Addr_inner(0x61100000,0x61103fff,0);
165 
166  *err6+= Memtest_Addr_inner(0x62000000,0x6200ffff,0xFFFFFFFF); //Тестовый доступ к памяти блок 2, данные
167  *err6+= Memtest_Addr_inner(0x62000000,0x6200ffff,0);
168 
169  *err7+= Memtest_Addr_inner(0x62100000,0x6210ffff,0x1F1F1F1F); //Тестовый доступ к памяти блок 2, биты ECC (доступно 20 бит)
170  *err7+= Memtest_Addr_inner(0x62100000,0x6210ffff,0);
171 
172  if ((*err>0)|(*err2>2)|(*err3>3)|(*err4>4)|(*err5>5)|(*err6>6)|(*err7>7))
173  {
174  common_out->ErrorFlag=1;
175  }
176 
177  return 0;
178 }
179 
180 void TestPage(Answer* common_out )
181 {
182  PRINT("Тестирование counter");
183  DBG_TX_Flush(); // Отправка всех данных по UART
184  for (int i=0;i<=31;i++)
185  {
186  PRINT("Тестирование страницы %d",i);
187  DBG_TX_Flush(); // Отправка всех данных по UART
188 
189  Memtest_Addr(i);
190 
191 
192 
193  }
194  for (int i=0;i<=31;i++)
195  {
196  PRINT("err_numbers:%d = %d",i,err_numbers[i]);
197  common_out->ErrorFlag+=err_numbers[i];
198  }
199 }
200 
201 char dbg_buffer[256]; // Отладочный буфер
202 const uint32_t sys_freq = 80000000; // Системная частота
203 
209 void Mem_Test()
210 {
211  PRINT("Тестирование памяти");
212  DBG_TX_Flush(); // Отправка всех данных по UART
213 
214  // Заполняем структуру TestMEM для проведения теста
215  TEST_MEM TestMEM = {0};
216 
217  // адрес и размер должны быть кратны четырем!
218  TestMEM.block.Addr = 0; // Задаем адрес тестируемого блока в памяти
219  TestMEM.block.Size = (64*1024); // Задаем размер тестируемого блока в памяти
220  TestMEM.param.radix = RADIX_32; // Задаем разряднось слова для работы с памятью
221  TestMEM.param.type = TEST_COUNTER; // Выбираем "Тест-Счетчик"
222  MEM_SetChip(MEM_SRAM); // Выбираем миросхему памяти SRAM
223  uint8_t Page = 10; // Страница
224  MEM_SetPage(Page); // Устанавливаем страницу номер 10
225  PRINT("Тест памяти MEM_SRAM: Тест-счетчик");
226  PRINT("Тестируется страница: %d",Page);
227  PRINT("Адрес тестируемого блока: %d",TestMEM.block.Addr);
228  PRINT("Размер тестируемого блока: %d",TestMEM.block.Size);
229  PRINT("Разрядность слов в транзакциях: %d",TestMEM.param.radix*8);
230  DBG_TX_Flush(); // Отправка всех данных по UART
231  if(!MEMTEST_generic(&TestMEM)) // Фызываем функцию тестирования
232  {
233  PRINT("Тест завершен с ошибками!");
234  }
235  else
236  {
237  PRINT("Тест завершен успешно!");
238  }
239  PRINT("К-во ошибок: %d", TestMEM.errors.Errors);
240  DBG_TX_Flush(); // Отправка всех данных по UART
241  memset((uint8_t*)&TestMEM.errors,0,sizeof(TEST_ERRORS)); // Обнуляем структуру TestMEM
242 
243  // Заполняем TestMEM для проведения нового теста
244  TestMEM.block.Addr = 0;
245  TestMEM.block.Size = (1024);
246  TestMEM.param.radix = RADIX_32;
247  TestMEM.param.type = TEST_GALOPPING; // Выбираем "Тест-Галлоп" TEST_GALOPPING
248  MEM_SetChip(MEM_MRAM); // Выбираем миросхему памяти SRAM
249  Page = 3; // Устанавливаем страницу номер 3
250  MEM_SetPage(Page);
251 
252  PRINT("Тестируется страница: %d",Page);
253  PRINT("Адрес тестируемого блока: %d",TestMEM.block.Addr);
254  PRINT("Размер тестируемого блока: %d",TestMEM.block.Size);
255  PRINT("Разрядность слов в транзакциях: %d",TestMEM.param.radix*8);
256  DBG_TX_Flush();
257  if(!MEMTEST_generic(&TestMEM)) // Фызываем функцию тестирования
258  {
259  PRINT("Тест завершен с ошибками!");
260  }
261  else
262  {
263  PRINT("Тест завершен успешно!");
264  }
265  PRINT("К-во ошибок: %d", TestMEM.errors.Errors);
266  DBG_TX_Flush();
267  memset((uint8_t*)&TestMEM.errors,0,sizeof(TEST_ERRORS)); // Обнуляем структуру TestMEM
268 
269  // Заполняем TestMEM для проведения нового теста
270  TestMEM.block.Addr = 0;
271  TestMEM.block.Size = (64*1024);
272  TestMEM.param.radix = RADIX_32;
273  TestMEM.param.type = TEST_MARCHAL; // Выбираем "Маршевый тест"
274  MEM_SetChip(MEM_MRAM); // Выбираем миросхему памяти SRAM
275  Page = 6;
276  MEM_SetPage(Page); // Устанавливаем страницу номер 6
277  PRINT("Тест памяти SRAM: Маршевый Тест");
278  PRINT("Тестируется страница: %d",Page);
279  PRINT("Адрес тестируемого блока: %d",TestMEM.block.Addr);
280  PRINT("Размер тестируемого блока: %d",TestMEM.block.Size);
281  PRINT("Разрядность слов в транзакциях: %d",TestMEM.param.radix*8);
282  DBG_TX_Flush();
283  if(!MEMTEST_generic(&TestMEM)) // Фызываем функцию тестирования
284  {
285  PRINT("Тест завершен с ошибками!");
286  }
287  else
288  {
289  PRINT("Тест завершен успешно!");
290  }
291  PRINT("К-во ошибок: %d", TestMEM.errors.Errors);
292  DBG_TX_Flush();
293 
294 }
295 
296 
297 
#define PRINT(...)
Макросы для использования отладочного выхода
Definition: debug_uart.h:48
int TestPage()
Тестирование модуля памяти
Definition: mem_test.c:76
Этот файл содержит тестовую программу для аппаратного модуля памяти.
uint32_t err_numbers[31]
Definition: mem_test.c:33
void Mem_Test()
Тестирование модуля памяти
Definition: mem_test.c:209
unsigned int Memtest_Addr_inner(unsigned int addr_start, unsigned int addr_stop, unsigned int mask)
Definition: mem_test.c:36
TEST_BLOCK block
Definition: test_memory.h:90
TEST_TYPE type
Definition: test_memory.h:71
Структура с отчетом об ошибках
Definition: test_memory.h:78
uint8_t * reg
Definition: mem_test.c:32
uint32_t Addr
Definition: test_memory.h:62
const uint32_t sys_freq
Системная частота
Definition: mem_test.c:202
void MEM_SetPage(uint8_t NumPage)
Установка страницы памяти
Definition: memory.c:214
структура Результатов теста памяти
Definition: mem_test.h:47
bool MEMTEST_generic(PTEST_MEM pMEMTest)
Чтение байтного слова
Definition: test_memory.c:217
uint32_t a
Definition: mem_test.c:34
uint32_t Size
Definition: test_memory.h:63
void Memtest_Addr(unsigned int mask)
Definition: mem_test.c:36
TEST_ERRORS errors
Definition: test_memory.h:92
uint8_t ErrorFlag
Definition: mem_test.h:48
void DBG_TX_Flush(void)
Вывод всех данных, накопленных в кольцевом буфере, в отладочный UART.
Definition: debug_uart.c:80
TEST_RADIX radix
Definition: test_memory.h:72
Структура для проведения тестирования памяти
Definition: test_memory.h:88
uint32_t Test_inner(uint32_t *err, uint32_t *err2, uint32_t *err3, uint32_t *err4, uint32_t *err5, uint32_t *err6, uint32_t *err7, Answer *common_out)
Definition: mem_test.c:140
uint32_t Errors
Definition: test_memory.h:82
char dbg_buffer[256]
Отладочный буфер
Definition: mem_test.c:201
TEST_CFG param
Definition: test_memory.h:91
void MEM_SetChip(MEMORY_CHIP MemChip)
Выбор микросхемы памяти
Definition: memory.c:137