drivers/mtd/nand/lpc32xx_nand.c

   1 /*
   2  * drivers/mtd/nand/lpc32xx_nand.c
   3  *
   4  * Author: Kevin Wells <kevin.wells@nxp.com>
   5  *
   6  * Copyright (C) 2010 NXP Semiconductors
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  */
  18
  19 #include <linux/slab.h>
  20 #include <linux/module.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/mtd/mtd.h>
  23 #include <linux/mtd/nand.h>
  24 #include <linux/mtd/partitions.h>
  25 #include <linux/clk.h>
  26 #include <linux/err.h>
  27 #include <linux/delay.h>
  28 #include <linux/completion.h>
  29
  30 #include <asm/io.h>
  31 #include <linux/mm.h>
  32 #include <linux/dma-mapping.h>
  33 #include <linux/mtd/nand_ecc.h>
  34
  35 #include <asm/sizes.h>
  36 #include <mach/hardware.h>
  37 #include <mach/board.h>
  38 #include <mach/slcnand.h>
  39 #include <mach/dmac.h>
  40 #include <mach/dma.h>
  41
  42 /*
  43  * LPC3250 has 3 bytes of ECC data but due to DMA
  44  * word transfer limitation, we'll use 4 bytes
  45  */
  46 #define NAND_ECC_LEN_PER_SUBPAGE        0x4
  47 #define NAND_ECC_SUBPAGE_LEN            256
  48
  49 #define NAND_LARGE_BLOCK_PAGE_SIZE      2048
  50 #define NAND_SMALL_BLOCK_PAGE_SIZE      512
  51
  52 #define NAND_ERASED_BLOCK_ECC_VALUE     0xFFFFFFFF
  53
  54 static struct nand_ecclayout lpc32xx_nand_oob_16 = {
  55         .eccbytes = 8,
  56         .eccpos = {8, 9, 10, 11, 12, 13, 14, 15},
  57         .oobfree = {
  58                 {.offset = 0,
  59                  . length = 5},
  60                 {.offset = 6,
  61                  . length = 2}}
  62 };
  63
  64 static struct nand_ecclayout lpc32xx_nand_oob_64 = {
  65         .eccbytes = 32,
  66         .eccpos = { 8, 9, 10, 11, 12, 13, 14, 15,
  67                    24, 25, 26, 27, 28, 29, 30, 31,
  68                    40, 41, 42, 43, 44, 45, 46, 47,
  69                    56, 57, 58, 59, 60, 61, 62, 63},
  70         .oobfree = {
  71                 {.offset = 2,
  72                  . length = 6},
  73                 {.offset = 16,
  74                  . length = 8},
  75                 {.offset = 32,
  76                  . length = 8},
  77                 {.offset = 48,
  78                  . length = 8}}
  79 };
  80
  81 struct lpc32xx_nand_host {
  82         struct nand_chip        nand_chip;
  83         struct clk              *clk;
  84         struct mtd_info         mtd;
  85         void __iomem            *io_base;
  86         struct lpc32XX_nand_cfg *ncfg;
  87         struct completion       comp;
  88         struct dma_config dmacfg;
  89         int dmach;
  90         uint32_t dma_xfer_status;
  91         uint32_t llptr;
  92         uint32_t dma_buf_len;
  93         /*
  94          * Physical addresses of ECC buffer,DMA data buffers,OOB data buffer
  95          */
  96         dma_addr_t oob_buf_phy;
  97         dma_addr_t ecc_calc_buf_phy;
  98         dma_addr_t dma_buf_phy;
  99         /*
 100          * Virtual addresses of ECC buffer,DMA data buffers,OOB data buffer
 101          */
 102         uint8_t *oob_buf;
 103         uint8_t *ecc_calc_buf;
 104         uint8_t * dma_buf;
 105         /* Physical address of DMA base address */
 106         dma_addr_t io_base_phy;
 107         uint8_t *erase_buf_data;
 108 };
 109
 110 #ifdef CONFIG_MTD_PARTITIONS
 111 const char *part_probes[] = { "cmdlinepart", NULL };
 112 #endif
 113
 114 static uint8_t nand_slc_bit_cnt16(uint16_t ch)
 115 {
 116         ch = (ch & 0x5555) + ((ch & ~0x5555) >> 1);
 117         ch = (ch & 0x3333) + ((ch & ~0x3333) >> 2);
 118         ch = (ch & 0x0F0F) + ((ch & ~0x0F0F) >> 4);
 119         return (ch + (ch >> 8)) & 0xFF;
 120 }
 121
 122 static uint8_t bit_cnt32(uint32_t val)
 123 {
 124         return nand_slc_bit_cnt16(val & 0xFFFF) +
 125                 nand_slc_bit_cnt16(val >> 16);
 126 }
 127
 128 static void lpc32xx_nand_setup(struct lpc32xx_nand_host *host)
 129 {
 130         u32 clkrate, tmp;
 131
 132         /* Reset SLC controller */
 133         __raw_writel(SLCCTRL_SW_RESET, SLC_CTRL(host->io_base));
 134         udelay(1000);
 135
 136         /* Basic setup */
 137         __raw_writel(0, SLC_CFG(host->io_base));
 138         __raw_writel(0, SLC_IEN(host->io_base));
 139         __raw_writel((SLCSTAT_INT_TC | SLCSTAT_INT_RDY_EN), SLC_ICR(host->io_base));
 140
 141         /* Get base clock for SLC block */
 142         clkrate = clk_get_rate(host->clk);
 143         if (clkrate == 0)
 144                 clkrate = 133000000;
 145
 146         /* Compute clock setup values */
 147         tmp = SLCTAC_WDR(host->ncfg->wdr_clks) |
 148                 SLCTAC_WWIDTH(1 + (clkrate / host->ncfg->wwidth)) |
 149                 SLCTAC_WHOLD(1 + (clkrate / host->ncfg->whold)) |
 150                 SLCTAC_WSETUP(1 + (clkrate / host->ncfg->wsetup)) |
 151                 SLCTAC_RDR(host->ncfg->rdr_clks) |
 152                 SLCTAC_RWIDTH(1 + (clkrate / host->ncfg->rwidth)) |
 153                 SLCTAC_RHOLD(1 + (clkrate / host->ncfg->rhold)) |
 154                 SLCTAC_RSETUP(1 + (clkrate / host->ncfg->rsetup));
 155         __raw_writel(tmp, SLC_TAC(host->io_base));
 156 }
 157
 158 /*
 159  * Hardware specific access to control lines
 160  */
 161 static void lpc32xx_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 162 {
 163         u32 tmp;
 164         struct nand_chip *nand_chip = mtd->priv;
 165         struct lpc32xx_nand_host *host = nand_chip->priv;
 166
 167         /* Does CE state need to be changed? */
 168         tmp = __raw_readl(SLC_CFG(host->io_base));
 169         if (ctrl & NAND_NCE)
 170                 tmp |= SLCCFG_CE_LOW;
 171         else
 172                 tmp &= ~SLCCFG_CE_LOW;
 173         __raw_writel(tmp, SLC_CFG(host->io_base));
 174
 175         if (cmd != NAND_CMD_NONE) {
 176                 if (ctrl & NAND_CLE)
 177                         __raw_writel(cmd, SLC_CMD(host->io_base));
 178                 else
 179                         __raw_writel(cmd, SLC_ADDR(host->io_base));
 180         }
 181 }
 182
 183 /*
 184  * Read the Device Ready pin.
 185  */
 186 static int lpc32xx_nand_device_ready(struct mtd_info *mtd)
 187 {
 188         struct nand_chip *nand_chip = mtd->priv;
 189         struct lpc32xx_nand_host *host = nand_chip->priv;
 190         int rdy = 0;
 191
 192         if ((__raw_readl(SLC_STAT(host->io_base)) & SLCSTAT_NAND_READY) != 0)
 193                 rdy = 1;
 194
 195         return rdy;
 196 }
 197
 198 /*
 199  * Enable NAND write protect
 200  */
 201 static void lpc32xx_wp_enable(struct lpc32xx_nand_host *host)
 202 {
 203         if (host->ncfg->enable_write_prot != NULL)
 204                 /* Disable write protection */
 205                 host->ncfg->enable_write_prot(1);
 206 }
 207
 208 /*
 209  * Disable NAND write protect
 210  */
 211 static void lpc32xx_wp_disable(struct lpc32xx_nand_host *host)
 212 {
 213         if (host->ncfg->enable_write_prot != NULL)
 214                 /* Enable write protection */
 215                 host->ncfg->enable_write_prot(0);
 216 }
 217
 218 static uint8_t lpc32xx_read_byte(struct mtd_info *mtd)
 219 {
 220         struct nand_chip *nand_chip = mtd->priv;
 221         struct lpc32xx_nand_host *host = nand_chip->priv;
 222
 223         return (uint8_t) __raw_readl(SLC_DATA(host->io_base));
 224 }
 225
 226 static void lpc32xx_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 227 {
 228         struct nand_chip *nand_chip = mtd->priv;
 229         struct lpc32xx_nand_host *host = nand_chip->priv;
 230         int i;
 231
 232         for (i = 0; i < len; i++)
 233                 buf[i] = (uint8_t) __raw_readl(SLC_DATA(host->io_base));
 234 }
 235
 236 static int lpc32xx_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 237 {
 238         struct nand_chip *nand_chip = mtd->priv;
 239         struct lpc32xx_nand_host *host = nand_chip->priv;
 240         int i;
 241
 242         for (i = 0; i < len; i++) {
 243                 if (buf[i] != (uint8_t) __raw_readl(SLC_DATA(host->io_base)))
 244                         return -EFAULT;
 245         }
 246
 247         return 0;
 248 }
 249
 250 static void lpc32xx_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 251 {
 252         struct nand_chip *nand_chip = mtd->priv;
 253         struct lpc32xx_nand_host *host = nand_chip->priv;
 254         int i;
 255
 256         for (i = 0; i < len; i++)
 257                 __raw_writel((u32) buf[i], SLC_DATA(host->io_base));
 258 }
 259
 260 /*
 261  * DMA ISR - occurs when DMA transfer complete.
 262  */
 263 static void lpc3xxx_nand_dma_irq(int channel, int cause,
 264                         struct lpc32xx_nand_host *host)
 265 {
 266         /* Flush DMA link list */
 267         lpc32xx_dma_flush_llist(host->dmach);
 268
 269         host->dma_xfer_status = (cause & DMA_TC_INT)? 0: 1;
 270         complete(&host->comp);
 271 }
 272
 273 /*
 274  * Get DMA channel and allocate DMA descriptors memory.
 275  * Prepare DMA descriptors link lists
 276  */
 277 static int lpc32xx_nand_dma_setup(struct lpc32xx_nand_host *host, int num_entries)
 278 {
 279         int ret = 0;
 280
 281         host->dmach = DMA_CH_SLCNAND;
 282         host->dmacfg.ch = DMA_CH_SLCNAND;
 283
 284         /*
 285          * All the DMA configuration parameters will
 286          * be overwritten in lpc32xx_nand_dma_configure().
 287          */
 288         host->dmacfg.tc_inten = 1;
 289         host->dmacfg.err_inten = 1;
 290         host->dmacfg.src_size = 4;
 291         host->dmacfg.src_inc = 1;
 292         host->dmacfg.src_ahb1 = 1;
 293         host->dmacfg.src_bsize = DMAC_CHAN_SRC_BURST_4;
 294         host->dmacfg.src_prph = 0;
 295         host->dmacfg.dst_size = 4;
 296         host->dmacfg.dst_inc = 0;
 297         host->dmacfg.dst_bsize = DMAC_CHAN_DEST_BURST_4;
 298         host->dmacfg.dst_ahb1 = 0;
 299         host->dmacfg.dst_prph = DMAC_DEST_PERIP(DMA_PERID_NAND1);
 300         host->dmacfg.flowctrl = DMAC_CHAN_FLOW_D_M2P;
 301         if (lpc32xx_dma_ch_get(&host->dmacfg, "dma_slcnand",
 302                                 &lpc3xxx_nand_dma_irq, host) < 0) {
 303                 printk(KERN_ERR "Error setting up SLC NAND DMA channel\n");
 304                 ret = -ENODEV;
 305                 goto dma_ch_err;
 306         }
 307
 308         /*
 309          * Allocate Linked list of total DMA Descriptors.
 310          * For Large Block: 17 descriptors = ((16 Data and ECC Read) + 1 Spare Area)
 311          * For Small Block: 5 descriptors = ((4 Data and ECC Read) + 1 Spare Area)
 312          */
 313         host->llptr = lpc32xx_dma_alloc_llist(host->dmach, num_entries);
 314         if (host->llptr == 0) {
 315                 lpc32xx_dma_ch_put(host->dmach);
 316                 host->dmach = -1;
 317                 printk(KERN_ERR "Error allocating list buffer for SLC NAND\n");
 318                 ret = -ENOMEM;
 319                 goto dma_alloc_err;
 320         }
 321
 322         return ret;
 323 dma_alloc_err:
 324         lpc32xx_dma_ch_put(host->dmach);
 325 dma_ch_err:
 326         return ret;
 327 }
 328
 329 /*
 330  * Configure DMA descriptors and start DMA x'fer
 331  */
 332 static void lpc32xx_nand_dma_configure(struct mtd_info *mtd,
 333                 dma_addr_t buffer, int size, int read)
 334 {
 335         struct nand_chip *chip = mtd->priv;
 336         struct lpc32xx_nand_host *host = chip->priv;
 337         uint32_t page_divider = (size == NAND_LARGE_BLOCK_PAGE_SIZE) ? 8: 2;
 338         uint32_t dmasrc, dmadst, ctrl, ecc_ctrl, oob_ctrl;
 339         int i;
 340         uint32_t *eccpos = chip->ecc.layout->eccpos;
 341
 342         /*
 343          * CTRL descriptor entry for reading ECC
 344          * Copy Multiple times to sync DMA with Flash Controller
 345          */
 346         ecc_ctrl =  (0x5 |
 347                         DMAC_CHAN_SRC_BURST_1 |
 348                         DMAC_CHAN_DEST_BURST_1 |
 349                         DMAC_CHAN_SRC_WIDTH_32 |
 350                         DMAC_CHAN_DEST_WIDTH_32 |
 351                         DMAC_CHAN_DEST_AHB1);
 352
 353         /* CTRL descriptor entry for reading/writing data */
 354         ctrl =     ((mtd->writesize / page_divider) / 4) |
 355                 DMAC_CHAN_SRC_BURST_4 |
 356                 DMAC_CHAN_DEST_BURST_4 |
 357                 DMAC_CHAN_SRC_WIDTH_32 |
 358                 DMAC_CHAN_DEST_WIDTH_32 |
 359                 DMAC_CHAN_DEST_AHB1;
 360
 361         /* CTRL descriptor entry for reading/writing Spare Area */
 362         oob_ctrl =  ((mtd->oobsize / 4) |
 363                         DMAC_CHAN_SRC_BURST_4 |
 364                         DMAC_CHAN_DEST_BURST_4 |
 365                         DMAC_CHAN_SRC_WIDTH_32 |
 366                         DMAC_CHAN_DEST_WIDTH_32 |
 367                         DMAC_CHAN_DEST_AHB1);
 368
 369         if (read) {
 370                 dmasrc = (uint32_t) SLC_DMA_DATA(host->io_base_phy);
 371                 dmadst = (uint32_t) (buffer);
 372                 ctrl |= DMAC_CHAN_DEST_AUTOINC;
 373         } else {
 374                 dmadst = (uint32_t) SLC_DMA_DATA(host->io_base_phy);
 375                 dmasrc = (uint32_t) (buffer);
 376                 ctrl |= DMAC_CHAN_SRC_AUTOINC;
 377         }
 378
 379         /*
 380          * Write Operation Sequence for Small Block NAND
 381          * ----------------------------------------------------------
 382          * 1. X'fer 256 bytes of data from Memory to Flash.
 383          * 2. Copy generated ECC data from Register to Spare Area
 384          * 3. X'fer next 256 bytes of data from Memory to Flash.
 385          * 4. Copy generated ECC data from Register to Spare Area.
 386          * 5. X'fer 16 byets of Spare area from Memory to Flash.
 387          *
 388          * Read Operation Sequence for Small Block NAND
 389          * ----------------------------------------------------------
 390          * 1. X'fer 256 bytes of data from Flash to Memory.
 391          * 2. Copy generated ECC data from Register to ECC calc Buffer.
 392          * 3. X'fer next 256 bytes of data from Flash to Memory.
 393          * 4. Copy generated ECC data from Register to ECC calc Buffer.
 394          * 5. X'fer 16 bytes of Spare area from Flash to Memory.
 395          *
 396          * Write Operation Sequence for Large Block NAND
 397          * ----------------------------------------------------------
 398          * 1. Steps(1-4) of Write Operations repeate for four times
 399          * which generates 16 DMA descriptors to X'fer 2048 byets of
 400          * data & 32 bytes of ECC data.
 401          * 2. X'fer 64 bytes of Spare area from Memory to Flash.
 402          *
 403          * Read Operation Sequence for Large Block NAND
 404          * ----------------------------------------------------------
 405          * 1. Steps(1-4) of Read Operations repeate for four times
 406          * which generates 16 DMA descriptors to X'fer 2048 byets of
 407          * data & 32 bytes of ECC data.
 408          * 2. X'fer 64 bytes of Spare area from Flash to Memory.
 409          */
 410         for (i = 0; i < size/256; i++) {
 411                 lpc32xx_dma_queue_llist(host->dmach,
 412                                 (void *)(read ?(dmasrc) :(dmasrc + (i*256))),
 413                                 (void *)(read ?(dmadst + (i*256)) :dmadst),
 414                                 -1, ctrl);
 415                 lpc32xx_dma_queue_llist(host->dmach,
 416                                 (void *)SLC_ECC(host->io_base_phy),
 417                                 (void *)(read ?((uint32_t) host->ecc_calc_buf_phy + (i*4)):
 418                                  ((uint32_t) host->oob_buf_phy + eccpos[i*4])),
 419                                 -1, ecc_ctrl);
 420         }
 421
 422         if (read) {
 423                 dmasrc = (uint32_t) (uint32_t) SLC_DMA_DATA(host->io_base_phy);
 424                 dmadst = (uint32_t) (host->oob_buf_phy);
 425                 oob_ctrl |= DMAC_CHAN_DEST_AUTOINC;
 426         } else {
 427                 dmadst = (uint32_t) (uint32_t) SLC_DMA_DATA(host->io_base_phy);
 428                 dmasrc = (uint32_t) (host->oob_buf_phy);
 429                 oob_ctrl |= DMAC_CHAN_SRC_AUTOINC;
 430         }
 431
 432         /* Read/ Write Spare Area Data To/From Flash */
 433         lpc32xx_dma_queue_llist(host->dmach, (void *)dmasrc, (void *)dmadst, -1,
 434                         oob_ctrl | DMAC_CHAN_INT_TC_EN);
 435 }
 436
 437 static void lpc32xx_nand_dma_xfer(struct mtd_info *mtd, u_char *buf, int len, int read)
 438 {
 439         struct nand_chip *this = mtd->priv;
 440         uint32_t config;
 441         struct lpc32xx_nand_host *host = this->priv;
 442         dma_addr_t buf_phy = (dma_addr_t) 0;
 443         int dma_mapped = 0;
 444
 445         /* Calculate the physical address of the Buffer */
 446         /* Check if memory not allocated by vmalloc */
 447         if (likely((void *) buf < high_memory)) {
 448                 buf_phy = dma_map_single(mtd->dev.parent,
 449                                 buf, len, read ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
 450                 if (unlikely(dma_mapping_error(mtd->dev.parent, buf_phy))) {
 451                         dev_err(mtd->dev.parent, "Unable to DMA map a buffer "
 452                                         "of size %d\r\n", len);
 453                         dma_mapped = 0;
 454                 }else {
 455                         dma_mapped = 1;
 456                 }
 457         }
 458
 459         if (!dma_mapped) {
 460                 memcpy(host->dma_buf, buf, len);
 461                 buf_phy = host->dma_buf_phy;
 462         }
 463
 464         config = DMAC_CHAN_ITC | DMAC_CHAN_IE |
 465                 (read ? DMAC_CHAN_FLOW_D_P2M : DMAC_CHAN_FLOW_D_M2P) |
 466                 (read ? DMAC_DEST_PERIP(0) : DMAC_DEST_PERIP(DMA_PERID_NAND1)) |
 467                 (read ? DMAC_SRC_PERIP(DMA_PERID_NAND1) : DMAC_SRC_PERIP(0)) |
 468                 DMAC_CHAN_ENABLE;
 469
 470         /* Prepare descriptors for read transfer */
 471         lpc32xx_nand_dma_configure(mtd, buf_phy, len, read);
 472
 473         /* This should start the DMA transfers */
 474         lpc32xx_dma_start_xfer(host->dmach, config);
 475         __raw_writel(__raw_readl(SLC_CTRL(host->io_base)) | SLCCTRL_DMA_START,
 476                         SLC_CTRL(host->io_base));
 477
 478         /* Wait for NAND to be ready */
 479         nand_wait_ready(mtd);
 480
 481         /* Wait till DMA transfer is DONE! */
 482         wait_for_completion(&host->comp);
 483         if (unlikely(host->dma_xfer_status != 0)) {
 484                 dev_err(mtd->dev.parent, "DMA transfer error!\r\n");
 485                 WARN_ON(1);
 486         }
 487
 488         if (dma_mapped)
 489                 dma_unmap_single(mtd->dev.parent, buf_phy, len,
 490                                 read ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
 491
 492         /* Stop DMA & HW ECC */
 493         __raw_writel(__raw_readl(SLC_CTRL(host->io_base)) & ~SLCCTRL_DMA_START,
 494                         SLC_CTRL(host->io_base));
 495         __raw_writel( __raw_readl(SLC_CFG(host->io_base)) &
 496                         ~(SLCCFG_DMA_BURST | SLCCFG_ECC_EN |
 497                           SLCCFG_DMA_ECC | SLCCFG_DMA_DIR),
 498                         SLC_CFG(host->io_base));
 499 }
 500
 501 static int lpc32xx_nand_correct_data(struct mtd_info *mtd, u_char *dat,
 502                 u_char *read_ecc, u_char *calc_ecc)
 503 {
 504         int ret = 0;
 505         uint32_t tmp, err;
 506         uint32_t *ecc_stored = (uint32_t*)read_ecc;
 507         uint32_t *ecc_gen = (uint32_t*)calc_ecc;
 508
 509
 510         err = *ecc_stored ^ *ecc_gen;
 511         /* Only perform ECC processing if an error is detected */
 512         if (err) {
 513                 /* ECC Failure in i-th block */
 514                 tmp = bit_cnt32(err);
 515                 if (tmp == 11) {
 516                         uint32_t byte = err >> 6;
 517                         uint32_t bit = 0;
 518                         bit = ((err & _BIT(1)) >> 1)|((err & _BIT(3)) >> 2)|
 519                                 ((err & _BIT(5)) >> 3);
 520
 521                         /* Calculate Byte offset */
 522                         byte = ((byte & _BIT(1)) >> 1)|((byte & _BIT(3)) >> 2)|
 523                                 ((byte & _BIT(5)) >> 3)|((byte & _BIT(7)) >> 4)|
 524                                 ((byte & _BIT(9)) >> 5)|((byte & _BIT(11)) >> 6)|
 525                                 ((byte & _BIT(13)) >> 7)|((byte & _BIT(15)) >> 8);
 526
 527                         /* Do the correction */
 528                         dat[byte] ^= _BIT(bit);
 529                         ret = 1;
 530                 }else {
 531                         /* Non-corrrectable */
 532                         ret = -1;
 533                 }
 534         }
 535         return ret;
 536 }
 537
 538 /* Prepares SLC for transfers with H/W ECC enabled */
 539 static void lpc32xx_ecc_enable(struct mtd_info *mtd, int mode)
 540 {
 541         struct nand_chip *this = mtd->priv;
 542         struct lpc32xx_nand_host *host = this->priv;
 543
 544         /* Clear ECC, start DMA */
 545         __raw_writel(SLCCTRL_ECC_CLEAR, SLC_CTRL(host->io_base));
 546
 547         if (mode == NAND_ECC_READ) {
 548                 __raw_writel( __raw_readl(SLC_CFG(host->io_base)) |
 549                         SLCCFG_DMA_DIR, SLC_CFG(host->io_base));
 550         }
 551         else  { /* NAND_ECC_WRITE */
 552                 __raw_writel( __raw_readl(SLC_CFG(host->io_base)) &
 553                         ~SLCCFG_DMA_DIR, SLC_CFG(host->io_base));
 554         }
 555
 556         __raw_writel( __raw_readl(SLC_CFG(host->io_base)) |
 557                         SLCCFG_DMA_BURST | SLCCFG_ECC_EN | SLCCFG_DMA_ECC,
 558                         SLC_CFG(host->io_base));
 559
 560         /* Set transfer count */
 561         __raw_writel(this->ecc.size + mtd->oobsize, SLC_TC(host->io_base));
 562 }
 563
 564 /* Function to calculate inverted ECC from the ECC got from H/W */
 565 static int lpc32xx_ecc_calculate(struct mtd_info *mtd, const uint8_t *dat,
 566                                  uint8_t *ecc_code)
 567 {
 568         return 0;
 569 }
 570
 571 static void lpc32xx_nand_write_page_hwecc(struct mtd_info *mtd,
 572                                 struct nand_chip *chip, const uint8_t *buf)
 573 {
 574         struct nand_chip *this = mtd->priv;
 575         struct lpc32xx_nand_host *host = this->priv;
 576         int eccsize = chip->ecc.size;
 577
 578         /*
 579          * Skip writting page which has all 0xFF data as this will
 580          * generate 0x0 value.
 581          */
 582         if(memcmp(buf, host->erase_buf_data, mtd->writesize) == 0)
 583                 return;
 584
 585         /* Enable H/W ECC & DMA */
 586         chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
 587
 588         /* Copy OOB data from kernel buffer to DMA memory */
 589         memcpy(host->oob_buf, chip->oob_poi,mtd->oobsize);
 590
 591         /* Configure DMA Desriptor for NAND Write Operation */
 592         lpc32xx_nand_dma_xfer(mtd, (uint8_t *)buf, eccsize, 0);
 593 }
 594
 595 static int lpc32xx_nand_read_page_hwecc(struct mtd_info *mtd,
 596                                  struct nand_chip *chip, uint8_t *buf, int page)
 597 {
 598         struct nand_chip *this = mtd->priv;
 599         struct lpc32xx_nand_host *host = this->priv;
 600         int i, eccsize = chip->ecc.size;
 601         int eccsteps = (mtd->writesize/NAND_ECC_SUBPAGE_LEN);
 602         uint8_t *p = buf;
 603         uint8_t *ecc_calc = chip->buffers->ecccalc;
 604         uint8_t *ecc_code = chip->buffers->ecccode;
 605         uint32_t *eccpos = chip->ecc.layout->eccpos;
 606
 607         memset(host->ecc_calc_buf, 0x0, this->ecc.bytes);
 608
 609         /* Enable HW ECC & DMA */
 610         chip->ecc.hwctl(mtd, NAND_ECC_READ);
 611
 612         /* Configure DMA Desriptor for NAND Read Operation */
 613         lpc32xx_nand_dma_xfer(mtd, buf, eccsize, 1);
 614
 615         /* Copy OOB data from DMA memory to kernel buffer */
 616         memcpy(chip->oob_poi, host->oob_buf, mtd->oobsize);
 617
 618         /* Copy only ECC data which are stored into Flash */
 619         for (i = 0; i < chip->ecc.total; i++) {
 620                 ecc_code[i] = chip->oob_poi[eccpos[i]];
 621                 ecc_calc[i] = host->ecc_calc_buf[i];
 622         }
 623
 624         /*
 625          * LPC3250 has 4 bytes of ECC data per 256 bytes of data block
 626          * As eccsteps are calucated based on subpage size.
 627          */
 628         for (i = 0; eccsteps; eccsteps--, i += NAND_ECC_LEN_PER_SUBPAGE,
 629                          p += NAND_ECC_SUBPAGE_LEN) {
 630                 int stat;
 631
 632                 /*
 633                  * Once block is erased, all the data including OOB data are 0xFF.
 634                  * ECC generator always generate zero value ECC for such page while,
 635                  * stored value is 0xFFFFFFFF.
 636                  */
 637                 if(*((uint32_t *)&ecc_code[i]) == NAND_ERASED_BLOCK_ECC_VALUE)
 638                         continue;
 639
 640                 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
 641                 if (stat == -1)
 642                         mtd->ecc_stats.failed++;
 643                 else
 644                         mtd->ecc_stats.corrected += stat;
 645         }
 646         return 0;
 647 }
 648
 649 /*
 650  * Probe for NAND controller
 651  */
 652 static int __init lpc32xx_nand_probe(struct platform_device *pdev)
 653 {
 654         struct lpc32xx_nand_host *host;
 655         struct mtd_info *mtd;
 656         struct nand_chip *nand_chip;
 657         struct resource *rc;
 658         int res;
 659
 660 #ifdef CONFIG_MTD_PARTITIONS
 661         struct mtd_partition *partitions = NULL;
 662         int num_partitions = 0;
 663 #endif
 664
 665         /* Allocate memory for the device structure (and zero it) */
 666         host = kzalloc(sizeof(struct lpc32xx_nand_host), GFP_KERNEL);
 667         if (!host) {
 668                  dev_err(&pdev->dev,"lpc32xx_nand: failed to allocate device structure.\n");
 669                 return -ENOMEM;
 670         }
 671
 672         rc = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 673         if (rc == NULL) {
 674                 dev_err(&pdev->dev,"No memory resource found for device!\r\n");
 675                 res = -ENXIO;
 676                 goto err_exit1;
 677         }
 678
 679         host->io_base = ioremap(rc->start, rc->end - rc->start + 1);
 680         if (host->io_base == NULL) {
 681                  dev_err(&pdev->dev,"lpc32xx_nand: ioremap failed\n");
 682                 res = -EIO;
 683                 goto err_exit1;
 684         }
 685
 686         mtd = &host->mtd;
 687         nand_chip = &host->nand_chip;
 688         host->ncfg = pdev->dev.platform_data;
 689
 690         nand_chip->priv = host;         /* link the private data structures */
 691         mtd->priv = nand_chip;
 692         mtd->owner = THIS_MODULE;
 693         mtd->dev.parent = &pdev->dev;
 694
 695         /* Get NAND clock */
 696         host->clk = clk_get(&pdev->dev, "nand_ck");
 697         if (IS_ERR(host->clk)) {
 698                  dev_err(&pdev->dev,"lpc32xx_nand: Clock failure\n");
 699                 res = -ENOENT;
 700                 goto err_exit2;
 701         }
 702         clk_enable(host->clk);
 703
 704         /* Set address of NAND IO lines */
 705         nand_chip->IO_ADDR_R = SLC_DATA(host->io_base);
 706         nand_chip->IO_ADDR_W = SLC_DATA(host->io_base);
 707         nand_chip->cmd_ctrl = lpc32xx_nand_cmd_ctrl;
 708         nand_chip->dev_ready = lpc32xx_nand_device_ready;
 709         nand_chip->chip_delay = 20;             /* 20us command delay time */
 710         nand_chip->read_byte = lpc32xx_read_byte;
 711         nand_chip->read_buf = lpc32xx_read_buf;
 712         nand_chip->verify_buf = lpc32xx_verify_buf;
 713         nand_chip->write_buf = lpc32xx_write_buf;
 714
 715         /* Init NAND controller */
 716         lpc32xx_nand_setup(host);
 717         lpc32xx_wp_disable(host);
 718
 719         platform_set_drvdata(pdev, host);
 720
 721         /*
 722          * Scan to find existance of the device and
 723          * Get the type of NAND device SMALL block or LARGE block
 724          */
 725         if (nand_scan_ident(mtd, 1)) {
 726                 res = -ENXIO;
 727                 goto err_exit3;
 728         }
 729
 730         nand_chip->ecc.mode = NAND_ECC_HW;
 731         nand_chip->ecc.size = mtd->writesize;
 732         nand_chip->ecc.bytes = (mtd->writesize / 256) * 4;
 733         nand_chip->ecc.read_page_raw = lpc32xx_nand_read_page_hwecc;
 734         nand_chip->ecc.read_page = lpc32xx_nand_read_page_hwecc;
 735         nand_chip->ecc.write_page = lpc32xx_nand_write_page_hwecc;
 736
 737         switch (mtd->oobsize) {
 738                 case 16:
 739                         nand_chip->ecc.layout = &lpc32xx_nand_oob_16;
 740                         break;
 741                 case 64:
 742                         nand_chip->ecc.layout = &lpc32xx_nand_oob_64;
 743                         break;
 744                 default:
 745                          dev_err(&pdev->dev, "No oob scheme defined for "
 746                                         "oobsize %d\n", mtd->oobsize);
 747                         BUG();
 748         }
 749
 750         /* H/W ECC specific functions */
 751         nand_chip->ecc.hwctl = lpc32xx_ecc_enable;
 752         nand_chip->ecc.correct = lpc32xx_nand_correct_data;
 753         nand_chip->ecc.calculate = lpc32xx_ecc_calculate;
 754
 755         /*
 756          * Fills out all the uninitialized function pointers with the defaults
 757          * And scans for a bad block table if appropriate.
 758          */
 759         if (nand_scan_tail(mtd)) {
 760                 res = -ENXIO;
 761                 goto err_exit3;
 762         }
 763
 764         /* Get free DMA channel and alloc DMA descriptor link list */
 765         res = lpc32xx_nand_dma_setup(host,((mtd->writesize/128) + 1));
 766         if(res) {
 767                 res = -EIO;
 768                 goto err_exit3;
 769         }
 770
 771         /* allocate DMA buffer */
 772         host->dma_buf_len =
 773                 (/* OOB size area for storing OOB data including ECC */
 774                  mtd->oobsize +
 775                  /* Page Size area for storing Page RAW data */
 776                  mtd->writesize +
 777                  /* ECC bytes area for storing Calculated ECC at the time reading page */
 778                  nand_chip->ecc.bytes);
 779
 780         host->oob_buf = dmam_alloc_coherent(&pdev->dev, host->dma_buf_len,
 781                         &host->oob_buf_phy, GFP_KERNEL);
 782         if (host->oob_buf == NULL) {
 783                 dev_err(&pdev->dev, "Unable to allocate DMA memory!\r\n");
 784                 res = -ENOMEM;
 785                 goto err_exit4;
 786         }
 787
 788         host->dma_buf = (uint8_t *)host->oob_buf + mtd->oobsize;
 789         host->ecc_calc_buf = (uint8_t *)host->dma_buf + mtd->writesize;
 790
 791         host->dma_buf_phy = host->oob_buf_phy + mtd->oobsize;
 792         host->ecc_calc_buf_phy = host->dma_buf_phy + mtd->writesize;
 793
 794         host->io_base_phy = platform_get_resource(pdev, IORESOURCE_MEM, 0)->start;
 795
 796         /*
 797          * Allocate a page size buffer to check all 0xFF data
 798          * at the time page writting.
 799          */
 800         host->erase_buf_data = kmalloc(mtd->writesize, GFP_KERNEL);
 801         if (!host->erase_buf_data) {
 802                  dev_err(&pdev->dev,"lpc32xx_nand: failed to allocate device structure.\n");
 803                 return -ENOMEM;
 804                 goto err_exit5;
 805         }
 806         memset(host->erase_buf_data, 0xFF, mtd->writesize);
 807         init_completion(&host->comp);
 808
 809 #ifdef CONFIG_MTD_PARTITIONS
 810 #ifdef CONFIG_MTD_CMDLINE_PARTS
 811         mtd->name = "lpc32xx_nand";
 812         num_partitions = parse_mtd_partitions(mtd, part_probes,
 813                                               &partitions, 0);
 814 #endif
 815         if ((num_partitions <= 0) && (host->ncfg->partition_info)) {
 816                 partitions = host->ncfg->partition_info(mtd->size,
 817                                                          &num_partitions);
 818         }
 819
 820         if ((!partitions) || (num_partitions == 0)) {
 821                  dev_err(&pdev->dev,"lpc32xx_nand: No parititions defined, or unsupported device.\n");
 822                 res = ENXIO;
 823                 goto err_exit6;
 824         }
 825
 826         res = add_mtd_partitions(mtd, partitions, num_partitions);
 827 #else
 828         res = add_mtd_device(mtd);
 829 #endif
 830         if (!res)
 831                 return res;
 832
 833         nand_release(mtd);
 834 err_exit6:
 835         kfree(host->erase_buf_data);
 836 err_exit5:
 837         dma_free_coherent(&pdev->dev, host->dma_buf_len,
 838                                 host->oob_buf, host->oob_buf_phy);
 839 err_exit4:
 840         /* Free the DMA channel used by us */
 841         lpc32xx_dma_ch_disable(host->dmach);
 842         lpc32xx_dma_dealloc_llist(host->dmach);
 843         lpc32xx_dma_ch_put(host->dmach);
 844         host->dmach = -1;
 845 err_exit3:
 846         clk_disable(host->clk);
 847         clk_put(host->clk);
 848         platform_set_drvdata(pdev, NULL);
 849 err_exit2:
 850         lpc32xx_wp_enable(host);
 851         iounmap(host->io_base);
 852 err_exit1:
 853         kfree(host);
 854
 855         return res;
 856 }
 857
 858 /*
 859  * Remove NAND device.
 860  */
 861 static int __devexit lpc32xx_nand_remove(struct platform_device *pdev)
 862 {
 863         u32 tmp;
 864         struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
 865         struct mtd_info *mtd = &host->mtd;
 866
 867         /* Free the DMA channel used by us */
 868         lpc32xx_dma_ch_disable(host->dmach);
 869         lpc32xx_dma_dealloc_llist(host->dmach);
 870         lpc32xx_dma_ch_put(host->dmach);
 871         host->dmach = -1;
 872
 873         dma_free_coherent(&pdev->dev, host->dma_buf_len,
 874                                 host->oob_buf, host->oob_buf_phy);
 875         nand_release(mtd);
 876
 877         /* Force CE high */
 878         tmp = __raw_readl(SLC_CTRL(host->io_base));
 879         tmp &= ~SLCCFG_CE_LOW;
 880         __raw_writel(tmp, SLC_CTRL(host->io_base));
 881
 882         lpc32xx_wp_enable(host);
 883         clk_disable(host->clk);
 884         clk_put(host->clk);
 885
 886         iounmap(host->io_base);
 887
 888         kfree(host->erase_buf_data);
 889         kfree(host);
 890
 891         return 0;
 892 }
 893
 894 #if defined (CONFIG_PM)
 895 static int lpc32xx_nand_resume(struct platform_device *pdev)
 896 {
 897         struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
 898
 899         /* Re-enable NAND clock */
 900         clk_enable(host->clk);
 901
 902         /* Fresh init of NAND controller */
 903         lpc32xx_nand_setup(host);
 904
 905         /* Disable write protect */
 906         lpc32xx_wp_disable(host);
 907
 908         return 0;
 909 }
 910
 911 static int lpc32xx_nand_suspend(struct platform_device *pdev, pm_message_t pm)
 912 {
 913         u32 tmp;
 914         struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
 915
 916         /* Force CE high */
 917         tmp = __raw_readl(SLC_CTRL(host->io_base));
 918         tmp &= ~SLCCFG_CE_LOW;
 919         __raw_writel(tmp, SLC_CTRL(host->io_base));
 920
 921         /* Enable write protect for safety */
 922         lpc32xx_wp_enable(host);
 923
 924         /* Disable clock */
 925         clk_disable(host->clk);
 926
 927         return 0;
 928 }
 929
 930 #else
 931 #define lpc32xx_nand_resume NULL
 932 #define lpc32xx_nand_suspend NULL
 933 #endif
 934
 935 static struct platform_driver lpc32xx_nand_driver = {
 936         .probe          = lpc32xx_nand_probe,
 937         .remove         = __devexit_p(lpc32xx_nand_remove),
 938         .resume         = lpc32xx_nand_resume,
 939         .suspend        = lpc32xx_nand_suspend,
 940         .driver         = {
 941                 .name   = "lpc32xx-nand",
 942                 .owner  = THIS_MODULE,
 943         },
 944 };
 945
 946 static int __init lpc32xx_nand_init(void)
 947 {
 948         return platform_driver_register(&lpc32xx_nand_driver);
 949 }
 950
 951 static void __exit lpc32xx_nand_exit(void)
 952 {
 953         platform_driver_unregister(&lpc32xx_nand_driver);
 954 }
 955
 956 module_init(lpc32xx_nand_init);
 957 module_exit(lpc32xx_nand_exit);
 958
 959 MODULE_LICENSE("GPL");
 960 MODULE_AUTHOR("Kevin Wells(kevin.wells@nxp.com)");
 961 MODULE_DESCRIPTION("NAND driver for the NXP LPC32XX SLC controller");
 962