nand:lpc32xx:NAND Flash ECC correction fixes
[uboot-2011.12-lpc32xx.git] / drivers / mtd / nand / lpc32xx_nand.c
1 /*
2  * Copyright (C) 2008 by NXP Semiconductors
3  * All rights reserved.
4  *
5  * @Author: Kevin Wells
6  * @Descr: LPC3250 SLC NAND controller interface support functions
7  *
8  * See file CREDITS for list of people who contributed to this
9  * project.
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License as
13  * published by the Free Software Foundation; either version 2 of
14  * the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
24  * MA 02111-1307 USA
25  */
26
27 #include <common.h>
28 #include "lpc3250.h"
29 #include <nand.h>
30 #include <asm/errno.h>
31 #include <asm/io.h>
32
33 #define NAND_ALE_OFFS   4
34 #define NAND_CLE_OFFS   8
35
36 #define NAND_LARGE_BLOCK_PAGE_SIZE      2048
37 #define NAND_SMALL_BLOCK_PAGE_SIZE      512
38
39 static struct nand_ecclayout lpc32xx_nand_oob_16 = {
40         .eccbytes = 6,
41         .eccpos = {10, 11, 12, 13, 14, 15},
42         .oobfree = {
43                 {.offset = 0,
44                  . length = 4},
45                 {.offset = 6,
46                  . length = 4}
47                 }
48 };
49
50 extern int nand_correct_data(struct mtd_info *mtd, u_char *dat,
51                              u_char *read_ecc, u_char *calc_ecc);
52 /*
53  * DMA Descriptors
54  * For Large Block: 17 descriptors = ((16 Data and ECC Read) + 1 Spare Area)
55  * For Small Block: 5 descriptors = ((4 Data and ECC Read) + 1 Spare Area)
56  */
57 static dmac_ll_t dmalist[(CONFIG_SYS_NAND_ECCSIZE/256) * 2 + 1];
58 static uint32_t ecc_buffer[8]; /* MAX ECC size */
59 static int dmachan = -1;
60 #define XFER_PENDING ((SLCNAND->slc_stat & SLCSTAT_DMA_FIFO) | SLCNAND->slc_tc)
61
62 static void lpc32xx_nand_init(void)
63 {
64         /* Enable clocks to the SLC NAND controller */
65         CLKPWR->clkpwr_nand_clk_ctrl = (CLKPWR_NANDCLK_SEL_SLC |
66                                         CLKPWR_NANDCLK_SLCCLK_EN);
67
68         /* Reset SLC NAND controller & clear ECC */
69         SLCNAND->slc_ctrl = (SLCCTRL_SW_RESET | SLCCTRL_ECC_CLEAR);
70
71         /* 8-bit bus, no DMA, CE normal */
72         SLCNAND->slc_cfg = 0;
73
74         /* Interrupts disabled and cleared */
75         SLCNAND->slc_ien = 0;
76         SLCNAND->slc_icr = (SLCSTAT_INT_TC | SLCSTAT_INT_RDY_EN);
77
78         SLCNAND->slc_tac = LPC32XX_SLC_NAND_TIMING;
79 }
80
81 static void lpc32xx_nand_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
82 {
83         struct nand_chip *this = mtd->priv;
84         ulong  IO_ADDR_W;
85
86         if (ctrl & NAND_CTRL_CHANGE) {
87                 IO_ADDR_W = (ulong) this->IO_ADDR_W;
88                 IO_ADDR_W &= ~(NAND_CLE_OFFS | NAND_ALE_OFFS);
89
90                 if ( ctrl & NAND_CLE ) {
91                         IO_ADDR_W |= NAND_CLE_OFFS;
92                 }
93                 else if ( ctrl & NAND_ALE ) {
94                         IO_ADDR_W |= NAND_ALE_OFFS;
95                 }
96
97                 if ( ctrl & NAND_NCE ) {
98                         SLCNAND->slc_cfg |= SLCCFG_CE_LOW;
99                 }
100                 else {
101                         SLCNAND->slc_cfg &= ~SLCCFG_CE_LOW;
102                 }
103
104                 this->IO_ADDR_W = (void *) IO_ADDR_W;
105         }
106
107         if (cmd != NAND_CMD_NONE) {
108                 writel(cmd, this->IO_ADDR_W);
109         }
110 }
111
112 static int lpc32xx_nand_ready(struct mtd_info *mtd)
113 {
114         /* Check the SLC NAND controller status */
115         return (SLCNAND->slc_stat & SLCSTAT_NAND_READY);
116 }
117
118 static u_char lpc32xx_read_byte(struct mtd_info *mtd)
119 {
120         struct nand_chip *this = mtd->priv;
121         unsigned long *pReg = (unsigned long *) this->IO_ADDR_R;
122         volatile unsigned long tmp32;
123         tmp32 = *pReg;
124         return (u_char) tmp32;
125 }
126
127 /*
128  * lpc32xx_verify_buf - [DEFAULT] Verify chip data against buffer
129  * mtd: MTD device structure
130  * buf: buffer containing the data to compare
131  * len: number of bytes to compare
132  *
133  * Default verify function for 8bit buswith
134  */
135 static int lpc32xx_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
136 {
137         int i;
138         struct nand_chip *this = mtd->priv;
139         unsigned long *pReg = (unsigned long *) this->IO_ADDR_R;
140         volatile unsigned long tmp32;
141
142         for (i=0; i<len; i++) {
143                 tmp32 = *pReg;
144                 if (buf[i] != (u_char) tmp32)
145                         return -EFAULT;
146         }
147         return 0;
148 }
149
150 /* Prepares DMA descriptors for NAND RD/WR operations */
151 /* If the size is < 256 Bytes then it is assumed to be
152  * an OOB transfer */
153 static void lpc32xx_nand_dma_configure(struct nand_chip *chip,
154                 const void * buffer, int size, int read)
155 {
156         uint32_t i, dmasrc, ctrl, ecc_ctrl, oob_ctrl, dmadst;
157         void __iomem * base = chip->IO_ADDR_R;
158         uint32_t *ecc_gen = ecc_buffer;
159
160         /*
161          * CTRL descriptor entry for reading ECC
162          * Copy Multiple times to sync DMA with Flash Controller
163          */
164         ecc_ctrl =  (0x5 |
165                         DMAC_CHAN_SRC_BURST_1 |
166                         DMAC_CHAN_DEST_BURST_1 |
167                         DMAC_CHAN_SRC_WIDTH_32 |
168                         DMAC_CHAN_DEST_WIDTH_32 |
169                         DMAC_CHAN_DEST_AHB1);
170
171         /* CTRL descriptor entry for reading/writing Data */
172         ctrl =  64 | /* 256/4 */
173                         DMAC_CHAN_SRC_BURST_4 |
174                         DMAC_CHAN_DEST_BURST_4 |
175                         DMAC_CHAN_SRC_WIDTH_32 |
176                         DMAC_CHAN_DEST_WIDTH_32 |
177                         DMAC_CHAN_DEST_AHB1;
178
179         /* CTRL descriptor entry for reading/writing Spare Area */
180         oob_ctrl =  ((CONFIG_SYS_NAND_OOBSIZE / 4) |
181                         DMAC_CHAN_SRC_BURST_4 |
182                         DMAC_CHAN_DEST_BURST_4 |
183                         DMAC_CHAN_SRC_WIDTH_32 |
184                         DMAC_CHAN_DEST_WIDTH_32 |
185                         DMAC_CHAN_DEST_AHB1);
186
187         if (read) {
188                 dmasrc = (uint32_t) (base + offsetof(SLCNAND_REGS_T, slc_dma_data));
189                 dmadst = (uint32_t) (buffer);
190                 ctrl |= DMAC_CHAN_DEST_AUTOINC;
191         } else {
192                 dmadst = (uint32_t) (base + offsetof(SLCNAND_REGS_T, slc_dma_data));
193                 dmasrc = (uint32_t) (buffer);
194                 ctrl |= DMAC_CHAN_SRC_AUTOINC;
195         }
196
197         /*
198          * Write Operation Sequence for Small Block NAND
199          * ----------------------------------------------------------
200          * 1. X'fer 256 bytes of data from Memory to Flash.
201          * 2. Copy generated ECC data from Register to Spare Area
202          * 3. X'fer next 256 bytes of data from Memory to Flash.
203          * 4. Copy generated ECC data from Register to Spare Area.
204          * 5. X'fer 16 byets of Spare area from Memory to Flash.
205          * Read Operation Sequence for Small Block NAND
206          * ----------------------------------------------------------
207          * 1. X'fer 256 bytes of data from Flash to Memory.
208          * 2. Copy generated ECC data from Register to ECC calc Buffer.
209          * 3. X'fer next 256 bytes of data from Flash to Memory.
210          * 4. Copy generated ECC data from Register to ECC calc Buffer.
211          * 5. X'fer 16 bytes of Spare area from Flash to Memory.
212          * Write Operation Sequence for Large Block NAND
213          * ----------------------------------------------------------
214          * 1. Steps(1-4) of Write Operations repeate for four times
215          * which generates 16 DMA descriptors to X'fer 2048 bytes of
216          * data & 32 bytes of ECC data.
217          * 2. X'fer 64 bytes of Spare area from Memory to Flash.
218          * Read Operation Sequence for Large Block NAND
219          * ----------------------------------------------------------
220          * 1. Steps(1-4) of Read Operations repeate for four times
221          * which generates 16 DMA descriptors to X'fer 2048 bytes of
222          * data & 32 bytes of ECC data.
223          * 2. X'fer 64 bytes of Spare area from Flash to Memory.
224          */
225
226         for (i = 0; i < size/256; i++) {
227                 dmalist[i*2].dma_src = (read ?(dmasrc) :(dmasrc + (i*256)));
228                 dmalist[i*2].dma_dest = (read ?(dmadst + (i*256)) :dmadst);
229                 dmalist[i*2].next_lli = (uint32_t) & dmalist[(i*2)+1];
230                 dmalist[i*2].next_ctrl = ctrl;
231
232                 dmalist[(i*2) + 1].dma_src = (uint32_t)
233                         (base + offsetof(SLCNAND_REGS_T, slc_ecc));
234                 dmalist[(i*2) + 1].dma_dest =  (uint32_t) & ecc_gen[i];
235                 dmalist[(i*2) + 1].next_lli = (uint32_t) & dmalist[(i*2)+2];
236                 dmalist[(i*2) + 1].next_ctrl = ecc_ctrl;
237         }
238
239         if (i) { /* Data only transfer */
240                 dmalist[(i*2) - 1].next_lli = 0;
241                 dmalist[(i*2) - 1].next_ctrl |= DMAC_CHAN_INT_TC_EN;
242                 return ;
243         }
244
245         /* OOB only transfer */
246         if (read) {
247                 dmasrc = (uint32_t) (base + offsetof(SLCNAND_REGS_T, slc_dma_data));
248                 dmadst = (uint32_t) (buffer);
249                 oob_ctrl |= DMAC_CHAN_DEST_AUTOINC;
250         } else {
251                 dmadst = (uint32_t) (base + offsetof(SLCNAND_REGS_T, slc_dma_data));
252                 dmasrc = (uint32_t) (buffer);
253                 oob_ctrl |= DMAC_CHAN_SRC_AUTOINC;
254         }
255
256         /* Read/ Write Spare Area Data To/From Flash */
257         dmalist[i*2].dma_src = dmasrc;
258         dmalist[i*2].dma_dest = dmadst;
259         dmalist[i*2].next_lli = 0;
260         dmalist[i*2].next_ctrl = (oob_ctrl | DMAC_CHAN_INT_TC_EN);
261 }
262
263 static void lpc32xx_nand_xfer(struct mtd_info *mtd, const u_char *buf, int len, int read)
264 {
265         struct nand_chip *chip = mtd->priv;
266         uint32_t config;
267
268         /* DMA Channel Configuration */
269         config = (read ? DMAC_CHAN_FLOW_D_P2M : DMAC_CHAN_FLOW_D_M2P) |
270                 (read ? DMAC_DEST_PERIP(0) : DMAC_DEST_PERIP(DMA_PERID_NAND1)) |
271                 (read ? DMAC_SRC_PERIP(DMA_PERID_NAND1) : DMAC_SRC_PERIP(0)) |
272                 DMAC_CHAN_ENABLE;
273
274         /* Prepare DMA descriptors */
275         lpc32xx_nand_dma_configure(chip, buf, len, read);
276
277         /* Setup SLC controller and start transfer */
278         if (read)
279                 SLCNAND->slc_cfg |= SLCCFG_DMA_DIR;
280         else  /* NAND_ECC_WRITE */
281                 SLCNAND->slc_cfg &= ~SLCCFG_DMA_DIR;
282         SLCNAND->slc_cfg |= SLCCFG_DMA_BURST;
283
284         /* Write length for new transfers */
285         if (!XFER_PENDING)
286                 SLCNAND->slc_tc = len +
287                         (len != mtd->oobsize ? mtd->oobsize : 0);
288
289         SLCNAND->slc_ctrl |= SLCCTRL_DMA_START;
290
291         /* Start DMA transfers */
292         lpc32xx_dma_start_xfer(dmachan, dmalist, config);
293
294         /* Wait for NAND to be ready */
295         while(!lpc32xx_nand_ready(mtd));
296
297         /* Wait till DMA transfer is DONE */
298         if (lpc32xx_dma_wait_status(dmachan)) {
299                 printk(KERN_ERR "NAND DMA transfer error!\r\n");
300         }
301
302         /* Stop DMA & HW ECC */
303         SLCNAND->slc_ctrl &= ~SLCCTRL_DMA_START;
304         SLCNAND->slc_cfg &= ~(SLCCFG_DMA_DIR | SLCCFG_DMA_BURST |
305                                 SLCCFG_ECC_EN | SLCCFG_DMA_ECC);
306 }
307
308 static uint32_t slc_ecc_copy_to_buffer(uint8_t * spare,
309                 const uint32_t * ecc, int count)
310 {
311         int i;
312         for (i = 0; i < (count * 3); i += 3) {
313                 uint32_t ce = ecc[i/3];
314                 ce = ~(ce << 2) & 0xFFFFFF;
315                 spare[i+2] = (uint8_t)(ce & 0xFF); ce >>= 8;
316                 spare[i+1] = (uint8_t)(ce & 0xFF); ce >>= 8;
317                 spare[i]   = (uint8_t)(ce & 0xFF);
318         }
319         return 0;
320 }
321
322 static int lpc32xx_ecc_calculate(struct mtd_info *mtd, const uint8_t *dat,
323                                              uint8_t *ecc_code)
324 {
325         return slc_ecc_copy_to_buffer(ecc_code, ecc_buffer,
326                         CONFIG_SYS_NAND_ECCSIZE == NAND_LARGE_BLOCK_PAGE_SIZE ? 8 : 2);
327 }
328
329 /*
330  * Enables and prepares SLC NAND controller
331  * for doing data transfers with H/W ECC enabled.
332  */
333 static void lpc32xx_hwecc_enable(struct mtd_info *mtd, int mode)
334 {
335         /* Clear ECC */
336         SLCNAND->slc_ctrl = SLCCTRL_ECC_CLEAR;
337
338         /* Setup SLC controller for H/W ECC operations */
339         SLCNAND->slc_cfg |= (SLCCFG_ECC_EN | SLCCFG_DMA_ECC);
340 }
341
342 /*
343  * lpc32xx_write_buf - [DEFAULT] write buffer to chip
344  * mtd: MTD device structure
345  * buf: data buffer
346  * len: number of bytes to write
347  *
348  * Default write function for 8bit buswith
349  */
350 static void lpc32xx_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
351 {
352         lpc32xx_nand_xfer(mtd, buf, len, 0);
353 }
354
355 /**
356  * lpc32xx_correct_data - [NAND Interface] Detect and correct bit error(s)
357  * mtd: MTD block structure
358  * dat: raw data read from the chip
359  * read_ecc:    ECC from the chip
360  * calc_ecc:    the ECC calculated from raw data
361  *
362  * Detect and correct a 1 bit error for 256 byte block
363  *
364  */
365 int lpc32xx_correct_data(struct mtd_info *mtd, u_char *dat,
366                       u_char *read_ecc, u_char *calc_ecc)
367 {
368         uint8_t i, nb_ecc256;
369         int     ret1, ret2 = 0;
370         u_char  *r = read_ecc;
371         u_char  *c = calc_ecc;
372         uint16_t        data_offset = 0;
373
374         nb_ecc256 = (CONFIG_SYS_NAND_ECCSIZE == NAND_LARGE_BLOCK_PAGE_SIZE ? 8 : 2);
375
376         for( i = 0 ; i < nb_ecc256 ; i++ , r += 3, c += 3, data_offset += 256 )
377         {
378                 ret1 = nand_correct_data(mtd, dat + data_offset, r, c);
379
380                 if( ret1 < 0 )
381                         return -EBADMSG;
382                 else
383                         ret2 += ret1;
384         }
385
386         return(ret2);
387 }
388
389 /*
390  * lpc32xx_read_buf - [DEFAULT] read chip data into buffer
391  * mtd: MTD device structure
392  * buf: buffer to store date
393  * len: number of bytes to read
394  *
395  * Default read function for 8bit buswith
396  */
397 static void lpc32xx_read_buf(struct mtd_info *mtd, u_char *buf, int len)
398 {
399         lpc32xx_nand_xfer(mtd, buf, len, 1);
400 }
401
402 int board_nand_init(struct nand_chip *nand)
403 {
404         /* Initial NAND interface */
405         lpc32xx_nand_init();
406
407         /* Acquire a channel for our use */
408         dmachan = lpc32xx_dma_get_channel();
409         if (unlikely(dmachan < 0)){
410                 printk(KERN_INFO "Unable to get a free DMA "
411                                 "channel for NAND transfers\r\n");
412                 return -1;
413         }
414
415         /* ECC mode and size */
416         nand->ecc.mode = NAND_ECC_HW;
417         nand->ecc.bytes = CONFIG_SYS_NAND_ECCBYTES;
418         nand->ecc.size = CONFIG_SYS_NAND_ECCSIZE;
419
420         if(CONFIG_SYS_NAND_ECCSIZE != NAND_LARGE_BLOCK_PAGE_SIZE)
421                 nand->ecc.layout = &lpc32xx_nand_oob_16;
422
423         nand->ecc.calculate = lpc32xx_ecc_calculate;
424         nand->ecc.correct = lpc32xx_correct_data;
425         nand->ecc.hwctl = lpc32xx_hwecc_enable;
426         nand->cmd_ctrl = lpc32xx_nand_hwcontrol;
427         nand->dev_ready = lpc32xx_nand_ready;
428         nand->chip_delay = 2000;
429
430         nand->read_buf = lpc32xx_read_buf;
431         nand->write_buf = lpc32xx_write_buf;
432         nand->read_byte = lpc32xx_read_byte;
433         nand->verify_buf = lpc32xx_verify_buf;
434
435         return 0;
436 }