oobtest.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2006-2008 Nokia Corporation
  4. *
  5. * Test OOB read and write on MTD device.
  6. *
  7. * Author: Adrian Hunter <ext-adrian.hunter@nokia.com>
  8. */
  9. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10. #include <asm/div64.h>
  11. #include <linux/init.h>
  12. #include <linux/module.h>
  13. #include <linux/moduleparam.h>
  14. #include <linux/err.h>
  15. #include <linux/mtd/mtd.h>
  16. #include <linux/slab.h>
  17. #include <linux/sched.h>
  18. #include <linux/random.h>
  19. #include "mtd_test.h"
  20. static int dev = -EINVAL;
  21. static int bitflip_limit;
  22. module_param(dev, int, S_IRUGO);
  23. MODULE_PARM_DESC(dev, "MTD device number to use");
  24. module_param(bitflip_limit, int, S_IRUGO);
  25. MODULE_PARM_DESC(bitflip_limit, "Max. allowed bitflips per page");
  26. static struct mtd_info *mtd;
  27. static unsigned char *readbuf;
  28. static unsigned char *writebuf;
  29. static unsigned char *bbt;
  30. static int ebcnt;
  31. static int pgcnt;
  32. static int errcnt;
  33. static int use_offset;
  34. static int use_len;
  35. static int use_len_max;
  36. static int vary_offset;
  37. static struct rnd_state rnd_state;
  38. static void do_vary_offset(void)
  39. {
  40. use_len -= 1;
  41. if (use_len < 1) {
  42. use_offset += 1;
  43. if (use_offset >= use_len_max)
  44. use_offset = 0;
  45. use_len = use_len_max - use_offset;
  46. }
  47. }
  48. static int write_eraseblock(int ebnum)
  49. {
  50. int i;
  51. struct mtd_oob_ops ops;
  52. int err = 0;
  53. loff_t addr = (loff_t)ebnum * mtd->erasesize;
  54. prandom_bytes_state(&rnd_state, writebuf, use_len_max * pgcnt);
  55. for (i = 0; i < pgcnt; ++i, addr += mtd->writesize) {
  56. ops.mode = MTD_OPS_AUTO_OOB;
  57. ops.len = 0;
  58. ops.retlen = 0;
  59. ops.ooblen = use_len;
  60. ops.oobretlen = 0;
  61. ops.ooboffs = use_offset;
  62. ops.datbuf = NULL;
  63. ops.oobbuf = writebuf + (use_len_max * i) + use_offset;
  64. err = mtd_write_oob(mtd, addr, &ops);
  65. if (err || ops.oobretlen != use_len) {
  66. pr_err("error: writeoob failed at %#llx\n",
  67. (long long)addr);
  68. pr_err("error: use_len %d, use_offset %d\n",
  69. use_len, use_offset);
  70. errcnt += 1;
  71. return err ? err : -1;
  72. }
  73. if (vary_offset)
  74. do_vary_offset();
  75. }
  76. return err;
  77. }
  78. static int write_whole_device(void)
  79. {
  80. int err;
  81. unsigned int i;
  82. pr_info("writing OOBs of whole device\n");
  83. for (i = 0; i < ebcnt; ++i) {
  84. if (bbt[i])
  85. continue;
  86. err = write_eraseblock(i);
  87. if (err)
  88. return err;
  89. if (i % 256 == 0)
  90. pr_info("written up to eraseblock %u\n", i);
  91. err = mtdtest_relax();
  92. if (err)
  93. return err;
  94. }
  95. pr_info("written %u eraseblocks\n", i);
  96. return 0;
  97. }
  98. /*
  99. * Display the address, offset and data bytes at comparison failure.
  100. * Return number of bitflips encountered.
  101. */
  102. static size_t memcmpshowoffset(loff_t addr, loff_t offset, const void *cs,
  103. const void *ct, size_t count)
  104. {
  105. const unsigned char *su1, *su2;
  106. int res;
  107. size_t i = 0;
  108. size_t bitflips = 0;
  109. for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--, i++) {
  110. res = *su1 ^ *su2;
  111. if (res) {
  112. pr_info("error @addr[0x%lx:0x%lx] 0x%x -> 0x%x diff 0x%x\n",
  113. (unsigned long)addr, (unsigned long)offset + i,
  114. *su1, *su2, res);
  115. bitflips += hweight8(res);
  116. }
  117. }
  118. return bitflips;
  119. }
  120. #define memcmpshow(addr, cs, ct, count) memcmpshowoffset((addr), 0, (cs), (ct),\
  121. (count))
  122. /*
  123. * Compare with 0xff and show the address, offset and data bytes at
  124. * comparison failure. Return number of bitflips encountered.
  125. */
  126. static size_t memffshow(loff_t addr, loff_t offset, const void *cs,
  127. size_t count)
  128. {
  129. const unsigned char *su1;
  130. int res;
  131. size_t i = 0;
  132. size_t bitflips = 0;
  133. for (su1 = cs; 0 < count; ++su1, count--, i++) {
  134. res = *su1 ^ 0xff;
  135. if (res) {
  136. pr_info("error @addr[0x%lx:0x%lx] 0x%x -> 0xff diff 0x%x\n",
  137. (unsigned long)addr, (unsigned long)offset + i,
  138. *su1, res);
  139. bitflips += hweight8(res);
  140. }
  141. }
  142. return bitflips;
  143. }
  144. static int verify_eraseblock(int ebnum)
  145. {
  146. int i;
  147. struct mtd_oob_ops ops;
  148. int err = 0;
  149. loff_t addr = (loff_t)ebnum * mtd->erasesize;
  150. size_t bitflips;
  151. prandom_bytes_state(&rnd_state, writebuf, use_len_max * pgcnt);
  152. for (i = 0; i < pgcnt; ++i, addr += mtd->writesize) {
  153. ops.mode = MTD_OPS_AUTO_OOB;
  154. ops.len = 0;
  155. ops.retlen = 0;
  156. ops.ooblen = use_len;
  157. ops.oobretlen = 0;
  158. ops.ooboffs = use_offset;
  159. ops.datbuf = NULL;
  160. ops.oobbuf = readbuf;
  161. err = mtd_read_oob(mtd, addr, &ops);
  162. if (mtd_is_bitflip(err))
  163. err = 0;
  164. if (err || ops.oobretlen != use_len) {
  165. pr_err("error: readoob failed at %#llx\n",
  166. (long long)addr);
  167. errcnt += 1;
  168. return err ? err : -1;
  169. }
  170. bitflips = memcmpshow(addr, readbuf,
  171. writebuf + (use_len_max * i) + use_offset,
  172. use_len);
  173. if (bitflips > bitflip_limit) {
  174. pr_err("error: verify failed at %#llx\n",
  175. (long long)addr);
  176. errcnt += 1;
  177. if (errcnt > 1000) {
  178. pr_err("error: too many errors\n");
  179. return -1;
  180. }
  181. } else if (bitflips) {
  182. pr_info("ignoring error as within bitflip_limit\n");
  183. }
  184. if (use_offset != 0 || use_len < mtd->oobavail) {
  185. int k;
  186. ops.mode = MTD_OPS_AUTO_OOB;
  187. ops.len = 0;
  188. ops.retlen = 0;
  189. ops.ooblen = mtd->oobavail;
  190. ops.oobretlen = 0;
  191. ops.ooboffs = 0;
  192. ops.datbuf = NULL;
  193. ops.oobbuf = readbuf;
  194. err = mtd_read_oob(mtd, addr, &ops);
  195. if (mtd_is_bitflip(err))
  196. err = 0;
  197. if (err || ops.oobretlen != mtd->oobavail) {
  198. pr_err("error: readoob failed at %#llx\n",
  199. (long long)addr);
  200. errcnt += 1;
  201. return err ? err : -1;
  202. }
  203. bitflips = memcmpshowoffset(addr, use_offset,
  204. readbuf + use_offset,
  205. writebuf + (use_len_max * i) + use_offset,
  206. use_len);
  207. /* verify pre-offset area for 0xff */
  208. bitflips += memffshow(addr, 0, readbuf, use_offset);
  209. /* verify post-(use_offset + use_len) area for 0xff */
  210. k = use_offset + use_len;
  211. bitflips += memffshow(addr, k, readbuf + k,
  212. mtd->oobavail - k);
  213. if (bitflips > bitflip_limit) {
  214. pr_err("error: verify failed at %#llx\n",
  215. (long long)addr);
  216. errcnt += 1;
  217. if (errcnt > 1000) {
  218. pr_err("error: too many errors\n");
  219. return -1;
  220. }
  221. } else if (bitflips) {
  222. pr_info("ignoring errors as within bitflip limit\n");
  223. }
  224. }
  225. if (vary_offset)
  226. do_vary_offset();
  227. }
  228. return err;
  229. }
  230. static int verify_eraseblock_in_one_go(int ebnum)
  231. {
  232. struct mtd_oob_ops ops;
  233. int err = 0;
  234. loff_t addr = (loff_t)ebnum * mtd->erasesize;
  235. size_t len = mtd->oobavail * pgcnt;
  236. size_t oobavail = mtd->oobavail;
  237. size_t bitflips;
  238. int i;
  239. prandom_bytes_state(&rnd_state, writebuf, len);
  240. ops.mode = MTD_OPS_AUTO_OOB;
  241. ops.len = 0;
  242. ops.retlen = 0;
  243. ops.ooblen = len;
  244. ops.oobretlen = 0;
  245. ops.ooboffs = 0;
  246. ops.datbuf = NULL;
  247. ops.oobbuf = readbuf;
  248. /* read entire block's OOB at one go */
  249. err = mtd_read_oob(mtd, addr, &ops);
  250. if (mtd_is_bitflip(err))
  251. err = 0;
  252. if (err || ops.oobretlen != len) {
  253. pr_err("error: readoob failed at %#llx\n",
  254. (long long)addr);
  255. errcnt += 1;
  256. return err ? err : -1;
  257. }
  258. /* verify one page OOB at a time for bitflip per page limit check */
  259. for (i = 0; i < pgcnt; ++i, addr += mtd->writesize) {
  260. bitflips = memcmpshow(addr, readbuf + (i * oobavail),
  261. writebuf + (i * oobavail), oobavail);
  262. if (bitflips > bitflip_limit) {
  263. pr_err("error: verify failed at %#llx\n",
  264. (long long)addr);
  265. errcnt += 1;
  266. if (errcnt > 1000) {
  267. pr_err("error: too many errors\n");
  268. return -1;
  269. }
  270. } else if (bitflips) {
  271. pr_info("ignoring error as within bitflip_limit\n");
  272. }
  273. }
  274. return err;
  275. }
  276. static int verify_all_eraseblocks(void)
  277. {
  278. int err;
  279. unsigned int i;
  280. pr_info("verifying all eraseblocks\n");
  281. for (i = 0; i < ebcnt; ++i) {
  282. if (bbt[i])
  283. continue;
  284. err = verify_eraseblock(i);
  285. if (err)
  286. return err;
  287. if (i % 256 == 0)
  288. pr_info("verified up to eraseblock %u\n", i);
  289. err = mtdtest_relax();
  290. if (err)
  291. return err;
  292. }
  293. pr_info("verified %u eraseblocks\n", i);
  294. return 0;
  295. }
  296. static int __init mtd_oobtest_init(void)
  297. {
  298. int err = 0;
  299. unsigned int i;
  300. uint64_t tmp;
  301. struct mtd_oob_ops ops;
  302. loff_t addr = 0, addr0;
  303. printk(KERN_INFO "\n");
  304. printk(KERN_INFO "=================================================\n");
  305. if (dev < 0) {
  306. pr_info("Please specify a valid mtd-device via module parameter\n");
  307. pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n");
  308. return -EINVAL;
  309. }
  310. pr_info("MTD device: %d\n", dev);
  311. mtd = get_mtd_device(NULL, dev);
  312. if (IS_ERR(mtd)) {
  313. err = PTR_ERR(mtd);
  314. pr_err("error: cannot get MTD device\n");
  315. return err;
  316. }
  317. if (!mtd_type_is_nand(mtd)) {
  318. pr_info("this test requires NAND flash\n");
  319. goto out;
  320. }
  321. tmp = mtd->size;
  322. do_div(tmp, mtd->erasesize);
  323. ebcnt = tmp;
  324. pgcnt = mtd->erasesize / mtd->writesize;
  325. pr_info("MTD device size %llu, eraseblock size %u, "
  326. "page size %u, count of eraseblocks %u, pages per "
  327. "eraseblock %u, OOB size %u\n",
  328. (unsigned long long)mtd->size, mtd->erasesize,
  329. mtd->writesize, ebcnt, pgcnt, mtd->oobsize);
  330. err = -ENOMEM;
  331. readbuf = kmalloc(mtd->erasesize, GFP_KERNEL);
  332. if (!readbuf)
  333. goto out;
  334. writebuf = kmalloc(mtd->erasesize, GFP_KERNEL);
  335. if (!writebuf)
  336. goto out;
  337. bbt = kzalloc(ebcnt, GFP_KERNEL);
  338. if (!bbt)
  339. goto out;
  340. err = mtdtest_scan_for_bad_eraseblocks(mtd, bbt, 0, ebcnt);
  341. if (err)
  342. goto out;
  343. use_offset = 0;
  344. use_len = mtd->oobavail;
  345. use_len_max = mtd->oobavail;
  346. vary_offset = 0;
  347. /* First test: write all OOB, read it back and verify */
  348. pr_info("test 1 of 5\n");
  349. err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
  350. if (err)
  351. goto out;
  352. prandom_seed_state(&rnd_state, 1);
  353. err = write_whole_device();
  354. if (err)
  355. goto out;
  356. prandom_seed_state(&rnd_state, 1);
  357. err = verify_all_eraseblocks();
  358. if (err)
  359. goto out;
  360. /*
  361. * Second test: write all OOB, a block at a time, read it back and
  362. * verify.
  363. */
  364. pr_info("test 2 of 5\n");
  365. err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
  366. if (err)
  367. goto out;
  368. prandom_seed_state(&rnd_state, 3);
  369. err = write_whole_device();
  370. if (err)
  371. goto out;
  372. /* Check all eraseblocks */
  373. prandom_seed_state(&rnd_state, 3);
  374. pr_info("verifying all eraseblocks\n");
  375. for (i = 0; i < ebcnt; ++i) {
  376. if (bbt[i])
  377. continue;
  378. err = verify_eraseblock_in_one_go(i);
  379. if (err)
  380. goto out;
  381. if (i % 256 == 0)
  382. pr_info("verified up to eraseblock %u\n", i);
  383. err = mtdtest_relax();
  384. if (err)
  385. goto out;
  386. }
  387. pr_info("verified %u eraseblocks\n", i);
  388. /*
  389. * Third test: write OOB at varying offsets and lengths, read it back
  390. * and verify.
  391. */
  392. pr_info("test 3 of 5\n");
  393. err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
  394. if (err)
  395. goto out;
  396. /* Write all eraseblocks */
  397. use_offset = 0;
  398. use_len = mtd->oobavail;
  399. use_len_max = mtd->oobavail;
  400. vary_offset = 1;
  401. prandom_seed_state(&rnd_state, 5);
  402. err = write_whole_device();
  403. if (err)
  404. goto out;
  405. /* Check all eraseblocks */
  406. use_offset = 0;
  407. use_len = mtd->oobavail;
  408. use_len_max = mtd->oobavail;
  409. vary_offset = 1;
  410. prandom_seed_state(&rnd_state, 5);
  411. err = verify_all_eraseblocks();
  412. if (err)
  413. goto out;
  414. use_offset = 0;
  415. use_len = mtd->oobavail;
  416. use_len_max = mtd->oobavail;
  417. vary_offset = 0;
  418. /* Fourth test: try to write off end of device */
  419. pr_info("test 4 of 5\n");
  420. err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
  421. if (err)
  422. goto out;
  423. addr0 = 0;
  424. for (i = 0; i < ebcnt && bbt[i]; ++i)
  425. addr0 += mtd->erasesize;
  426. /* Attempt to write off end of OOB */
  427. ops.mode = MTD_OPS_AUTO_OOB;
  428. ops.len = 0;
  429. ops.retlen = 0;
  430. ops.ooblen = 1;
  431. ops.oobretlen = 0;
  432. ops.ooboffs = mtd->oobavail;
  433. ops.datbuf = NULL;
  434. ops.oobbuf = writebuf;
  435. pr_info("attempting to start write past end of OOB\n");
  436. pr_info("an error is expected...\n");
  437. err = mtd_write_oob(mtd, addr0, &ops);
  438. if (err) {
  439. pr_info("error occurred as expected\n");
  440. err = 0;
  441. } else {
  442. pr_err("error: can write past end of OOB\n");
  443. errcnt += 1;
  444. }
  445. /* Attempt to read off end of OOB */
  446. ops.mode = MTD_OPS_AUTO_OOB;
  447. ops.len = 0;
  448. ops.retlen = 0;
  449. ops.ooblen = 1;
  450. ops.oobretlen = 0;
  451. ops.ooboffs = mtd->oobavail;
  452. ops.datbuf = NULL;
  453. ops.oobbuf = readbuf;
  454. pr_info("attempting to start read past end of OOB\n");
  455. pr_info("an error is expected...\n");
  456. err = mtd_read_oob(mtd, addr0, &ops);
  457. if (mtd_is_bitflip(err))
  458. err = 0;
  459. if (err) {
  460. pr_info("error occurred as expected\n");
  461. err = 0;
  462. } else {
  463. pr_err("error: can read past end of OOB\n");
  464. errcnt += 1;
  465. }
  466. if (bbt[ebcnt - 1])
  467. pr_info("skipping end of device tests because last "
  468. "block is bad\n");
  469. else {
  470. /* Attempt to write off end of device */
  471. ops.mode = MTD_OPS_AUTO_OOB;
  472. ops.len = 0;
  473. ops.retlen = 0;
  474. ops.ooblen = mtd->oobavail + 1;
  475. ops.oobretlen = 0;
  476. ops.ooboffs = 0;
  477. ops.datbuf = NULL;
  478. ops.oobbuf = writebuf;
  479. pr_info("attempting to write past end of device\n");
  480. pr_info("an error is expected...\n");
  481. err = mtd_write_oob(mtd, mtd->size - mtd->writesize, &ops);
  482. if (err) {
  483. pr_info("error occurred as expected\n");
  484. err = 0;
  485. } else {
  486. pr_err("error: wrote past end of device\n");
  487. errcnt += 1;
  488. }
  489. /* Attempt to read off end of device */
  490. ops.mode = MTD_OPS_AUTO_OOB;
  491. ops.len = 0;
  492. ops.retlen = 0;
  493. ops.ooblen = mtd->oobavail + 1;
  494. ops.oobretlen = 0;
  495. ops.ooboffs = 0;
  496. ops.datbuf = NULL;
  497. ops.oobbuf = readbuf;
  498. pr_info("attempting to read past end of device\n");
  499. pr_info("an error is expected...\n");
  500. err = mtd_read_oob(mtd, mtd->size - mtd->writesize, &ops);
  501. if (mtd_is_bitflip(err))
  502. err = 0;
  503. if (err) {
  504. pr_info("error occurred as expected\n");
  505. err = 0;
  506. } else {
  507. pr_err("error: read past end of device\n");
  508. errcnt += 1;
  509. }
  510. err = mtdtest_erase_eraseblock(mtd, ebcnt - 1);
  511. if (err)
  512. goto out;
  513. /* Attempt to write off end of device */
  514. ops.mode = MTD_OPS_AUTO_OOB;
  515. ops.len = 0;
  516. ops.retlen = 0;
  517. ops.ooblen = mtd->oobavail;
  518. ops.oobretlen = 0;
  519. ops.ooboffs = 1;
  520. ops.datbuf = NULL;
  521. ops.oobbuf = writebuf;
  522. pr_info("attempting to write past end of device\n");
  523. pr_info("an error is expected...\n");
  524. err = mtd_write_oob(mtd, mtd->size - mtd->writesize, &ops);
  525. if (err) {
  526. pr_info("error occurred as expected\n");
  527. err = 0;
  528. } else {
  529. pr_err("error: wrote past end of device\n");
  530. errcnt += 1;
  531. }
  532. /* Attempt to read off end of device */
  533. ops.mode = MTD_OPS_AUTO_OOB;
  534. ops.len = 0;
  535. ops.retlen = 0;
  536. ops.ooblen = mtd->oobavail;
  537. ops.oobretlen = 0;
  538. ops.ooboffs = 1;
  539. ops.datbuf = NULL;
  540. ops.oobbuf = readbuf;
  541. pr_info("attempting to read past end of device\n");
  542. pr_info("an error is expected...\n");
  543. err = mtd_read_oob(mtd, mtd->size - mtd->writesize, &ops);
  544. if (mtd_is_bitflip(err))
  545. err = 0;
  546. if (err) {
  547. pr_info("error occurred as expected\n");
  548. err = 0;
  549. } else {
  550. pr_err("error: read past end of device\n");
  551. errcnt += 1;
  552. }
  553. }
  554. /* Fifth test: write / read across block boundaries */
  555. pr_info("test 5 of 5\n");
  556. /* Erase all eraseblocks */
  557. err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
  558. if (err)
  559. goto out;
  560. /* Write all eraseblocks */
  561. prandom_seed_state(&rnd_state, 11);
  562. pr_info("writing OOBs of whole device\n");
  563. for (i = 0; i < ebcnt - 1; ++i) {
  564. int cnt = 2;
  565. int pg;
  566. size_t sz = mtd->oobavail;
  567. if (bbt[i] || bbt[i + 1])
  568. continue;
  569. addr = (loff_t)(i + 1) * mtd->erasesize - mtd->writesize;
  570. prandom_bytes_state(&rnd_state, writebuf, sz * cnt);
  571. for (pg = 0; pg < cnt; ++pg) {
  572. ops.mode = MTD_OPS_AUTO_OOB;
  573. ops.len = 0;
  574. ops.retlen = 0;
  575. ops.ooblen = sz;
  576. ops.oobretlen = 0;
  577. ops.ooboffs = 0;
  578. ops.datbuf = NULL;
  579. ops.oobbuf = writebuf + pg * sz;
  580. err = mtd_write_oob(mtd, addr, &ops);
  581. if (err)
  582. goto out;
  583. if (i % 256 == 0)
  584. pr_info("written up to eraseblock %u\n", i);
  585. err = mtdtest_relax();
  586. if (err)
  587. goto out;
  588. addr += mtd->writesize;
  589. }
  590. }
  591. pr_info("written %u eraseblocks\n", i);
  592. /* Check all eraseblocks */
  593. prandom_seed_state(&rnd_state, 11);
  594. pr_info("verifying all eraseblocks\n");
  595. for (i = 0; i < ebcnt - 1; ++i) {
  596. if (bbt[i] || bbt[i + 1])
  597. continue;
  598. prandom_bytes_state(&rnd_state, writebuf, mtd->oobavail * 2);
  599. addr = (loff_t)(i + 1) * mtd->erasesize - mtd->writesize;
  600. ops.mode = MTD_OPS_AUTO_OOB;
  601. ops.len = 0;
  602. ops.retlen = 0;
  603. ops.ooblen = mtd->oobavail * 2;
  604. ops.oobretlen = 0;
  605. ops.ooboffs = 0;
  606. ops.datbuf = NULL;
  607. ops.oobbuf = readbuf;
  608. err = mtd_read_oob(mtd, addr, &ops);
  609. if (mtd_is_bitflip(err))
  610. err = 0;
  611. if (err)
  612. goto out;
  613. if (memcmpshow(addr, readbuf, writebuf,
  614. mtd->oobavail * 2)) {
  615. pr_err("error: verify failed at %#llx\n",
  616. (long long)addr);
  617. errcnt += 1;
  618. if (errcnt > 1000) {
  619. pr_err("error: too many errors\n");
  620. goto out;
  621. }
  622. }
  623. if (i % 256 == 0)
  624. pr_info("verified up to eraseblock %u\n", i);
  625. err = mtdtest_relax();
  626. if (err)
  627. goto out;
  628. }
  629. pr_info("verified %u eraseblocks\n", i);
  630. pr_info("finished with %d errors\n", errcnt);
  631. out:
  632. kfree(bbt);
  633. kfree(writebuf);
  634. kfree(readbuf);
  635. put_mtd_device(mtd);
  636. if (err)
  637. pr_info("error %d occurred\n", err);
  638. printk(KERN_INFO "=================================================\n");
  639. return err;
  640. }
  641. module_init(mtd_oobtest_init);
  642. static void __exit mtd_oobtest_exit(void)
  643. {
  644. return;
  645. }
  646. module_exit(mtd_oobtest_exit);
  647. MODULE_DESCRIPTION("Out-of-band test module");
  648. MODULE_AUTHOR("Adrian Hunter");
  649. MODULE_LICENSE("GPL");