mtd/tests/mtd_nandecctest.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0003
0004 #include <linux/kernel.h>
0005 #include <linux/module.h>
0006 #include <linux/list.h>
0007 #include <linux/random.h>
0008 #include <linux/string.h>
0009 #include <linux/bitops.h>
0010 #include <linux/slab.h>
0011 #include <linux/mtd/nand-ecc-sw-hamming.h>
0012
0013 #include "mtd_test.h"
0014
0015 /*
0016  * Test the implementation for software ECC
0017  *
0018  * No actual MTD device is needed, So we don't need to warry about losing
0019  * important data by human error.
0020  *
0021  * This covers possible patterns of corruption which can be reliably corrected
0022  * or detected.
0023  */
0024
0025 #if IS_ENABLED(CONFIG_MTD_RAW_NAND)
0026
0027 struct nand_ecc_test {
0028     const char *name;
0029     void (*prepare)(void *, void *, void *, void *, const size_t);
0030     int (*verify)(void *, void *, void *, const size_t);
0031 };
0032
0033 /*
0034  * The reason for this __change_bit_le() instead of __change_bit() is to inject
0035  * bit error properly within the region which is not a multiple of
0036  * sizeof(unsigned long) on big-endian systems
0037  */
0038 #ifdef __LITTLE_ENDIAN
0039 #define __change_bit_le(nr, addr) __change_bit(nr, addr)
0040 #elif defined(__BIG_ENDIAN)
0041 #define __change_bit_le(nr, addr) \
0042         __change_bit((nr) ^ ((BITS_PER_LONG - 1) & ~0x7), addr)
0043 #else
0044 #error "Unknown byte order"
0045 #endif
0046
0047 static void single_bit_error_data(void *error_data, void *correct_data,
0048                 size_t size)
0049 {
0050     unsigned int offset = prandom_u32() % (size * BITS_PER_BYTE);
0051
0052     memcpy(error_data, correct_data, size);
0053     __change_bit_le(offset, error_data);
0054 }
0055
0056 static void double_bit_error_data(void *error_data, void *correct_data,
0057                 size_t size)
0058 {
0059     unsigned int offset[2];
0060
0061     offset[0] = prandom_u32() % (size * BITS_PER_BYTE);
0062     do {
0063         offset[1] = prandom_u32() % (size * BITS_PER_BYTE);
0064     } while (offset[0] == offset[1]);
0065
0066     memcpy(error_data, correct_data, size);
0067
0068     __change_bit_le(offset[0], error_data);
0069     __change_bit_le(offset[1], error_data);
0070 }
0071
0072 static unsigned int random_ecc_bit(size_t size)
0073 {
0074     unsigned int offset = prandom_u32() % (3 * BITS_PER_BYTE);
0075
0076     if (size == 256) {
0077         /*
0078          * Don't inject a bit error into the insignificant bits (16th
0079          * and 17th bit) in ECC code for 256 byte data block
0080          */
0081         while (offset == 16 || offset == 17)
0082             offset = prandom_u32() % (3 * BITS_PER_BYTE);
0083     }
0084
0085     return offset;
0086 }
0087
0088 static void single_bit_error_ecc(void *error_ecc, void *correct_ecc,
0089                 size_t size)
0090 {
0091     unsigned int offset = random_ecc_bit(size);
0092
0093     memcpy(error_ecc, correct_ecc, 3);
0094     __change_bit_le(offset, error_ecc);
0095 }
0096
0097 static void double_bit_error_ecc(void *error_ecc, void *correct_ecc,
0098                 size_t size)
0099 {
0100     unsigned int offset[2];
0101
0102     offset[0] = random_ecc_bit(size);
0103     do {
0104         offset[1] = random_ecc_bit(size);
0105     } while (offset[0] == offset[1]);
0106
0107     memcpy(error_ecc, correct_ecc, 3);
0108     __change_bit_le(offset[0], error_ecc);
0109     __change_bit_le(offset[1], error_ecc);
0110 }
0111
0112 static void no_bit_error(void *error_data, void *error_ecc,
0113         void *correct_data, void *correct_ecc, const size_t size)
0114 {
0115     memcpy(error_data, correct_data, size);
0116     memcpy(error_ecc, correct_ecc, 3);
0117 }
0118
0119 static int no_bit_error_verify(void *error_data, void *error_ecc,
0120                 void *correct_data, const size_t size)
0121 {
0122     bool sm_order = IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING_SMC);
0123     unsigned char calc_ecc[3];
0124     int ret;
0125
0126     ecc_sw_hamming_calculate(error_data, size, calc_ecc, sm_order);
0127     ret = ecc_sw_hamming_correct(error_data, error_ecc, calc_ecc, size,
0128                      sm_order);
0129     if (ret == 0 && !memcmp(correct_data, error_data, size))
0130         return 0;
0131
0132     return -EINVAL;
0133 }
0134
0135 static void single_bit_error_in_data(void *error_data, void *error_ecc,
0136         void *correct_data, void *correct_ecc, const size_t size)
0137 {
0138     single_bit_error_data(error_data, correct_data, size);
0139     memcpy(error_ecc, correct_ecc, 3);
0140 }
0141
0142 static void single_bit_error_in_ecc(void *error_data, void *error_ecc,
0143         void *correct_data, void *correct_ecc, const size_t size)
0144 {
0145     memcpy(error_data, correct_data, size);
0146     single_bit_error_ecc(error_ecc, correct_ecc, size);
0147 }
0148
0149 static int single_bit_error_correct(void *error_data, void *error_ecc,
0150                 void *correct_data, const size_t size)
0151 {
0152     bool sm_order = IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING_SMC);
0153     unsigned char calc_ecc[3];
0154     int ret;
0155
0156     ecc_sw_hamming_calculate(error_data, size, calc_ecc, sm_order);
0157     ret = ecc_sw_hamming_correct(error_data, error_ecc, calc_ecc, size,
0158                      sm_order);
0159     if (ret == 1 && !memcmp(correct_data, error_data, size))
0160         return 0;
0161
0162     return -EINVAL;
0163 }
0164
0165 static void double_bit_error_in_data(void *error_data, void *error_ecc,
0166         void *correct_data, void *correct_ecc, const size_t size)
0167 {
0168     double_bit_error_data(error_data, correct_data, size);
0169     memcpy(error_ecc, correct_ecc, 3);
0170 }
0171
0172 static void single_bit_error_in_data_and_ecc(void *error_data, void *error_ecc,
0173         void *correct_data, void *correct_ecc, const size_t size)
0174 {
0175     single_bit_error_data(error_data, correct_data, size);
0176     single_bit_error_ecc(error_ecc, correct_ecc, size);
0177 }
0178
0179 static void double_bit_error_in_ecc(void *error_data, void *error_ecc,
0180         void *correct_data, void *correct_ecc, const size_t size)
0181 {
0182     memcpy(error_data, correct_data, size);
0183     double_bit_error_ecc(error_ecc, correct_ecc, size);
0184 }
0185
0186 static int double_bit_error_detect(void *error_data, void *error_ecc,
0187                 void *correct_data, const size_t size)
0188 {
0189     bool sm_order = IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING_SMC);
0190     unsigned char calc_ecc[3];
0191     int ret;
0192
0193     ecc_sw_hamming_calculate(error_data, size, calc_ecc, sm_order);
0194     ret = ecc_sw_hamming_correct(error_data, error_ecc, calc_ecc, size,
0195                      sm_order);
0196
0197     return (ret == -EBADMSG) ? 0 : -EINVAL;
0198 }
0199
0200 static const struct nand_ecc_test nand_ecc_test[] = {
0201     {
0202         .name = "no-bit-error",
0203         .prepare = no_bit_error,
0204         .verify = no_bit_error_verify,
0205     },
0206     {
0207         .name = "single-bit-error-in-data-correct",
0208         .prepare = single_bit_error_in_data,
0209         .verify = single_bit_error_correct,
0210     },
0211     {
0212         .name = "single-bit-error-in-ecc-correct",
0213         .prepare = single_bit_error_in_ecc,
0214         .verify = single_bit_error_correct,
0215     },
0216     {
0217         .name = "double-bit-error-in-data-detect",
0218         .prepare = double_bit_error_in_data,
0219         .verify = double_bit_error_detect,
0220     },
0221     {
0222         .name = "single-bit-error-in-data-and-ecc-detect",
0223         .prepare = single_bit_error_in_data_and_ecc,
0224         .verify = double_bit_error_detect,
0225     },
0226     {
0227         .name = "double-bit-error-in-ecc-detect",
0228         .prepare = double_bit_error_in_ecc,
0229         .verify = double_bit_error_detect,
0230     },
0231 };
0232
0233 static void dump_data_ecc(void *error_data, void *error_ecc, void *correct_data,
0234             void *correct_ecc, const size_t size)
0235 {
0236     pr_info("hexdump of error data:\n");
0237     print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 4,
0238             error_data, size, false);
0239     print_hex_dump(KERN_INFO, "hexdump of error ecc: ",
0240             DUMP_PREFIX_NONE, 16, 1, error_ecc, 3, false);
0241
0242     pr_info("hexdump of correct data:\n");
0243     print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 4,
0244             correct_data, size, false);
0245     print_hex_dump(KERN_INFO, "hexdump of correct ecc: ",
0246             DUMP_PREFIX_NONE, 16, 1, correct_ecc, 3, false);
0247 }
0248
0249 static int nand_ecc_test_run(const size_t size)
0250 {
0251     bool sm_order = IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING_SMC);
0252     int i;
0253     int err = 0;
0254     void *error_data;
0255     void *error_ecc;
0256     void *correct_data;
0257     void *correct_ecc;
0258
0259     error_data = kmalloc(size, GFP_KERNEL);
0260     error_ecc = kmalloc(3, GFP_KERNEL);
0261     correct_data = kmalloc(size, GFP_KERNEL);
0262     correct_ecc = kmalloc(3, GFP_KERNEL);
0263
0264     if (!error_data || !error_ecc || !correct_data || !correct_ecc) {
0265         err = -ENOMEM;
0266         goto error;
0267     }
0268
0269     prandom_bytes(correct_data, size);
0270     ecc_sw_hamming_calculate(correct_data, size, correct_ecc, sm_order);
0271     for (i = 0; i < ARRAY_SIZE(nand_ecc_test); i++) {
0272         nand_ecc_test[i].prepare(error_data, error_ecc,
0273                 correct_data, correct_ecc, size);
0274         err = nand_ecc_test[i].verify(error_data, error_ecc,
0275                         correct_data, size);
0276
0277         if (err) {
0278             pr_err("not ok - %s-%zd\n",
0279                 nand_ecc_test[i].name, size);
0280             dump_data_ecc(error_data, error_ecc,
0281                 correct_data, correct_ecc, size);
0282             break;
0283         }
0284         pr_info("ok - %s-%zd\n",
0285             nand_ecc_test[i].name, size);
0286
0287         err = mtdtest_relax();
0288         if (err)
0289             break;
0290     }
0291 error:
0292     kfree(error_data);
0293     kfree(error_ecc);
0294     kfree(correct_data);
0295     kfree(correct_ecc);
0296
0297     return err;
0298 }
0299
0300 #else
0301
0302 static int nand_ecc_test_run(const size_t size)
0303 {
0304     return 0;
0305 }
0306
0307 #endif
0308
0309 static int __init ecc_test_init(void)
0310 {
0311     int err;
0312
0313     err = nand_ecc_test_run(256);
0314     if (err)
0315         return err;
0316
0317     return nand_ecc_test_run(512);
0318 }
0319
0320 static void __exit ecc_test_exit(void)
0321 {
0322 }
0323
0324 module_init(ecc_test_init);
0325 module_exit(ecc_test_exit);
0326
0327 MODULE_DESCRIPTION("NAND ECC function test module");
0328 MODULE_AUTHOR("Akinobu Mita");
0329 MODULE_LICENSE("GPL");