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
  36 #include <mach/nand.h>
  37
  38 #include <asm/mach-types.h>
  39
  40
  41 /*
  42  * This is a device driver for the NAND flash controller found on the
  43  * various DaVinci family chips.  It handles up to four SoC chipselects,
  44  * and some flavors of secondary chipselect (e.g. based on A12) as used
  45  * with multichip packages.
  46  *
  47  * The 1-bit ECC hardware is supported, but not yet the newer 4-bit ECC
  48  * available on chips like the DM355 and OMAP-L137 and needed with the
  49  * more error-prone MLC NAND chips.
  50  *
  51  * This driver assumes EM_WAIT connects all the NAND devices' RDY/nBUSY
  52  * outputs in a "wire-AND" configuration, with no per-chip signals.
  53  */
  54 struct davinci_nand_info {
  55         struct mtd_info         mtd;
  56         struct nand_chip        chip;
  57
  58         struct device           *dev;
  59         struct clk              *clk;
  60         bool                    partitioned;
  61
  62         void __iomem            *base;
  63         void __iomem            *vaddr;
  64
  65         uint32_t                ioaddr;
  66         uint32_t                current_cs;
  67
  68         uint32_t                mask_chipsel;
  69         uint32_t                mask_ale;
  70         uint32_t                mask_cle;
  71
  72         uint32_t                core_chipsel;
  73 };
  74
  75 static DEFINE_SPINLOCK(davinci_nand_lock);
  76
  77 #define to_davinci_nand(m) container_of(m, struct davinci_nand_info, mtd)
  78
  79
  80 static inline unsigned int davinci_nand_readl(struct davinci_nand_info *info,
  81                 int offset)
  82 {
  83         return __raw_readl(info->base + offset);
  84 }
  85
  86 static inline void davinci_nand_writel(struct davinci_nand_info *info,
  87                 int offset, unsigned long value)
  88 {
  89         __raw_writel(value, info->base + offset);
  90 }
  91
  92 /*----------------------------------------------------------------------*/
  93
  94 /*
  95  * Access to hardware control lines:  ALE, CLE, secondary chipselect.
  96  */
  97
  98 static void nand_davinci_hwcontrol(struct mtd_info *mtd, int cmd,
  99                                    unsigned int ctrl)
 100 {
 101         struct davinci_nand_info        *info = to_davinci_nand(mtd);
 102         uint32_t                        addr = info->current_cs;
 103         struct nand_chip                *nand = mtd->priv;
 104
 105         /* Did the control lines change? */
 106         if (ctrl & NAND_CTRL_CHANGE) {
 107                 if ((ctrl & NAND_CTRL_CLE) == NAND_CTRL_CLE)
 108                         addr |= info->mask_cle;
 109                 else if ((ctrl & NAND_CTRL_ALE) == NAND_CTRL_ALE)
 110                         addr |= info->mask_ale;
 111
 112                 nand->IO_ADDR_W = (void __iomem __force *)addr;
 113         }
 114
 115         if (cmd != NAND_CMD_NONE)
 116                 iowrite8(cmd, nand->IO_ADDR_W);
 117 }
 118
 119 static void nand_davinci_select_chip(struct mtd_info *mtd, int chip)
 120 {
 121         struct davinci_nand_info        *info = to_davinci_nand(mtd);
 122         uint32_t                        addr = info->ioaddr;
 123
 124         /* maybe kick in a second chipselect */
 125         if (chip > 0)
 126                 addr |= info->mask_chipsel;
 127         info->current_cs = addr;
 128
 129         info->chip.IO_ADDR_W = (void __iomem __force *)addr;
 130         info->chip.IO_ADDR_R = info->chip.IO_ADDR_W;
 131 }
 132
 133 /*----------------------------------------------------------------------*/
 134
 135 /*
 136  * 1-bit hardware ECC ... context maintained for each core chipselect
 137  */
 138
 139 static inline uint32_t nand_davinci_readecc_1bit(struct mtd_info *mtd)
 140 {
 141         struct davinci_nand_info *info = to_davinci_nand(mtd);
 142
 143         return davinci_nand_readl(info, NANDF1ECC_OFFSET
 144                         + 4 * info->core_chipsel);
 145 }
 146
 147 static void nand_davinci_hwctl_1bit(struct mtd_info *mtd, int mode)
 148 {
 149         struct davinci_nand_info *info;
 150         uint32_t nandcfr;
 151         unsigned long flags;
 152
 153         info = to_davinci_nand(mtd);
 154
 155         /* Reset ECC hardware */
 156         nand_davinci_readecc_1bit(mtd);
 157
 158         spin_lock_irqsave(&davinci_nand_lock, flags);
 159
 160         /* Restart ECC hardware */
 161         nandcfr = davinci_nand_readl(info, NANDFCR_OFFSET);
 162         nandcfr |= BIT(8 + info->core_chipsel);
 163         davinci_nand_writel(info, NANDFCR_OFFSET, nandcfr);
 164
 165         spin_unlock_irqrestore(&davinci_nand_lock, flags);
 166 }
 167
 168 /*
 169  * Read hardware ECC value and pack into three bytes
 170  */
 171 static int nand_davinci_calculate_1bit(struct mtd_info *mtd,
 172                                       const u_char *dat, u_char *ecc_code)
 173 {
 174         unsigned int ecc_val = nand_davinci_readecc_1bit(mtd);
 175         unsigned int ecc24 = (ecc_val & 0x0fff) | ((ecc_val & 0x0fff0000) >> 4);
 176
 177         /* invert so that erased block ecc is correct */
 178         ecc24 = ~ecc24;
 179         ecc_code[0] = (u_char)(ecc24);
 180         ecc_code[1] = (u_char)(ecc24 >> 8);
 181         ecc_code[2] = (u_char)(ecc24 >> 16);
 182
 183         return 0;
 184 }
 185
 186 static int nand_davinci_correct_1bit(struct mtd_info *mtd, u_char *dat,
 187                                      u_char *read_ecc, u_char *calc_ecc)
 188 {
 189         struct nand_chip *chip = mtd->priv;
 190         uint32_t eccNand = read_ecc[0] | (read_ecc[1] << 8) |
 191                                           (read_ecc[2] << 16);
 192         uint32_t eccCalc = calc_ecc[0] | (calc_ecc[1] << 8) |
 193                                           (calc_ecc[2] << 16);
 194         uint32_t diff = eccCalc ^ eccNand;
 195
 196         if (diff) {
 197                 if ((((diff >> 12) ^ diff) & 0xfff) == 0xfff) {
 198                         /* Correctable error */
 199                         if ((diff >> (12 + 3)) < chip->ecc.size) {
 200                                 dat[diff >> (12 + 3)] ^= BIT((diff >> 12) & 7);
 201                                 return 1;
 202                         } else {
 203                                 return -1;
 204                         }
 205                 } else if (!(diff & (diff - 1))) {
 206                         /* Single bit ECC error in the ECC itself,
 207                          * nothing to fix */
 208                         return 1;
 209                 } else {
 210                         /* Uncorrectable error */
 211                         return -1;
 212                 }
 213
 214         }
 215         return 0;
 216 }
 217
 218 /*----------------------------------------------------------------------*/
 219
 220 /*
 221  * NOTE:  NAND boot requires ALE == EM_A[1], CLE == EM_A[2], so that's
 222  * how these chips are normally wired.  This translates to both 8 and 16
 223  * bit busses using ALE == BIT(3) in byte addresses, and CLE == BIT(4).
 224  *
 225  * For now we assume that configuration, or any other one which ignores
 226  * the two LSBs for NAND access ... so we can issue 32-bit reads/writes
 227  * and have that transparently morphed into multiple NAND operations.
 228  */
 229 static void nand_davinci_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 230 {
 231         struct nand_chip *chip = mtd->priv;
 232
 233         if ((0x03 & ((unsigned)buf)) == 0 && (0x03 & len) == 0)
 234                 ioread32_rep(chip->IO_ADDR_R, buf, len >> 2);
 235         else if ((0x01 & ((unsigned)buf)) == 0 && (0x01 & len) == 0)
 236                 ioread16_rep(chip->IO_ADDR_R, buf, len >> 1);
 237         else
 238                 ioread8_rep(chip->IO_ADDR_R, buf, len);
 239 }
 240
 241 static void nand_davinci_write_buf(struct mtd_info *mtd,
 242                 const uint8_t *buf, int len)
 243 {
 244         struct nand_chip *chip = mtd->priv;
 245
 246         if ((0x03 & ((unsigned)buf)) == 0 && (0x03 & len) == 0)
 247                 iowrite32_rep(chip->IO_ADDR_R, buf, len >> 2);
 248         else if ((0x01 & ((unsigned)buf)) == 0 && (0x01 & len) == 0)
 249                 iowrite16_rep(chip->IO_ADDR_R, buf, len >> 1);
 250         else
 251                 iowrite8_rep(chip->IO_ADDR_R, buf, len);
 252 }
 253
 254 /*
 255  * Check hardware register for wait status. Returns 1 if device is ready,
 256  * 0 if it is still busy.
 257  */
 258 static int nand_davinci_dev_ready(struct mtd_info *mtd)
 259 {
 260         struct davinci_nand_info *info = to_davinci_nand(mtd);
 261
 262         return davinci_nand_readl(info, NANDFSR_OFFSET) & BIT(0);
 263 }
 264
 265 static void __init nand_dm6446evm_flash_init(struct davinci_nand_info *info)
 266 {
 267         uint32_t regval, a1cr;
 268
 269         /*
 270          * NAND FLASH timings @ PLL1 == 459 MHz
 271          *  - AEMIF.CLK freq   = PLL1/6 = 459/6 = 76.5 MHz
 272          *  - AEMIF.CLK period = 1/76.5 MHz = 13.1 ns
 273          */
 274         regval = 0
 275                 | (0 << 31)           /* selectStrobe */
 276                 | (0 << 30)           /* extWait (never with NAND) */
 277                 | (1 << 26)           /* writeSetup      10 ns */
 278                 | (3 << 20)           /* writeStrobe     40 ns */
 279                 | (1 << 17)           /* writeHold       10 ns */
 280                 | (0 << 13)           /* readSetup       10 ns */
 281                 | (3 << 7)            /* readStrobe      60 ns */
 282                 | (0 << 4)            /* readHold        10 ns */
 283                 | (3 << 2)            /* turnAround      ?? ns */
 284                 | (0 << 0)            /* asyncSize       8-bit bus */
 285                 ;
 286         a1cr = davinci_nand_readl(info, A1CR_OFFSET);
 287         if (a1cr != regval) {
 288                 dev_dbg(info->dev, "Warning: NAND config: Set A1CR " \
 289                        "reg to 0x%08x, was 0x%08x, should be done by " \
 290                        "bootloader.\n", regval, a1cr);
 291                 davinci_nand_writel(info, A1CR_OFFSET, regval);
 292         }
 293 }
 294
 295 /*----------------------------------------------------------------------*/
 296
 297 static int __init nand_davinci_probe(struct platform_device *pdev)
 298 {
 299         struct davinci_nand_pdata       *pdata = pdev->dev.platform_data;
 300         struct davinci_nand_info        *info;
 301         struct resource                 *res1;
 302         struct resource                 *res2;
 303         void __iomem                    *vaddr;
 304         void __iomem                    *base;
 305         int                             ret;
 306         uint32_t                        val;
 307         nand_ecc_modes_t                ecc_mode;
 308
 309         /* insist on board-specific configuration */
 310         if (!pdata)
 311                 return -ENODEV;
 312
 313         /* which external chipselect will we be managing? */
 314         if (pdev->id < 0 || pdev->id > 3)
 315                 return -ENODEV;
 316
 317         info = kzalloc(sizeof(*info), GFP_KERNEL);
 318         if (!info) {
 319                 dev_err(&pdev->dev, "unable to allocate memory\n");
 320                 ret = -ENOMEM;
 321                 goto err_nomem;
 322         }
 323
 324         platform_set_drvdata(pdev, info);
 325
 326         res1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 327         res2 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 328         if (!res1 || !res2) {
 329                 dev_err(&pdev->dev, "resource missing\n");
 330                 ret = -EINVAL;
 331                 goto err_nomem;
 332         }
 333
 334         vaddr = ioremap(res1->start, res1->end - res1->start);
 335         base = ioremap(res2->start, res2->end - res2->start);
 336         if (!vaddr || !base) {
 337                 dev_err(&pdev->dev, "ioremap failed\n");
 338                 ret = -EINVAL;
 339                 goto err_ioremap;
 340         }
 341
 342         info->dev               = &pdev->dev;
 343         info->base              = base;
 344         info->vaddr             = vaddr;
 345
 346         info->mtd.priv          = &info->chip;
 347         info->mtd.name          = dev_name(&pdev->dev);
 348         info->mtd.owner         = THIS_MODULE;
 349
 350         info->mtd.dev.parent    = &pdev->dev;
 351
 352         info->chip.IO_ADDR_R    = vaddr;
 353         info->chip.IO_ADDR_W    = vaddr;
 354         info->chip.chip_delay   = 0;
 355         info->chip.select_chip  = nand_davinci_select_chip;
 356
 357         /* options such as NAND_USE_FLASH_BBT or 16-bit widths */
 358         info->chip.options      = pdata->options;
 359
 360         info->ioaddr            = (uint32_t __force) vaddr;
 361
 362         info->current_cs        = info->ioaddr;
 363         info->core_chipsel      = pdev->id;
 364         info->mask_chipsel      = pdata->mask_chipsel;
 365
 366         /* use nandboot-capable ALE/CLE masks by default */
 367         info->mask_ale          = pdata->mask_cle ? : MASK_ALE;
 368         info->mask_cle          = pdata->mask_cle ? : MASK_CLE;
 369
 370         /* Set address of hardware control function */
 371         info->chip.cmd_ctrl     = nand_davinci_hwcontrol;
 372         info->chip.dev_ready    = nand_davinci_dev_ready;
 373
 374         /* Speed up buffer I/O */
 375         info->chip.read_buf     = nand_davinci_read_buf;
 376         info->chip.write_buf    = nand_davinci_write_buf;
 377
 378         /* Use board-specific ECC config */
 379         ecc_mode                = pdata->ecc_mode;
 380
 381         switch (ecc_mode) {
 382         case NAND_ECC_NONE:
 383         case NAND_ECC_SOFT:
 384                 break;
 385         case NAND_ECC_HW:
 386                 info->chip.ecc.calculate = nand_davinci_calculate_1bit;
 387                 info->chip.ecc.correct = nand_davinci_correct_1bit;
 388                 info->chip.ecc.hwctl = nand_davinci_hwctl_1bit;
 389                 info->chip.ecc.size = 512;
 390                 info->chip.ecc.bytes = 3;
 391                 break;
 392         case NAND_ECC_HW_SYNDROME:
 393                 /* FIXME implement */
 394                 info->chip.ecc.size = 512;
 395                 info->chip.ecc.bytes = 10;
 396
 397                 dev_warn(&pdev->dev, "4-bit ECC nyet supported\n");
 398                 /* FALL THROUGH */
 399         default:
 400                 ret = -EINVAL;
 401                 goto err_ecc;
 402         }
 403         info->chip.ecc.mode = ecc_mode;
 404
 405         info->clk = clk_get(&pdev->dev, "AEMIFCLK");
 406         if (IS_ERR(info->clk)) {
 407                 ret = PTR_ERR(info->clk);
 408                 dev_dbg(&pdev->dev, "unable to get AEMIFCLK, err %d\n", ret);
 409                 goto err_clk;
 410         }
 411
 412         ret = clk_enable(info->clk);
 413         if (ret < 0) {
 414                 dev_dbg(&pdev->dev, "unable to enable AEMIFCLK, err %d\n", ret);
 415                 goto err_clk_enable;
 416         }
 417
 418         /* EMIF timings should normally be set by the boot loader,
 419          * especially after boot-from-NAND.  The *only* reason to
 420          * have this special casing for the DM6446 EVM is to work
 421          * with boot-from-NOR ... with CS0 manually re-jumpered
 422          * (after startup) so it addresses the NAND flash, not NOR.
 423          * Even for dev boards, that's unusually rude...
 424          */
 425         if (machine_is_davinci_evm())
 426                 nand_dm6446evm_flash_init(info);
 427
 428         spin_lock_irq(&davinci_nand_lock);
 429
 430         /* put CSxNAND into NAND mode */
 431         val = davinci_nand_readl(info, NANDFCR_OFFSET);
 432         val |= BIT(info->core_chipsel);
 433         davinci_nand_writel(info, NANDFCR_OFFSET, val);
 434
 435         spin_unlock_irq(&davinci_nand_lock);
 436
 437         /* Scan to find existence of the device(s) */
 438         ret = nand_scan(&info->mtd, pdata->mask_chipsel ? 2 : 1);
 439         if (ret < 0) {
 440                 dev_dbg(&pdev->dev, "no NAND chip(s) found\n");
 441                 goto err_scan;
 442         }
 443
 444         if (mtd_has_partitions()) {
 445                 struct mtd_partition    *mtd_parts = NULL;
 446                 int                     mtd_parts_nb = 0;
 447
 448                 if (mtd_has_cmdlinepart()) {
 449                         static const char *probes[] __initconst =
 450                                 { "cmdlinepart", NULL };
 451
 452                         const char              *master_name;
 453
 454                         /* Set info->mtd.name = 0 temporarily */
 455                         master_name             = info->mtd.name;
 456                         info->mtd.name          = (char *)0;
 457
 458                         /* info->mtd.name == 0, means: don't bother checking
 459                            <mtd-id> */
 460                         mtd_parts_nb = parse_mtd_partitions(&info->mtd, probes,
 461                                                             &mtd_parts, 0);
 462
 463                         /* Restore info->mtd.name */
 464                         info->mtd.name = master_name;
 465                 }
 466
 467                 if (mtd_parts_nb <= 0) {
 468                         mtd_parts = pdata->parts;
 469                         mtd_parts_nb = pdata->nr_parts;
 470                 }
 471
 472                 /* Register any partitions */
 473                 if (mtd_parts_nb > 0) {
 474                         ret = add_mtd_partitions(&info->mtd,
 475                                         mtd_parts, mtd_parts_nb);
 476                         if (ret == 0)
 477                                 info->partitioned = true;
 478                 }
 479
 480         } else if (pdata->nr_parts) {
 481                 dev_warn(&pdev->dev, "ignoring %d default partitions on %s\n",
 482                                 pdata->nr_parts, info->mtd.name);
 483         }
 484
 485         /* If there's no partition info, just package the whole chip
 486          * as a single MTD device.
 487          */
 488         if (!info->partitioned)
 489                 ret = add_mtd_device(&info->mtd) ? -ENODEV : 0;
 490
 491         if (ret < 0)
 492                 goto err_scan;
 493
 494         val = davinci_nand_readl(info, NRCSR_OFFSET);
 495         dev_info(&pdev->dev, "controller rev. %d.%d\n",
 496                (val >> 8) & 0xff, val & 0xff);
 497
 498         return 0;
 499
 500 err_scan:
 501         clk_disable(info->clk);
 502
 503 err_clk_enable:
 504         clk_put(info->clk);
 505
 506 err_ecc:
 507 err_clk:
 508 err_ioremap:
 509         if (base)
 510                 iounmap(base);
 511         if (vaddr)
 512                 iounmap(vaddr);
 513
 514 err_nomem:
 515         kfree(info);
 516         return ret;
 517 }
 518
 519 static int __exit nand_davinci_remove(struct platform_device *pdev)
 520 {
 521         struct davinci_nand_info *info = platform_get_drvdata(pdev);
 522         int status;
 523
 524         if (mtd_has_partitions() && info->partitioned)
 525                 status = del_mtd_partitions(&info->mtd);
 526         else
 527                 status = del_mtd_device(&info->mtd);
 528
 529         iounmap(info->base);
 530         iounmap(info->vaddr);
 531
 532         nand_release(&info->mtd);
 533
 534         clk_disable(info->clk);
 535         clk_put(info->clk);
 536
 537         kfree(info);
 538
 539         return 0;
 540 }
 541
 542 static struct platform_driver nand_davinci_driver = {
 543         .remove         = __exit_p(nand_davinci_remove),
 544         .driver         = {
 545                 .name   = "davinci_nand",
 546         },
 547 };
 548 MODULE_ALIAS("platform:davinci_nand");
 549
 550 static int __init nand_davinci_init(void)
 551 {
 552         return platform_driver_probe(&nand_davinci_driver, nand_davinci_probe);
 553 }
 554 module_init(nand_davinci_init);
 555
 556 static void __exit nand_davinci_exit(void)
 557 {
 558         platform_driver_unregister(&nand_davinci_driver);
 559 }
 560 module_exit(nand_davinci_exit);
 561
 562 MODULE_LICENSE("GPL");
 563 MODULE_AUTHOR("Texas Instruments");
 564 MODULE_DESCRIPTION("Davinci NAND flash driver");
 565