1 #include <linux/kernel.h> 2 #include <linux/module.h> 3 #include <linux/list.h> 4 #include <linux/random.h> 5 #include <linux/string.h> 6 #include <linux/bitops.h> 7 #include <linux/slab.h> 8 #include <linux/mtd/nand_ecc.h> 9 10 /* 11 * Test the implementation for software ECC 12 * 13 * No actual MTD device is needed, So we don't need to warry about losing 14 * important data by human error. 15 * 16 * This covers possible patterns of corruption which can be reliably corrected 17 * or detected. 18 */ 19 20 #if defined(CONFIG_MTD_NAND) || defined(CONFIG_MTD_NAND_MODULE) 21 22 struct nand_ecc_test { 23 const char *name; 24 void (*prepare)(void *, void *, void *, void *, const size_t); 25 int (*verify)(void *, void *, void *, const size_t); 26 }; 27 28 /* 29 * The reason for this __change_bit_le() instead of __change_bit() is to inject 30 * bit error properly within the region which is not a multiple of 31 * sizeof(unsigned long) on big-endian systems 32 */ 33 #ifdef __LITTLE_ENDIAN 34 #define __change_bit_le(nr, addr) __change_bit(nr, addr) 35 #elif defined(__BIG_ENDIAN) 36 #define __change_bit_le(nr, addr) \ 37 __change_bit((nr) ^ ((BITS_PER_LONG - 1) & ~0x7), addr) 38 #else 39 #error "Unknown byte order" 40 #endif 41 42 static void single_bit_error_data(void *error_data, void *correct_data, 43 size_t size) 44 { 45 unsigned int offset = random32() % (size * BITS_PER_BYTE); 46 47 memcpy(error_data, correct_data, size); 48 __change_bit_le(offset, error_data); 49 } 50 51 static unsigned int random_ecc_bit(size_t size) 52 { 53 unsigned int offset = random32() % (3 * BITS_PER_BYTE); 54 55 if (size == 256) { 56 /* 57 * Don't inject a bit error into the insignificant bits (16th 58 * and 17th bit) in ECC code for 256 byte data block 59 */ 60 while (offset == 16 || offset == 17) 61 offset = random32() % (3 * BITS_PER_BYTE); 62 } 63 64 return offset; 65 } 66 67 static void single_bit_error_ecc(void *error_ecc, void *correct_ecc, 68 size_t size) 69 { 70 unsigned int offset = random_ecc_bit(size); 71 72 memcpy(error_ecc, correct_ecc, 3); 73 __change_bit_le(offset, error_ecc); 74 } 75 76 static void no_bit_error(void *error_data, void *error_ecc, 77 void *correct_data, void *correct_ecc, const size_t size) 78 { 79 memcpy(error_data, correct_data, size); 80 memcpy(error_ecc, correct_ecc, 3); 81 } 82 83 static int no_bit_error_verify(void *error_data, void *error_ecc, 84 void *correct_data, const size_t size) 85 { 86 unsigned char calc_ecc[3]; 87 int ret; 88 89 __nand_calculate_ecc(error_data, size, calc_ecc); 90 ret = __nand_correct_data(error_data, error_ecc, calc_ecc, size); 91 if (ret == 0 && !memcmp(correct_data, error_data, size)) 92 return 0; 93 94 return -EINVAL; 95 } 96 97 static void single_bit_error_in_data(void *error_data, void *error_ecc, 98 void *correct_data, void *correct_ecc, const size_t size) 99 { 100 single_bit_error_data(error_data, correct_data, size); 101 memcpy(error_ecc, correct_ecc, 3); 102 } 103 104 static void single_bit_error_in_ecc(void *error_data, void *error_ecc, 105 void *correct_data, void *correct_ecc, const size_t size) 106 { 107 memcpy(error_data, correct_data, size); 108 single_bit_error_ecc(error_ecc, correct_ecc, size); 109 } 110 111 static int single_bit_error_correct(void *error_data, void *error_ecc, 112 void *correct_data, const size_t size) 113 { 114 unsigned char calc_ecc[3]; 115 int ret; 116 117 __nand_calculate_ecc(error_data, size, calc_ecc); 118 ret = __nand_correct_data(error_data, error_ecc, calc_ecc, size); 119 if (ret == 1 && !memcmp(correct_data, error_data, size)) 120 return 0; 121 122 return -EINVAL; 123 } 124 125 static const struct nand_ecc_test nand_ecc_test[] = { 126 { 127 .name = "no-bit-error", 128 .prepare = no_bit_error, 129 .verify = no_bit_error_verify, 130 }, 131 { 132 .name = "single-bit-error-in-data-correct", 133 .prepare = single_bit_error_in_data, 134 .verify = single_bit_error_correct, 135 }, 136 { 137 .name = "single-bit-error-in-ecc-correct", 138 .prepare = single_bit_error_in_ecc, 139 .verify = single_bit_error_correct, 140 }, 141 }; 142 143 static void dump_data_ecc(void *error_data, void *error_ecc, void *correct_data, 144 void *correct_ecc, const size_t size) 145 { 146 pr_info("hexdump of error data:\n"); 147 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 4, 148 error_data, size, false); 149 print_hex_dump(KERN_INFO, "hexdump of error ecc: ", 150 DUMP_PREFIX_NONE, 16, 1, error_ecc, 3, false); 151 152 pr_info("hexdump of correct data:\n"); 153 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 4, 154 correct_data, size, false); 155 print_hex_dump(KERN_INFO, "hexdump of correct ecc: ", 156 DUMP_PREFIX_NONE, 16, 1, correct_ecc, 3, false); 157 } 158 159 static int nand_ecc_test_run(const size_t size) 160 { 161 int i; 162 int err = 0; 163 void *error_data; 164 void *error_ecc; 165 void *correct_data; 166 void *correct_ecc; 167 168 error_data = kmalloc(size, GFP_KERNEL); 169 error_ecc = kmalloc(3, GFP_KERNEL); 170 correct_data = kmalloc(size, GFP_KERNEL); 171 correct_ecc = kmalloc(3, GFP_KERNEL); 172 173 if (!error_data || !error_ecc || !correct_data || !correct_ecc) { 174 err = -ENOMEM; 175 goto error; 176 } 177 178 get_random_bytes(correct_data, size); 179 __nand_calculate_ecc(correct_data, size, correct_ecc); 180 181 for (i = 0; i < ARRAY_SIZE(nand_ecc_test); i++) { 182 nand_ecc_test[i].prepare(error_data, error_ecc, 183 correct_data, correct_ecc, size); 184 err = nand_ecc_test[i].verify(error_data, error_ecc, 185 correct_data, size); 186 187 if (err) { 188 pr_err("mtd_nandecctest: not ok - %s-%zd\n", 189 nand_ecc_test[i].name, size); 190 dump_data_ecc(error_data, error_ecc, 191 correct_data, correct_ecc, size); 192 break; 193 } 194 pr_info("mtd_nandecctest: ok - %s-%zd\n", 195 nand_ecc_test[i].name, size); 196 } 197 error: 198 kfree(error_data); 199 kfree(error_ecc); 200 kfree(correct_data); 201 kfree(correct_ecc); 202 203 return err; 204 } 205 206 #else 207 208 static int nand_ecc_test_run(const size_t size) 209 { 210 return 0; 211 } 212 213 #endif 214 215 static int __init ecc_test_init(void) 216 { 217 int err; 218 219 err = nand_ecc_test_run(256); 220 if (err) 221 return err; 222 223 return nand_ecc_test_run(512); 224 } 225 226 static void __exit ecc_test_exit(void) 227 { 228 } 229 230 module_init(ecc_test_init); 231 module_exit(ecc_test_exit); 232 233 MODULE_DESCRIPTION("NAND ECC function test module"); 234 MODULE_AUTHOR("Akinobu Mita"); 235 MODULE_LICENSE("GPL"); 236