1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2006-2008 Nokia Corporation 4 * 5 * Test page read and write on MTD device. 6 * 7 * Author: Adrian Hunter <ext-adrian.hunter@nokia.com> 8 */ 9 10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 11 12 #include <asm/div64.h> 13 #include <linux/init.h> 14 #include <linux/module.h> 15 #include <linux/moduleparam.h> 16 #include <linux/err.h> 17 #include <linux/mtd/mtd.h> 18 #include <linux/slab.h> 19 #include <linux/sched.h> 20 #include <linux/prandom.h> 21 22 #include "mtd_test.h" 23 24 static int dev = -EINVAL; 25 module_param(dev, int, S_IRUGO); 26 MODULE_PARM_DESC(dev, "MTD device number to use"); 27 28 static struct mtd_info *mtd; 29 static unsigned char *twopages; 30 static unsigned char *writebuf; 31 static unsigned char *boundary; 32 static unsigned char *bbt; 33 34 static int pgsize; 35 static int bufsize; 36 static int ebcnt; 37 static int pgcnt; 38 static int errcnt; 39 static struct rnd_state rnd_state; 40 41 static int write_eraseblock(int ebnum) 42 { 43 loff_t addr = (loff_t)ebnum * mtd->erasesize; 44 45 prandom_bytes_state(&rnd_state, writebuf, mtd->erasesize); 46 cond_resched(); 47 return mtdtest_write(mtd, addr, mtd->erasesize, writebuf); 48 } 49 50 static int verify_eraseblock(int ebnum) 51 { 52 uint32_t j; 53 int err = 0, i; 54 loff_t addr0, addrn; 55 loff_t addr = (loff_t)ebnum * mtd->erasesize; 56 57 addr0 = 0; 58 for (i = 0; i < ebcnt && bbt[i]; ++i) 59 addr0 += mtd->erasesize; 60 61 addrn = mtd->size; 62 for (i = 0; i < ebcnt && bbt[ebcnt - i - 1]; ++i) 63 addrn -= mtd->erasesize; 64 65 prandom_bytes_state(&rnd_state, writebuf, mtd->erasesize); 66 for (j = 0; j < pgcnt - 1; ++j, addr += pgsize) { 67 /* Do a read to set the internal dataRAMs to different data */ 68 err = mtdtest_read(mtd, addr0, bufsize, twopages); 69 if (err) 70 return err; 71 err = mtdtest_read(mtd, addrn - bufsize, bufsize, twopages); 72 if (err) 73 return err; 74 memset(twopages, 0, bufsize); 75 err = mtdtest_read(mtd, addr, bufsize, twopages); 76 if (err) 77 break; 78 if (memcmp(twopages, writebuf + (j * pgsize), bufsize)) { 79 pr_err("error: verify failed at %#llx\n", 80 (long long)addr); 81 errcnt += 1; 82 } 83 } 84 /* Check boundary between eraseblocks */ 85 if (addr <= addrn - pgsize - pgsize && !bbt[ebnum + 1]) { 86 struct rnd_state old_state = rnd_state; 87 88 /* Do a read to set the internal dataRAMs to different data */ 89 err = mtdtest_read(mtd, addr0, bufsize, twopages); 90 if (err) 91 return err; 92 err = mtdtest_read(mtd, addrn - bufsize, bufsize, twopages); 93 if (err) 94 return err; 95 memset(twopages, 0, bufsize); 96 err = mtdtest_read(mtd, addr, bufsize, twopages); 97 if (err) 98 return err; 99 memcpy(boundary, writebuf + mtd->erasesize - pgsize, pgsize); 100 prandom_bytes_state(&rnd_state, boundary + pgsize, pgsize); 101 if (memcmp(twopages, boundary, bufsize)) { 102 pr_err("error: verify failed at %#llx\n", 103 (long long)addr); 104 errcnt += 1; 105 } 106 rnd_state = old_state; 107 } 108 return err; 109 } 110 111 static int crosstest(void) 112 { 113 int err = 0, i; 114 loff_t addr, addr0, addrn; 115 unsigned char *pp1, *pp2, *pp3, *pp4; 116 117 pr_info("crosstest\n"); 118 pp1 = kcalloc(pgsize, 4, GFP_KERNEL); 119 if (!pp1) 120 return -ENOMEM; 121 pp2 = pp1 + pgsize; 122 pp3 = pp2 + pgsize; 123 pp4 = pp3 + pgsize; 124 125 addr0 = 0; 126 for (i = 0; i < ebcnt && bbt[i]; ++i) 127 addr0 += mtd->erasesize; 128 129 addrn = mtd->size; 130 for (i = 0; i < ebcnt && bbt[ebcnt - i - 1]; ++i) 131 addrn -= mtd->erasesize; 132 133 /* Read 2nd-to-last page to pp1 */ 134 addr = addrn - pgsize - pgsize; 135 err = mtdtest_read(mtd, addr, pgsize, pp1); 136 if (err) { 137 kfree(pp1); 138 return err; 139 } 140 141 /* Read 3rd-to-last page to pp1 */ 142 addr = addrn - pgsize - pgsize - pgsize; 143 err = mtdtest_read(mtd, addr, pgsize, pp1); 144 if (err) { 145 kfree(pp1); 146 return err; 147 } 148 149 /* Read first page to pp2 */ 150 addr = addr0; 151 pr_info("reading page at %#llx\n", (long long)addr); 152 err = mtdtest_read(mtd, addr, pgsize, pp2); 153 if (err) { 154 kfree(pp1); 155 return err; 156 } 157 158 /* Read last page to pp3 */ 159 addr = addrn - pgsize; 160 pr_info("reading page at %#llx\n", (long long)addr); 161 err = mtdtest_read(mtd, addr, pgsize, pp3); 162 if (err) { 163 kfree(pp1); 164 return err; 165 } 166 167 /* Read first page again to pp4 */ 168 addr = addr0; 169 pr_info("reading page at %#llx\n", (long long)addr); 170 err = mtdtest_read(mtd, addr, pgsize, pp4); 171 if (err) { 172 kfree(pp1); 173 return err; 174 } 175 176 /* pp2 and pp4 should be the same */ 177 pr_info("verifying pages read at %#llx match\n", 178 (long long)addr0); 179 if (memcmp(pp2, pp4, pgsize)) { 180 pr_err("verify failed!\n"); 181 errcnt += 1; 182 } else if (!err) 183 pr_info("crosstest ok\n"); 184 kfree(pp1); 185 return err; 186 } 187 188 static int erasecrosstest(void) 189 { 190 int err = 0, i, ebnum, ebnum2; 191 loff_t addr0; 192 char *readbuf = twopages; 193 194 pr_info("erasecrosstest\n"); 195 196 ebnum = 0; 197 addr0 = 0; 198 for (i = 0; i < ebcnt && bbt[i]; ++i) { 199 addr0 += mtd->erasesize; 200 ebnum += 1; 201 } 202 203 ebnum2 = ebcnt - 1; 204 while (ebnum2 && bbt[ebnum2]) 205 ebnum2 -= 1; 206 207 pr_info("erasing block %d\n", ebnum); 208 err = mtdtest_erase_eraseblock(mtd, ebnum); 209 if (err) 210 return err; 211 212 pr_info("writing 1st page of block %d\n", ebnum); 213 prandom_bytes_state(&rnd_state, writebuf, pgsize); 214 strcpy(writebuf, "There is no data like this!"); 215 err = mtdtest_write(mtd, addr0, pgsize, writebuf); 216 if (err) 217 return err; 218 219 pr_info("reading 1st page of block %d\n", ebnum); 220 memset(readbuf, 0, pgsize); 221 err = mtdtest_read(mtd, addr0, pgsize, readbuf); 222 if (err) 223 return err; 224 225 pr_info("verifying 1st page of block %d\n", ebnum); 226 if (memcmp(writebuf, readbuf, pgsize)) { 227 pr_err("verify failed!\n"); 228 errcnt += 1; 229 return -1; 230 } 231 232 pr_info("erasing block %d\n", ebnum); 233 err = mtdtest_erase_eraseblock(mtd, ebnum); 234 if (err) 235 return err; 236 237 pr_info("writing 1st page of block %d\n", ebnum); 238 prandom_bytes_state(&rnd_state, writebuf, pgsize); 239 strcpy(writebuf, "There is no data like this!"); 240 err = mtdtest_write(mtd, addr0, pgsize, writebuf); 241 if (err) 242 return err; 243 244 pr_info("erasing block %d\n", ebnum2); 245 err = mtdtest_erase_eraseblock(mtd, ebnum2); 246 if (err) 247 return err; 248 249 pr_info("reading 1st page of block %d\n", ebnum); 250 memset(readbuf, 0, pgsize); 251 err = mtdtest_read(mtd, addr0, pgsize, readbuf); 252 if (err) 253 return err; 254 255 pr_info("verifying 1st page of block %d\n", ebnum); 256 if (memcmp(writebuf, readbuf, pgsize)) { 257 pr_err("verify failed!\n"); 258 errcnt += 1; 259 return -1; 260 } 261 262 if (!err) 263 pr_info("erasecrosstest ok\n"); 264 return err; 265 } 266 267 static int erasetest(void) 268 { 269 int err = 0, i, ebnum, ok = 1; 270 loff_t addr0; 271 272 pr_info("erasetest\n"); 273 274 ebnum = 0; 275 addr0 = 0; 276 for (i = 0; i < ebcnt && bbt[i]; ++i) { 277 addr0 += mtd->erasesize; 278 ebnum += 1; 279 } 280 281 pr_info("erasing block %d\n", ebnum); 282 err = mtdtest_erase_eraseblock(mtd, ebnum); 283 if (err) 284 return err; 285 286 pr_info("writing 1st page of block %d\n", ebnum); 287 prandom_bytes_state(&rnd_state, writebuf, pgsize); 288 err = mtdtest_write(mtd, addr0, pgsize, writebuf); 289 if (err) 290 return err; 291 292 pr_info("erasing block %d\n", ebnum); 293 err = mtdtest_erase_eraseblock(mtd, ebnum); 294 if (err) 295 return err; 296 297 pr_info("reading 1st page of block %d\n", ebnum); 298 err = mtdtest_read(mtd, addr0, pgsize, twopages); 299 if (err) 300 return err; 301 302 pr_info("verifying 1st page of block %d is all 0xff\n", 303 ebnum); 304 for (i = 0; i < pgsize; ++i) 305 if (twopages[i] != 0xff) { 306 pr_err("verifying all 0xff failed at %d\n", 307 i); 308 errcnt += 1; 309 ok = 0; 310 break; 311 } 312 313 if (ok && !err) 314 pr_info("erasetest ok\n"); 315 316 return err; 317 } 318 319 static int __init mtd_pagetest_init(void) 320 { 321 int err = 0; 322 uint64_t tmp; 323 uint32_t i; 324 325 printk(KERN_INFO "\n"); 326 printk(KERN_INFO "=================================================\n"); 327 328 if (dev < 0) { 329 pr_info("Please specify a valid mtd-device via module parameter\n"); 330 pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n"); 331 return -EINVAL; 332 } 333 334 pr_info("MTD device: %d\n", dev); 335 336 mtd = get_mtd_device(NULL, dev); 337 if (IS_ERR(mtd)) { 338 err = PTR_ERR(mtd); 339 pr_err("error: cannot get MTD device\n"); 340 return err; 341 } 342 343 if (!mtd_type_is_nand(mtd)) { 344 pr_info("this test requires NAND flash\n"); 345 goto out; 346 } 347 348 tmp = mtd->size; 349 do_div(tmp, mtd->erasesize); 350 ebcnt = tmp; 351 pgcnt = mtd->erasesize / mtd->writesize; 352 pgsize = mtd->writesize; 353 354 pr_info("MTD device size %llu, eraseblock size %u, " 355 "page size %u, count of eraseblocks %u, pages per " 356 "eraseblock %u, OOB size %u\n", 357 (unsigned long long)mtd->size, mtd->erasesize, 358 pgsize, ebcnt, pgcnt, mtd->oobsize); 359 360 err = -ENOMEM; 361 bufsize = pgsize * 2; 362 writebuf = kmalloc(mtd->erasesize, GFP_KERNEL); 363 if (!writebuf) 364 goto out; 365 twopages = kmalloc(bufsize, GFP_KERNEL); 366 if (!twopages) 367 goto out; 368 boundary = kmalloc(bufsize, GFP_KERNEL); 369 if (!boundary) 370 goto out; 371 372 bbt = kzalloc(ebcnt, GFP_KERNEL); 373 if (!bbt) 374 goto out; 375 err = mtdtest_scan_for_bad_eraseblocks(mtd, bbt, 0, ebcnt); 376 if (err) 377 goto out; 378 379 /* Erase all eraseblocks */ 380 pr_info("erasing whole device\n"); 381 err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt); 382 if (err) 383 goto out; 384 pr_info("erased %u eraseblocks\n", ebcnt); 385 386 /* Write all eraseblocks */ 387 prandom_seed_state(&rnd_state, 1); 388 pr_info("writing whole device\n"); 389 for (i = 0; i < ebcnt; ++i) { 390 if (bbt[i]) 391 continue; 392 err = write_eraseblock(i); 393 if (err) 394 goto out; 395 if (i % 256 == 0) 396 pr_info("written up to eraseblock %u\n", i); 397 398 err = mtdtest_relax(); 399 if (err) 400 goto out; 401 } 402 pr_info("written %u eraseblocks\n", i); 403 404 /* Check all eraseblocks */ 405 prandom_seed_state(&rnd_state, 1); 406 pr_info("verifying all eraseblocks\n"); 407 for (i = 0; i < ebcnt; ++i) { 408 if (bbt[i]) 409 continue; 410 err = verify_eraseblock(i); 411 if (err) 412 goto out; 413 if (i % 256 == 0) 414 pr_info("verified up to eraseblock %u\n", i); 415 416 err = mtdtest_relax(); 417 if (err) 418 goto out; 419 } 420 pr_info("verified %u eraseblocks\n", i); 421 422 err = crosstest(); 423 if (err) 424 goto out; 425 426 if (ebcnt > 1) { 427 err = erasecrosstest(); 428 if (err) 429 goto out; 430 } else { 431 pr_info("skipping erasecrosstest, 2 erase blocks needed\n"); 432 } 433 434 err = erasetest(); 435 if (err) 436 goto out; 437 438 pr_info("finished with %d errors\n", errcnt); 439 out: 440 441 kfree(bbt); 442 kfree(boundary); 443 kfree(twopages); 444 kfree(writebuf); 445 put_mtd_device(mtd); 446 if (err) 447 pr_info("error %d occurred\n", err); 448 printk(KERN_INFO "=================================================\n"); 449 return err; 450 } 451 module_init(mtd_pagetest_init); 452 453 static void __exit mtd_pagetest_exit(void) 454 { 455 return; 456 } 457 module_exit(mtd_pagetest_exit); 458 459 MODULE_DESCRIPTION("NAND page test"); 460 MODULE_AUTHOR("Adrian Hunter"); 461 MODULE_LICENSE("GPL"); 462