ddrscan.c 28 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright(C) 2021 Alibaba Communications Inc.
  4. * Author: David Li <liyong.li@alibaba-inc.com>
  5. */
  6. /*
  7. * Memory Bits Scan Functions
  8. *
  9. */
  10. #include <common.h>
  11. #include <console.h>
  12. #include <bootretry.h>
  13. #include <cli.h>
  14. #include <command.h>
  15. #include <console.h>
  16. #include <hash.h>
  17. #include <mapmem.h>
  18. #include <watchdog.h>
  19. #include <asm/io.h>
  20. #include <linux/compiler.h>
  21. #include <asm/asm.h>
  22. #include <asm/csr.h>
  23. #define ONE 0x00000001L
  24. #define rand() get_timer(0)*100000
  25. #define rand32() ((unsigned int) rand() | ( (unsigned int) rand() << 16))
  26. #if (ULONG_MAX == 4294967295UL)
  27. #define rand_ul() rand32()
  28. #define UL_ONEBITS 0xffffffff
  29. #define UL_LEN 32
  30. #define CHECKERBOARD1 0x55555555
  31. #define CHECKERBOARD2 0xaaaaaaaa
  32. #define UL_BYTE(x) ((x | x << 8 | x << 16 | x << 24))
  33. #elif (ULONG_MAX == 18446744073709551615ULL)
  34. #define rand64() (((ul) rand32()) << 32 | ((ul) rand32()))
  35. #define rand_ul() rand64()
  36. #define ul ulong
  37. #define UL_ONEBITS 0xffffffffffffffffUL
  38. #define UL_LEN 64
  39. #define CHECKERBOARD1 0x5555555555555555
  40. #define CHECKERBOARD2 0xaaaaaaaaaaaaaaaa
  41. #define UL_BYTE(x) (((ul)x | (ul)x<<8 | (ul)x<<16 | (ul)x<<24 | (ul)x<<32 | (ul)x<<40 | (ul)x<<48 | (ul)x<<56))
  42. #else
  43. #error long on this platform is not 32 or 64 bits
  44. #endif
  45. #define DISPLAY_COUNT 1000000
  46. #define BYTE_PER_CACHELINE 64
  47. #define BIT_PER_BYTE 8
  48. typedef unsigned long volatile ulv;
  49. int use_phys = 1;
  50. off_t physaddrbase = 0;
  51. extern unsigned long get_ddr_density(void);
  52. extern char* get_ddr_type(void);
  53. extern void lp4_mrw(int addr, int wdata, int dch, int rank);
  54. extern int lp4_mrr(int addr, int dch, int rank);
  55. extern int lp4_set_ron(int ron);
  56. extern void ddr_sysreg_wr(unsigned long int addr,unsigned int wr_data);
  57. extern void ddr_phy0_reg_wr(unsigned long int addr,unsigned int wr_data);
  58. extern void ddr_phy1_reg_wr(unsigned long int addr,unsigned int wr_data);
  59. extern unsigned int ddr_sysreg_rd(unsigned long int addr);
  60. extern unsigned int ddr_phy0_reg_rd(unsigned long int addr);
  61. extern unsigned int ddr_phy1_reg_rd(unsigned long int addr);
  62. #ifdef CONFIG_CMD_MEMTEST
  63. extern ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr,
  64. vu_long *dummy);
  65. extern ulong mem_test_quick(vu_long *buf, ulong start_addr, ulong end_addr,
  66. vu_long pattern, int iteration);
  67. #endif
  68. extern void flush_dcache_range(unsigned long start, unsigned long end);
  69. extern void invalidate_dcache_range(unsigned long start, unsigned long end);
  70. extern void invalid_dcache_range(unsigned long start, unsigned long end);
  71. #ifdef CONFIG_CMD_MEMTEST
  72. int test_stuck_address(ulv *bufa, ulong count);
  73. int test_random_value(ulv *bufa, ulv *bufb, ulong count);
  74. int test_xor_comparison(ulv *bufa, ulv *bufb, ulong count);
  75. int test_sub_comparison(ulv *bufa, ulv *bufb, ulong count);
  76. int test_mul_comparison(ulv *bufa, ulv *bufb, ulong count);
  77. int test_div_comparison(ulv *bufa, ulv *bufb, ulong count);
  78. int test_or_comparison(ulv *bufa, ulv *bufb, ulong count);
  79. int test_and_comparison(ulv *bufa, ulv *bufb, ulong count);
  80. int test_seqinc_comparison(ulv *bufa, ulv *bufb, ulong count);
  81. int test_solidbits_comparison(ulv *bufa, ulv *bufb, ulong count);
  82. int test_blockseq_comparison(ulv *bufa, ulv *bufb, ulong count);
  83. int test_checkerboard_comparison(ulv *bufa, ulv *bufb, ulong count);
  84. int test_bitspread_comparison(ulv *bufa, ulv *bufb, ulong count);
  85. int test_bitflip_comparison(ulv *bufa, ulv *bufb, ulong count);
  86. int test_walkbits0_comparison(ulv *bufa, ulv *bufb, ulong count);
  87. int test_walkbits1_comparison(ulv *bufa, ulv *bufb, ulong count);
  88. enum test_index {
  89. IDX_STUCK = 0,
  90. IDX_RANDOM,
  91. IDX_XOR,
  92. IDX_SUB,
  93. IDX_MUL,
  94. IDX_DIV,
  95. IDX_OR,
  96. IDX_AND,
  97. IDX_SEQINC,
  98. IDX_SOLIDBITS,
  99. IDX_BLOCKSEQ,
  100. IDX_CHECKBOARD,
  101. IDX_BITSPREAD,
  102. IDX_BITFLIP,
  103. IDX_WALKONE,
  104. IDX_WALKZERO,
  105. IDX_MTEST = 20,
  106. IDX_MTESTALT,
  107. };
  108. #endif
  109. static inline void _l2cache_ciall(void)
  110. {
  111. asm volatile (".long 0x0170000b");
  112. }
  113. static inline void _l2cache_iall(void)
  114. {
  115. asm volatile (".long 0x0160000b");
  116. }
  117. static int print_heartbeat(ulong cnt)
  118. {
  119. if(cnt % DISPLAY_COUNT == 0)
  120. {
  121. printf("\r> \r");
  122. }
  123. else if(cnt % DISPLAY_COUNT == DISPLAY_COUNT/2)
  124. {
  125. printf("\r>>\r");
  126. }
  127. return 0;
  128. }
  129. #ifdef CONFIG_CMD_MEMTEST
  130. int compare_regions(ulv *bufa, ulv *bufb, ulong count) {
  131. int r = 0;
  132. ulong i;
  133. ulong cnt;
  134. ulv *p1 = bufa;
  135. ulv *p2 = bufb;
  136. off_t physaddr;
  137. cnt = 0;
  138. for (i = 0; i < count; i++, p1++, p2++) {
  139. if (*p1 != *p2) {
  140. if (use_phys) {
  141. physaddr = physaddrbase + (i * sizeof(ulong));
  142. fprintf(stderr,
  143. "FAILURE: 0x%08lx != 0x%08lx at physical address "
  144. "0x%08lx.\n",
  145. (ulong) *p1, (ulong) *p2, physaddr);
  146. } else {
  147. fprintf(stderr,
  148. "FAILURE: 0x%08lx != 0x%08lx at offset 0x%08lx.\n",
  149. (ulong) *p1, (ulong) *p2, (ulong) (i * sizeof(ulong)));
  150. }
  151. r = -1;
  152. }
  153. print_heartbeat(cnt++);
  154. }
  155. return r;
  156. }
  157. static int do_bits_test(int argc, char * const argv[], enum test_index cmd)
  158. {
  159. ulong start, end, count, size;
  160. ulv *bufa, *bufb;
  161. ulong iteration_limit = 0;
  162. ulong pattern = 0;
  163. int ret;
  164. ulong errs = 0; /* number of errors, or -1 if interrupted */
  165. int iteration;
  166. start = CONFIG_SYS_MEMTEST_START;
  167. end = CONFIG_SYS_MEMTEST_START + 0x100000;
  168. if (argc > 1)
  169. if (strict_strtoul(argv[1], 16, &start) < 0)
  170. return CMD_RET_USAGE;
  171. if (argc > 2)
  172. if (strict_strtoul(argv[2], 16, &end) < 0)
  173. return CMD_RET_USAGE;
  174. if (argc > 3)
  175. if (strict_strtoul(argv[3], 16, &pattern) < 0)
  176. return CMD_RET_USAGE;
  177. if (argc > 4)
  178. if (strict_strtoul(argv[4], 16, &iteration_limit) < 0)
  179. return CMD_RET_USAGE;
  180. if ((start < CONFIG_SYS_MEMTEST_START) || (end > CONFIG_SYS_MEMTEST_END)) {
  181. printf("Refusing to do invalid region test\n");
  182. //return -1;
  183. }
  184. printf("Testing [0x%9lx ... 0x%9lx]\n", start, end);
  185. size = end-start+1;
  186. bufa = map_sysmem(start, size/2);
  187. bufb = map_sysmem(start+size/2, size/2);
  188. count = size / 2 / sizeof(ulv);
  189. for (iteration = 0;
  190. !iteration_limit || iteration < iteration_limit;
  191. iteration++) {
  192. if (ctrlc()) {
  193. errs = -1UL;
  194. break;
  195. }
  196. printf("Iteration: %6d\r", iteration + 1);
  197. debug("\n");
  198. switch(cmd) {
  199. case IDX_STUCK:
  200. printf("begin to stuck test\n");
  201. errs = test_stuck_address(bufa, count);
  202. break;
  203. case IDX_RANDOM:
  204. printf("begin to random test\n");
  205. errs = test_random_value(bufa, bufb, count);
  206. break;
  207. case IDX_XOR:
  208. printf("begin to xor test\n");
  209. errs = test_xor_comparison(bufa, bufb, count);
  210. break;
  211. case IDX_SUB:
  212. printf("begin to sub test\n");
  213. errs = test_sub_comparison(bufa, bufb, count);
  214. break;
  215. case IDX_MUL:
  216. printf("begin to mul test\n");
  217. errs = test_mul_comparison(bufa, bufb, count);
  218. break;
  219. case IDX_DIV:
  220. printf("begin to div test\n");
  221. errs = test_div_comparison(bufa, bufb, count);
  222. break;
  223. case IDX_OR:
  224. printf("begin to or test\n");
  225. errs = test_or_comparison(bufa, bufb, count);
  226. break;
  227. case IDX_AND:
  228. printf("begin to and test\n");
  229. errs = test_and_comparison(bufa, bufb, count);
  230. break;
  231. case IDX_SEQINC:
  232. printf("begin to seqinc test\n");
  233. errs = test_seqinc_comparison(bufa, bufb, count);
  234. break;
  235. case IDX_SOLIDBITS:
  236. printf("begin to solidbits test\n");
  237. errs = test_solidbits_comparison(bufa, bufb, count);
  238. break;
  239. case IDX_BLOCKSEQ:
  240. printf("begin to blockseq test\n");
  241. errs = test_blockseq_comparison(bufa, bufb, count);
  242. break;
  243. case IDX_WALKZERO:
  244. printf("begin to walkbits0 test\n");
  245. errs = test_walkbits0_comparison(bufa, bufb, count);
  246. break;
  247. case IDX_WALKONE:
  248. printf("begin to walkbits1 test\n");
  249. errs = test_walkbits1_comparison(bufa, bufb, count);
  250. break;
  251. case IDX_BITSPREAD:
  252. printf("begin to bitspread test\n");
  253. errs = test_bitspread_comparison(bufa, bufb, count);
  254. break;
  255. case IDX_BITFLIP:
  256. printf("begin to bitflip test\n");
  257. errs = test_bitflip_comparison(bufa, bufb, count);
  258. break;
  259. case IDX_CHECKBOARD:
  260. printf("begin to checkerboard test\n");
  261. errs = test_checkerboard_comparison(bufa, bufb, count);
  262. break;
  263. case IDX_MTESTALT:
  264. printf("begin to mtest_alt test\n");
  265. errs = mem_test_alt(bufa, start, start+size/2, bufb);
  266. break;
  267. case IDX_MTEST:
  268. printf("begin to mtest test\n");
  269. errs = mem_test_quick(bufa, start, end, pattern, 10);
  270. break;
  271. default:
  272. printf("default: begin to bitspread test\n");
  273. errs = test_bitspread_comparison(bufa, bufb, count);
  274. break;
  275. }
  276. if (errs == -1)
  277. break;
  278. }
  279. {
  280. void *vbufa = (void *)bufa;
  281. void *vbufb = (void *)bufb;
  282. unmap_sysmem(vbufa);
  283. unmap_sysmem(vbufb);
  284. }
  285. if (errs == -1) {
  286. /* Memory test was aborted - write a newline to finish off */
  287. putc('\n');
  288. ret = 1;
  289. } else {
  290. printf("Tested %d iteration(s) with %lu errors.\n",
  291. iteration, errs);
  292. ret = errs != 0;
  293. }
  294. return ret;
  295. }
  296. int test_stuck_address(ulv *bufa, ulong count) {
  297. ulv *p1 = bufa;
  298. unsigned int j;
  299. ulong i;
  300. off_t physaddr;
  301. for (j = 0; j < 16; j++) {
  302. p1 = (ulv *) bufa;
  303. for (i = 0; i < count; i++) {
  304. *p1 = ((j + i) % 2) == 0 ? (ul) p1 : ~((ul) p1);
  305. *p1++;
  306. }
  307. p1 = (ulv *) bufa;
  308. for (i = 0; i < count; i++, p1++) {
  309. if (*p1 != (((j + i) % 2) == 0 ? (ul) p1 : ~((ul) p1))) {
  310. if (use_phys) {
  311. physaddr = physaddrbase + (i * sizeof(ul));
  312. fprintf(stderr,
  313. "FAILURE: possible bad address line at physical "
  314. "address 0x%08lx.\n",
  315. physaddr);
  316. } else {
  317. fprintf(stderr,
  318. "FAILURE: possible bad address line at offset "
  319. "0x%08lx.\n",
  320. (ul) (i * sizeof(ul)));
  321. }
  322. return -1;
  323. }
  324. }
  325. }
  326. return 0;
  327. }
  328. static int do_mem_stuck(cmd_tbl_t *cmdtp, int flag, int argc,
  329. char * const argv[])
  330. {
  331. int ret = 0;
  332. _l2cache_ciall();
  333. ret = do_bits_test(argc, argv, IDX_STUCK);
  334. return ret;
  335. }
  336. int test_random_value(ulv *bufa, ulv *bufb, ulong count) {
  337. ulv *p1 = bufa;
  338. ulv *p2 = bufb;
  339. ulong i;
  340. for (i = 0; i < count; i++) {
  341. *p1++ = *p2++ = rand_ul();
  342. }
  343. return compare_regions(bufa, bufb, count);
  344. }
  345. static int do_mem_random(cmd_tbl_t *cmdtp, int flag, int argc,
  346. char * const argv[])
  347. {
  348. int ret = 0;
  349. _l2cache_ciall();
  350. ret = do_bits_test(argc, argv, IDX_RANDOM);
  351. return ret;
  352. }
  353. int test_xor_comparison(ulv *bufa, ulv *bufb, ulong count) {
  354. ulv *p1 = bufa;
  355. ulv *p2 = bufb;
  356. ulong i;
  357. ul q = rand_ul();
  358. for (i = 0; i < count; i++) {
  359. *p1++ ^= q;
  360. *p2++ ^= q;
  361. }
  362. return compare_regions(bufa, bufb, count);
  363. }
  364. static int do_mem_xor(cmd_tbl_t *cmdtp, int flag, int argc,
  365. char * const argv[])
  366. {
  367. int ret = 0;
  368. _l2cache_ciall();
  369. ret = do_bits_test(argc, argv, IDX_XOR);
  370. return ret;
  371. }
  372. int test_sub_comparison(ulv *bufa, ulv *bufb, ulong count) {
  373. ulv *p1 = bufa;
  374. ulv *p2 = bufb;
  375. ulong i;
  376. ul q = rand_ul();
  377. for (i = 0; i < count; i++) {
  378. *p1++ -= q;
  379. *p2++ -= q;
  380. }
  381. return compare_regions(bufa, bufb, count);
  382. }
  383. static int do_mem_sub(cmd_tbl_t *cmdtp, int flag, int argc,
  384. char * const argv[])
  385. {
  386. int ret = 0;
  387. _l2cache_ciall();
  388. ret = do_bits_test(argc, argv, IDX_SUB);
  389. return ret;
  390. }
  391. int test_mul_comparison(ulv *bufa, ulv *bufb, ulong count) {
  392. ulv *p1 = bufa;
  393. ulv *p2 = bufb;
  394. ulong i;
  395. ul q = rand_ul();
  396. for (i = 0; i < count; i++) {
  397. *p1++ *= q;
  398. *p2++ *= q;
  399. }
  400. return compare_regions(bufa, bufb, count);
  401. }
  402. static int do_mem_mul(cmd_tbl_t *cmdtp, int flag, int argc,
  403. char * const argv[])
  404. {
  405. int ret = 0;
  406. _l2cache_ciall();
  407. ret = do_bits_test(argc, argv, IDX_MUL);
  408. return ret;
  409. }
  410. int test_div_comparison(ulv *bufa, ulv *bufb, ulong count) {
  411. ulv *p1 = bufa;
  412. ulv *p2 = bufb;
  413. ulong i;
  414. ul q = rand_ul();
  415. for (i = 0; i < count; i++) {
  416. if (!q) {
  417. q++;
  418. }
  419. *p1++ /= q;
  420. *p2++ /= q;
  421. }
  422. return compare_regions(bufa, bufb, count);
  423. }
  424. static int do_mem_div(cmd_tbl_t *cmdtp, int flag, int argc,
  425. char * const argv[])
  426. {
  427. int ret = 0;
  428. _l2cache_ciall();
  429. ret = do_bits_test(argc, argv, IDX_DIV);
  430. return ret;
  431. }
  432. int test_or_comparison(ulv *bufa, ulv *bufb, ulong count) {
  433. ulv *p1 = bufa;
  434. ulv *p2 = bufb;
  435. ulong i;
  436. ul q = rand_ul();
  437. for (i = 0; i < count; i++) {
  438. *p1++ |= q;
  439. *p2++ |= q;
  440. }
  441. return compare_regions(bufa, bufb, count);
  442. }
  443. static int do_mem_or(cmd_tbl_t *cmdtp, int flag, int argc,
  444. char * const argv[])
  445. {
  446. int ret = 0;
  447. _l2cache_ciall();
  448. ret = do_bits_test(argc, argv, IDX_OR);
  449. return ret;
  450. }
  451. int test_and_comparison(ulv *bufa, ulv *bufb, ulong count) {
  452. ulv *p1 = bufa;
  453. ulv *p2 = bufb;
  454. ulong i;
  455. ul q = rand_ul();
  456. for (i = 0; i < count; i++) {
  457. *p1++ &= q;
  458. *p2++ &= q;
  459. }
  460. return compare_regions(bufa, bufb, count);
  461. }
  462. static int do_mem_and(cmd_tbl_t *cmdtp, int flag, int argc,
  463. char * const argv[])
  464. {
  465. int ret = 0;
  466. _l2cache_ciall();
  467. ret = do_bits_test(argc, argv, IDX_AND);
  468. return ret;
  469. }
  470. int test_seqinc_comparison(ulv *bufa, ulv *bufb, ulong count) {
  471. ulv *p1 = bufa;
  472. ulv *p2 = bufb;
  473. ulong i;
  474. ul q = rand_ul();
  475. for (i = 0; i < count; i++) {
  476. *p1++ = *p2++ = (i + q);
  477. }
  478. return compare_regions(bufa, bufb, count);
  479. }
  480. static int do_mem_seqinc(cmd_tbl_t *cmdtp, int flag, int argc,
  481. char * const argv[])
  482. {
  483. int ret = 0;
  484. _l2cache_ciall();
  485. ret = do_bits_test(argc, argv, IDX_SEQINC);
  486. return ret;
  487. }
  488. int test_blockseq_comparison(ulv *bufa, ulv *bufb, ulong count) {
  489. ulv *p1 = bufa;
  490. ulv *p2 = bufb;
  491. unsigned int j;
  492. ulong i;
  493. for (j = 0; j < 256; j++) {
  494. p1 = (ulv *) bufa;
  495. p2 = (ulv *) bufb;
  496. for (i = 0; i < count; i++) {
  497. *p1++ = *p2++ = (ul) UL_BYTE(j);
  498. }
  499. if (compare_regions(bufa, bufb, count)) {
  500. return -1;
  501. }
  502. }
  503. return 0;
  504. }
  505. static int do_mem_blockseq(cmd_tbl_t *cmdtp, int flag, int argc,
  506. char * const argv[])
  507. {
  508. int ret = 0;
  509. _l2cache_ciall();
  510. ret = do_bits_test(argc, argv, IDX_BLOCKSEQ);
  511. return ret;
  512. }
  513. int test_walkbits0_comparison(ulv *bufa, ulv *bufb, ulong count) {
  514. ulv *p1 = bufa;
  515. ulv *p2 = bufb;
  516. unsigned int j;
  517. ulong i;
  518. ulong cnt;
  519. for (j = 0; j < UL_LEN * 2; j++) {
  520. p1 = (ulv *) bufa;
  521. p2 = (ulv *) bufb;
  522. cnt = 0;
  523. for (i = 0; i < count; i++) {
  524. if (j < UL_LEN) { /* Walk it up. */
  525. *p1++ = *p2++ = ONE << j;
  526. } else { /* Walk it back down. */
  527. *p1++ = *p2++ = ONE << (UL_LEN * 2 - j - 1);
  528. }
  529. print_heartbeat(cnt++);
  530. }
  531. if (compare_regions(bufa, bufb, count)) {
  532. return -1;
  533. }
  534. }
  535. return 0;
  536. }
  537. static int do_mem_walkbits0(cmd_tbl_t *cmdtp, int flag, int argc,
  538. char * const argv[])
  539. {
  540. int ret = 0;
  541. _l2cache_ciall();
  542. ret = do_bits_test(argc, argv, IDX_WALKZERO);
  543. return ret;
  544. }
  545. int test_walkbits1_comparison(ulv *bufa, ulv *bufb, ulong count) {
  546. ulv *p1 = bufa;
  547. ulv *p2 = bufb;
  548. unsigned int j;
  549. ulong i;
  550. ulong cnt;
  551. for (j = 0; j < UL_LEN * 2; j++) {
  552. p1 = (ulv *) bufa;
  553. p2 = (ulv *) bufb;
  554. cnt = 0;
  555. for (i = 0; i < count; i++) {
  556. if (j < UL_LEN) { /* Walk it up. */
  557. *p1++ = *p2++ = UL_ONEBITS ^ (ONE << j);
  558. } else { /* Walk it back down. */
  559. *p1++ = *p2++ = UL_ONEBITS ^ (ONE << (UL_LEN * 2 - j - 1));
  560. }
  561. print_heartbeat(cnt++);
  562. }
  563. if (compare_regions(bufa, bufb, count)) {
  564. return -1;
  565. }
  566. }
  567. return 0;
  568. }
  569. static int do_mem_walkbits1(cmd_tbl_t *cmdtp, int flag, int argc,
  570. char * const argv[])
  571. {
  572. int ret = 0;
  573. _l2cache_ciall();
  574. ret = do_bits_test(argc, argv, IDX_WALKONE);
  575. return ret;
  576. }
  577. int test_bitspread_comparison(ulv *bufa, ulv *bufb, ulong count) {
  578. ulv *p1 = bufa;
  579. ulv *p2 = bufb;
  580. unsigned int j;
  581. ulong i;
  582. ulong cnt;
  583. for (j = 0; j < UL_LEN * 2; j++) {
  584. p1 = (ulv *) bufa;
  585. p2 = (ulv *) bufb;
  586. cnt = 0;
  587. for (i = 0; i < count; i++) {
  588. if (j < UL_LEN) { /* Walk it up. */
  589. *p1++ = *p2++ = (i % 2 == 0)
  590. ? (ONE << j) | (ONE << (j + 2))
  591. : UL_ONEBITS ^ ((ONE << j)
  592. | (ONE << (j + 2)));
  593. } else { /* Walk it back down. */
  594. *p1++ = *p2++ = (i % 2 == 0)
  595. ? (ONE << (UL_LEN * 2 - 1 - j)) | (ONE << (UL_LEN * 2 + 1 - j))
  596. : UL_ONEBITS ^ (ONE << (UL_LEN * 2 - 1 - j)
  597. | (ONE << (UL_LEN * 2 + 1 - j)));
  598. }
  599. print_heartbeat(cnt++);
  600. }
  601. if (compare_regions(bufa, bufb, count)) {
  602. return -1;
  603. }
  604. }
  605. return 0;
  606. }
  607. static int do_mem_bitspread(cmd_tbl_t *cmdtp, int flag, int argc,
  608. char * const argv[])
  609. {
  610. int ret = 0;
  611. _l2cache_ciall();
  612. ret = do_bits_test(argc, argv, IDX_BITSPREAD);
  613. return ret;
  614. }
  615. int test_bitflip_comparison(ulv *bufa, ulv *bufb, ulong count) {
  616. ulv *p1 = bufa;
  617. ulv *p2 = bufb;
  618. unsigned int j, k;
  619. ulong q;
  620. ulong i;
  621. ulong cnt;
  622. for (k = 0; k < UL_LEN; k++) {
  623. q = ONE << k;
  624. for (j = 0; j < 8; j++) {
  625. q = ~q;
  626. p1 = (ulv *) bufa;
  627. p2 = (ulv *) bufb;
  628. cnt = 0;
  629. for (i = 0; i < count; i++) {
  630. *p1++ = *p2++ = (i % 2) == 0 ? q : ~q;
  631. print_heartbeat(cnt++);
  632. }
  633. if (compare_regions(bufa, bufb, count)) {
  634. return -1;
  635. }
  636. }
  637. }
  638. return 0;
  639. }
  640. static int do_mem_bitflip(cmd_tbl_t *cmdtp, int flag, int argc,
  641. char * const argv[])
  642. {
  643. int ret = 0;
  644. _l2cache_ciall();
  645. ret = do_bits_test(argc, argv, IDX_BITFLIP);
  646. return ret;
  647. }
  648. int test_solidbits_comparison(ulv *bufa, ulv *bufb, ulong count) {
  649. ulv *p1 = bufa;
  650. ulv *p2 = bufb;
  651. unsigned int j;
  652. ulong q;
  653. ulong i;
  654. ulong cnt;
  655. for (j = 0; j < 64; j++) {
  656. q = (j % 2) == 0 ? UL_ONEBITS : 0;
  657. p1 = (ulv *) bufa;
  658. p2 = (ulv *) bufb;
  659. cnt=0;
  660. for (i = 0; i < count; i++) {
  661. *p1++ = *p2++ = (i % 2) == 0 ? q : ~q;
  662. print_heartbeat(cnt++);
  663. }
  664. if (compare_regions(bufa, bufb, count)) {
  665. return -1;
  666. }
  667. }
  668. return 0;
  669. }
  670. static int do_mem_solidbits(cmd_tbl_t *cmdtp, int flag, int argc,
  671. char * const argv[])
  672. {
  673. int ret = 0;
  674. _l2cache_ciall();
  675. ret = do_bits_test(argc, argv, IDX_SOLIDBITS);
  676. return ret;
  677. }
  678. int test_checkerboard_comparison(ulv *bufa, ulv *bufb, ulong count) {
  679. ulv *p1 = bufa;
  680. ulv *p2 = bufb;
  681. unsigned int j;
  682. ulong q;
  683. ulong cnt;
  684. ulong i;
  685. for (j = 0; j < 64; j++) {
  686. q = (j % 2) == 0 ? CHECKERBOARD1 : CHECKERBOARD2;
  687. p1 = (ulv *) bufa;
  688. p2 = (ulv *) bufb;
  689. cnt=0;
  690. for (i = 0; i < count; i++) {
  691. *p1++ = *p2++ = (i % 2) == 0 ? q : ~q;
  692. print_heartbeat(cnt++);
  693. }
  694. if (compare_regions(bufa, bufb, count)) {
  695. return -1;
  696. }
  697. }
  698. return 0;
  699. }
  700. static int do_mem_checkerboard(cmd_tbl_t *cmdtp, int flag, int argc,
  701. char * const argv[])
  702. {
  703. int ret = 0;
  704. _l2cache_ciall();
  705. ret = do_bits_test(argc, argv, IDX_CHECKBOARD);
  706. return ret;
  707. }
  708. static int do_mem_stress_test(cmd_tbl_t *cmdtp, int flag, int argc,
  709. char * const argv[])
  710. {
  711. int ret = 0;
  712. printf("ddr stress test suite\n");
  713. _l2cache_ciall();
  714. ret = do_bits_test(argc, argv, IDX_MTEST);
  715. ret = do_bits_test(argc, argv, IDX_MTESTALT);
  716. ret = do_bits_test(argc, argv, IDX_STUCK);
  717. ret = do_bits_test(argc, argv, IDX_RANDOM);
  718. ret = do_bits_test(argc, argv, IDX_XOR);
  719. ret = do_bits_test(argc, argv, IDX_SUB);
  720. ret = do_bits_test(argc, argv, IDX_MUL);
  721. ret = do_bits_test(argc, argv, IDX_DIV);
  722. ret = do_bits_test(argc, argv, IDX_OR);
  723. ret = do_bits_test(argc, argv, IDX_AND);
  724. ret = do_bits_test(argc, argv, IDX_SEQINC);
  725. ret = do_bits_test(argc, argv, IDX_SOLIDBITS);
  726. ret = do_bits_test(argc, argv, IDX_BLOCKSEQ);
  727. ret = do_bits_test(argc, argv, IDX_CHECKBOARD);
  728. ret = do_bits_test(argc, argv, IDX_BITSPREAD);
  729. ret = do_bits_test(argc, argv, IDX_BITFLIP);
  730. ret = do_bits_test(argc, argv, IDX_WALKONE);
  731. ret = do_bits_test(argc, argv, IDX_WALKZERO);
  732. return ret;
  733. }
  734. #endif // CONFIG_CMD_MEMTEST
  735. /*
  736. * 0x1 - Select rank 0 only
  737. * 0x2 - Select rank 1 only
  738. * 0x5 - Select rank 0 and 1
  739. */
  740. static int get_device_mr(cmd_tbl_t *cmdtp, int flag, int argc,
  741. char * const argv[])
  742. {
  743. int ret = 0;
  744. ulong addr = 0;
  745. ulong dch = 0;
  746. ulong rank = 1;
  747. int data = -1;
  748. if (argc != 4) {
  749. printf("should be 3 input parameters!!!");
  750. return CMD_RET_USAGE;
  751. }
  752. if (strict_strtoul(argv[1], 16, &addr) < 0)
  753. return CMD_RET_USAGE;
  754. if (strict_strtoul(argv[2], 16, &dch) < 0)
  755. return CMD_RET_USAGE;
  756. if (strict_strtoul(argv[3], 16, &rank) < 0)
  757. return CMD_RET_USAGE;
  758. data = lp4_mrr((int)addr, (int)dch, (int)rank);
  759. printf("Get MR register: addr=%x, dch=%d, rank=%d, MR_vaule=0x%x\n",
  760. (int)addr, (int)dch, (int)rank, data);
  761. return ret;
  762. }
  763. /*
  764. * 0x1 - Select rank 0 only
  765. * 0x2 - Select rank 1 only
  766. * 0x5 - Select rank 0 and 1
  767. */
  768. static int set_device_mr(cmd_tbl_t *cmdtp, int flag, int argc,
  769. char * const argv[])
  770. {
  771. int ret = 0;
  772. ulong addr = 0;
  773. ulong data = 0;
  774. ulong dch = 0;
  775. ulong rank = 1;
  776. if (argc != 5) {
  777. printf("should be 4 input parameters!!!");
  778. return CMD_RET_USAGE;
  779. }
  780. if (strict_strtoul(argv[1], 16, &addr) < 0)
  781. return CMD_RET_USAGE;
  782. if (strict_strtoul(argv[2], 16, &data) < 0)
  783. return CMD_RET_USAGE;
  784. if (strict_strtoul(argv[3], 16, &dch) < 0)
  785. return CMD_RET_USAGE;
  786. if (strict_strtoul(argv[4], 16, &rank) < 0)
  787. return CMD_RET_USAGE;
  788. printf("Set MR register: addr=%x, data=%x, dch=%d, rank=%d\n",
  789. (int)addr, (int)data, (int)dch, (int)rank);
  790. lp4_mrw((int)addr, (int)data, (int)dch, (int)rank);
  791. return ret;
  792. }
  793. static int set_device_ron(cmd_tbl_t *cmdtp, int flag, int argc,
  794. char * const argv[])
  795. {
  796. int ret = 0;
  797. ulong ron = 0;
  798. if (argc != 2) {
  799. printf("should be 1 input parameters!!!");
  800. return CMD_RET_USAGE;
  801. }
  802. if (strict_strtoul(argv[1], 16, &ron) < 0)
  803. return CMD_RET_USAGE;
  804. printf("Set ron register: ron=%d\n",
  805. (int)ron);
  806. lp4_set_ron((int)ron);
  807. return ret;
  808. }
  809. static int do_ddr_sysreg_rd(cmd_tbl_t *cmdtp, int flag, int argc,
  810. char * const argv[])
  811. {
  812. int ret = 0;
  813. ulong addr = 0;
  814. unsigned int data = 0;
  815. if (argc != 2) {
  816. printf("should be 1 input parameters!!!");
  817. return CMD_RET_USAGE;
  818. }
  819. if (strict_strtoul(argv[1], 16, &addr) < 0)
  820. return CMD_RET_USAGE;
  821. data = ddr_sysreg_rd(addr);
  822. printf("ddr_sysreg_rd: addr=%lx, data=%x\n", addr, data);
  823. return ret;
  824. }
  825. static int do_ddr_sysreg_wr(cmd_tbl_t *cmdtp, int flag, int argc,
  826. char * const argv[])
  827. {
  828. int ret = 0;
  829. ulong addr = 0;
  830. ulong data = 0;
  831. if (argc != 3) {
  832. printf("should be 2 input parameters!!!");
  833. return CMD_RET_USAGE;
  834. }
  835. if (strict_strtoul(argv[1], 16, &addr) < 0)
  836. return CMD_RET_USAGE;
  837. if (strict_strtoul(argv[2], 16, &data) < 0)
  838. return CMD_RET_USAGE;
  839. ddr_sysreg_wr(addr, (unsigned int)data);
  840. return ret;
  841. }
  842. static int do_ddr_phy0_reg_rd(cmd_tbl_t *cmdtp, int flag, int argc,
  843. char * const argv[])
  844. {
  845. int ret = 0;
  846. ulong addr = 0;
  847. unsigned int data = 0;
  848. if (argc != 2) {
  849. printf("should be 1 input parameters!!!");
  850. return CMD_RET_USAGE;
  851. }
  852. if (strict_strtoul(argv[1], 16, &addr) < 0)
  853. return CMD_RET_USAGE;
  854. data = ddr_phy0_reg_rd(addr);
  855. printf("ddr_phy_reg_rd: addr=%lx, data=%x\n", addr, data);
  856. return ret;
  857. }
  858. static int do_ddr_phy0_reg_wr(cmd_tbl_t *cmdtp, int flag, int argc,
  859. char * const argv[])
  860. {
  861. int ret = 0;
  862. ulong addr = 0;
  863. ulong data = 0;
  864. if (argc != 3) {
  865. printf("should be 2 input parameters!!!");
  866. return CMD_RET_USAGE;
  867. }
  868. if (strict_strtoul(argv[1], 16, &addr) < 0)
  869. return CMD_RET_USAGE;
  870. if (strict_strtoul(argv[2], 16, &data) < 0)
  871. return CMD_RET_USAGE;
  872. ddr_phy0_reg_wr(addr, (unsigned int)data);
  873. return ret;
  874. }
  875. static int do_ddr_phy1_reg_rd(cmd_tbl_t *cmdtp, int flag, int argc,
  876. char * const argv[])
  877. {
  878. int ret = 0;
  879. ulong addr = 0;
  880. unsigned int data = 0;
  881. if (argc != 2) {
  882. printf("should be 1 input parameters!!!");
  883. return CMD_RET_USAGE;
  884. }
  885. if (strict_strtoul(argv[1], 16, &addr) < 0)
  886. return CMD_RET_USAGE;
  887. data = ddr_phy1_reg_rd(addr);
  888. printf("ddr_phy1_reg_rd: addr=%lx, data=%x\n", addr, data);
  889. return ret;
  890. }
  891. static int do_ddr_phy1_reg_wr(cmd_tbl_t *cmdtp, int flag, int argc,
  892. char * const argv[])
  893. {
  894. int ret = 0;
  895. ulong addr = 0;
  896. ulong data = 0;
  897. if (argc != 3) {
  898. printf("should be 2 input parameters!!!");
  899. return CMD_RET_USAGE;
  900. }
  901. if (strict_strtoul(argv[1], 16, &addr) < 0)
  902. return CMD_RET_USAGE;
  903. if (strict_strtoul(argv[2], 16, &data) < 0)
  904. return CMD_RET_USAGE;
  905. ddr_phy1_reg_wr(addr, (unsigned int)data);
  906. return ret;
  907. }
  908. /**
  909. Clear&invalid L2cache
  910. */
  911. static int do_l2cache_ciall(cmd_tbl_t *cmdtp, int flag, int argc,
  912. char * const argv[])
  913. {
  914. _l2cache_ciall();
  915. return 0;
  916. }
  917. #ifdef CONFIG_CMD_MEMTEST
  918. U_BOOT_CMD(
  919. stuck_address, 5, 1, do_mem_stuck,
  920. "Stuck Address test",
  921. "[start end [pattern [iterations]]]"
  922. );
  923. U_BOOT_CMD(
  924. random_value, 5, 1, do_mem_random,
  925. "Random Value test",
  926. "[start end [pattern [iterations]]]"
  927. );
  928. U_BOOT_CMD(
  929. compare_xor, 5, 1, do_mem_xor,
  930. "Compare XOR test",
  931. "[start end [pattern [iterations]]]"
  932. );
  933. U_BOOT_CMD(
  934. compare_sub, 5, 1, do_mem_sub,
  935. "Compare SUB test",
  936. "[start end [pattern [iterations]]]"
  937. );
  938. U_BOOT_CMD(
  939. compare_mul, 5, 1, do_mem_mul,
  940. "Compare MUL test",
  941. "[start end [pattern [iterations]]]"
  942. );
  943. U_BOOT_CMD(
  944. compare_div, 5, 1, do_mem_div,
  945. "Compare DIV test",
  946. "[start end [pattern [iterations]]]"
  947. );
  948. U_BOOT_CMD(
  949. compare_or, 5, 1, do_mem_or,
  950. "Compare OR test",
  951. "[start end [pattern [iterations]]]"
  952. );
  953. U_BOOT_CMD(
  954. compare_and, 5, 1, do_mem_and,
  955. "Compare AND test",
  956. "[start end [pattern [iterations]]]"
  957. );
  958. U_BOOT_CMD(
  959. seqinc, 5, 1, do_mem_seqinc,
  960. "Sequential Increment test",
  961. "[start end [pattern [iterations]]]"
  962. );
  963. U_BOOT_CMD(
  964. solidbits, 5, 1, do_mem_solidbits,
  965. "Solid bits test",
  966. "[start end [pattern [iterations]]]"
  967. );
  968. U_BOOT_CMD(
  969. blockseq, 5, 1, do_mem_blockseq,
  970. "Block Sequential test",
  971. "[start end [pattern [iterations]]]"
  972. );
  973. U_BOOT_CMD(
  974. checkerboard, 5, 1, do_mem_checkerboard,
  975. "Checker Board test",
  976. "[start end [pattern [iterations]]]"
  977. );
  978. U_BOOT_CMD(
  979. bitspread, 5, 1, do_mem_bitspread,
  980. "Bit Spread test",
  981. "[start end [pattern [iterations]]]"
  982. );
  983. U_BOOT_CMD(
  984. bitflip, 5, 1, do_mem_bitflip,
  985. "Bit Flip test",
  986. "[start end [pattern [iterations]]]"
  987. );
  988. U_BOOT_CMD(
  989. walkbits1, 5, 1, do_mem_walkbits1,
  990. "Walking Ones test",
  991. "[start end [pattern [iterations]]]"
  992. );
  993. U_BOOT_CMD(
  994. walkbits0, 5, 1, do_mem_walkbits0,
  995. "Walking Zeroes test",
  996. "[start end [pattern [iterations]]]"
  997. );
  998. U_BOOT_CMD(
  999. stress_test, 5, 1, do_mem_stress_test,
  1000. "SolidBits, BitSpread, BitFlip, WalkBits Zero, WalkBits One, CheckerBoard, mtest_alt, mtest",
  1001. "[start end [pattern [iterations]]]"
  1002. );
  1003. #endif // CONFIG_CMD_MEMTEST
  1004. U_BOOT_CMD(
  1005. setmr, 5, 1, set_device_mr,
  1006. "set ddr MR register",
  1007. "addr data dch(phy id) rank"
  1008. );
  1009. U_BOOT_CMD(
  1010. getmr, 4, 1, get_device_mr,
  1011. "get ddr MR register",
  1012. "addr dch(phy id) rank"
  1013. );
  1014. U_BOOT_CMD(
  1015. setron, 2, 1, set_device_ron,
  1016. "set ddr ron register",
  1017. "ron"
  1018. );
  1019. U_BOOT_CMD(
  1020. ddr_sysreg_rd, 2, 1, do_ddr_sysreg_rd,
  1021. "read ddr sys reg",
  1022. "addr"
  1023. );
  1024. U_BOOT_CMD(
  1025. ddr_sysreg_wr, 3, 1, do_ddr_sysreg_wr,
  1026. "write ddr sys reg",
  1027. "addr wdata"
  1028. );
  1029. U_BOOT_CMD(
  1030. ddr_phy0_reg_rd, 2, 1, do_ddr_phy0_reg_rd,
  1031. "read ddr phy0 reg",
  1032. "addr"
  1033. );
  1034. U_BOOT_CMD(
  1035. ddr_phy0_reg_wr, 3, 1, do_ddr_phy0_reg_wr,
  1036. "write ddr phy0 reg",
  1037. "addr wdata"
  1038. );
  1039. U_BOOT_CMD(
  1040. ddr_phy1_reg_rd, 2, 1, do_ddr_phy1_reg_rd,
  1041. "read ddr phy1 reg",
  1042. "addr"
  1043. );
  1044. U_BOOT_CMD(
  1045. ddr_phy1_reg_wr, 3, 1, do_ddr_phy1_reg_wr,
  1046. "write ddr phy1 reg",
  1047. "addr wdata"
  1048. );
  1049. U_BOOT_CMD(
  1050. l2cache_ciall, 3, 1, do_l2cache_ciall,
  1051. "clear & invlid l2 cache",
  1052. ""
  1053. );