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 = jiffies + msecs_to_jiffies(100);
 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 wait till ECC_STATE
 376          * reads less than 4, which means ECC HW has entered correction state.
 377          */
 378         do {
 379                 ecc_state = (davinci_nand_readl(info,
 380                                 NANDFSR_OFFSET) >> 8) & 0x0f;
 381                 cpu_relax();
 382         } while ((ecc_state < 4) && time_before(jiffies, timeo));
 383
 384         for (;;) {
 385                 u32     fsr = davinci_nand_readl(info, NANDFSR_OFFSET);
 386
 387                 switch ((fsr >> 8) & 0x0f) {
 388                 case 0:         /* no error, should not happen */
 389                         davinci_nand_readl(info, NAND_ERR_ERRVAL1_OFFSET);
 390                         return 0;
 391                 case 1:         /* five or more errors detected */
 392                         davinci_nand_readl(info, NAND_ERR_ERRVAL1_OFFSET);
 393                         return -EIO;
 394                 case 2:         /* error addresses computed */
 395                 case 3:
 396                         num_errors = 1 + ((fsr >> 16) & 0x03);
 397                         goto correct;
 398                 default:        /* still working on it */
 399                         cpu_relax();
 400                         continue;
 401                 }
 402         }
 403
 404 correct:
 405         /* correct each error */
 406         for (i = 0, corrected = 0; i < num_errors; i++) {
 407                 int error_address, error_value;
 408
 409                 if (i > 1) {
 410                         error_address = davinci_nand_readl(info,
 411                                                 NAND_ERR_ADD2_OFFSET);
 412                         error_value = davinci_nand_readl(info,
 413                                                 NAND_ERR_ERRVAL2_OFFSET);
 414                 } else {
 415                         error_address = davinci_nand_readl(info,
 416                                                 NAND_ERR_ADD1_OFFSET);
 417                         error_value = davinci_nand_readl(info,
 418                                                 NAND_ERR_ERRVAL1_OFFSET);
 419                 }
 420
 421                 if (i & 1) {
 422                         error_address >>= 16;
 423                         error_value >>= 16;
 424                 }
 425                 error_address &= 0x3ff;
 426                 error_address = (512 + 7) - error_address;
 427
 428                 if (error_address < 512) {
 429                         data[error_address] ^= error_value;
 430                         corrected++;
 431                 }
 432         }
 433
 434         return corrected;
 435 }
 436
 437 /*----------------------------------------------------------------------*/
 438
 439 /*
 440  * NOTE:  NAND boot requires ALE == EM_A[1], CLE == EM_A[2], so that's
 441  * how these chips are normally wired.  This translates to both 8 and 16
 442  * bit busses using ALE == BIT(3) in byte addresses, and CLE == BIT(4).
 443  *
 444  * For now we assume that configuration, or any other one which ignores
 445  * the two LSBs for NAND access ... so we can issue 32-bit reads/writes
 446  * and have that transparently morphed into multiple NAND operations.
 447  */
 448 static void nand_davinci_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 449 {
 450         struct nand_chip *chip = mtd->priv;
 451
 452         if ((0x03 & ((unsigned)buf)) == 0 && (0x03 & len) == 0)
 453                 ioread32_rep(chip->IO_ADDR_R, buf, len >> 2);
 454         else if ((0x01 & ((unsigned)buf)) == 0 && (0x01 & len) == 0)
 455                 ioread16_rep(chip->IO_ADDR_R, buf, len >> 1);
 456         else
 457                 ioread8_rep(chip->IO_ADDR_R, buf, len);
 458 }
 459
 460 static void nand_davinci_write_buf(struct mtd_info *mtd,
 461                 const uint8_t *buf, int len)
 462 {
 463         struct nand_chip *chip = mtd->priv;
 464
 465         if ((0x03 & ((unsigned)buf)) == 0 && (0x03 & len) == 0)
 466                 iowrite32_rep(chip->IO_ADDR_R, buf, len >> 2);
 467         else if ((0x01 & ((unsigned)buf)) == 0 && (0x01 & len) == 0)
 468                 iowrite16_rep(chip->IO_ADDR_R, buf, len >> 1);
 469         else
 470                 iowrite8_rep(chip->IO_ADDR_R, buf, len);
 471 }
 472
 473 /*
 474  * Check hardware register for wait status. Returns 1 if device is ready,
 475  * 0 if it is still busy.
 476  */
 477 static int nand_davinci_dev_ready(struct mtd_info *mtd)
 478 {
 479         struct davinci_nand_info *info = to_davinci_nand(mtd);
 480
 481         return davinci_nand_readl(info, NANDFSR_OFFSET) & BIT(0);
 482 }
 483
 484 /*----------------------------------------------------------------------*/
 485
 486 /* An ECC layout for using 4-bit ECC with small-page flash, storing
 487  * ten ECC bytes plus the manufacturer's bad block marker byte, and
 488  * and not overlapping the default BBT markers.
 489  */
 490 static struct nand_ecclayout hwecc4_small __initconst = {
 491         .eccbytes = 10,
 492         .eccpos = { 0, 1, 2, 3, 4,
 493                 /* offset 5 holds the badblock marker */
 494                 6, 7,
 495                 13, 14, 15, },
 496         .oobfree = {
 497                 {.offset = 8, .length = 5, },
 498                 {.offset = 16, },
 499         },
 500 };
 501
 502 /* An ECC layout for using 4-bit ECC with large-page (2048bytes) flash,
 503  * storing ten ECC bytes plus the manufacturer's bad block marker byte,
 504  * and not overlapping the default BBT markers.
 505  */
 506 static struct nand_ecclayout hwecc4_2048 __initconst = {
 507         .eccbytes = 40,
 508         .eccpos = {
 509                 /* at the end of spare sector */
 510                 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
 511                 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
 512                 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
 513                 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 514                 },
 515         .oobfree = {
 516                 /* 2 bytes at offset 0 hold manufacturer badblock markers */
 517                 {.offset = 2, .length = 22, },
 518                 /* 5 bytes at offset 8 hold BBT markers */
 519                 /* 8 bytes at offset 16 hold JFFS2 clean markers */
 520         },
 521 };
 522
 523 static int __init nand_davinci_probe(struct platform_device *pdev)
 524 {
 525         struct davinci_nand_pdata       *pdata = pdev->dev.platform_data;
 526         struct davinci_nand_info        *info;
 527         struct resource                 *res1;
 528         struct resource                 *res2;
 529         void __iomem                    *vaddr;
 530         void __iomem                    *base;
 531         int                             ret;
 532         uint32_t                        val;
 533         nand_ecc_modes_t                ecc_mode;
 534
 535         /* insist on board-specific configuration */
 536         if (!pdata)
 537                 return -ENODEV;
 538
 539         /* which external chipselect will we be managing? */
 540         if (pdev->id < 0 || pdev->id > 3)
 541                 return -ENODEV;
 542
 543         info = kzalloc(sizeof(*info), GFP_KERNEL);
 544         if (!info) {
 545                 dev_err(&pdev->dev, "unable to allocate memory\n");
 546                 ret = -ENOMEM;
 547                 goto err_nomem;
 548         }
 549
 550         platform_set_drvdata(pdev, info);
 551
 552         res1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 553         res2 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 554         if (!res1 || !res2) {
 555                 dev_err(&pdev->dev, "resource missing\n");
 556                 ret = -EINVAL;
 557                 goto err_nomem;
 558         }
 559
 560         vaddr = ioremap(res1->start, resource_size(res1));
 561         base = ioremap(res2->start, resource_size(res2));
 562         if (!vaddr || !base) {
 563                 dev_err(&pdev->dev, "ioremap failed\n");
 564                 ret = -EINVAL;
 565                 goto err_ioremap;
 566         }
 567
 568         info->dev               = &pdev->dev;
 569         info->base              = base;
 570         info->vaddr             = vaddr;
 571
 572         info->mtd.priv          = &info->chip;
 573         info->mtd.name          = dev_name(&pdev->dev);
 574         info->mtd.owner         = THIS_MODULE;
 575
 576         info->mtd.dev.parent    = &pdev->dev;
 577
 578         info->chip.IO_ADDR_R    = vaddr;
 579         info->chip.IO_ADDR_W    = vaddr;
 580         info->chip.chip_delay   = 0;
 581         info->chip.select_chip  = nand_davinci_select_chip;
 582
 583         /* options such as NAND_USE_FLASH_BBT or 16-bit widths */
 584         info->chip.options      = pdata->options;
 585         info->chip.bbt_td       = pdata->bbt_td;
 586         info->chip.bbt_md       = pdata->bbt_md;
 587         info->timing            = pdata->timing;
 588
 589         info->ioaddr            = (uint32_t __force) vaddr;
 590
 591         info->current_cs        = info->ioaddr;
 592         info->core_chipsel      = pdev->id;
 593         info->mask_chipsel      = pdata->mask_chipsel;
 594
 595         /* use nandboot-capable ALE/CLE masks by default */
 596         info->mask_ale          = pdata->mask_ale ? : MASK_ALE;
 597         info->mask_cle          = pdata->mask_cle ? : MASK_CLE;
 598
 599         /* Set address of hardware control function */
 600         info->chip.cmd_ctrl     = nand_davinci_hwcontrol;
 601         info->chip.dev_ready    = nand_davinci_dev_ready;
 602
 603         /* Speed up buffer I/O */
 604         info->chip.read_buf     = nand_davinci_read_buf;
 605         info->chip.write_buf    = nand_davinci_write_buf;
 606
 607         /* Use board-specific ECC config */
 608         ecc_mode                = pdata->ecc_mode;
 609
 610         ret = -EINVAL;
 611         switch (ecc_mode) {
 612         case NAND_ECC_NONE:
 613         case NAND_ECC_SOFT:
 614                 pdata->ecc_bits = 0;
 615                 break;
 616         case NAND_ECC_HW:
 617                 if (pdata->ecc_bits == 4) {
 618                         /* No sanity checks:  CPUs must support this,
 619                          * and the chips may not use NAND_BUSWIDTH_16.
 620                          */
 621
 622                         /* No sharing 4-bit hardware between chipselects yet */
 623                         spin_lock_irq(&davinci_nand_lock);
 624                         if (ecc4_busy)
 625                                 ret = -EBUSY;
 626                         else
 627                                 ecc4_busy = true;
 628                         spin_unlock_irq(&davinci_nand_lock);
 629
 630                         if (ret == -EBUSY)
 631                                 goto err_ecc;
 632
 633                         info->chip.ecc.calculate = nand_davinci_calculate_4bit;
 634                         info->chip.ecc.correct = nand_davinci_correct_4bit;
 635                         info->chip.ecc.hwctl = nand_davinci_hwctl_4bit;
 636                         info->chip.ecc.bytes = 10;
 637                 } else {
 638                         info->chip.ecc.calculate = nand_davinci_calculate_1bit;
 639                         info->chip.ecc.correct = nand_davinci_correct_1bit;
 640                         info->chip.ecc.hwctl = nand_davinci_hwctl_1bit;
 641                         info->chip.ecc.bytes = 3;
 642                 }
 643                 info->chip.ecc.size = 512;
 644                 break;
 645         default:
 646                 ret = -EINVAL;
 647                 goto err_ecc;
 648         }
 649         info->chip.ecc.mode = ecc_mode;
 650
 651         info->clk = clk_get(&pdev->dev, "aemif");
 652         if (IS_ERR(info->clk)) {
 653                 ret = PTR_ERR(info->clk);
 654                 dev_dbg(&pdev->dev, "unable to get AEMIF clock, err %d\n", ret);
 655                 goto err_clk;
 656         }
 657
 658         ret = clk_enable(info->clk);
 659         if (ret < 0) {
 660                 dev_dbg(&pdev->dev, "unable to enable AEMIF clock, err %d\n",
 661                         ret);
 662                 goto err_clk_enable;
 663         }
 664
 665         /*
 666          * Setup Async configuration register in case we did not boot from
 667          * NAND and so bootloader did not bother to set it up.
 668          */
 669         val = davinci_nand_readl(info, A1CR_OFFSET + info->core_chipsel * 4);
 670
 671         /* Extended Wait is not valid and Select Strobe mode is not used */
 672         val &= ~(ACR_ASIZE_MASK | ACR_EW_MASK | ACR_SS_MASK);
 673         if (info->chip.options & NAND_BUSWIDTH_16)
 674                 val |= 0x1;
 675
 676         davinci_nand_writel(info, A1CR_OFFSET + info->core_chipsel * 4, val);
 677
 678         ret = davinci_aemif_setup_timing(info->timing, info->base,
 679                                                         info->core_chipsel);
 680         if (ret < 0) {
 681                 dev_dbg(&pdev->dev, "NAND timing values setup fail\n");
 682                 goto err_timing;
 683         }
 684
 685         spin_lock_irq(&davinci_nand_lock);
 686
 687         /* put CSxNAND into NAND mode */
 688         val = davinci_nand_readl(info, NANDFCR_OFFSET);
 689         val |= BIT(info->core_chipsel);
 690         davinci_nand_writel(info, NANDFCR_OFFSET, val);
 691
 692         spin_unlock_irq(&davinci_nand_lock);
 693
 694         /* Scan to find existence of the device(s) */
 695         ret = nand_scan_ident(&info->mtd, pdata->mask_chipsel ? 2 : 1, NULL);
 696         if (ret < 0) {
 697                 dev_dbg(&pdev->dev, "no NAND chip(s) found\n");
 698                 goto err_scan;
 699         }
 700
 701         /* Update ECC layout if needed ... for 1-bit HW ECC, the default
 702          * is OK, but it allocates 6 bytes when only 3 are needed (for
 703          * each 512 bytes).  For the 4-bit HW ECC, that default is not
 704          * usable:  10 bytes are needed, not 6.
 705          */
 706         if (pdata->ecc_bits == 4) {
 707                 int     chunks = info->mtd.writesize / 512;
 708
 709                 if (!chunks || info->mtd.oobsize < 16) {
 710                         dev_dbg(&pdev->dev, "too small\n");
 711                         ret = -EINVAL;
 712                         goto err_scan;
 713                 }
 714
 715                 /* For small page chips, preserve the manufacturer's
 716                  * badblock marking data ... and make sure a flash BBT
 717                  * table marker fits in the free bytes.
 718                  */
 719                 if (chunks == 1) {
 720                         info->ecclayout = hwecc4_small;
 721                         info->ecclayout.oobfree[1].length =
 722                                 info->mtd.oobsize - 16;
 723                         goto syndrome_done;
 724                 }
 725                 if (chunks == 4) {
 726                         info->ecclayout = hwecc4_2048;
 727                         info->chip.ecc.mode = NAND_ECC_HW_OOB_FIRST;
 728                         goto syndrome_done;
 729                 }
 730
 731                 /* 4KiB page chips are not yet supported. The eccpos from
 732                  * nand_ecclayout cannot hold 80 bytes and change to eccpos[]
 733                  * breaks userspace ioctl interface with mtd-utils. Once we
 734                  * resolve this issue, NAND_ECC_HW_OOB_FIRST mode can be used
 735                  * for the 4KiB page chips.
 736                  */
 737                 dev_warn(&pdev->dev, "no 4-bit ECC support yet "
 738                                 "for 4KiB-page NAND\n");
 739                 ret = -EIO;
 740                 goto err_scan;
 741
 742 syndrome_done:
 743                 info->chip.ecc.layout = &info->ecclayout;
 744         }
 745
 746         ret = nand_scan_tail(&info->mtd);
 747         if (ret < 0)
 748                 goto err_scan;
 749
 750         if (mtd_has_partitions()) {
 751                 struct mtd_partition    *mtd_parts = NULL;
 752                 int                     mtd_parts_nb = 0;
 753
 754                 if (mtd_has_cmdlinepart()) {
 755                         static const char *probes[] __initconst =
 756                                 { "cmdlinepart", NULL };
 757
 758                         mtd_parts_nb = parse_mtd_partitions(&info->mtd, probes,
 759                                                             &mtd_parts, 0);
 760                 }
 761
 762                 if (mtd_parts_nb <= 0) {
 763                         mtd_parts = pdata->parts;
 764                         mtd_parts_nb = pdata->nr_parts;
 765                 }
 766
 767                 /* Register any partitions */
 768                 if (mtd_parts_nb > 0) {
 769                         ret = add_mtd_partitions(&info->mtd,
 770                                         mtd_parts, mtd_parts_nb);
 771                         if (ret == 0)
 772                                 info->partitioned = true;
 773                 }
 774
 775         } else if (pdata->nr_parts) {
 776                 dev_warn(&pdev->dev, "ignoring %d default partitions on %s\n",
 777                                 pdata->nr_parts, info->mtd.name);
 778         }
 779
 780         /* If there's no partition info, just package the whole chip
 781          * as a single MTD device.
 782          */
 783         if (!info->partitioned)
 784                 ret = add_mtd_device(&info->mtd) ? -ENODEV : 0;
 785
 786         if (ret < 0)
 787                 goto err_scan;
 788
 789         val = davinci_nand_readl(info, NRCSR_OFFSET);
 790         dev_info(&pdev->dev, "controller rev. %d.%d\n",
 791                (val >> 8) & 0xff, val & 0xff);
 792
 793         return 0;
 794
 795 err_scan:
 796 err_timing:
 797         clk_disable(info->clk);
 798
 799 err_clk_enable:
 800         clk_put(info->clk);
 801
 802         spin_lock_irq(&davinci_nand_lock);
 803         if (ecc_mode == NAND_ECC_HW_SYNDROME)
 804                 ecc4_busy = false;
 805         spin_unlock_irq(&davinci_nand_lock);
 806
 807 err_ecc:
 808 err_clk:
 809 err_ioremap:
 810         if (base)
 811                 iounmap(base);
 812         if (vaddr)
 813                 iounmap(vaddr);
 814
 815 err_nomem:
 816         kfree(info);
 817         return ret;
 818 }
 819
 820 static int __exit nand_davinci_remove(struct platform_device *pdev)
 821 {
 822         struct davinci_nand_info *info = platform_get_drvdata(pdev);
 823         int status;
 824
 825         if (mtd_has_partitions() && info->partitioned)
 826                 status = del_mtd_partitions(&info->mtd);
 827         else
 828                 status = del_mtd_device(&info->mtd);
 829
 830         spin_lock_irq(&davinci_nand_lock);
 831         if (info->chip.ecc.mode == NAND_ECC_HW_SYNDROME)
 832                 ecc4_busy = false;
 833         spin_unlock_irq(&davinci_nand_lock);
 834
 835         iounmap(info->base);
 836         iounmap(info->vaddr);
 837
 838         nand_release(&info->mtd);
 839
 840         clk_disable(info->clk);
 841         clk_put(info->clk);
 842
 843         kfree(info);
 844
 845         return 0;
 846 }
 847
 848 static struct platform_driver nand_davinci_driver = {
 849         .remove         = __exit_p(nand_davinci_remove),
 850         .driver         = {
 851                 .name   = "davinci_nand",
 852         },
 853 };
 854 MODULE_ALIAS("platform:davinci_nand");
 855
 856 static int __init nand_davinci_init(void)
 857 {
 858         return platform_driver_probe(&nand_davinci_driver, nand_davinci_probe);
 859 }
 860 module_init(nand_davinci_init);
 861
 862 static void __exit nand_davinci_exit(void)
 863 {
 864         platform_driver_unregister(&nand_davinci_driver);
 865 }
 866 module_exit(nand_davinci_exit);
 867
 868 MODULE_LICENSE("GPL");
 869 MODULE_AUTHOR("Texas Instruments");
 870 MODULE_DESCRIPTION("Davinci NAND flash driver");
 871