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