14cd10358SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
2a995c792SAkinobu Mita /*
3a995c792SAkinobu Mita * Copyright (C) 2006-2008 Artem Bityutskiy
4a995c792SAkinobu Mita * Copyright (C) 2006-2008 Jarkko Lavinen
5a995c792SAkinobu Mita * Copyright (C) 2006-2008 Adrian Hunter
6a995c792SAkinobu Mita *
7a995c792SAkinobu Mita * Authors: Artem Bityutskiy, Jarkko Lavinen, Adria Hunter
8a995c792SAkinobu Mita *
9a995c792SAkinobu Mita * WARNING: this test program may kill your flash and your device. Do not
10a995c792SAkinobu Mita * use it unless you know what you do. Authors are not responsible for any
11a995c792SAkinobu Mita * damage caused by this program.
12a995c792SAkinobu Mita */
13a995c792SAkinobu Mita
14a995c792SAkinobu Mita #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15a995c792SAkinobu Mita
16a995c792SAkinobu Mita #include <linux/init.h>
17af30c0a0SShraddha Barke #include <linux/ktime.h>
18a995c792SAkinobu Mita #include <linux/module.h>
19a995c792SAkinobu Mita #include <linux/moduleparam.h>
20a995c792SAkinobu Mita #include <linux/err.h>
21a995c792SAkinobu Mita #include <linux/mtd/mtd.h>
22a995c792SAkinobu Mita #include <linux/slab.h>
23a995c792SAkinobu Mita #include <linux/sched.h>
246cf78358SAkinobu Mita #include "mtd_test.h"
25a995c792SAkinobu Mita
26a995c792SAkinobu Mita #define RETRIES 3
27a995c792SAkinobu Mita
28a995c792SAkinobu Mita static int eb = 8;
29a995c792SAkinobu Mita module_param(eb, int, S_IRUGO);
30a995c792SAkinobu Mita MODULE_PARM_DESC(eb, "eraseblock number within the selected MTD device");
31a995c792SAkinobu Mita
32a995c792SAkinobu Mita static int ebcnt = 32;
33a995c792SAkinobu Mita module_param(ebcnt, int, S_IRUGO);
34a995c792SAkinobu Mita MODULE_PARM_DESC(ebcnt, "number of consecutive eraseblocks to torture");
35a995c792SAkinobu Mita
36a995c792SAkinobu Mita static int pgcnt;
37a995c792SAkinobu Mita module_param(pgcnt, int, S_IRUGO);
38a995c792SAkinobu Mita MODULE_PARM_DESC(pgcnt, "number of pages per eraseblock to torture (0 => all)");
39a995c792SAkinobu Mita
40a995c792SAkinobu Mita static int dev = -EINVAL;
41a995c792SAkinobu Mita module_param(dev, int, S_IRUGO);
42a995c792SAkinobu Mita MODULE_PARM_DESC(dev, "MTD device number to use");
43a995c792SAkinobu Mita
44a995c792SAkinobu Mita static int gran = 512;
45a995c792SAkinobu Mita module_param(gran, int, S_IRUGO);
46a995c792SAkinobu Mita MODULE_PARM_DESC(gran, "how often the status information should be printed");
47a995c792SAkinobu Mita
48a995c792SAkinobu Mita static int check = 1;
49a995c792SAkinobu Mita module_param(check, int, S_IRUGO);
50a995c792SAkinobu Mita MODULE_PARM_DESC(check, "if the written data should be checked");
51a995c792SAkinobu Mita
52a995c792SAkinobu Mita static unsigned int cycles_count;
53a995c792SAkinobu Mita module_param(cycles_count, uint, S_IRUGO);
54a995c792SAkinobu Mita MODULE_PARM_DESC(cycles_count, "how many erase cycles to do "
55a995c792SAkinobu Mita "(infinite by default)");
56a995c792SAkinobu Mita
57a995c792SAkinobu Mita static struct mtd_info *mtd;
58a995c792SAkinobu Mita
59a995c792SAkinobu Mita /* This buffer contains 0x555555...0xAAAAAA... pattern */
60a995c792SAkinobu Mita static unsigned char *patt_5A5;
61a995c792SAkinobu Mita /* This buffer contains 0xAAAAAA...0x555555... pattern */
62a995c792SAkinobu Mita static unsigned char *patt_A5A;
63a995c792SAkinobu Mita /* This buffer contains all 0xFF bytes */
64a995c792SAkinobu Mita static unsigned char *patt_FF;
65a995c792SAkinobu Mita /* This a temporary buffer is use when checking data */
66a995c792SAkinobu Mita static unsigned char *check_buf;
67a995c792SAkinobu Mita /* How many erase cycles were done */
68a995c792SAkinobu Mita static unsigned int erase_cycles;
69a995c792SAkinobu Mita
70a995c792SAkinobu Mita static int pgsize;
71af30c0a0SShraddha Barke static ktime_t start, finish;
72a995c792SAkinobu Mita
73a995c792SAkinobu Mita static void report_corrupt(unsigned char *read, unsigned char *written);
74a995c792SAkinobu Mita
start_timing(void)75a995c792SAkinobu Mita static inline void start_timing(void)
76a995c792SAkinobu Mita {
77af30c0a0SShraddha Barke start = ktime_get();
78a995c792SAkinobu Mita }
79a995c792SAkinobu Mita
stop_timing(void)80a995c792SAkinobu Mita static inline void stop_timing(void)
81a995c792SAkinobu Mita {
82af30c0a0SShraddha Barke finish = ktime_get();
83a995c792SAkinobu Mita }
84a995c792SAkinobu Mita
85a995c792SAkinobu Mita /*
86a995c792SAkinobu Mita * Check that the contents of eraseblock number @enbum is equivalent to the
87a995c792SAkinobu Mita * @buf buffer.
88a995c792SAkinobu Mita */
check_eraseblock(int ebnum,unsigned char * buf)89a995c792SAkinobu Mita static inline int check_eraseblock(int ebnum, unsigned char *buf)
90a995c792SAkinobu Mita {
91a995c792SAkinobu Mita int err, retries = 0;
92a995c792SAkinobu Mita size_t read;
93b9da8baeSBrian Norris loff_t addr = (loff_t)ebnum * mtd->erasesize;
94a995c792SAkinobu Mita size_t len = mtd->erasesize;
95a995c792SAkinobu Mita
96a995c792SAkinobu Mita if (pgcnt) {
97b9da8baeSBrian Norris addr = (loff_t)(ebnum + 1) * mtd->erasesize - pgcnt * pgsize;
98a995c792SAkinobu Mita len = pgcnt * pgsize;
99a995c792SAkinobu Mita }
100a995c792SAkinobu Mita
101a995c792SAkinobu Mita retry:
102a995c792SAkinobu Mita err = mtd_read(mtd, addr, len, &read, check_buf);
103a995c792SAkinobu Mita if (mtd_is_bitflip(err))
104a995c792SAkinobu Mita pr_err("single bit flip occurred at EB %d "
105a995c792SAkinobu Mita "MTD reported that it was fixed.\n", ebnum);
106a995c792SAkinobu Mita else if (err) {
107a995c792SAkinobu Mita pr_err("error %d while reading EB %d, "
108a995c792SAkinobu Mita "read %zd\n", err, ebnum, read);
109a995c792SAkinobu Mita return err;
110a995c792SAkinobu Mita }
111a995c792SAkinobu Mita
112a995c792SAkinobu Mita if (read != len) {
113a995c792SAkinobu Mita pr_err("failed to read %zd bytes from EB %d, "
114a995c792SAkinobu Mita "read only %zd, but no error reported\n",
115a995c792SAkinobu Mita len, ebnum, read);
116a995c792SAkinobu Mita return -EIO;
117a995c792SAkinobu Mita }
118a995c792SAkinobu Mita
119a995c792SAkinobu Mita if (memcmp(buf, check_buf, len)) {
120a995c792SAkinobu Mita pr_err("read wrong data from EB %d\n", ebnum);
121a995c792SAkinobu Mita report_corrupt(check_buf, buf);
122a995c792SAkinobu Mita
123a995c792SAkinobu Mita if (retries++ < RETRIES) {
124a995c792SAkinobu Mita /* Try read again */
125a995c792SAkinobu Mita yield();
126a995c792SAkinobu Mita pr_info("re-try reading data from EB %d\n",
127a995c792SAkinobu Mita ebnum);
128a995c792SAkinobu Mita goto retry;
129a995c792SAkinobu Mita } else {
130a995c792SAkinobu Mita pr_info("retried %d times, still errors, "
131a995c792SAkinobu Mita "give-up\n", RETRIES);
132a995c792SAkinobu Mita return -EINVAL;
133a995c792SAkinobu Mita }
134a995c792SAkinobu Mita }
135a995c792SAkinobu Mita
136a995c792SAkinobu Mita if (retries != 0)
137a995c792SAkinobu Mita pr_info("only attempt number %d was OK (!!!)\n",
138a995c792SAkinobu Mita retries);
139a995c792SAkinobu Mita
140a995c792SAkinobu Mita return 0;
141a995c792SAkinobu Mita }
142a995c792SAkinobu Mita
write_pattern(int ebnum,void * buf)143a995c792SAkinobu Mita static inline int write_pattern(int ebnum, void *buf)
144a995c792SAkinobu Mita {
145a995c792SAkinobu Mita int err;
146a995c792SAkinobu Mita size_t written;
147b9da8baeSBrian Norris loff_t addr = (loff_t)ebnum * mtd->erasesize;
148a995c792SAkinobu Mita size_t len = mtd->erasesize;
149a995c792SAkinobu Mita
150a995c792SAkinobu Mita if (pgcnt) {
151b9da8baeSBrian Norris addr = (loff_t)(ebnum + 1) * mtd->erasesize - pgcnt * pgsize;
152a995c792SAkinobu Mita len = pgcnt * pgsize;
153a995c792SAkinobu Mita }
154a995c792SAkinobu Mita err = mtd_write(mtd, addr, len, &written, buf);
155a995c792SAkinobu Mita if (err) {
156a995c792SAkinobu Mita pr_err("error %d while writing EB %d, written %zd"
157a995c792SAkinobu Mita " bytes\n", err, ebnum, written);
158a995c792SAkinobu Mita return err;
159a995c792SAkinobu Mita }
160a995c792SAkinobu Mita if (written != len) {
161a995c792SAkinobu Mita pr_info("written only %zd bytes of %zd, but no error"
162a995c792SAkinobu Mita " reported\n", written, len);
163a995c792SAkinobu Mita return -EIO;
164a995c792SAkinobu Mita }
165a995c792SAkinobu Mita
166a995c792SAkinobu Mita return 0;
167a995c792SAkinobu Mita }
168a995c792SAkinobu Mita
tort_init(void)169a995c792SAkinobu Mita static int __init tort_init(void)
170a995c792SAkinobu Mita {
171a995c792SAkinobu Mita int err = 0, i, infinite = !cycles_count;
1726cf78358SAkinobu Mita unsigned char *bad_ebs;
173a995c792SAkinobu Mita
174a995c792SAkinobu Mita printk(KERN_INFO "\n");
175a995c792SAkinobu Mita printk(KERN_INFO "=================================================\n");
176a995c792SAkinobu Mita pr_info("Warning: this program is trying to wear out your "
177a995c792SAkinobu Mita "flash, stop it if this is not wanted.\n");
178a995c792SAkinobu Mita
179a995c792SAkinobu Mita if (dev < 0) {
180a995c792SAkinobu Mita pr_info("Please specify a valid mtd-device via module parameter\n");
181a995c792SAkinobu Mita pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n");
182a995c792SAkinobu Mita return -EINVAL;
183a995c792SAkinobu Mita }
184a995c792SAkinobu Mita
185a995c792SAkinobu Mita pr_info("MTD device: %d\n", dev);
186a995c792SAkinobu Mita pr_info("torture %d eraseblocks (%d-%d) of mtd%d\n",
187a995c792SAkinobu Mita ebcnt, eb, eb + ebcnt - 1, dev);
188a995c792SAkinobu Mita if (pgcnt)
189a995c792SAkinobu Mita pr_info("torturing just %d pages per eraseblock\n",
190a995c792SAkinobu Mita pgcnt);
191a995c792SAkinobu Mita pr_info("write verify %s\n", check ? "enabled" : "disabled");
192a995c792SAkinobu Mita
193a995c792SAkinobu Mita mtd = get_mtd_device(NULL, dev);
194a995c792SAkinobu Mita if (IS_ERR(mtd)) {
195a995c792SAkinobu Mita err = PTR_ERR(mtd);
196a995c792SAkinobu Mita pr_err("error: cannot get MTD device\n");
197a995c792SAkinobu Mita return err;
198a995c792SAkinobu Mita }
199a995c792SAkinobu Mita
200a995c792SAkinobu Mita if (mtd->writesize == 1) {
201a995c792SAkinobu Mita pr_info("not NAND flash, assume page size is 512 "
202a995c792SAkinobu Mita "bytes.\n");
203a995c792SAkinobu Mita pgsize = 512;
204a995c792SAkinobu Mita } else
205a995c792SAkinobu Mita pgsize = mtd->writesize;
206a995c792SAkinobu Mita
207a995c792SAkinobu Mita if (pgcnt && (pgcnt > mtd->erasesize / pgsize || pgcnt < 0)) {
208a995c792SAkinobu Mita pr_err("error: invalid pgcnt value %d\n", pgcnt);
209a995c792SAkinobu Mita goto out_mtd;
210a995c792SAkinobu Mita }
211a995c792SAkinobu Mita
212a995c792SAkinobu Mita err = -ENOMEM;
213a995c792SAkinobu Mita patt_5A5 = kmalloc(mtd->erasesize, GFP_KERNEL);
214a995c792SAkinobu Mita if (!patt_5A5)
215a995c792SAkinobu Mita goto out_mtd;
216a995c792SAkinobu Mita
217a995c792SAkinobu Mita patt_A5A = kmalloc(mtd->erasesize, GFP_KERNEL);
218a995c792SAkinobu Mita if (!patt_A5A)
219a995c792SAkinobu Mita goto out_patt_5A5;
220a995c792SAkinobu Mita
221a995c792SAkinobu Mita patt_FF = kmalloc(mtd->erasesize, GFP_KERNEL);
222a995c792SAkinobu Mita if (!patt_FF)
223a995c792SAkinobu Mita goto out_patt_A5A;
224a995c792SAkinobu Mita
225a995c792SAkinobu Mita check_buf = kmalloc(mtd->erasesize, GFP_KERNEL);
226a995c792SAkinobu Mita if (!check_buf)
227a995c792SAkinobu Mita goto out_patt_FF;
228a995c792SAkinobu Mita
2296cf78358SAkinobu Mita bad_ebs = kzalloc(ebcnt, GFP_KERNEL);
230a995c792SAkinobu Mita if (!bad_ebs)
231a995c792SAkinobu Mita goto out_check_buf;
232a995c792SAkinobu Mita
233a995c792SAkinobu Mita /* Initialize patterns */
234a995c792SAkinobu Mita memset(patt_FF, 0xFF, mtd->erasesize);
235a995c792SAkinobu Mita for (i = 0; i < mtd->erasesize / pgsize; i++) {
236a995c792SAkinobu Mita if (!(i & 1)) {
237a995c792SAkinobu Mita memset(patt_5A5 + i * pgsize, 0x55, pgsize);
238a995c792SAkinobu Mita memset(patt_A5A + i * pgsize, 0xAA, pgsize);
239a995c792SAkinobu Mita } else {
240a995c792SAkinobu Mita memset(patt_5A5 + i * pgsize, 0xAA, pgsize);
241a995c792SAkinobu Mita memset(patt_A5A + i * pgsize, 0x55, pgsize);
242a995c792SAkinobu Mita }
243a995c792SAkinobu Mita }
244a995c792SAkinobu Mita
2456cf78358SAkinobu Mita err = mtdtest_scan_for_bad_eraseblocks(mtd, bad_ebs, eb, ebcnt);
2466cf78358SAkinobu Mita if (err)
247a995c792SAkinobu Mita goto out;
248a995c792SAkinobu Mita
249a995c792SAkinobu Mita start_timing();
250a995c792SAkinobu Mita while (1) {
251a995c792SAkinobu Mita int i;
252a995c792SAkinobu Mita void *patt;
253a995c792SAkinobu Mita
25468f29815SBrian Norris err = mtdtest_erase_good_eraseblocks(mtd, bad_ebs, eb, ebcnt);
25568f29815SBrian Norris if (err)
25668f29815SBrian Norris goto out;
257a995c792SAkinobu Mita
258a995c792SAkinobu Mita /* Check if the eraseblocks contain only 0xFF bytes */
259a995c792SAkinobu Mita if (check) {
260a995c792SAkinobu Mita for (i = eb; i < eb + ebcnt; i++) {
261a995c792SAkinobu Mita if (bad_ebs[i - eb])
262a995c792SAkinobu Mita continue;
263a995c792SAkinobu Mita err = check_eraseblock(i, patt_FF);
264a995c792SAkinobu Mita if (err) {
265a995c792SAkinobu Mita pr_info("verify failed"
266a995c792SAkinobu Mita " for 0xFF... pattern\n");
267a995c792SAkinobu Mita goto out;
268a995c792SAkinobu Mita }
2692a6a28e7SRichard Weinberger
2702a6a28e7SRichard Weinberger err = mtdtest_relax();
2712a6a28e7SRichard Weinberger if (err)
2722a6a28e7SRichard Weinberger goto out;
273a995c792SAkinobu Mita }
274a995c792SAkinobu Mita }
275a995c792SAkinobu Mita
276a995c792SAkinobu Mita /* Write the pattern */
277a995c792SAkinobu Mita for (i = eb; i < eb + ebcnt; i++) {
278a995c792SAkinobu Mita if (bad_ebs[i - eb])
279a995c792SAkinobu Mita continue;
280a995c792SAkinobu Mita if ((eb + erase_cycles) & 1)
281a995c792SAkinobu Mita patt = patt_5A5;
282a995c792SAkinobu Mita else
283a995c792SAkinobu Mita patt = patt_A5A;
284a995c792SAkinobu Mita err = write_pattern(i, patt);
285a995c792SAkinobu Mita if (err)
286a995c792SAkinobu Mita goto out;
2872a6a28e7SRichard Weinberger
2882a6a28e7SRichard Weinberger err = mtdtest_relax();
2892a6a28e7SRichard Weinberger if (err)
2902a6a28e7SRichard Weinberger goto out;
291a995c792SAkinobu Mita }
292a995c792SAkinobu Mita
293a995c792SAkinobu Mita /* Verify what we wrote */
294a995c792SAkinobu Mita if (check) {
295a995c792SAkinobu Mita for (i = eb; i < eb + ebcnt; i++) {
296a995c792SAkinobu Mita if (bad_ebs[i - eb])
297a995c792SAkinobu Mita continue;
298a995c792SAkinobu Mita if ((eb + erase_cycles) & 1)
299a995c792SAkinobu Mita patt = patt_5A5;
300a995c792SAkinobu Mita else
301a995c792SAkinobu Mita patt = patt_A5A;
302a995c792SAkinobu Mita err = check_eraseblock(i, patt);
303a995c792SAkinobu Mita if (err) {
304a995c792SAkinobu Mita pr_info("verify failed for %s"
305a995c792SAkinobu Mita " pattern\n",
306a995c792SAkinobu Mita ((eb + erase_cycles) & 1) ?
307a995c792SAkinobu Mita "0x55AA55..." : "0xAA55AA...");
308a995c792SAkinobu Mita goto out;
309a995c792SAkinobu Mita }
3102a6a28e7SRichard Weinberger
3112a6a28e7SRichard Weinberger err = mtdtest_relax();
3122a6a28e7SRichard Weinberger if (err)
3132a6a28e7SRichard Weinberger goto out;
314a995c792SAkinobu Mita }
315a995c792SAkinobu Mita }
316a995c792SAkinobu Mita
317a995c792SAkinobu Mita erase_cycles += 1;
318a995c792SAkinobu Mita
319a995c792SAkinobu Mita if (erase_cycles % gran == 0) {
320a995c792SAkinobu Mita long ms;
321a995c792SAkinobu Mita
322a995c792SAkinobu Mita stop_timing();
323af30c0a0SShraddha Barke ms = ktime_ms_delta(finish, start);
324a995c792SAkinobu Mita pr_info("%08u erase cycles done, took %lu "
325a995c792SAkinobu Mita "milliseconds (%lu seconds)\n",
326a995c792SAkinobu Mita erase_cycles, ms, ms / 1000);
327a995c792SAkinobu Mita start_timing();
328a995c792SAkinobu Mita }
329a995c792SAkinobu Mita
330a995c792SAkinobu Mita if (!infinite && --cycles_count == 0)
331a995c792SAkinobu Mita break;
332a995c792SAkinobu Mita }
333a995c792SAkinobu Mita out:
334a995c792SAkinobu Mita
335a995c792SAkinobu Mita pr_info("finished after %u erase cycles\n",
336a995c792SAkinobu Mita erase_cycles);
337a995c792SAkinobu Mita kfree(bad_ebs);
338a995c792SAkinobu Mita out_check_buf:
339a995c792SAkinobu Mita kfree(check_buf);
340a995c792SAkinobu Mita out_patt_FF:
341a995c792SAkinobu Mita kfree(patt_FF);
342a995c792SAkinobu Mita out_patt_A5A:
343a995c792SAkinobu Mita kfree(patt_A5A);
344a995c792SAkinobu Mita out_patt_5A5:
345a995c792SAkinobu Mita kfree(patt_5A5);
346a995c792SAkinobu Mita out_mtd:
347a995c792SAkinobu Mita put_mtd_device(mtd);
348a995c792SAkinobu Mita if (err)
349a995c792SAkinobu Mita pr_info("error %d occurred during torturing\n", err);
350a995c792SAkinobu Mita printk(KERN_INFO "=================================================\n");
351a995c792SAkinobu Mita return err;
352a995c792SAkinobu Mita }
353a995c792SAkinobu Mita module_init(tort_init);
354a995c792SAkinobu Mita
tort_exit(void)355a995c792SAkinobu Mita static void __exit tort_exit(void)
356a995c792SAkinobu Mita {
357a995c792SAkinobu Mita return;
358a995c792SAkinobu Mita }
359a995c792SAkinobu Mita module_exit(tort_exit);
360a995c792SAkinobu Mita
361a995c792SAkinobu Mita static int countdiffs(unsigned char *buf, unsigned char *check_buf,
362a995c792SAkinobu Mita unsigned offset, unsigned len, unsigned *bytesp,
363a995c792SAkinobu Mita unsigned *bitsp);
364a995c792SAkinobu Mita static void print_bufs(unsigned char *read, unsigned char *written, int start,
365a995c792SAkinobu Mita int len);
366a995c792SAkinobu Mita
367a995c792SAkinobu Mita /*
368a995c792SAkinobu Mita * Report the detailed information about how the read EB differs from what was
369a995c792SAkinobu Mita * written.
370a995c792SAkinobu Mita */
report_corrupt(unsigned char * read,unsigned char * written)371a995c792SAkinobu Mita static void report_corrupt(unsigned char *read, unsigned char *written)
372a995c792SAkinobu Mita {
373a995c792SAkinobu Mita int i;
374a995c792SAkinobu Mita int bytes, bits, pages, first;
375a995c792SAkinobu Mita int offset, len;
376a995c792SAkinobu Mita size_t check_len = mtd->erasesize;
377a995c792SAkinobu Mita
378a995c792SAkinobu Mita if (pgcnt)
379a995c792SAkinobu Mita check_len = pgcnt * pgsize;
380a995c792SAkinobu Mita
381a995c792SAkinobu Mita bytes = bits = pages = 0;
382a995c792SAkinobu Mita for (i = 0; i < check_len; i += pgsize)
383a995c792SAkinobu Mita if (countdiffs(written, read, i, pgsize, &bytes,
384a995c792SAkinobu Mita &bits) >= 0)
385a995c792SAkinobu Mita pages++;
386a995c792SAkinobu Mita
387a995c792SAkinobu Mita pr_info("verify fails on %d pages, %d bytes/%d bits\n",
388a995c792SAkinobu Mita pages, bytes, bits);
389a995c792SAkinobu Mita pr_info("The following is a list of all differences between"
390a995c792SAkinobu Mita " what was read from flash and what was expected\n");
391a995c792SAkinobu Mita
392a995c792SAkinobu Mita for (i = 0; i < check_len; i += pgsize) {
393a995c792SAkinobu Mita cond_resched();
394a995c792SAkinobu Mita bytes = bits = 0;
395a995c792SAkinobu Mita first = countdiffs(written, read, i, pgsize, &bytes,
396a995c792SAkinobu Mita &bits);
397a995c792SAkinobu Mita if (first < 0)
398a995c792SAkinobu Mita continue;
399a995c792SAkinobu Mita
400a995c792SAkinobu Mita printk("-------------------------------------------------------"
401a995c792SAkinobu Mita "----------------------------------\n");
402a995c792SAkinobu Mita
403a995c792SAkinobu Mita pr_info("Page %zd has %d bytes/%d bits failing verify,"
404a995c792SAkinobu Mita " starting at offset 0x%x\n",
405a995c792SAkinobu Mita (mtd->erasesize - check_len + i) / pgsize,
406a995c792SAkinobu Mita bytes, bits, first);
407a995c792SAkinobu Mita
408a995c792SAkinobu Mita offset = first & ~0x7;
409a995c792SAkinobu Mita len = ((first + bytes) | 0x7) + 1 - offset;
410a995c792SAkinobu Mita
411a995c792SAkinobu Mita print_bufs(read, written, offset, len);
412a995c792SAkinobu Mita }
413a995c792SAkinobu Mita }
414a995c792SAkinobu Mita
print_bufs(unsigned char * read,unsigned char * written,int start,int len)415a995c792SAkinobu Mita static void print_bufs(unsigned char *read, unsigned char *written, int start,
416a995c792SAkinobu Mita int len)
417a995c792SAkinobu Mita {
418a995c792SAkinobu Mita int i = 0, j1, j2;
419a995c792SAkinobu Mita char *diff;
420a995c792SAkinobu Mita
421a995c792SAkinobu Mita printk("Offset Read Written\n");
422a995c792SAkinobu Mita while (i < len) {
423a995c792SAkinobu Mita printk("0x%08x: ", start + i);
424a995c792SAkinobu Mita diff = " ";
425a995c792SAkinobu Mita for (j1 = 0; j1 < 8 && i + j1 < len; j1++) {
426a995c792SAkinobu Mita printk(" %02x", read[start + i + j1]);
427a995c792SAkinobu Mita if (read[start + i + j1] != written[start + i + j1])
428a995c792SAkinobu Mita diff = "***";
429a995c792SAkinobu Mita }
430a995c792SAkinobu Mita
431a995c792SAkinobu Mita while (j1 < 8) {
432a995c792SAkinobu Mita printk(" ");
433a995c792SAkinobu Mita j1 += 1;
434a995c792SAkinobu Mita }
435a995c792SAkinobu Mita
436a995c792SAkinobu Mita printk(" %s ", diff);
437a995c792SAkinobu Mita
438a995c792SAkinobu Mita for (j2 = 0; j2 < 8 && i + j2 < len; j2++)
439a995c792SAkinobu Mita printk(" %02x", written[start + i + j2]);
440a995c792SAkinobu Mita printk("\n");
441a995c792SAkinobu Mita i += 8;
442a995c792SAkinobu Mita }
443a995c792SAkinobu Mita }
444a995c792SAkinobu Mita
445a995c792SAkinobu Mita /*
446a995c792SAkinobu Mita * Count the number of differing bytes and bits and return the first differing
447a995c792SAkinobu Mita * offset.
448a995c792SAkinobu Mita */
countdiffs(unsigned char * buf,unsigned char * check_buf,unsigned offset,unsigned len,unsigned * bytesp,unsigned * bitsp)449a995c792SAkinobu Mita static int countdiffs(unsigned char *buf, unsigned char *check_buf,
450a995c792SAkinobu Mita unsigned offset, unsigned len, unsigned *bytesp,
451a995c792SAkinobu Mita unsigned *bitsp)
452a995c792SAkinobu Mita {
453a995c792SAkinobu Mita unsigned i, bit;
454a995c792SAkinobu Mita int first = -1;
455a995c792SAkinobu Mita
456a995c792SAkinobu Mita for (i = offset; i < offset + len; i++)
457a995c792SAkinobu Mita if (buf[i] != check_buf[i]) {
458a995c792SAkinobu Mita first = i;
459a995c792SAkinobu Mita break;
460a995c792SAkinobu Mita }
461a995c792SAkinobu Mita
462a995c792SAkinobu Mita while (i < offset + len) {
463a995c792SAkinobu Mita if (buf[i] != check_buf[i]) {
464a995c792SAkinobu Mita (*bytesp)++;
465a995c792SAkinobu Mita bit = 1;
466a995c792SAkinobu Mita while (bit < 256) {
467a995c792SAkinobu Mita if ((buf[i] & bit) != (check_buf[i] & bit))
468a995c792SAkinobu Mita (*bitsp)++;
469a995c792SAkinobu Mita bit <<= 1;
470a995c792SAkinobu Mita }
471a995c792SAkinobu Mita }
472a995c792SAkinobu Mita i++;
473a995c792SAkinobu Mita }
474a995c792SAkinobu Mita
475a995c792SAkinobu Mita return first;
476a995c792SAkinobu Mita }
477a995c792SAkinobu Mita
478a995c792SAkinobu Mita MODULE_DESCRIPTION("Eraseblock torturing module");
479a995c792SAkinobu Mita MODULE_AUTHOR("Artem Bityutskiy, Jarkko Lavinen, Adrian Hunter");
480a995c792SAkinobu Mita MODULE_LICENSE("GPL");
481