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