drivers/mtd/nand/davinci_nand.c

   1 /*
   2  * davinci_nand.c - NAND Flash Driver for DaVinci family chips
   3  *
   4  * Copyright © 2006 Texas Instruments.
   5  *
   6  * Port to 2.6.23 Copyright © 2008 by:
   7  *   Sander Huijsen <Shuijsen@optelecom-nkf.com>
   8  *   Troy Kisky <troy.kisky@boundarydevices.com>
   9  *   Dirk Behme <Dirk.Behme@gmail.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 #include <linux/kernel.h>
  27 #include <linux/init.h>
  28 #include <linux/module.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/err.h>
  31 #include <linux/clk.h>
  32 #include <linux/io.h>
  33 #include <linux/mtd/nand.h>
  34 #include <linux/mtd/partitions.h>
  35 #include <linux/slab.h>
  36
  37 #include <mach/nand.h>
  38 #include <mach/aemif.h>
  39
  40 #include <asm/mach-types.h>
  41
  42
  43 /*
  44  * This is a device driver for the NAND flash controller found on the
  45  * various DaVinci family chips.  It handles up to four SoC chipselects,
  46  * and some flavors of secondary chipselect (e.g. based on A12) as used
  47  * with multichip packages.
  48  *
  49  * The 1-bit ECC hardware is supported, as well as the newer 4-bit ECC
  50  * available on chips like the DM355 and OMAP-L137 and needed with the
  51  * more error-prone MLC NAND chips.
  52  *
  53  * This driver assumes EM_WAIT connects all the NAND devices' RDY/nBUSY
  54  * outputs in a "wire-AND" configuration, with no per-chip signals.
  55  */
  56 struct davinci_nand_info {
  57         struct mtd_info         mtd;
  58         struct nand_chip        chip;
  59         struct nand_ecclayout   ecclayout;
  60
  61         struct device           *dev;
  62         struct clk              *clk;
  63         bool                    partitioned;
  64
  65         bool                    is_readmode;
  66
  67         void __iomem            *base;
  68         void __iomem            *vaddr;
  69
  70         uint32_t                ioaddr;
  71         uint32_t                current_cs;
  72
  73         uint32_t                mask_chipsel;
  74         uint32_t                mask_ale;
  75         uint32_t                mask_cle;
  76
  77         uint32_t                core_chipsel;
  78
  79         struct davinci_aemif_timing     *timing;
  80 };
  81
  82 static DEFINE_SPINLOCK(davinci_nand_lock);
  83 static bool ecc4_busy;
  84
  85 #define to_davinci_nand(m) container_of(m, struct davinci_nand_info, mtd)
  86
  87
  88 static inline unsigned int davinci_nand_readl(struct davinci_nand_info *info,
  89                 int offset)
  90 {
  91         return __raw_readl(info->base + offset);
  92 }
  93
  94 static inline void davinci_nand_writel(struct davinci_nand_info *info,
  95                 int offset, unsigned long value)
  96 {
  97         __raw_writel(value, info->base + offset);
  98 }
  99
 100 /*----------------------------------------------------------------------*/
 101
 102 /*
 103  * Access to hardware control lines:  ALE, CLE, secondary chipselect.
 104  */
 105
 106 static void nand_davinci_hwcontrol(struct mtd_info *mtd, int cmd,
 107                                    unsigned int ctrl)
 108 {
 109         struct davinci_nand_info        *info = to_davinci_nand(mtd);
 110         uint32_t                        addr = info->current_cs;
 111         struct nand_chip                *nand = mtd->priv;
 112
 113         /* Did the control lines change? */
 114         if (ctrl & NAND_CTRL_CHANGE) {
 115                 if ((ctrl & NAND_CTRL_CLE) == NAND_CTRL_CLE)
 116                         addr |= info->mask_cle;
 117                 else if ((ctrl & NAND_CTRL_ALE) == NAND_CTRL_ALE)
 118                         addr |= info->mask_ale;
 119
 120                 nand->IO_ADDR_W = (void __iomem __force *)addr;
 121         }
 122
 123         if (cmd != NAND_CMD_NONE)
 124                 iowrite8(cmd, nand->IO_ADDR_W);
 125 }
 126
 127 static void nand_davinci_select_chip(struct mtd_info *mtd, int chip)
 128 {
 129         struct davinci_nand_info        *info = to_davinci_nand(mtd);
 130         uint32_t                        addr = info->ioaddr;
 131
 132         /* maybe kick in a second chipselect */
 133         if (chip > 0)
 134                 addr |= info->mask_chipsel;
 135         info->current_cs = addr;
 136
 137         info->chip.IO_ADDR_W = (void __iomem __force *)addr;
 138         info->chip.IO_ADDR_R = info->chip.IO_ADDR_W;
 139 }
 140
 141 /*----------------------------------------------------------------------*/
 142
 143 /*
 144  * 1-bit hardware ECC ... context maintained for each core chipselect
 145  */
 146
 147 static inline uint32_t nand_davinci_readecc_1bit(struct mtd_info *mtd)
 148 {
 149         struct davinci_nand_info *info = to_davinci_nand(mtd);
 150
 151         return davinci_nand_readl(info, NANDF1ECC_OFFSET
 152                         + 4 * info->core_chipsel);
 153 }
 154
 155 static void nand_davinci_hwctl_1bit(struct mtd_info *mtd, int mode)
 156 {
 157         struct davinci_nand_info *info;
 158         uint32_t nandcfr;
 159         unsigned long flags;
 160
 161         info = to_davinci_nand(mtd);
 162
 163         /* Reset ECC hardware */
 164         nand_davinci_readecc_1bit(mtd);
 165
 166         spin_lock_irqsave(&davinci_nand_lock, flags);
 167
 168         /* Restart ECC hardware */
 169         nandcfr = davinci_nand_readl(info, NANDFCR_OFFSET);
 170         nandcfr |= BIT(8 + info->core_chipsel);
 171         davinci_nand_writel(info, NANDFCR_OFFSET, nandcfr);
 172
 173         spin_unlock_irqrestore(&davinci_nand_lock, flags);
 174 }
 175
 176 /*
 177  * Read hardware ECC value and pack into three bytes
 178  */
 179 static int nand_davinci_calculate_1bit(struct mtd_info *mtd,
 180                                       const u_char *dat, u_char *ecc_code)
 181 {
 182         unsigned int ecc_val = nand_davinci_readecc_1bit(mtd);
 183         unsigned int ecc24 = (ecc_val & 0x0fff) | ((ecc_val & 0x0fff0000) >> 4);
 184
 185         /* invert so that erased block ecc is correct */
 186         ecc24 = ~ecc24;
 187         ecc_code[0] = (u_char)(ecc24);
 188         ecc_code[1] = (u_char)(ecc24 >> 8);
 189         ecc_code[2] = (u_char)(ecc24 >> 16);
 190
 191         return 0;
 192 }
 193
 194 static int nand_davinci_correct_1bit(struct mtd_info *mtd, u_char *dat,
 195                                      u_char *read_ecc, u_char *calc_ecc)
 196 {
 197         struct nand_chip *chip = mtd->priv;
 198         uint32_t eccNand = read_ecc[0] | (read_ecc[1] << 8) |
 199                                           (read_ecc[2] << 16);
 200         uint32_t eccCalc = calc_ecc[0] | (calc_ecc[1] << 8) |
 201                                           (calc_ecc[2] << 16);
 202         uint32_t diff = eccCalc ^ eccNand;
 203
 204         if (diff) {
 205                 if ((((diff >> 12) ^ diff) & 0xfff) == 0xfff) {
 206                         /* Correctable error */
 207                         if ((diff >> (12 + 3)) < chip->ecc.size) {
 208                                 dat[diff >> (12 + 3)] ^= BIT((diff >> 12) & 7);
 209                                 return 1;
 210                         } else {
 211                                 return -1;
 212                         }
 213                 } else if (!(diff & (diff - 1))) {
 214                         /* Single bit ECC error in the ECC itself,
 215                          * nothing to fix */
 216                         return 1;
 217                 } else {
 218                         /* Uncorrectable error */
 219                         return -1;
 220                 }
 221
 222         }
 223         return 0;
 224 }
 225
 226 /*----------------------------------------------------------------------*/
 227
 228 /*
 229  * 4-bit hardware ECC ... context maintained over entire AEMIF
 230  *
 231  * This is a syndrome engine, but we avoid NAND_ECC_HW_SYNDROME
 232  * since that forces use of a problematic "infix OOB" layout.
 233  * Among other things, it trashes manufacturer bad block markers.
 234  * Also, and specific to this hardware, it ECC-protects the "prepad"
 235  * in the OOB ... while having ECC protection for parts of OOB would
 236  * seem useful, the current MTD stack sometimes wants to update the
 237  * OOB without recomputing ECC.
 238  */
 239
 240 static void nand_davinci_hwctl_4bit(struct mtd_info *mtd, int mode)
 241 {
 242         struct davinci_nand_info *info = to_davinci_nand(mtd);
 243         unsigned long flags;
 244         u32 val;
 245
 246         spin_lock_irqsave(&davinci_nand_lock, flags);
 247
 248         /* Start 4-bit ECC calculation for read/write */
 249         val = davinci_nand_readl(info, NANDFCR_OFFSET);
 250         val &= ~(0x03 << 4);
 251         val |= (info->core_chipsel << 4) | BIT(12);
 252         davinci_nand_writel(info, NANDFCR_OFFSET, val);
 253
 254         info->is_readmode = (mode == NAND_ECC_READ);
 255
 256         spin_unlock_irqrestore(&davinci_nand_lock, flags);
 257 }
 258
 259 /* Read raw ECC code after writing to NAND. */
 260 static void
 261 nand_davinci_readecc_4bit(struct davinci_nand_info *info, u32 code[4])
 262 {
 263         const u32 mask = 0x03ff03ff;
 264
 265         code[0] = davinci_nand_readl(info, NAND_4BIT_ECC1_OFFSET) & mask;
 266         code[1] = davinci_nand_readl(info, NAND_4BIT_ECC2_OFFSET) & mask;
 267         code[2] = davinci_nand_readl(info, NAND_4BIT_ECC3_OFFSET) & mask;
 268         code[3] = davinci_nand_readl(info, NAND_4BIT_ECC4_OFFSET) & mask;
 269 }
 270
 271 /* Terminate read ECC; or return ECC (as bytes) of data written to NAND. */
 272 static int nand_davinci_calculate_4bit(struct mtd_info *mtd,
 273                 const u_char *dat, u_char *ecc_code)
 274 {
 275         struct davinci_nand_info *info = to_davinci_nand(mtd);
 276         u32 raw_ecc[4], *p;
 277         unsigned i;
 278
 279         /* After a read, terminate ECC calculation by a dummy read
 280          * of some 4-bit ECC register.  ECC covers everything that
 281          * was read; correct() just uses the hardware state, so
 282          * ecc_code is not needed.
 283          */
 284         if (info->is_readmode) {
 285                 davinci_nand_readl(info, NAND_4BIT_ECC1_OFFSET);
 286                 return 0;
 287         }
 288
 289         /* Pack eight raw 10-bit ecc values into ten bytes, making
 290          * two passes which each convert four values (in upper and
 291          * lower halves of two 32-bit words) into five bytes.  The
 292          * ROM boot loader uses this same packing scheme.
 293          */
 294         nand_davinci_readecc_4bit(info, raw_ecc);
 295         for (i = 0, p = raw_ecc; i < 2; i++, p += 2) {
 296                 *ecc_code++ =   p[0]        & 0xff;
 297                 *ecc_code++ = ((p[0] >>  8) & 0x03) | ((p[0] >> 14) & 0xfc);
 298                 *ecc_code++ = ((p[0] >> 22) & 0x0f) | ((p[1] <<  4) & 0xf0);
 299                 *ecc_code++ = ((p[1] >>  4) & 0x3f) | ((p[1] >> 10) & 0xc0);
 300                 *ecc_code++ =  (p[1] >> 18) & 0xff;
 301         }
 302
 303         return 0;
 304 }
 305
 306 /* Correct up to 4 bits in data we just read, using state left in the
 307  * hardware plus the ecc_code computed when it was first written.
 308  */
 309 static int nand_davinci_correct_4bit(struct mtd_info *mtd,
 310                 u_char *data, u_char *ecc_code, u_char *null)
 311 {
 312         int i;
 313         struct davinci_nand_info *info = to_davinci_nand(mtd);
 314         unsigned short ecc10[8];
 315         unsigned short *ecc16;
 316         u32 syndrome[4];
 317         u32 ecc_state;
 318         unsigned num_errors, corrected;
 319         unsigned long timeo;
 320
 321         /* All bytes 0xff?  It's an erased page; ignore its ECC. */
 322         for (i = 0; i < 10; i++) {
 323                 if (ecc_code[i] != 0xff)
 324                         goto compare;
 325         }
 326         return 0;
 327
 328 compare:
 329         /* Unpack ten bytes into eight 10 bit values.  We know we're
 330          * little-endian, and use type punning for less shifting/masking.
 331          */
 332         if (WARN_ON(0x01 & (unsigned) ecc_code))
 333                 return -EINVAL;
 334         ecc16 = (unsigned short *)ecc_code;
 335
 336         ecc10[0] =  (ecc16[0] >>  0) & 0x3ff;
 337         ecc10[1] = ((ecc16[0] >> 10) & 0x3f) | ((ecc16[1] << 6) & 0x3c0);
 338         ecc10[2] =  (ecc16[1] >>  4) & 0x3ff;
 339         ecc10[3] = ((ecc16[1] >> 14) & 0x3)  | ((ecc16[2] << 2) & 0x3fc);
 340         ecc10[4] =  (ecc16[2] >>  8)         | ((ecc16[3] << 8) & 0x300);
 341         ecc10[5] =  (ecc16[3] >>  2) & 0x3ff;
 342         ecc10[6] = ((ecc16[3] >> 12) & 0xf)  | ((ecc16[4] << 4) & 0x3f0);
 343         ecc10[7] =  (ecc16[4] >>  6) & 0x3ff;
 344
 345         /* Tell ECC controller about the expected ECC codes. */
 346         for (i = 7; i >= 0; i--)
 347                 davinci_nand_writel(info, NAND_4BIT_ECC_LOAD_OFFSET, ecc10[i]);
 348
 349         /* Allow time for syndrome calculation ... then read it.
 350          * A syndrome of all zeroes 0 means no detected errors.
 351          */
 352         davinci_nand_readl(info, NANDFSR_OFFSET);
 353         nand_davinci_readecc_4bit(info, syndrome);
 354         if (!(syndrome[0] | syndrome[1] | syndrome[2] | syndrome[3]))
 355                 return 0;
 356
 357         /*
 358          * Clear any previous address calculation by doing a dummy read of an
 359          * error address register.
 360          */
 361         davinci_nand_readl(info, NAND_ERR_ADD1_OFFSET);
 362
 363         /* Start address calculation, and wait for it to complete.
 364          * We _could_ start reading more data while this is working,
 365          * to speed up the overall page read.
 366          */
 367         davinci_nand_writel(info, NANDFCR_OFFSET,
 368                         davinci_nand_readl(info, NANDFCR_OFFSET) | BIT(13));
 369
 370         /*
 371          * ECC_STATE field reads 0x3 (Error correction complete) immediately
 372          * after setting the 4BITECC_ADD_CALC_START bit. So if you immediately
 373          * begin trying to poll for the state, you may fall right out of your
 374          * loop without any of the correction calculations having taken place.
 375          * The recommendation from the hardware team is to initially delay as
 376          * long as ECC_STATE reads less than 4. After that, ECC HW has entered
 377          * correction state.
 378          */
 379         timeo = jiffies + usecs_to_jiffies(100);
 380         do {
 381                 ecc_state = (davinci_nand_readl(info,
 382                                 NANDFSR_OFFSET) >> 8) & 0x0f;
 383                 cpu_relax();
 384         } while ((ecc_state < 4) && time_before(jiffies, timeo));
 385
 386         for (;;) {
 387                 u32     fsr = davinci_nand_readl(info, NANDFSR_OFFSET);
 388
 389                 switch ((fsr >> 8) & 0x0f) {
 390                 case 0:         /* no error, should not happen */
 391                         davinci_nand_readl(info, NAND_ERR_ERRVAL1_OFFSET);
 392                         return 0;
 393                 case 1:         /* five or more errors detected */
 394                         davinci_nand_readl(info, NAND_ERR_ERRVAL1_OFFSET);
 395                         return -EIO;
 396                 case 2:         /* error addresses computed */
 397                 case 3:
 398                         num_errors = 1 + ((fsr >> 16) & 0x03);
 399                         goto correct;
 400                 default:        /* still working on it */
 401                         cpu_relax();
 402                         continue;
 403                 }
 404         }
 405
 406 correct:
 407         /* correct each error */
 408         for (i = 0, corrected = 0; i < num_errors; i++) {
 409                 int error_address, error_value;
 410
 411                 if (i > 1) {
 412                         error_address = davinci_nand_readl(info,
 413                                                 NAND_ERR_ADD2_OFFSET);
 414                         error_value = davinci_nand_readl(info,
 415                                                 NAND_ERR_ERRVAL2_OFFSET);
 416                 } else {
 417                         error_address = davinci_nand_readl(info,
 418                                                 NAND_ERR_ADD1_OFFSET);
 419                         error_value = davinci_nand_readl(info,
 420                                                 NAND_ERR_ERRVAL1_OFFSET);
 421                 }
 422
 423                 if (i & 1) {
 424                         error_address >>= 16;
 425                         error_value >>= 16;
 426                 }
 427                 error_address &= 0x3ff;
 428                 error_address = (512 + 7) - error_address;
 429
 430                 if (error_address < 512) {
 431                         data[error_address] ^= error_value;
 432                         corrected++;
 433                 }
 434         }
 435
 436         return corrected;
 437 }
 438
 439 /*----------------------------------------------------------------------*/
 440
 441 /*
 442  * NOTE:  NAND boot requires ALE == EM_A[1], CLE == EM_A[2], so that's
 443  * how these chips are normally wired.  This translates to both 8 and 16
 444  * bit busses using ALE == BIT(3) in byte addresses, and CLE == BIT(4).
 445  *
 446  * For now we assume that configuration, or any other one which ignores
 447  * the two LSBs for NAND access ... so we can issue 32-bit reads/writes
 448  * and have that transparently morphed into multiple NAND operations.
 449  */
 450 static void nand_davinci_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 451 {
 452         struct nand_chip *chip = mtd->priv;
 453
 454         if ((0x03 & ((unsigned)buf)) == 0 && (0x03 & len) == 0)
 455                 ioread32_rep(chip->IO_ADDR_R, buf, len >> 2);
 456         else if ((0x01 & ((unsigned)buf)) == 0 && (0x01 & len) == 0)
 457                 ioread16_rep(chip->IO_ADDR_R, buf, len >> 1);
 458         else
 459                 ioread8_rep(chip->IO_ADDR_R, buf, len);
 460 }
 461
 462 static void nand_davinci_write_buf(struct mtd_info *mtd,
 463                 const uint8_t *buf, int len)
 464 {
 465         struct nand_chip *chip = mtd->priv;
 466
 467         if ((0x03 & ((unsigned)buf)) == 0 && (0x03 & len) == 0)
 468                 iowrite32_rep(chip->IO_ADDR_R, buf, len >> 2);
 469         else if ((0x01 & ((unsigned)buf)) == 0 && (0x01 & len) == 0)
 470                 iowrite16_rep(chip->IO_ADDR_R, buf, len >> 1);
 471         else
 472                 iowrite8_rep(chip->IO_ADDR_R, buf, len);
 473 }
 474
 475 /*
 476  * Check hardware register for wait status. Returns 1 if device is ready,
 477  * 0 if it is still busy.
 478  */
 479 static int nand_davinci_dev_ready(struct mtd_info *mtd)
 480 {
 481         struct davinci_nand_info *info = to_davinci_nand(mtd);
 482
 483         return davinci_nand_readl(info, NANDFSR_OFFSET) & BIT(0);
 484 }
 485
 486 /*----------------------------------------------------------------------*/
 487
 488 /* An ECC layout for using 4-bit ECC with small-page flash, storing
 489  * ten ECC bytes plus the manufacturer's bad block marker byte, and
 490  * and not overlapping the default BBT markers.
 491  */
 492 static struct nand_ecclayout hwecc4_small __initconst = {
 493         .eccbytes = 10,
 494         .eccpos = { 0, 1, 2, 3, 4,
 495                 /* offset 5 holds the badblock marker */
 496                 6, 7,
 497                 13, 14, 15, },
 498         .oobfree = {
 499                 {.offset = 8, .length = 5, },
 500                 {.offset = 16, },
 501         },
 502 };
 503
 504 /* An ECC layout for using 4-bit ECC with large-page (2048bytes) flash,
 505  * storing ten ECC bytes plus the manufacturer's bad block marker byte,
 506  * and not overlapping the default BBT markers.
 507  */
 508 static struct nand_ecclayout hwecc4_2048 __initconst = {
 509         .eccbytes = 40,
 510         .eccpos = {
 511                 /* at the end of spare sector */
 512                 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
 513                 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
 514                 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
 515                 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 516                 },
 517         .oobfree = {
 518                 /* 2 bytes at offset 0 hold manufacturer badblock markers */
 519                 {.offset = 2, .length = 22, },
 520                 /* 5 bytes at offset 8 hold BBT markers */
 521                 /* 8 bytes at offset 16 hold JFFS2 clean markers */
 522         },
 523 };
 524
 525 static int __init nand_davinci_probe(struct platform_device *pdev)
 526 {
 527         struct davinci_nand_pdata       *pdata = pdev->dev.platform_data;
 528         struct davinci_nand_info        *info;
 529         struct resource                 *res1;
 530         struct resource                 *res2;
 531         void __iomem                    *vaddr;
 532         void __iomem                    *base;
 533         int                             ret;
 534         uint32_t                        val;
 535         nand_ecc_modes_t                ecc_mode;
 536
 537         /* insist on board-specific configuration */
 538         if (!pdata)
 539                 return -ENODEV;
 540
 541         /* which external chipselect will we be managing? */
 542         if (pdev->id < 0 || pdev->id > 3)
 543                 return -ENODEV;
 544
 545         info = kzalloc(sizeof(*info), GFP_KERNEL);
 546         if (!info) {
 547                 dev_err(&pdev->dev, "unable to allocate memory\n");
 548                 ret = -ENOMEM;
 549                 goto err_nomem;
 550         }
 551
 552         platform_set_drvdata(pdev, info);
 553
 554         res1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 555         res2 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 556         if (!res1 || !res2) {
 557                 dev_err(&pdev->dev, "resource missing\n");
 558                 ret = -EINVAL;
 559                 goto err_nomem;
 560         }
 561
 562         vaddr = ioremap(res1->start, resource_size(res1));
 563         base = ioremap(res2->start, resource_size(res2));
 564         if (!vaddr || !base) {
 565                 dev_err(&pdev->dev, "ioremap failed\n");
 566                 ret = -EINVAL;
 567                 goto err_ioremap;
 568         }
 569
 570         info->dev               = &pdev->dev;
 571         info->base              = base;
 572         info->vaddr             = vaddr;
 573
 574         info->mtd.priv          = &info->chip;
 575         info->mtd.name          = dev_name(&pdev->dev);
 576         info->mtd.owner         = THIS_MODULE;
 577
 578         info->mtd.dev.parent    = &pdev->dev;
 579
 580         info->chip.IO_ADDR_R    = vaddr;
 581         info->chip.IO_ADDR_W    = vaddr;
 582         info->chip.chip_delay   = 0;
 583         info->chip.select_chip  = nand_davinci_select_chip;
 584
 585         /* options such as NAND_USE_FLASH_BBT or 16-bit widths */
 586         info->chip.options      = pdata->options;
 587         info->chip.bbt_td       = pdata->bbt_td;
 588         info->chip.bbt_md       = pdata->bbt_md;
 589         info->timing            = pdata->timing;
 590
 591         info->ioaddr            = (uint32_t __force) vaddr;
 592
 593         info->current_cs        = info->ioaddr;
 594         info->core_chipsel      = pdev->id;
 595         info->mask_chipsel      = pdata->mask_chipsel;
 596
 597         /* use nandboot-capable ALE/CLE masks by default */
 598         info->mask_ale          = pdata->mask_ale ? : MASK_ALE;
 599         info->mask_cle          = pdata->mask_cle ? : MASK_CLE;
 600
 601         /* Set address of hardware control function */
 602         info->chip.cmd_ctrl     = nand_davinci_hwcontrol;
 603         info->chip.dev_ready    = nand_davinci_dev_ready;
 604
 605         /* Speed up buffer I/O */
 606         info->chip.read_buf     = nand_davinci_read_buf;
 607         info->chip.write_buf    = nand_davinci_write_buf;
 608
 609         /* Use board-specific ECC config */
 610         ecc_mode                = pdata->ecc_mode;
 611
 612         ret = -EINVAL;
 613         switch (ecc_mode) {
 614         case NAND_ECC_NONE:
 615         case NAND_ECC_SOFT:
 616                 pdata->ecc_bits = 0;
 617                 break;
 618         case NAND_ECC_HW:
 619                 if (pdata->ecc_bits == 4) {
 620                         /* No sanity checks:  CPUs must support this,
 621                          * and the chips may not use NAND_BUSWIDTH_16.
 622                          */
 623
 624                         /* No sharing 4-bit hardware between chipselects yet */
 625                         spin_lock_irq(&davinci_nand_lock);
 626                         if (ecc4_busy)
 627                                 ret = -EBUSY;
 628                         else
 629                                 ecc4_busy = true;
 630                         spin_unlock_irq(&davinci_nand_lock);
 631
 632                         if (ret == -EBUSY)
 633                                 goto err_ecc;
 634
 635                         info->chip.ecc.calculate = nand_davinci_calculate_4bit;
 636                         info->chip.ecc.correct = nand_davinci_correct_4bit;
 637                         info->chip.ecc.hwctl = nand_davinci_hwctl_4bit;
 638                         info->chip.ecc.bytes = 10;
 639                 } else {
 640                         info->chip.ecc.calculate = nand_davinci_calculate_1bit;
 641                         info->chip.ecc.correct = nand_davinci_correct_1bit;
 642                         info->chip.ecc.hwctl = nand_davinci_hwctl_1bit;
 643                         info->chip.ecc.bytes = 3;
 644                 }
 645                 info->chip.ecc.size = 512;
 646                 break;
 647         default:
 648                 ret = -EINVAL;
 649                 goto err_ecc;
 650         }
 651         info->chip.ecc.mode = ecc_mode;
 652
 653         info->clk = clk_get(&pdev->dev, "aemif");
 654         if (IS_ERR(info->clk)) {
 655                 ret = PTR_ERR(info->clk);
 656                 dev_dbg(&pdev->dev, "unable to get AEMIF clock, err %d\n", ret);
 657                 goto err_clk;
 658         }
 659
 660         ret = clk_enable(info->clk);
 661         if (ret < 0) {
 662                 dev_dbg(&pdev->dev, "unable to enable AEMIF clock, err %d\n",
 663                         ret);
 664                 goto err_clk_enable;
 665         }
 666
 667         /*
 668          * Setup Async configuration register in case we did not boot from
 669          * NAND and so bootloader did not bother to set it up.
 670          */
 671         val = davinci_nand_readl(info, A1CR_OFFSET + info->core_chipsel * 4);
 672
 673         /* Extended Wait is not valid and Select Strobe mode is not used */
 674         val &= ~(ACR_ASIZE_MASK | ACR_EW_MASK | ACR_SS_MASK);
 675         if (info->chip.options & NAND_BUSWIDTH_16)
 676                 val |= 0x1;
 677
 678         davinci_nand_writel(info, A1CR_OFFSET + info->core_chipsel * 4, val);
 679
 680         ret = davinci_aemif_setup_timing(info->timing, info->base,
 681                                                         info->core_chipsel);
 682         if (ret < 0) {
 683                 dev_dbg(&pdev->dev, "NAND timing values setup fail\n");
 684                 goto err_timing;
 685         }
 686
 687         spin_lock_irq(&davinci_nand_lock);
 688
 689         /* put CSxNAND into NAND mode */
 690         val = davinci_nand_readl(info, NANDFCR_OFFSET);
 691         val |= BIT(info->core_chipsel);
 692         davinci_nand_writel(info, NANDFCR_OFFSET, val);
 693
 694         spin_unlock_irq(&davinci_nand_lock);
 695
 696         /* Scan to find existence of the device(s) */
 697         ret = nand_scan_ident(&info->mtd, pdata->mask_chipsel ? 2 : 1, NULL);
 698         if (ret < 0) {
 699                 dev_dbg(&pdev->dev, "no NAND chip(s) found\n");
 700                 goto err_scan;
 701         }
 702
 703         /* Update ECC layout if needed ... for 1-bit HW ECC, the default
 704          * is OK, but it allocates 6 bytes when only 3 are needed (for
 705          * each 512 bytes).  For the 4-bit HW ECC, that default is not
 706          * usable:  10 bytes are needed, not 6.
 707          */
 708         if (pdata->ecc_bits == 4) {
 709                 int     chunks = info->mtd.writesize / 512;
 710
 711                 if (!chunks || info->mtd.oobsize < 16) {
 712                         dev_dbg(&pdev->dev, "too small\n");
 713                         ret = -EINVAL;
 714                         goto err_scan;
 715                 }
 716
 717                 /* For small page chips, preserve the manufacturer's
 718                  * badblock marking data ... and make sure a flash BBT
 719                  * table marker fits in the free bytes.
 720                  */
 721                 if (chunks == 1) {
 722                         info->ecclayout = hwecc4_small;
 723                         info->ecclayout.oobfree[1].length =
 724                                 info->mtd.oobsize - 16;
 725                         goto syndrome_done;
 726                 }
 727                 if (chunks == 4) {
 728                         info->ecclayout = hwecc4_2048;
 729                         info->chip.ecc.mode = NAND_ECC_HW_OOB_FIRST;
 730                         goto syndrome_done;
 731                 }
 732
 733                 /* 4KiB page chips are not yet supported. The eccpos from
 734                  * nand_ecclayout cannot hold 80 bytes and change to eccpos[]
 735                  * breaks userspace ioctl interface with mtd-utils. Once we
 736                  * resolve this issue, NAND_ECC_HW_OOB_FIRST mode can be used
 737                  * for the 4KiB page chips.
 738                  *
 739                  * TODO: Note that nand_ecclayout has now been expanded and can
 740                  *  hold plenty of OOB entries.
 741                  */
 742                 dev_warn(&pdev->dev, "no 4-bit ECC support yet "
 743                                 "for 4KiB-page NAND\n");
 744                 ret = -EIO;
 745                 goto err_scan;
 746
 747 syndrome_done:
 748                 info->chip.ecc.layout = &info->ecclayout;
 749         }
 750
 751         ret = nand_scan_tail(&info->mtd);
 752         if (ret < 0)
 753                 goto err_scan;
 754
 755         if (mtd_has_partitions()) {
 756                 struct mtd_partition    *mtd_parts = NULL;
 757                 int                     mtd_parts_nb = 0;
 758
 759                 if (mtd_has_cmdlinepart()) {
 760                         static const char *probes[] __initconst =
 761                                 { "cmdlinepart", NULL };
 762
 763                         mtd_parts_nb = parse_mtd_partitions(&info->mtd, probes,
 764                                                             &mtd_parts, 0);
 765                 }
 766
 767                 if (mtd_parts_nb <= 0) {
 768                         mtd_parts = pdata->parts;
 769                         mtd_parts_nb = pdata->nr_parts;
 770                 }
 771
 772                 /* Register any partitions */
 773                 if (mtd_parts_nb > 0) {
 774                         ret = add_mtd_partitions(&info->mtd,
 775                                         mtd_parts, mtd_parts_nb);
 776                         if (ret == 0)
 777                                 info->partitioned = true;
 778                 }
 779
 780         } else if (pdata->nr_parts) {
 781                 dev_warn(&pdev->dev, "ignoring %d default partitions on %s\n",
 782                                 pdata->nr_parts, info->mtd.name);
 783         }
 784
 785         /* If there's no partition info, just package the whole chip
 786          * as a single MTD device.
 787          */
 788         if (!info->partitioned)
 789                 ret = add_mtd_device(&info->mtd) ? -ENODEV : 0;
 790
 791         if (ret < 0)
 792                 goto err_scan;
 793
 794         val = davinci_nand_readl(info, NRCSR_OFFSET);
 795         dev_info(&pdev->dev, "controller rev. %d.%d\n",
 796                (val >> 8) & 0xff, val & 0xff);
 797
 798         return 0;
 799
 800 err_scan:
 801 err_timing:
 802         clk_disable(info->clk);
 803
 804 err_clk_enable:
 805         clk_put(info->clk);
 806
 807         spin_lock_irq(&davinci_nand_lock);
 808         if (ecc_mode == NAND_ECC_HW_SYNDROME)
 809                 ecc4_busy = false;
 810         spin_unlock_irq(&davinci_nand_lock);
 811
 812 err_ecc:
 813 err_clk:
 814 err_ioremap:
 815         if (base)
 816                 iounmap(base);
 817         if (vaddr)
 818                 iounmap(vaddr);
 819
 820 err_nomem:
 821         kfree(info);
 822         return ret;
 823 }
 824
 825 static int __exit nand_davinci_remove(struct platform_device *pdev)
 826 {
 827         struct davinci_nand_info *info = platform_get_drvdata(pdev);
 828         int status;
 829
 830         if (mtd_has_partitions() && info->partitioned)
 831                 status = del_mtd_partitions(&info->mtd);
 832         else
 833                 status = del_mtd_device(&info->mtd);
 834
 835         spin_lock_irq(&davinci_nand_lock);
 836         if (info->chip.ecc.mode == NAND_ECC_HW_SYNDROME)
 837                 ecc4_busy = false;
 838         spin_unlock_irq(&davinci_nand_lock);
 839
 840         iounmap(info->base);
 841         iounmap(info->vaddr);
 842
 843         nand_release(&info->mtd);
 844
 845         clk_disable(info->clk);
 846         clk_put(info->clk);
 847
 848         kfree(info);
 849
 850         return 0;
 851 }
 852
 853 static struct platform_driver nand_davinci_driver = {
 854         .remove         = __exit_p(nand_davinci_remove),
 855         .driver         = {
 856                 .name   = "davinci_nand",
 857         },
 858 };
 859 MODULE_ALIAS("platform:davinci_nand");
 860
 861 static int __init nand_davinci_init(void)
 862 {
 863         return platform_driver_probe(&nand_davinci_driver, nand_davinci_probe);
 864 }
 865 module_init(nand_davinci_init);
 866
 867 static void __exit nand_davinci_exit(void)
 868 {
 869         platform_driver_unregister(&nand_davinci_driver);
 870 }
 871 module_exit(nand_davinci_exit);
 872
 873 MODULE_LICENSE("GPL");
 874 MODULE_AUTHOR("Texas Instruments");
 875 MODULE_DESCRIPTION("Davinci NAND flash driver");
 876