drivers/mtd/nand/davinci_nand.c

   1 /*
   2  * NAND driver for TI DaVinci based boards.
   3  *
   4  * Copyright (C) 2007 Sergey Kubushyn <ksi@koi8.net>
   5  *
   6  * Based on Linux DaVinci NAND driver by TI. Original copyright follows:
   7  */
   8
   9 /*
  10  *
  11  * linux/drivers/mtd/nand/nand_davinci.c
  12  *
  13  * NAND Flash Driver
  14  *
  15  * Copyright (C) 2006 Texas Instruments.
  16  *
  17  * ----------------------------------------------------------------------------
  18  *
  19  * This program is free software; you can redistribute it and/or modify
  20  * it under the terms of the GNU General Public License as published by
  21  * the Free Software Foundation; either version 2 of the License, or
  22  * (at your option) any later version.
  23  *
  24  * This program is distributed in the hope that it will be useful,
  25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  * GNU General Public License for more details.
  28  *
  29  *  You should have received a copy of the GNU General Public License
  30  *  along with this program; if not, write to the Free Software
  31  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  32  * ----------------------------------------------------------------------------
  33  *
  34  *  Overview:
  35  *   This is a device driver for the NAND flash device found on the
  36  *   DaVinci board which utilizes the Samsung k9k2g08 part.
  37  *
  38  Modifications:
  39  ver. 1.0: Feb 2005, Vinod/Sudhakar
  40  -
  41  *
  42  */
  43
  44 #include <common.h>
  45 #include <asm/io.h>
  46 #include <nand.h>
  47 #include <asm/arch/nand_defs.h>
  48 #include <asm/arch/emif_defs.h>
  49
  50 /* Definitions for 4-bit hardware ECC */
  51 #define NAND_TIMEOUT                    10240
  52 #define NAND_ECC_BUSY                   0xC
  53 #define NAND_4BITECC_MASK               0x03FF03FF
  54 #define EMIF_NANDFSR_ECC_STATE_MASK     0x00000F00
  55 #define ECC_STATE_NO_ERR                0x0
  56 #define ECC_STATE_TOO_MANY_ERRS         0x1
  57 #define ECC_STATE_ERR_CORR_COMP_P       0x2
  58 #define ECC_STATE_ERR_CORR_COMP_N       0x3
  59
  60 static emif_registers *const emif_regs = (void *) DAVINCI_ASYNC_EMIF_CNTRL_BASE;
  61
  62 static void nand_davinci_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
  63 {
  64         struct          nand_chip *this = mtd->priv;
  65         u_int32_t       IO_ADDR_W = (u_int32_t)this->IO_ADDR_W;
  66
  67         IO_ADDR_W &= ~(MASK_ALE|MASK_CLE);
  68
  69         if (ctrl & NAND_CTRL_CHANGE) {
  70                 if ( ctrl & NAND_CLE )
  71                         IO_ADDR_W |= MASK_CLE;
  72                 if ( ctrl & NAND_ALE )
  73                         IO_ADDR_W |= MASK_ALE;
  74                 this->IO_ADDR_W = (void __iomem *) IO_ADDR_W;
  75         }
  76
  77         if (cmd != NAND_CMD_NONE)
  78                 writeb(cmd, this->IO_ADDR_W);
  79 }
  80
  81 #ifdef CONFIG_SYS_NAND_HW_ECC
  82
  83 static void nand_davinci_enable_hwecc(struct mtd_info *mtd, int mode)
  84 {
  85         int             dummy;
  86
  87         dummy = emif_regs->NANDF1ECC;
  88
  89         /* FIXME:  only chipselect 0 is supported for now */
  90         emif_regs->NANDFCR |= 1 << 8;
  91 }
  92
  93 static u_int32_t nand_davinci_readecc(struct mtd_info *mtd, u_int32_t region)
  94 {
  95         u_int32_t       ecc = 0;
  96
  97         if (region == 1)
  98                 ecc = emif_regs->NANDF1ECC;
  99         else if (region == 2)
 100                 ecc = emif_regs->NANDF2ECC;
 101         else if (region == 3)
 102                 ecc = emif_regs->NANDF3ECC;
 103         else if (region == 4)
 104                 ecc = emif_regs->NANDF4ECC;
 105
 106         return(ecc);
 107 }
 108
 109 static int nand_davinci_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code)
 110 {
 111         u_int32_t               tmp;
 112         const int region = 1;
 113
 114         tmp = nand_davinci_readecc(mtd, region);
 115
 116         /* Squeeze 4 bytes ECC into 3 bytes by removing RESERVED bits
 117          * and shifting. RESERVED bits are 31 to 28 and 15 to 12. */
 118         tmp = (tmp & 0x00000fff) | ((tmp & 0x0fff0000) >> 4);
 119
 120         /* Invert so that erased block ECC is correct */
 121         tmp = ~tmp;
 122
 123         *ecc_code++ = tmp;
 124         *ecc_code++ = tmp >>  8;
 125         *ecc_code++ = tmp >> 16;
 126
 127         /* NOTE:  the above code matches mainline Linux:
 128          *      .PQR.stu ==> ~PQRstu
 129          *
 130          * MontaVista/TI kernels encode those bytes differently, use
 131          * complicated (and allegedly sometimes-wrong) correction code,
 132          * and usually shipped with U-Boot that uses software ECC:
 133          *      .PQR.stu ==> PsQRtu
 134          *
 135          * If you need MV/TI compatible NAND I/O in U-Boot, it should
 136          * be possible to (a) change the mangling above, (b) reverse
 137          * that mangling in nand_davinci_correct_data() below.
 138          */
 139
 140         return 0;
 141 }
 142
 143 static int nand_davinci_correct_data(struct mtd_info *mtd, u_char *dat, u_char *read_ecc, u_char *calc_ecc)
 144 {
 145         struct nand_chip *this = mtd->priv;
 146         u_int32_t ecc_nand = read_ecc[0] | (read_ecc[1] << 8) |
 147                                           (read_ecc[2] << 16);
 148         u_int32_t ecc_calc = calc_ecc[0] | (calc_ecc[1] << 8) |
 149                                           (calc_ecc[2] << 16);
 150         u_int32_t diff = ecc_calc ^ ecc_nand;
 151
 152         if (diff) {
 153                 if ((((diff >> 12) ^ diff) & 0xfff) == 0xfff) {
 154                         /* Correctable error */
 155                         if ((diff >> (12 + 3)) < this->ecc.size) {
 156                                 uint8_t find_bit = 1 << ((diff >> 12) & 7);
 157                                 uint32_t find_byte = diff >> (12 + 3);
 158
 159                                 dat[find_byte] ^= find_bit;
 160                                 MTDDEBUG(MTD_DEBUG_LEVEL0, "Correcting single "
 161                                          "bit ECC error at offset: %d, bit: "
 162                                          "%d\n", find_byte, find_bit);
 163                                 return 1;
 164                         } else {
 165                                 return -1;
 166                         }
 167                 } else if (!(diff & (diff - 1))) {
 168                         /* Single bit ECC error in the ECC itself,
 169                            nothing to fix */
 170                         MTDDEBUG(MTD_DEBUG_LEVEL0, "Single bit ECC error in "
 171                                  "ECC.\n");
 172                         return 1;
 173                 } else {
 174                         /* Uncorrectable error */
 175                         MTDDEBUG(MTD_DEBUG_LEVEL0, "ECC UNCORRECTED_ERROR 1\n");
 176                         return -1;
 177                 }
 178         }
 179         return(0);
 180 }
 181 #endif /* CONFIG_SYS_NAND_HW_ECC */
 182
 183 #ifdef CONFIG_SYS_NAND_4BIT_HW_ECC_OOBFIRST
 184 static struct nand_ecclayout nand_davinci_4bit_layout_oobfirst = {
 185 /*
 186  * TI uses a different layout for 4K page deviecs. Since the
 187  * eccpos filed can hold only a limited number of entries, adding
 188  * support for 4K page will result in compilation warnings
 189  * 4K Support will be added later
 190  */
 191 #ifdef CONFIG_SYS_NAND_PAGE_2K
 192         .eccbytes = 40,
 193         .eccpos = {
 194                 24, 25, 26, 27, 28,
 195                 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
 196                 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
 197                 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
 198                 59, 60, 61, 62, 63,
 199                 },
 200         .oobfree = {
 201                 {.offset = 2, .length = 22, },
 202         },
 203 #endif
 204 };
 205 #endif
 206
 207 static void nand_davinci_4bit_enable_hwecc(struct mtd_info *mtd, int mode)
 208 {
 209         u32 val;
 210
 211         switch (mode) {
 212         case NAND_ECC_WRITE:
 213         case NAND_ECC_READ:
 214                 /*
 215                  * Start a new ECC calculation for reading or writing 512 bytes
 216                  * of data.
 217                  */
 218                 val = (emif_regs->NANDFCR & ~(3 << 4)) | (1 << 12);
 219                 emif_regs->NANDFCR = val;
 220                 break;
 221         case NAND_ECC_READSYN:
 222                 val = emif_regs->NAND4BITECC1;
 223                 break;
 224         default:
 225                 break;
 226         }
 227 }
 228
 229 static u32 nand_davinci_4bit_readecc(struct mtd_info *mtd, unsigned int ecc[4])
 230 {
 231         ecc[0] = emif_regs->NAND4BITECC1 & NAND_4BITECC_MASK;
 232         ecc[1] = emif_regs->NAND4BITECC2 & NAND_4BITECC_MASK;
 233         ecc[2] = emif_regs->NAND4BITECC3 & NAND_4BITECC_MASK;
 234         ecc[3] = emif_regs->NAND4BITECC4 & NAND_4BITECC_MASK;
 235
 236         return 0;
 237 }
 238
 239 static int nand_davinci_4bit_calculate_ecc(struct mtd_info *mtd,
 240                                            const uint8_t *dat,
 241                                            uint8_t *ecc_code)
 242 {
 243         unsigned int hw_4ecc[4] = { 0, 0, 0, 0 };
 244         unsigned int const1 = 0, const2 = 0;
 245         unsigned char count1 = 0;
 246
 247         nand_davinci_4bit_readecc(mtd, hw_4ecc);
 248
 249         /*Convert 10 bit ecc value to 8 bit */
 250         for (count1 = 0; count1 < 2; count1++) {
 251                 const2 = count1 * 5;
 252                 const1 = count1 * 2;
 253
 254                 /* Take first 8 bits from val1 (count1=0) or val5 (count1=1) */
 255                 ecc_code[const2] = hw_4ecc[const1] & 0xFF;
 256
 257                 /*
 258                  * Take 2 bits as LSB bits from val1 (count1=0) or val5
 259                  * (count1=1) and 6 bits from val2 (count1=0) or
 260                  * val5 (count1=1)
 261                  */
 262                 ecc_code[const2 + 1] =
 263                     ((hw_4ecc[const1] >> 8) & 0x3) | ((hw_4ecc[const1] >> 14) &
 264                                                       0xFC);
 265
 266                 /*
 267                  * Take 4 bits from val2 (count1=0) or val5 (count1=1) and
 268                  * 4 bits from val3 (count1=0) or val6 (count1=1)
 269                  */
 270                 ecc_code[const2 + 2] =
 271                     ((hw_4ecc[const1] >> 22) & 0xF) |
 272                     ((hw_4ecc[const1 + 1] << 4) & 0xF0);
 273
 274                 /*
 275                  * Take 6 bits from val3(count1=0) or val6 (count1=1) and
 276                  * 2 bits from val4 (count1=0) or  val7 (count1=1)
 277                  */
 278                 ecc_code[const2 + 3] =
 279                     ((hw_4ecc[const1 + 1] >> 4) & 0x3F) |
 280                     ((hw_4ecc[const1 + 1] >> 10) & 0xC0);
 281
 282                 /* Take 8 bits from val4 (count1=0) or val7 (count1=1) */
 283                 ecc_code[const2 + 4] = (hw_4ecc[const1 + 1] >> 18) & 0xFF;
 284         }
 285         return 0;
 286 }
 287
 288
 289 static int nand_davinci_4bit_correct_data(struct mtd_info *mtd, uint8_t *dat,
 290                                           uint8_t *read_ecc, uint8_t *calc_ecc)
 291 {
 292         struct nand_chip *this = mtd->priv;
 293         unsigned short ecc_10bit[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
 294         int i;
 295         unsigned int hw_4ecc[4] = { 0, 0, 0, 0 }, iserror = 0;
 296         unsigned short *pspare = NULL, *pspare1 = NULL;
 297         unsigned int numerrors, erroraddress, errorvalue;
 298         u32 val;
 299
 300         /*
 301          * Check for an ECC where all bytes are 0xFF.  If this is the case, we
 302          * will assume we are looking at an erased page and we should ignore
 303          * the ECC.
 304          */
 305         for (i = 0; i < 10; i++) {
 306                 if (read_ecc[i] != 0xFF)
 307                         break;
 308         }
 309         if (i == 10)
 310                 return 0;
 311
 312         /* Convert 8 bit in to 10 bit */
 313         pspare = (unsigned short *)&read_ecc[2];
 314         pspare1 = (unsigned short *)&read_ecc[0];
 315
 316         /* Take 10 bits from 0th and 1st bytes */
 317         ecc_10bit[0] = (*pspare1) & 0x3FF;
 318
 319         /* Take 6 bits from 1st byte and 4 bits from 2nd byte */
 320         ecc_10bit[1] = (((*pspare1) >> 10) & 0x3F)
 321             | (((pspare[0]) << 6) & 0x3C0);
 322
 323         /* Take 4 bits form 2nd bytes and 6 bits from 3rd bytes */
 324         ecc_10bit[2] = ((pspare[0]) >> 4) & 0x3FF;
 325
 326         /*Take 2 bits from 3rd byte and 8 bits from 4th byte */
 327         ecc_10bit[3] = (((pspare[0]) >> 14) & 0x3)
 328             | ((((pspare[1])) << 2) & 0x3FC);
 329
 330         /* Take 8 bits from 5th byte and 2 bits from 6th byte */
 331         ecc_10bit[4] = ((pspare[1]) >> 8)
 332             | ((((pspare[2])) << 8) & 0x300);
 333
 334         /* Take 6 bits from 6th byte and 4 bits from 7th byte */
 335         ecc_10bit[5] = (pspare[2] >> 2) & 0x3FF;
 336
 337         /* Take 4 bits from 7th byte and 6 bits from 8th byte */
 338         ecc_10bit[6] = (((pspare[2]) >> 12) & 0xF)
 339             | ((((pspare[3])) << 4) & 0x3F0);
 340
 341         /*Take 2 bits from 8th byte and 8 bits from 9th byte */
 342         ecc_10bit[7] = ((pspare[3]) >> 6) & 0x3FF;
 343
 344         /*
 345          * Write the parity values in the NAND Flash 4-bit ECC Load register.
 346          * Write each parity value one at a time starting from 4bit_ecc_val8
 347          * to 4bit_ecc_val1.
 348          */
 349         for (i = 7; i >= 0; i--)
 350                 emif_regs->NAND4BITECCLOAD = ecc_10bit[i];
 351
 352         /*
 353          * Perform a dummy read to the EMIF Revision Code and Status register.
 354          * This is required to ensure time for syndrome calculation after
 355          * writing the ECC values in previous step.
 356          */
 357
 358         val = emif_regs->NANDFSR;
 359
 360         /*
 361          * Read the syndrome from the NAND Flash 4-Bit ECC 1-4 registers.
 362          * A syndrome value of 0 means no bit errors. If the syndrome is
 363          * non-zero then go further otherwise return.
 364          */
 365         nand_davinci_4bit_readecc(mtd, hw_4ecc);
 366
 367         if (hw_4ecc[0] == ECC_STATE_NO_ERR && hw_4ecc[1] == ECC_STATE_NO_ERR &&
 368             hw_4ecc[2] == ECC_STATE_NO_ERR && hw_4ecc[3] == ECC_STATE_NO_ERR)
 369                 return 0;
 370
 371         /*
 372          * Clear any previous address calculation by doing a dummy read of an
 373          * error address register.
 374          */
 375         val = emif_regs->NANDERRADD1;
 376
 377         /*
 378          * Set the addr_calc_st bit(bit no 13) in the NAND Flash Control
 379          * register to 1.
 380          */
 381         emif_regs->NANDFCR |= 1 << 13;
 382
 383         /*
 384          * Wait for the corr_state field (bits 8 to 11)in the
 385          * NAND Flash Status register to be equal to 0x0, 0x1, 0x2, or 0x3.
 386          */
 387         i = NAND_TIMEOUT;
 388         do {
 389                 val = emif_regs->NANDFSR;
 390                 val &= 0xc00;
 391                 i--;
 392         } while ((i > 0) && val);
 393
 394         iserror = emif_regs->NANDFSR;
 395         iserror &= EMIF_NANDFSR_ECC_STATE_MASK;
 396         iserror = iserror >> 8;
 397
 398         /*
 399          * ECC_STATE_TOO_MANY_ERRS (0x1) means errors cannot be
 400          * corrected (five or more errors).  The number of errors
 401          * calculated (err_num field) differs from the number of errors
 402          * searched.  ECC_STATE_ERR_CORR_COMP_P (0x2) means error
 403          * correction complete (errors on bit 8 or 9).
 404          * ECC_STATE_ERR_CORR_COMP_N (0x3) means error correction
 405          * complete (error exists).
 406          */
 407
 408         if (iserror == ECC_STATE_NO_ERR) {
 409                 val = emif_regs->NANDERRVAL1;
 410                 return 0;
 411         } else if (iserror == ECC_STATE_TOO_MANY_ERRS) {
 412                 val = emif_regs->NANDERRVAL1;
 413                 return -1;
 414         }
 415
 416         numerrors = ((emif_regs->NANDFSR >> 16) & 0x3) + 1;
 417
 418         /* Read the error address, error value and correct */
 419         for (i = 0; i < numerrors; i++) {
 420                 if (i > 1) {
 421                         erroraddress =
 422                             ((emif_regs->NANDERRADD2 >>
 423                               (16 * (i & 1))) & 0x3FF);
 424                         erroraddress = ((512 + 7) - erroraddress);
 425                         errorvalue =
 426                             ((emif_regs->NANDERRVAL2 >>
 427                               (16 * (i & 1))) & 0xFF);
 428                 } else {
 429                         erroraddress =
 430                             ((emif_regs->NANDERRADD1 >>
 431                               (16 * (i & 1))) & 0x3FF);
 432                         erroraddress = ((512 + 7) - erroraddress);
 433                         errorvalue =
 434                             ((emif_regs->NANDERRVAL1 >>
 435                               (16 * (i & 1))) & 0xFF);
 436                 }
 437                 /* xor the corrupt data with error value */
 438                 if (erroraddress < 512)
 439                         dat[erroraddress] ^= errorvalue;
 440         }
 441
 442         return numerrors;
 443 }
 444
 445 static int nand_davinci_dev_ready(struct mtd_info *mtd)
 446 {
 447         return emif_regs->NANDFSR & 0x1;
 448 }
 449
 450 static void nand_flash_init(void)
 451 {
 452         /* This is for DM6446 EVM and *very* similar.  DO NOT GROW THIS!
 453          * Instead, have your board_init() set EMIF timings, based on its
 454          * knowledge of the clocks and what devices are hooked up ... and
 455          * don't even do that unless no UBL handled it.
 456          */
 457 #ifdef CONFIG_SOC_DM644X
 458         u_int32_t       acfg1 = 0x3ffffffc;
 459
 460         /*------------------------------------------------------------------*
 461          *  NAND FLASH CHIP TIMEOUT @ 459 MHz                               *
 462          *                                                                  *
 463          *  AEMIF.CLK freq   = PLL1/6 = 459/6 = 76.5 MHz                    *
 464          *  AEMIF.CLK period = 1/76.5 MHz = 13.1 ns                         *
 465          *                                                                  *
 466          *------------------------------------------------------------------*/
 467          acfg1 = 0
 468                 | (0 << 31 )    /* selectStrobe */
 469                 | (0 << 30 )    /* extWait */
 470                 | (1 << 26 )    /* writeSetup   10 ns */
 471                 | (3 << 20 )    /* writeStrobe  40 ns */
 472                 | (1 << 17 )    /* writeHold    10 ns */
 473                 | (1 << 13 )    /* readSetup    10 ns */
 474                 | (5 << 7 )     /* readStrobe   60 ns */
 475                 | (1 << 4 )     /* readHold     10 ns */
 476                 | (3 << 2 )     /* turnAround   ?? ns */
 477                 | (0 << 0 )     /* asyncSize    8-bit bus */
 478                 ;
 479
 480         emif_regs->AB1CR = acfg1; /* CS2 */
 481
 482         emif_regs->NANDFCR = 0x00000101; /* NAND flash on CS2 */
 483 #endif
 484 }
 485
 486 void davinci_nand_init(struct nand_chip *nand)
 487 {
 488         nand->chip_delay  = 0;
 489 #ifdef CONFIG_SYS_NAND_USE_FLASH_BBT
 490         nand->options     |= NAND_USE_FLASH_BBT;
 491 #endif
 492 #ifdef CONFIG_SYS_NAND_HW_ECC
 493         nand->ecc.mode = NAND_ECC_HW;
 494         nand->ecc.size = 512;
 495         nand->ecc.bytes = 3;
 496         nand->ecc.calculate = nand_davinci_calculate_ecc;
 497         nand->ecc.correct  = nand_davinci_correct_data;
 498         nand->ecc.hwctl  = nand_davinci_enable_hwecc;
 499 #else
 500         nand->ecc.mode = NAND_ECC_SOFT;
 501 #endif /* CONFIG_SYS_NAND_HW_ECC */
 502 #ifdef CONFIG_SYS_NAND_4BIT_HW_ECC_OOBFIRST
 503         nand->ecc.mode = NAND_ECC_HW_OOB_FIRST;
 504         nand->ecc.size = 512;
 505         nand->ecc.bytes = 10;
 506         nand->ecc.calculate = nand_davinci_4bit_calculate_ecc;
 507         nand->ecc.correct = nand_davinci_4bit_correct_data;
 508         nand->ecc.hwctl = nand_davinci_4bit_enable_hwecc;
 509         nand->ecc.layout = &nand_davinci_4bit_layout_oobfirst;
 510 #endif
 511         /* Set address of hardware control function */
 512         nand->cmd_ctrl = nand_davinci_hwcontrol;
 513
 514         nand->dev_ready = nand_davinci_dev_ready;
 515
 516         nand_flash_init();
 517 }
 518
 519 int board_nand_init(struct nand_chip *chip) __attribute__((weak));
 520
 521 int board_nand_init(struct nand_chip *chip)
 522 {
 523         davinci_nand_init(chip);
 524         return 0;
 525 }