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