mtd: lpc32xx_nand: NAND driver changes
[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) 2011 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
29 #include <linux/io.h>
30 #include <linux/mm.h>
31 #include <linux/dma-mapping.h>
32 #include <linux/mtd/nand_ecc.h>
33
34 #include <mach/hardware.h>
35 #include <mach/board.h>
36 #include <mach/slcnand.h>
37 #include <mach/dmac.h>
38 #include <mach/dma.h>
39
40 #define LPC32XX_MODNAME                 "lpc32xx-nand"
41
42 /*
43  * DMA requires storage space for the DMA local buffer and the hardware ECC
44  * storage area. The DMA local buffer is only used if DMA mapping fails
45  * during runtime.
46  */
47 #define LPC32XX_DMA_DATA_SIZE           4096
48 #define LPC32XX_ECC_SAVE_SIZE           ((4096 / 256) * 4)
49
50 /* Number of bytes used for ECC stored in NAND per 256 bytes */
51 #define LPC32XX_SLC_DEV_ECC_BYTES       3
52
53 /*
54  * 2 DMA descriptors are needed for every 256 byte data transfer, 1 descriptor
55  * is for the data, and the other is for the saved ECC data. These are not
56  * needed for OOB data.
57  */
58 #define LPC32XX_MAX_DMA_DESCRIPTORS     (((4096 / 256) * 2) + 1)
59
60 /*
61  * If the NAND base clock frequency can't be fetched, this frequency will be
62  * used instead as the base. This rate is used to setup the timing registers
63  * used for NAND accesses.
64  */
65 #define LPC32XX_DEF_BUS_RATE            133250000
66
67 /* DMA transfer completion failure timeout */
68 #define LPC32XX_DMA_WAIT_TIMEOUT_MS     20
69
70 /*
71  * This timeout is used for verifying the NAND buffer has commited it's
72  * FIFO to memory or FLASH, or verifying the DMA transfer has completed.
73  * The timeout is used as a count for simple polled checks of the hardware.
74  * For most hardware, the actual timeouts are much lower than this, but
75  * very slow hardware may use most of this time.
76  */
77 #define LPC32XX_DMA_SIMPLE_TIMEOUT      10000
78
79 /*
80  * This is the number of reads of the ECC register after a DMA write to
81  * the NAND device. On writes, the DMA data is buffered in the NAND controller
82  * prior to ECC calculation, so the DMA transfer 'completes' prior to the
83  * NAND controller completing the transfer and ECC calculation for the write
84  * data. Because of this, the initial reads of the ECC register by the DMA
85  * controller may be incorrect as the data is still in transfer, so multiple
86  * reads are needed. With very slow NAND devices, this count may need to be
87  * increased. This doesn't apply to read operations.
88  */
89 #define LPC32XX_DMA_ECC_REP_READ        10
90
91 /*
92  * NAND ECC Layout for small page NAND devices
93  * Note: For large and huge page devices, the default layouts are used
94  */
95 static struct nand_ecclayout lpc32xx_nand_oob_16 = {
96         .eccbytes = 6,
97         .eccpos = {10, 11, 12, 13, 14, 15},
98         .oobfree = {
99                 {.offset = 0,
100                  . length = 4},
101                 {.offset = 6,
102                  . length = 4}}
103 };
104
105 static uint8_t bbt_pattern[] = {'B', 'b', 't', '0' };
106 static uint8_t mirror_pattern[] = {'1', 't', 'b', 'B' };
107
108 /*
109  * Small page FLASH BBT descriptors, marker at offset 0, version at offset 6
110  * Note: Large page devices used the default layout
111  */
112 static struct nand_bbt_descr bbt_smallpage_main_descr = {
113         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
114                 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
115         .offs = 0,
116         .len = 4,
117         .veroffs = 6,
118         .maxblocks = 4,
119         .pattern = bbt_pattern
120 };
121
122 static struct nand_bbt_descr bbt_smallpage_mirror_descr = {
123         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
124                 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
125         .offs = 0,
126         .len = 4,
127         .veroffs = 6,
128         .maxblocks = 4,
129         .pattern = mirror_pattern
130 };
131
132 struct lpc32xx_nand_host {
133         struct nand_chip        nand_chip;
134         struct clk              *clk;
135         struct mtd_info         mtd;
136         void __iomem            *io_base;
137         struct lpc32XX_nand_cfg *ncfg;
138
139         wait_queue_head_t       dma_waitq;
140         volatile u32            dmapending;
141         struct dma_config       dmacfg;
142         int                     dmach;
143         volatile uint32_t       dma_xfer_status;
144         uint32_t                llptr;
145         uint32_t                dma_buf_len;
146         /*
147          * DMA and CPU addresses of ECC work area and data buffer
148          */
149         dma_addr_t              ecc_buf_dma;
150         uint32_t                *ecc_buf;
151         dma_addr_t              data_buf_dma;
152         uint8_t                 *data_buf;
153         dma_addr_t              io_base_dma;
154 };
155
156 static void lpc32xx_nand_setup(struct lpc32xx_nand_host *host)
157 {
158         u32 clkrate, tmp;
159
160         /* Reset SLC controller */
161         __raw_writel(SLCCTRL_SW_RESET, SLC_CTRL(host->io_base));
162         udelay(1000);
163
164         /* Basic setup */
165         __raw_writel(0, SLC_CFG(host->io_base));
166         __raw_writel(0, SLC_IEN(host->io_base));
167         __raw_writel((SLCSTAT_INT_TC | SLCSTAT_INT_RDY_EN),
168                 SLC_ICR(host->io_base));
169
170         /* Get base clock for SLC block */
171         clkrate = clk_get_rate(host->clk);
172         if (clkrate == 0)
173                 clkrate = LPC32XX_DEF_BUS_RATE;
174
175         /* Compute clock setup values */
176         tmp = SLCTAC_WDR(host->ncfg->wdr_clks) |
177                 SLCTAC_WWIDTH(1 + (clkrate / host->ncfg->wwidth)) |
178                 SLCTAC_WHOLD(1 + (clkrate / host->ncfg->whold)) |
179                 SLCTAC_WSETUP(1 + (clkrate / host->ncfg->wsetup)) |
180                 SLCTAC_RDR(host->ncfg->rdr_clks) |
181                 SLCTAC_RWIDTH(1 + (clkrate / host->ncfg->rwidth)) |
182                 SLCTAC_RHOLD(1 + (clkrate / host->ncfg->rhold)) |
183                 SLCTAC_RSETUP(1 + (clkrate / host->ncfg->rsetup));
184         __raw_writel(tmp, SLC_TAC(host->io_base));
185 }
186
187 /*
188  * Hardware specific access to control lines
189  */
190 static void lpc32xx_nand_cmd_ctrl(struct mtd_info *mtd, int cmd,
191         unsigned int ctrl)
192 {
193         u32 tmp;
194         struct nand_chip *chip = mtd->priv;
195         struct lpc32xx_nand_host *host = chip->priv;
196
197         /* Does CE state need to be changed? */
198         tmp = __raw_readl(SLC_CFG(host->io_base));
199         if (ctrl & NAND_NCE)
200                 tmp |= SLCCFG_CE_LOW;
201         else
202                 tmp &= ~SLCCFG_CE_LOW;
203         __raw_writel(tmp, SLC_CFG(host->io_base));
204
205         if (cmd != NAND_CMD_NONE) {
206                 if (ctrl & NAND_CLE)
207                         __raw_writel(cmd, SLC_CMD(host->io_base));
208                 else
209                         __raw_writel(cmd, SLC_ADDR(host->io_base));
210         }
211 }
212
213 /*
214  * Read the Device Ready pin
215  */
216 static int lpc32xx_nand_device_ready(struct mtd_info *mtd)
217 {
218         struct nand_chip *chip = mtd->priv;
219         struct lpc32xx_nand_host *host = chip->priv;
220         int rdy = 0;
221
222         if ((__raw_readl(SLC_STAT(host->io_base)) & SLCSTAT_NAND_READY) != 0)
223                 rdy = 1;
224
225         return rdy;
226 }
227
228 /*
229  * Enable NAND write protect
230  */
231 static void lpc32xx_wp_enable(struct lpc32xx_nand_host *host)
232 {
233         if (host->ncfg->enable_write_prot != NULL)
234                 /* Disable write protection */
235                 host->ncfg->enable_write_prot(1);
236 }
237
238 /*
239  * Disable NAND write protect
240  */
241 static void lpc32xx_wp_disable(struct lpc32xx_nand_host *host)
242 {
243         if (host->ncfg->enable_write_prot != NULL)
244                 /* Enable write protection */
245                 host->ncfg->enable_write_prot(0);
246 }
247
248 /* 
249  * Prepares SLC for transfers with H/W ECC enabled
250  */
251 static void lpc32xx_nand_ecc_enable(struct mtd_info *mtd, int mode)
252 {
253         (void)mtd;
254         (void)mode;
255
256         /* Hardware ECC is enabled automatically in hardware as needed */
257 }
258
259 /*
260  * Calculates the ECC for the data
261  */
262 static int lpc32xx_nand_ecc_calculate(struct mtd_info *mtd,
263         const unsigned char *buf, unsigned char *code)
264 {
265         (void) mtd;
266         (void) buf;
267         (void) code;
268
269         /*
270          * ECC is calculated automatically in hardware during syndrome read
271          * and write operations, so it doesn't need to be calculated here.
272          */
273
274         return 0;
275 }
276
277 /*
278  * Read a single byte from NAND device
279  */
280 static uint8_t lpc32xx_nand_read_byte(struct mtd_info *mtd)
281 {
282         struct nand_chip *chip = mtd->priv;
283         struct lpc32xx_nand_host *host = chip->priv;
284
285         return (uint8_t) __raw_readl(SLC_DATA(host->io_base));
286 }
287
288 /*
289  * Simple device read without ECC
290  */
291 static void lpc32xx_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
292 {
293         struct nand_chip *chip = mtd->priv;
294         struct lpc32xx_nand_host *host = chip->priv;
295
296         /* Direct device read with no ECC */
297         while (len-- > 0)
298                 *buf++ = (uint8_t) __raw_readl(SLC_DATA(host->io_base));
299 }
300
301 /*
302  * Simple device write without ECC
303  */
304 static void lpc32xx_nand_write_buf(struct mtd_info *mtd, const uint8_t *buf,
305         int len)
306 {
307         struct nand_chip *chip = mtd->priv;
308         struct lpc32xx_nand_host *host = chip->priv;
309
310         /* Direct device write with no ECC */
311         while (len-- > 0)
312                 __raw_writel((u32) *buf++, SLC_DATA(host->io_base));
313 }
314
315 /*
316  * Verify data in buffer to data on device
317  */
318 static int lpc32xx_verify_buf(struct mtd_info *mtd, const uint8_t *buf, 
319         int len)
320 {
321         struct nand_chip *chip = mtd->priv;
322         struct lpc32xx_nand_host *host = chip->priv;
323         int i;
324
325         /* DATA register must be read as 32 bits or it will fail */
326         for (i = 0; i < len; i++) {
327                 if (buf[i] != (uint8_t) __raw_readl(SLC_DATA(host->io_base)))
328                         return -EFAULT;
329         }
330
331         return 0;
332 }
333
334 /*
335  * Read the OOB data from the device without ECC using FIFO method
336  */
337 static int lpc32xx_nand_read_oob_syndrome(struct mtd_info *mtd,
338         struct nand_chip *chip, int page, int sndcmd)
339 {
340         (void)page;
341
342         if (sndcmd) {
343                 chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
344                 sndcmd = 0;
345         }
346         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
347
348         return sndcmd;
349 }
350
351 /*
352  * Write the OOB data to the device without ECC using FIFO method
353  */
354 static int lpc32xx_nand_write_oob_syndrome(struct mtd_info *mtd,
355         struct nand_chip *chip, int page)
356 {
357         int status;
358
359         chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page);
360         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
361
362         /* Send command to program the OOB data */
363         chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
364
365         status = chip->waitfunc(mtd, chip);
366
367         return status & NAND_STATUS_FAIL ? -EIO : 0;
368 }
369
370 /*
371  * Fills in the ECC fields in the OOB buffer with the hardware generated ECC
372  */
373 static void lpc32xx_slc_ecc_copy(uint8_t *spare, const uint32_t *ecc, 
374         int count)
375 {
376         int i;
377
378         for (i = 0; i < (count * 3); i += 3) {
379                 uint32_t ce = ecc[i / 3];
380                 ce = ~(ce << 2) & 0xFFFFFF;
381                 spare[i + 2] = (uint8_t)(ce & 0xFF);
382                 ce >>= 8;
383                 spare[i + 1] = (uint8_t)(ce & 0xFF);
384                 ce >>= 8;
385                 spare[i] = (uint8_t)(ce & 0xFF);
386         }
387 }
388
389 /*
390  * Configure DMA descriptors and enable DMA channel for data and ECC reads
391  */
392 static void lpc32xx_nand_dma_configure(struct mtd_info *mtd,
393         dma_addr_t databuf, int eccsubpages, int read)
394 {
395         struct nand_chip *chip = mtd->priv;
396         struct lpc32xx_nand_host *host = chip->priv;
397         uint32_t ecc_ctrl, *ecc_buf;
398         uint32_t dataaddr, data_ctrl;
399         int i;
400
401         /* DMA buffer pointer for calculated ECC values */
402         ecc_buf = (uint32_t *)host->ecc_buf_dma;
403
404         /*
405          * ctrl descriptor entry for reading ECC
406          */
407         ecc_ctrl = DMAC_CHAN_SRC_BURST_1 |
408                 DMAC_CHAN_DEST_BURST_1 |
409                 DMAC_CHAN_SRC_WIDTH_32 |
410                 DMAC_CHAN_DEST_WIDTH_32 |
411                 DMAC_CHAN_DEST_AHB1;
412
413         /* data descriptor entry for reading/writing data */
414         data_ctrl = ((mtd->writesize / eccsubpages) / 4) |
415                 DMAC_CHAN_SRC_BURST_4 |
416                 DMAC_CHAN_DEST_BURST_4 |
417                 DMAC_CHAN_SRC_WIDTH_32 |
418                 DMAC_CHAN_DEST_WIDTH_32 |
419                 DMAC_CHAN_DEST_AHB1;
420
421         if (read) {
422                 data_ctrl |= DMAC_CHAN_DEST_AUTOINC;
423                 ecc_ctrl |= DMAC_CHAN_TRANSFER_SIZE(1);
424         } else {
425                 data_ctrl |= DMAC_CHAN_SRC_AUTOINC;
426                 ecc_ctrl |= DMAC_CHAN_TRANSFER_SIZE(LPC32XX_DMA_ECC_REP_READ);
427         }
428
429         /*
430          * Only transfer the data areas plus ECC from hardware. The last ECC
431          * from hardware and OOB area will be transferred later.
432          */
433         dataaddr = (uint32_t)databuf;
434
435         for (i = 0; i < eccsubpages; i++) {
436                 if ((i == (eccsubpages - 1)) &&
437                         (!host->ncfg->polled_completion))
438                         data_ctrl |= DMAC_CHAN_INT_TC_EN;
439
440                 if (read)
441                         lpc32xx_dma_queue_llist(host->dmach,
442                                 (void *)SLC_DMA_DATA(host->io_base_dma),
443                                 (void *)dataaddr, -1, data_ctrl);
444                 else
445                         lpc32xx_dma_queue_llist(host->dmach, (void *)dataaddr,
446                                 (void *)SLC_DMA_DATA(host->io_base_dma), -1,
447                                 data_ctrl);
448
449                 dataaddr += (uint32_t)chip->ecc.size;;
450
451                 if (i != (eccsubpages - 1)) {
452                         lpc32xx_dma_queue_llist(host->dmach,
453                                 (void *)SLC_ECC(host->io_base_dma),
454                                 (void *)ecc_buf, -1, ecc_ctrl);
455                         ecc_buf++;;
456                 }
457         }
458 }
459
460 /*
461  * DMA read/write transfers with ECC support
462  */
463 static int lpc32xx_dma_xfer(struct mtd_info *mtd, uint8_t *buf,
464         int eccsubpages, int read)
465 {
466         struct nand_chip *chip = mtd->priv;
467         struct lpc32xx_nand_host *host = chip->priv;
468         uint32_t config, tmpreg;
469         dma_addr_t buf_phy;
470         int i, timeout, dma_mapped = 0, status = 0;
471
472         /* Map DMA buffer */
473         if (likely((void *) buf < high_memory)) {
474                 buf_phy = dma_map_single(mtd->dev.parent, buf, mtd->writesize,
475                         read ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
476                 if (unlikely(dma_mapping_error(mtd->dev.parent, buf_phy))) {
477                         dev_err(mtd->dev.parent,
478                                 "Unable to map DMA buffer\n");
479                         dma_mapped = 0;
480                 } else
481                         dma_mapped = 1;
482         }
483
484         /* If a buffer can't be mapped, use the local buffer */
485         if (!dma_mapped) {
486                 buf_phy = host->data_buf_dma;
487                 if (!read)
488                         memcpy(host->data_buf, buf, mtd->writesize);
489         }
490
491         if (read)
492                 config = DMAC_CHAN_ITC | DMAC_CHAN_IE | DMAC_CHAN_FLOW_D_P2M |
493                         DMAC_DEST_PERIP (0) |
494                         DMAC_SRC_PERIP(DMA_PERID_NAND1) | DMAC_CHAN_ENABLE;
495         else
496                 config = DMAC_CHAN_ITC | DMAC_CHAN_IE | DMAC_CHAN_FLOW_D_M2P |
497                         DMAC_DEST_PERIP(DMA_PERID_NAND1) |
498                         DMAC_SRC_PERIP (0) | DMAC_CHAN_ENABLE;
499
500         /* DMA mode with ECC enabled */
501         tmpreg = __raw_readl(SLC_CFG(host->io_base));
502         __raw_writel(SLCCFG_ECC_EN | SLCCFG_DMA_ECC | tmpreg,
503                 SLC_CFG(host->io_base));
504
505         /* Clear initial ECC */
506         __raw_writel(SLCCTRL_ECC_CLEAR, SLC_CTRL(host->io_base));
507
508         /* Prepare DMA descriptors */
509         lpc32xx_nand_dma_configure(mtd, buf_phy, chip->ecc.steps, read);
510
511         /* Setup DMA direction and burst mode */
512         if (read)
513                 __raw_writel(__raw_readl(SLC_CFG(host->io_base)) |
514                         SLCCFG_DMA_DIR, SLC_CFG(host->io_base));
515         else
516                 __raw_writel(__raw_readl(SLC_CFG(host->io_base)) &
517                         ~SLCCFG_DMA_DIR, SLC_CFG(host->io_base));
518         __raw_writel(__raw_readl(SLC_CFG(host->io_base)) | SLCCFG_DMA_BURST,
519                 SLC_CFG(host->io_base));
520
521         /* Transfer size is data area only */
522         __raw_writel(mtd->writesize, SLC_TC(host->io_base));
523
524         /* Start transfer in the NAND controller */
525         __raw_writel(__raw_readl(SLC_CTRL(host->io_base)) | SLCCTRL_DMA_START,
526                 SLC_CTRL(host->io_base));
527
528         /* Start DMA to process NAND controller DMA FIFO */
529         host->dmapending = 0;
530         lpc32xx_dma_start_xfer(host->dmach, config);
531
532         /*
533          * On some systems, the DMA transfer will be very fast, so there is no
534          * point in waiting for the transfer to complete using the interrupt
535          * method. It's best to just poll the transfer here to prevent several
536          * costly context changes. This is especially true for systems that
537          * use small page devices or NAND devices with very fast access.
538          */
539         if (host->ncfg->polled_completion) {
540                 timeout = LPC32XX_DMA_SIMPLE_TIMEOUT;
541                 while ((timeout > 0) && lpc32xx_dma_is_active(host->dmach))
542                         timeout--;
543                 if (timeout == 0) {
544                         dev_err(mtd->dev.parent,
545                                 "DMA transfer timeout error\n");
546                         status = -EIO;
547
548                         /* Switch to non-polled mode */
549                         host->ncfg->polled_completion = false;
550                 }
551         }
552
553         if (!host->ncfg->polled_completion) {
554                 /* Wait till DMA transfer is done or timeout occurs */
555                 wait_event_timeout(host->dma_waitq, host->dmapending,
556                         msecs_to_jiffies(LPC32XX_DMA_WAIT_TIMEOUT_MS));
557                 if (host->dma_xfer_status != 0) {
558                         dev_err(mtd->dev.parent, "DMA transfer error\n");
559                         status = -EIO;
560                 }
561         }
562
563         /*
564          * The DMA is finished, but the NAND controller may still have
565          * buffered data. Wait until all the data is sent.
566          */
567         timeout = LPC32XX_DMA_SIMPLE_TIMEOUT;
568         while ((__raw_readl(SLC_STAT(host->io_base)) & SLCSTAT_DMA_FIFO)
569                 && (timeout > 0))
570                 timeout--;
571         if (timeout == 0) {
572                 dev_err(mtd->dev.parent, "FIFO held data too long\n");
573                 status = -EIO;
574         }
575
576         /* Read last calculated ECC value */
577         if (read)
578                 host->ecc_buf[chip->ecc.steps - 1] =
579                         __raw_readl(SLC_ECC(host->io_base));
580         else {
581                 for (i = 0; i < LPC32XX_DMA_ECC_REP_READ; i++)
582                         host->ecc_buf[chip->ecc.steps - 1] =
583                                 __raw_readl(SLC_ECC(host->io_base));
584         }
585
586         /*
587          * For reads, get the OOB data. For writes, the data will be written
588          * later
589          */
590         if (read)
591                 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
592
593         /* Flush DMA link list */
594         lpc32xx_dma_flush_llist(host->dmach);
595
596         if (__raw_readl(SLC_STAT(host->io_base)) & SLCSTAT_DMA_FIFO ||
597                 __raw_readl(SLC_TC(host->io_base))) {
598                 /* Something is left in the FIFO, something is wrong */
599                 dev_err(mtd->dev.parent, "DMA FIFO failure\n");
600                 status = -EIO;
601         }
602
603         if (dma_mapped)
604                 dma_unmap_single(mtd->dev.parent, buf_phy, mtd->writesize,
605                         read ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
606         else if (read)
607                 memcpy(buf, host->data_buf, mtd->writesize);
608
609         /* Stop DMA & HW ECC */
610         __raw_writel(__raw_readl(SLC_CTRL(host->io_base)) &
611                 ~SLCCTRL_DMA_START, SLC_CTRL(host->io_base));
612         __raw_writel(tmpreg, SLC_CFG(host->io_base));
613
614         return status;
615 }
616
617 /*
618  * Read the data and OOB data from the device, use ECC correction with the
619  * data, disable ECC for the OOB data
620  */
621 static int lpc32xx_nand_read_page_syndrome(struct mtd_info *mtd,
622         struct nand_chip *chip, uint8_t *buf, int page)
623 {
624         struct lpc32xx_nand_host *host = chip->priv;
625         int stat, i, status;
626         uint8_t *oobecc, tmpecc[LPC32XX_ECC_SAVE_SIZE];
627
628         /* Issue read command */
629         chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
630
631         /* Read data and oob, calculate ECC */
632         status = lpc32xx_dma_xfer(mtd, buf, chip->ecc.steps, 1);
633
634         /* Convert to stored ECC format */
635         lpc32xx_slc_ecc_copy(tmpecc, (uint32_t *) host->ecc_buf,
636                 chip->ecc.steps);
637
638         /* Pointer to ECC data retrieved from NAND spare area */
639         oobecc = chip->oob_poi + chip->ecc.layout->eccpos[0];
640
641         for (i = 0; i < chip->ecc.steps; i++) {
642                 stat = chip->ecc.correct(mtd, buf, oobecc,
643                         &tmpecc[i * chip->ecc.bytes]);
644                 if (stat < 0)
645                         mtd->ecc_stats.failed++;
646                 else
647                         mtd->ecc_stats.corrected += stat;
648
649                 buf += chip->ecc.size;
650                 oobecc += chip->ecc.bytes;
651         }
652
653         return status;
654 }
655
656 /*
657  * Read the data and OOB data from the device, no ECC correction with the
658  * data or OOB data
659  */
660 static int lpc32xx_nand_read_page_raw_syndrome(struct mtd_info *mtd,
661         struct nand_chip *chip, uint8_t *buf, int page)
662 {
663         /* Issue read command */
664         chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
665
666         /* Raw reads can just use the FIFO interface */
667         chip->read_buf(mtd, buf, chip->ecc.size * chip->ecc.steps);
668         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
669
670         return 0;
671 }
672
673 /*
674  * Write the data and OOB data to the device, use ECC with the data,
675  * disable ECC for the OOB data
676  */
677 static void lpc32xx_nand_write_page_syndrome(struct mtd_info *mtd,
678         struct nand_chip *chip, const uint8_t *buf)
679 {
680         struct lpc32xx_nand_host *host = chip->priv;
681         uint8_t *pb = chip->oob_poi + chip->ecc.layout->eccpos[0];
682
683         /* Write data, calculate ECC on outbound data */
684         lpc32xx_dma_xfer(mtd, (uint8_t *)buf, chip->ecc.steps, 0);
685
686         /*
687          * The calculated ECC needs some manual work done to it before
688          * committing it to NAND. Process the calculated ECC and place
689          * the resultant values directly into the OOB buffer. */
690         lpc32xx_slc_ecc_copy(pb, (uint32_t *) host->ecc_buf, chip->ecc.steps);
691
692         /* Write ECC data to device */
693         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
694 }
695
696 /*
697  * Write the data and OOB data to the device, no ECC correction with the
698  * data or OOB data
699  */
700 static void lpc32xx_nand_write_page_raw_syndrome(struct mtd_info *mtd,
701         struct nand_chip *chip, const uint8_t *buf)
702 {
703         /* Raw writes can just use the FIFO interface */
704         chip->write_buf(mtd, buf, chip->ecc.size * chip->ecc.steps);
705         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
706 }
707
708 /*
709  * DMA ISR - occurs when DMA transfer complete.
710  */
711 static void lpc3xxx_nand_dma_irq(int channel, int cause,
712                         struct lpc32xx_nand_host *host)
713 {
714         host->dma_xfer_status = (cause & DMA_TC_INT) ? 0: 1;
715         host->dmapending = 1;
716         wake_up(&host->dma_waitq);
717 }
718
719 /*
720  * Get DMA channel and allocate DMA descriptors memory.
721  * Prepare DMA descriptors link lists
722  */
723 static int lpc32xx_nand_dma_setup(struct lpc32xx_nand_host *host,
724         int num_entries)
725 {
726         int ret = 0;
727
728         host->dmach = DMA_CH_SLCNAND;
729         host->dmacfg.ch = DMA_CH_SLCNAND;
730
731         /*
732          * All the DMA configuration parameters will
733          * be overwritten in lpc32xx_nand_dma_configure().
734          */
735         host->dmacfg.tc_inten = 1;
736         host->dmacfg.err_inten = 1;
737         host->dmacfg.src_size = 4;
738         host->dmacfg.src_inc = 1;
739         host->dmacfg.src_ahb1 = 1;
740         host->dmacfg.src_bsize = DMAC_CHAN_SRC_BURST_4;
741         host->dmacfg.src_prph = 0;
742         host->dmacfg.dst_size = 4;
743         host->dmacfg.dst_inc = 0;
744         host->dmacfg.dst_bsize = DMAC_CHAN_DEST_BURST_4;
745         host->dmacfg.dst_ahb1 = 0;
746         host->dmacfg.dst_prph = DMAC_DEST_PERIP(DMA_PERID_NAND1);
747         host->dmacfg.flowctrl = DMAC_CHAN_FLOW_D_M2P;
748         if (lpc32xx_dma_ch_get(&host->dmacfg, LPC32XX_MODNAME,
749                 &lpc3xxx_nand_dma_irq, host) < 0) {
750                 dev_err(host->mtd.dev.parent, "Error setting up SLC NAND "
751                         "DMA channel\n");
752                 ret = -ENODEV;
753                 goto dma_ch_err;
754         }
755
756         /*
757          * Allocate Linked list of DMA Descriptors
758          */
759         host->llptr = lpc32xx_dma_alloc_llist(host->dmach, num_entries);
760         if (host->llptr == 0) {
761                 lpc32xx_dma_ch_put(host->dmach);
762                 host->dmach = -1;
763                 dev_err(host->mtd.dev.parent,
764                         "Error allocating list buffer for SLC NAND\n");
765                 ret = -ENOMEM;
766                 goto dma_alloc_err;
767         }
768
769         return ret;
770 dma_alloc_err:
771         lpc32xx_dma_ch_put(host->dmach);
772 dma_ch_err:
773         return ret;
774 }
775
776 static int __init lpc32xx_add_partitions(struct lpc32xx_nand_host *host)
777 {
778 #ifdef CONFIG_MTD_PARTITIONS
779         struct mtd_info *mtd = &host->mtd;
780         struct mtd_partition *partitions = NULL;
781         int num_partitions = 0;
782
783 #ifdef CONFIG_MTD_CMDLINE_PARTS
784         static const char *part_probes[] = { "cmdlinepart", NULL };
785
786         mtd->name = LPC32XX_MODNAME;
787         num_partitions = parse_mtd_partitions(mtd, part_probes,
788                                               &partitions, 0);
789 #endif
790         if ((num_partitions <= 0) && (host->ncfg->partition_info))
791                 partitions = host->ncfg->partition_info(mtd->size,
792                         &num_partitions);
793
794         if ((!partitions) || (num_partitions == 0)) {
795                 dev_err(mtd->dev.parent,"No parititions defined,"
796                         " or unsupported device.\n");
797                 return ENXIO;
798         }
799
800         return add_mtd_partitions(mtd, partitions, num_partitions);
801 #else
802         return add_mtd_device(mtd);
803 #endif
804 }
805
806 /*
807  * Probe for NAND controller
808  */
809 static int __init lpc32xx_nand_probe(struct platform_device *pdev)
810 {
811         struct lpc32xx_nand_host *host;
812         struct mtd_info *mtd;
813         struct nand_chip *chip;
814         struct resource *rc;
815         int res;
816
817         rc = platform_get_resource(pdev, IORESOURCE_MEM, 0);
818         if (rc == NULL) {
819                 dev_err(&pdev->dev,"No memory resource found for"
820                         " device\n");
821                 return -ENXIO;
822         }
823
824         /* Allocate memory for the device structure (and zero it) */
825         host = kzalloc(sizeof(struct lpc32xx_nand_host), GFP_KERNEL);
826         if (!host) {
827                 dev_err(&pdev->dev,"failed to allocate device structure\n");
828                 return -ENOMEM;
829         }
830         host->io_base_dma = (dma_addr_t) rc->start;
831
832         host->io_base = ioremap(rc->start, rc->end - rc->start + 1);
833         if (host->io_base == NULL) {
834                 dev_err(&pdev->dev,"ioremap failed\n");
835                 res = -EIO;
836                 goto err_exit1;
837         }
838
839         host->ncfg = pdev->dev.platform_data;
840         if (!host->ncfg) {
841                 dev_err(&pdev->dev,"Missing platform data\n");
842                 res = -ENOENT;
843                 goto err_exit1;
844         }
845
846         mtd = &host->mtd;
847         chip = &host->nand_chip;
848         chip->priv = host;
849         mtd->priv = chip;
850         mtd->owner = THIS_MODULE;
851         mtd->dev.parent = &pdev->dev;
852
853         /* Get NAND clock */
854         host->clk = clk_get(&pdev->dev, "nand_ck");
855         if (IS_ERR(host->clk)) {
856                  dev_err(&pdev->dev,"Clock failure\n");
857                 res = -ENOENT;
858                 goto err_exit2;
859         }
860         clk_enable(host->clk);
861
862         /* Set NAND IO addresses and command/ready functions */
863         chip->IO_ADDR_R = SLC_DATA(host->io_base);
864         chip->IO_ADDR_W = SLC_DATA(host->io_base);
865         chip->cmd_ctrl = lpc32xx_nand_cmd_ctrl;
866         chip->dev_ready = lpc32xx_nand_device_ready;
867         chip->chip_delay = 20; /* 20us command delay time */
868
869         /* Init NAND controller */
870         lpc32xx_nand_setup(host);
871         lpc32xx_wp_disable(host);
872
873         platform_set_drvdata(pdev, host);
874
875         /* NAND callbacks for LPC32xx SLC hardware */
876         chip->ecc.mode = NAND_ECC_HW_SYNDROME;
877         chip->read_byte = lpc32xx_nand_read_byte;
878         chip->read_buf = lpc32xx_nand_read_buf;
879         chip->write_buf = lpc32xx_nand_write_buf;
880         chip->ecc.read_page_raw = lpc32xx_nand_read_page_raw_syndrome;
881         chip->ecc.read_page = lpc32xx_nand_read_page_syndrome;
882         chip->ecc.write_page_raw = lpc32xx_nand_write_page_raw_syndrome;
883         chip->ecc.write_page = lpc32xx_nand_write_page_syndrome;
884         chip->ecc.write_oob = lpc32xx_nand_write_oob_syndrome;
885         chip->ecc.read_oob = lpc32xx_nand_read_oob_syndrome;
886         chip->ecc.calculate = lpc32xx_nand_ecc_calculate;
887         chip->ecc.correct   = nand_correct_data;
888         chip->ecc.hwctl = lpc32xx_nand_ecc_enable;
889         chip->verify_buf = lpc32xx_verify_buf;
890
891         /*
892          * Allocate a large enough buffer for a single huge page plus
893          * extra space for the spare area and ECC storage area
894          */
895         host->dma_buf_len = LPC32XX_DMA_DATA_SIZE + LPC32XX_ECC_SAVE_SIZE;
896         host->data_buf = dma_alloc_coherent(&pdev->dev, host->dma_buf_len,
897                 &host->data_buf_dma, GFP_KERNEL);
898         if (host->data_buf == NULL) {
899                 dev_err(&pdev->dev, "Error allocating memory\n");
900                 res = -ENOMEM;
901                 goto err_exit3;
902         }
903
904         /* Get free DMA channel and alloc DMA descriptor link list */
905         res = lpc32xx_nand_dma_setup(host, LPC32XX_MAX_DMA_DESCRIPTORS);
906         if(res) {
907                 res = -EIO;
908                 goto err_exit4;
909         }
910
911         init_waitqueue_head(&host->dma_waitq);
912
913         /* Find NAND device */
914         if (nand_scan_ident(mtd, 1)) {
915                 res = -ENXIO;
916                 goto err_exit5;
917         }
918
919         /* OOB and ECC CPU and DMA work areas */
920         host->ecc_buf_dma = host->data_buf_dma + LPC32XX_DMA_DATA_SIZE;
921         host->ecc_buf = (uint32_t *) (host->data_buf + LPC32XX_DMA_DATA_SIZE);
922
923         /*
924          * Small page FLASH has a unique OOB layout, but large and huge
925          * page FLASH use the standard layout. Small page FLASH uses a
926          * custom BBT marker layout.
927          */
928         if (mtd->writesize <= 512)
929                 chip->ecc.layout = &lpc32xx_nand_oob_16;
930
931         /* These sizes remain the same regardless of page size */
932         chip->ecc.size = 256;
933         chip->ecc.bytes = LPC32XX_SLC_DEV_ECC_BYTES;
934         chip->ecc.prepad = chip->ecc.postpad = 0;
935
936         /* Avoid extra scan if using BBT, setup BBT support */
937         if (host->ncfg->use_bbt) {
938                 chip->options |= NAND_USE_FLASH_BBT | NAND_SKIP_BBTSCAN;
939
940                 /*
941                  * Use a custom BBT marker setup for small page FLASH that
942                  * won't interfere with the ECC layout. Large and huge page
943                  * FLASH use the standard layout.
944                  */
945                 if (mtd->writesize <= 512) {
946                         chip->bbt_td = &bbt_smallpage_main_descr;
947                         chip->bbt_md = &bbt_smallpage_mirror_descr;
948                 }
949         }
950
951         /*
952          * Fills out all the uninitialized function pointers with the defaults
953          */
954         if (nand_scan_tail(mtd)) {
955                 res = -ENXIO;
956                 goto err_exit5;
957         }
958
959         /* Standard layout in FLASH for bad block tables */
960         if (host->ncfg->use_bbt) {
961                 if (nand_default_bbt(mtd) < 0)
962                         dev_err(&pdev->dev, "Error initializing default bad"
963                                 " block tables\n");
964         }
965
966         res = lpc32xx_add_partitions(host);
967         if (!res)
968                 return res;
969
970         nand_release(mtd);
971
972 err_exit5:
973         /* Free the DMA channel used by us */
974         lpc32xx_dma_ch_disable(host->dmach);
975         lpc32xx_dma_dealloc_llist(host->dmach);
976         lpc32xx_dma_ch_put(host->dmach);
977         host->dmach = -1;
978 err_exit4:
979         dma_free_coherent(&pdev->dev, host->dma_buf_len,
980                 host->data_buf, host->data_buf_dma);
981 err_exit3:
982         clk_disable(host->clk);
983         clk_put(host->clk);
984         platform_set_drvdata(pdev, NULL);
985 err_exit2:
986         lpc32xx_wp_enable(host);
987         iounmap(host->io_base);
988 err_exit1:
989         kfree(host);
990
991         return res;
992 }
993
994 /*
995  * Remove NAND device.
996  */
997 static int __devexit lpc32xx_nand_remove(struct platform_device *pdev)
998 {
999         u32 tmp;
1000         struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
1001         struct mtd_info *mtd = &host->mtd;
1002
1003         nand_release(mtd);
1004
1005         /* Free the DMA channel used by us */
1006         lpc32xx_dma_ch_disable(host->dmach);
1007         lpc32xx_dma_dealloc_llist(host->dmach);
1008         lpc32xx_dma_ch_put(host->dmach);
1009         host->dmach = -1;
1010
1011         dma_free_coherent(&pdev->dev, host->dma_buf_len,
1012                 host->data_buf, host->data_buf_dma);
1013
1014         /* Force CE high */
1015         tmp = __raw_readl(SLC_CTRL(host->io_base));
1016         tmp &= ~SLCCFG_CE_LOW;
1017         __raw_writel(tmp, SLC_CTRL(host->io_base));
1018
1019         lpc32xx_wp_enable(host);
1020         clk_disable(host->clk);
1021         clk_put(host->clk);
1022
1023         iounmap(host->io_base);
1024
1025         kfree(host);
1026
1027         return 0;
1028 }
1029
1030 #if defined (CONFIG_PM)
1031 static int lpc32xx_nand_resume(struct platform_device *pdev)
1032 {
1033         struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
1034
1035         /* Re-enable NAND clock */
1036         clk_enable(host->clk);
1037
1038         /* Fresh init of NAND controller */
1039         lpc32xx_nand_setup(host);
1040
1041         /* Disable write protect */
1042         lpc32xx_wp_disable(host);
1043
1044         return 0;
1045 }
1046
1047 static int lpc32xx_nand_suspend(struct platform_device *pdev, pm_message_t pm)
1048 {
1049         u32 tmp;
1050         struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
1051
1052         /* Force CE high */
1053         tmp = __raw_readl(SLC_CTRL(host->io_base));
1054         tmp &= ~SLCCFG_CE_LOW;
1055         __raw_writel(tmp, SLC_CTRL(host->io_base));
1056
1057         /* Enable write protect for safety */
1058         lpc32xx_wp_enable(host);
1059
1060         /* Disable clock */
1061         clk_disable(host->clk);
1062
1063         return 0;
1064 }
1065
1066 #else
1067 #define lpc32xx_nand_resume NULL
1068 #define lpc32xx_nand_suspend NULL
1069 #endif
1070
1071 static struct platform_driver lpc32xx_nand_driver = {
1072         .probe          = lpc32xx_nand_probe,
1073         .remove         = __devexit_p(lpc32xx_nand_remove),
1074         .resume         = lpc32xx_nand_resume,
1075         .suspend        = lpc32xx_nand_suspend,
1076         .driver         = {
1077                 .name   = LPC32XX_MODNAME,
1078                 .owner  = THIS_MODULE,
1079         },
1080 };
1081
1082 static int __init lpc32xx_nand_init(void)
1083 {
1084         return platform_driver_register(&lpc32xx_nand_driver);
1085 }
1086
1087 static void __exit lpc32xx_nand_exit(void)
1088 {
1089         platform_driver_unregister(&lpc32xx_nand_driver);
1090 }
1091
1092 module_init(lpc32xx_nand_init);
1093 module_exit(lpc32xx_nand_exit);
1094
1095 MODULE_LICENSE("GPL");
1096 MODULE_AUTHOR("Kevin Wells(kevin.wells@nxp.com)");
1097 MODULE_DESCRIPTION("NAND driver for the NXP LPC32XX SLC controller");
1098