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