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