1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2010 4 * Vipin Kumar, ST Microelectronics, vipin.kumar@st.com. 5 * 6 * (C) Copyright 2012 7 * Amit Virdi, ST Microelectronics, amit.virdi@st.com. 8 */ 9 10 #include <common.h> 11 #include <nand.h> 12 #include <asm/io.h> 13 #include <linux/bitops.h> 14 #include <linux/err.h> 15 #include <linux/mtd/nand_ecc.h> 16 #include <linux/mtd/fsmc_nand.h> 17 #include <asm/arch/hardware.h> 18 19 static u32 fsmc_version; 20 static struct fsmc_regs *const fsmc_regs_p = (struct fsmc_regs *) 21 CONFIG_SYS_FSMC_BASE; 22 23 /* 24 * ECC4 and ECC1 have 13 bytes and 3 bytes of ecc respectively for 512 bytes of 25 * data. ECC4 can correct up to 8 bits in 512 bytes of data while ECC1 can 26 * correct 1 bit in 512 bytes 27 */ 28 29 static struct nand_ecclayout fsmc_ecc4_lp_layout = { 30 .eccbytes = 104, 31 .eccpos = { 2, 3, 4, 5, 6, 7, 8, 32 9, 10, 11, 12, 13, 14, 33 18, 19, 20, 21, 22, 23, 24, 34 25, 26, 27, 28, 29, 30, 35 34, 35, 36, 37, 38, 39, 40, 36 41, 42, 43, 44, 45, 46, 37 50, 51, 52, 53, 54, 55, 56, 38 57, 58, 59, 60, 61, 62, 39 66, 67, 68, 69, 70, 71, 72, 40 73, 74, 75, 76, 77, 78, 41 82, 83, 84, 85, 86, 87, 88, 42 89, 90, 91, 92, 93, 94, 43 98, 99, 100, 101, 102, 103, 104, 44 105, 106, 107, 108, 109, 110, 45 114, 115, 116, 117, 118, 119, 120, 46 121, 122, 123, 124, 125, 126 47 }, 48 .oobfree = { 49 {.offset = 15, .length = 3}, 50 {.offset = 31, .length = 3}, 51 {.offset = 47, .length = 3}, 52 {.offset = 63, .length = 3}, 53 {.offset = 79, .length = 3}, 54 {.offset = 95, .length = 3}, 55 {.offset = 111, .length = 3}, 56 {.offset = 127, .length = 1} 57 } 58 }; 59 60 /* 61 * ECC4 layout for NAND of pagesize 4096 bytes & OOBsize 224 bytes. 13*8 bytes 62 * of OOB size is reserved for ECC, Byte no. 0 & 1 reserved for bad block & 118 63 * bytes are free for use. 64 */ 65 static struct nand_ecclayout fsmc_ecc4_224_layout = { 66 .eccbytes = 104, 67 .eccpos = { 2, 3, 4, 5, 6, 7, 8, 68 9, 10, 11, 12, 13, 14, 69 18, 19, 20, 21, 22, 23, 24, 70 25, 26, 27, 28, 29, 30, 71 34, 35, 36, 37, 38, 39, 40, 72 41, 42, 43, 44, 45, 46, 73 50, 51, 52, 53, 54, 55, 56, 74 57, 58, 59, 60, 61, 62, 75 66, 67, 68, 69, 70, 71, 72, 76 73, 74, 75, 76, 77, 78, 77 82, 83, 84, 85, 86, 87, 88, 78 89, 90, 91, 92, 93, 94, 79 98, 99, 100, 101, 102, 103, 104, 80 105, 106, 107, 108, 109, 110, 81 114, 115, 116, 117, 118, 119, 120, 82 121, 122, 123, 124, 125, 126 83 }, 84 .oobfree = { 85 {.offset = 15, .length = 3}, 86 {.offset = 31, .length = 3}, 87 {.offset = 47, .length = 3}, 88 {.offset = 63, .length = 3}, 89 {.offset = 79, .length = 3}, 90 {.offset = 95, .length = 3}, 91 {.offset = 111, .length = 3}, 92 {.offset = 127, .length = 97} 93 } 94 }; 95 96 /* 97 * ECC placement definitions in oobfree type format 98 * There are 13 bytes of ecc for every 512 byte block and it has to be read 99 * consecutively and immediately after the 512 byte data block for hardware to 100 * generate the error bit offsets in 512 byte data 101 * Managing the ecc bytes in the following way makes it easier for software to 102 * read ecc bytes consecutive to data bytes. This way is similar to 103 * oobfree structure maintained already in u-boot nand driver 104 */ 105 static struct fsmc_eccplace fsmc_eccpl_lp = { 106 .eccplace = { 107 {.offset = 2, .length = 13}, 108 {.offset = 18, .length = 13}, 109 {.offset = 34, .length = 13}, 110 {.offset = 50, .length = 13}, 111 {.offset = 66, .length = 13}, 112 {.offset = 82, .length = 13}, 113 {.offset = 98, .length = 13}, 114 {.offset = 114, .length = 13} 115 } 116 }; 117 118 static struct nand_ecclayout fsmc_ecc4_sp_layout = { 119 .eccbytes = 13, 120 .eccpos = { 0, 1, 2, 3, 6, 7, 8, 121 9, 10, 11, 12, 13, 14 122 }, 123 .oobfree = { 124 {.offset = 15, .length = 1}, 125 } 126 }; 127 128 static struct fsmc_eccplace fsmc_eccpl_sp = { 129 .eccplace = { 130 {.offset = 0, .length = 4}, 131 {.offset = 6, .length = 9} 132 } 133 }; 134 135 static struct nand_ecclayout fsmc_ecc1_layout = { 136 .eccbytes = 24, 137 .eccpos = {2, 3, 4, 18, 19, 20, 34, 35, 36, 50, 51, 52, 138 66, 67, 68, 82, 83, 84, 98, 99, 100, 114, 115, 116}, 139 .oobfree = { 140 {.offset = 8, .length = 8}, 141 {.offset = 24, .length = 8}, 142 {.offset = 40, .length = 8}, 143 {.offset = 56, .length = 8}, 144 {.offset = 72, .length = 8}, 145 {.offset = 88, .length = 8}, 146 {.offset = 104, .length = 8}, 147 {.offset = 120, .length = 8} 148 } 149 }; 150 151 /* Count the number of 0's in buff upto a max of max_bits */ 152 static int count_written_bits(uint8_t *buff, int size, int max_bits) 153 { 154 int k, written_bits = 0; 155 156 for (k = 0; k < size; k++) { 157 written_bits += hweight8(~buff[k]); 158 if (written_bits > max_bits) 159 break; 160 } 161 162 return written_bits; 163 } 164 165 static void fsmc_nand_hwcontrol(struct mtd_info *mtd, int cmd, uint ctrl) 166 { 167 struct nand_chip *this = mtd_to_nand(mtd); 168 ulong IO_ADDR_W; 169 170 if (ctrl & NAND_CTRL_CHANGE) { 171 IO_ADDR_W = (ulong)this->IO_ADDR_W; 172 173 IO_ADDR_W &= ~(CONFIG_SYS_NAND_CLE | CONFIG_SYS_NAND_ALE); 174 if (ctrl & NAND_CLE) 175 IO_ADDR_W |= CONFIG_SYS_NAND_CLE; 176 if (ctrl & NAND_ALE) 177 IO_ADDR_W |= CONFIG_SYS_NAND_ALE; 178 179 if (ctrl & NAND_NCE) { 180 writel(readl(&fsmc_regs_p->pc) | 181 FSMC_ENABLE, &fsmc_regs_p->pc); 182 } else { 183 writel(readl(&fsmc_regs_p->pc) & 184 ~FSMC_ENABLE, &fsmc_regs_p->pc); 185 } 186 this->IO_ADDR_W = (void *)IO_ADDR_W; 187 } 188 189 if (cmd != NAND_CMD_NONE) 190 writeb(cmd, this->IO_ADDR_W); 191 } 192 193 static int fsmc_bch8_correct_data(struct mtd_info *mtd, u_char *dat, 194 u_char *read_ecc, u_char *calc_ecc) 195 { 196 /* The calculated ecc is actually the correction index in data */ 197 u32 err_idx[8]; 198 u32 num_err, i; 199 u32 ecc1, ecc2, ecc3, ecc4; 200 201 num_err = (readl(&fsmc_regs_p->sts) >> 10) & 0xF; 202 203 if (likely(num_err == 0)) 204 return 0; 205 206 if (unlikely(num_err > 8)) { 207 /* 208 * This is a temporary erase check. A newly erased page read 209 * would result in an ecc error because the oob data is also 210 * erased to FF and the calculated ecc for an FF data is not 211 * FF..FF. 212 * This is a workaround to skip performing correction in case 213 * data is FF..FF 214 * 215 * Logic: 216 * For every page, each bit written as 0 is counted until these 217 * number of bits are greater than 8 (the maximum correction 218 * capability of FSMC for each 512 + 13 bytes) 219 */ 220 221 int bits_ecc = count_written_bits(read_ecc, 13, 8); 222 int bits_data = count_written_bits(dat, 512, 8); 223 224 if ((bits_ecc + bits_data) <= 8) { 225 if (bits_data) 226 memset(dat, 0xff, 512); 227 return bits_data + bits_ecc; 228 } 229 230 return -EBADMSG; 231 } 232 233 ecc1 = readl(&fsmc_regs_p->ecc1); 234 ecc2 = readl(&fsmc_regs_p->ecc2); 235 ecc3 = readl(&fsmc_regs_p->ecc3); 236 ecc4 = readl(&fsmc_regs_p->sts); 237 238 err_idx[0] = (ecc1 >> 0) & 0x1FFF; 239 err_idx[1] = (ecc1 >> 13) & 0x1FFF; 240 err_idx[2] = (((ecc2 >> 0) & 0x7F) << 6) | ((ecc1 >> 26) & 0x3F); 241 err_idx[3] = (ecc2 >> 7) & 0x1FFF; 242 err_idx[4] = (((ecc3 >> 0) & 0x1) << 12) | ((ecc2 >> 20) & 0xFFF); 243 err_idx[5] = (ecc3 >> 1) & 0x1FFF; 244 err_idx[6] = (ecc3 >> 14) & 0x1FFF; 245 err_idx[7] = (((ecc4 >> 16) & 0xFF) << 5) | ((ecc3 >> 27) & 0x1F); 246 247 i = 0; 248 while (i < num_err) { 249 err_idx[i] ^= 3; 250 251 if (err_idx[i] < 512 * 8) 252 __change_bit(err_idx[i], dat); 253 254 i++; 255 } 256 257 return num_err; 258 } 259 260 static int fsmc_read_hwecc(struct mtd_info *mtd, 261 const u_char *data, u_char *ecc) 262 { 263 u_int ecc_tmp; 264 int timeout = CONFIG_SYS_HZ; 265 ulong start; 266 267 switch (fsmc_version) { 268 case FSMC_VER8: 269 start = get_timer(0); 270 while (get_timer(start) < timeout) { 271 /* 272 * Busy waiting for ecc computation 273 * to finish for 512 bytes 274 */ 275 if (readl(&fsmc_regs_p->sts) & FSMC_CODE_RDY) 276 break; 277 } 278 279 ecc_tmp = readl(&fsmc_regs_p->ecc1); 280 ecc[0] = (u_char) (ecc_tmp >> 0); 281 ecc[1] = (u_char) (ecc_tmp >> 8); 282 ecc[2] = (u_char) (ecc_tmp >> 16); 283 ecc[3] = (u_char) (ecc_tmp >> 24); 284 285 ecc_tmp = readl(&fsmc_regs_p->ecc2); 286 ecc[4] = (u_char) (ecc_tmp >> 0); 287 ecc[5] = (u_char) (ecc_tmp >> 8); 288 ecc[6] = (u_char) (ecc_tmp >> 16); 289 ecc[7] = (u_char) (ecc_tmp >> 24); 290 291 ecc_tmp = readl(&fsmc_regs_p->ecc3); 292 ecc[8] = (u_char) (ecc_tmp >> 0); 293 ecc[9] = (u_char) (ecc_tmp >> 8); 294 ecc[10] = (u_char) (ecc_tmp >> 16); 295 ecc[11] = (u_char) (ecc_tmp >> 24); 296 297 ecc_tmp = readl(&fsmc_regs_p->sts); 298 ecc[12] = (u_char) (ecc_tmp >> 16); 299 break; 300 301 default: 302 ecc_tmp = readl(&fsmc_regs_p->ecc1); 303 ecc[0] = (u_char) (ecc_tmp >> 0); 304 ecc[1] = (u_char) (ecc_tmp >> 8); 305 ecc[2] = (u_char) (ecc_tmp >> 16); 306 break; 307 } 308 309 return 0; 310 } 311 312 void fsmc_enable_hwecc(struct mtd_info *mtd, int mode) 313 { 314 writel(readl(&fsmc_regs_p->pc) & ~FSMC_ECCPLEN_256, 315 &fsmc_regs_p->pc); 316 writel(readl(&fsmc_regs_p->pc) & ~FSMC_ECCEN, 317 &fsmc_regs_p->pc); 318 writel(readl(&fsmc_regs_p->pc) | FSMC_ECCEN, 319 &fsmc_regs_p->pc); 320 } 321 322 /* 323 * fsmc_read_page_hwecc 324 * @mtd: mtd info structure 325 * @chip: nand chip info structure 326 * @buf: buffer to store read data 327 * @oob_required: caller expects OOB data read to chip->oob_poi 328 * @page: page number to read 329 * 330 * This routine is needed for fsmc verison 8 as reading from NAND chip has to be 331 * performed in a strict sequence as follows: 332 * data(512 byte) -> ecc(13 byte) 333 * After this read, fsmc hardware generates and reports error data bits(upto a 334 * max of 8 bits) 335 */ 336 static int fsmc_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, 337 uint8_t *buf, int oob_required, int page) 338 { 339 struct fsmc_eccplace *fsmc_eccpl; 340 int i, j, s, stat, eccsize = chip->ecc.size; 341 int eccbytes = chip->ecc.bytes; 342 int eccsteps = chip->ecc.steps; 343 uint8_t *p = buf; 344 uint8_t *ecc_calc = chip->buffers->ecccalc; 345 uint8_t *ecc_code = chip->buffers->ecccode; 346 int off, len, group = 0; 347 uint8_t oob[13] __attribute__ ((aligned (2))); 348 349 /* Differentiate between small and large page ecc place definitions */ 350 if (mtd->writesize == 512) 351 fsmc_eccpl = &fsmc_eccpl_sp; 352 else 353 fsmc_eccpl = &fsmc_eccpl_lp; 354 355 for (i = 0, s = 0; s < eccsteps; s++, i += eccbytes, p += eccsize) { 356 357 chip->cmdfunc(mtd, NAND_CMD_READ0, s * eccsize, page); 358 chip->ecc.hwctl(mtd, NAND_ECC_READ); 359 chip->read_buf(mtd, p, eccsize); 360 361 for (j = 0; j < eccbytes;) { 362 off = fsmc_eccpl->eccplace[group].offset; 363 len = fsmc_eccpl->eccplace[group].length; 364 group++; 365 366 /* 367 * length is intentionally kept a higher multiple of 2 368 * to read at least 13 bytes even in case of 16 bit NAND 369 * devices 370 */ 371 if (chip->options & NAND_BUSWIDTH_16) 372 len = roundup(len, 2); 373 chip->cmdfunc(mtd, NAND_CMD_READOOB, off, page); 374 chip->read_buf(mtd, oob + j, len); 375 j += len; 376 } 377 378 memcpy(&ecc_code[i], oob, 13); 379 chip->ecc.calculate(mtd, p, &ecc_calc[i]); 380 381 stat = chip->ecc.correct(mtd, p, &ecc_code[i], 382 &ecc_calc[i]); 383 if (stat < 0) 384 mtd->ecc_stats.failed++; 385 else 386 mtd->ecc_stats.corrected += stat; 387 } 388 389 return 0; 390 } 391 392 #ifndef CONFIG_SPL_BUILD 393 /* 394 * fsmc_nand_switch_ecc - switch the ECC operation between different engines 395 * 396 * @eccstrength - the number of bits that could be corrected 397 * (1 - HW, 4 - SW BCH4) 398 */ 399 int fsmc_nand_switch_ecc(uint32_t eccstrength) 400 { 401 struct nand_chip *nand; 402 struct mtd_info *mtd; 403 int err; 404 405 /* 406 * This functions is only called on SPEAr600 platforms, supporting 407 * 1 bit HW ECC. The BCH8 HW ECC (FSMC_VER8) from the ST-Ericsson 408 * Nomadik SoC is currently supporting this fsmc_nand_switch_ecc() 409 * function, as it doesn't need to switch to a different ECC layout. 410 */ 411 mtd = get_nand_dev_by_index(nand_curr_device); 412 nand = mtd_to_nand(mtd); 413 414 /* Setup the ecc configurations again */ 415 if (eccstrength == 1) { 416 nand->ecc.mode = NAND_ECC_HW; 417 nand->ecc.bytes = 3; 418 nand->ecc.strength = 1; 419 nand->ecc.layout = &fsmc_ecc1_layout; 420 nand->ecc.calculate = fsmc_read_hwecc; 421 nand->ecc.correct = nand_correct_data; 422 } else if (eccstrength == 4) { 423 /* 424 * .calculate .correct and .bytes will be set in 425 * nand_scan_tail() 426 */ 427 nand->ecc.mode = NAND_ECC_SOFT_BCH; 428 nand->ecc.strength = 4; 429 nand->ecc.layout = NULL; 430 } else { 431 printf("Error: ECC strength %d not supported!\n", eccstrength); 432 } 433 434 /* Update NAND handling after ECC mode switch */ 435 err = nand_scan_tail(mtd); 436 437 return err; 438 } 439 #endif /* CONFIG_SPL_BUILD */ 440 441 int fsmc_nand_init(struct nand_chip *nand) 442 { 443 static int chip_nr; 444 struct mtd_info *mtd; 445 u32 peripid2 = readl(&fsmc_regs_p->peripid2); 446 447 fsmc_version = (peripid2 >> FSMC_REVISION_SHFT) & 448 FSMC_REVISION_MSK; 449 450 writel(readl(&fsmc_regs_p->ctrl) | FSMC_WP, &fsmc_regs_p->ctrl); 451 452 #if defined(CONFIG_SYS_FSMC_NAND_16BIT) 453 writel(FSMC_DEVWID_16 | FSMC_DEVTYPE_NAND | FSMC_ENABLE | FSMC_WAITON, 454 &fsmc_regs_p->pc); 455 #elif defined(CONFIG_SYS_FSMC_NAND_8BIT) 456 writel(FSMC_DEVWID_8 | FSMC_DEVTYPE_NAND | FSMC_ENABLE | FSMC_WAITON, 457 &fsmc_regs_p->pc); 458 #else 459 #error Please define CONFIG_SYS_FSMC_NAND_16BIT or CONFIG_SYS_FSMC_NAND_8BIT 460 #endif 461 writel(readl(&fsmc_regs_p->pc) | FSMC_TCLR_1 | FSMC_TAR_1, 462 &fsmc_regs_p->pc); 463 writel(FSMC_THIZ_1 | FSMC_THOLD_4 | FSMC_TWAIT_6 | FSMC_TSET_0, 464 &fsmc_regs_p->comm); 465 writel(FSMC_THIZ_1 | FSMC_THOLD_4 | FSMC_TWAIT_6 | FSMC_TSET_0, 466 &fsmc_regs_p->attrib); 467 468 nand->options = 0; 469 #if defined(CONFIG_SYS_FSMC_NAND_16BIT) 470 nand->options |= NAND_BUSWIDTH_16; 471 #endif 472 nand->ecc.mode = NAND_ECC_HW; 473 nand->ecc.size = 512; 474 nand->ecc.calculate = fsmc_read_hwecc; 475 nand->ecc.hwctl = fsmc_enable_hwecc; 476 nand->cmd_ctrl = fsmc_nand_hwcontrol; 477 nand->IO_ADDR_R = nand->IO_ADDR_W = 478 (void __iomem *)CONFIG_SYS_NAND_BASE; 479 nand->badblockbits = 7; 480 481 mtd = nand_to_mtd(nand); 482 483 switch (fsmc_version) { 484 case FSMC_VER8: 485 nand->ecc.bytes = 13; 486 nand->ecc.strength = 8; 487 nand->ecc.correct = fsmc_bch8_correct_data; 488 nand->ecc.read_page = fsmc_read_page_hwecc; 489 if (mtd->writesize == 512) 490 nand->ecc.layout = &fsmc_ecc4_sp_layout; 491 else { 492 if (mtd->oobsize == 224) 493 nand->ecc.layout = &fsmc_ecc4_224_layout; 494 else 495 nand->ecc.layout = &fsmc_ecc4_lp_layout; 496 } 497 498 break; 499 default: 500 nand->ecc.bytes = 3; 501 nand->ecc.strength = 1; 502 nand->ecc.layout = &fsmc_ecc1_layout; 503 nand->ecc.correct = nand_correct_data; 504 break; 505 } 506 507 /* Detect NAND chips */ 508 if (nand_scan_ident(mtd, CONFIG_SYS_MAX_NAND_DEVICE, NULL)) 509 return -ENXIO; 510 511 if (nand_scan_tail(mtd)) 512 return -ENXIO; 513 514 if (nand_register(chip_nr++, mtd)) 515 return -ENXIO; 516 517 return 0; 518 } 519