nand: am33xx_nand: Use a special scan_bbt routine to switch ECC mode
[karo-tx-uboot.git] / drivers / mtd / nand / am33xx_nand.c
1 /*
2  * (C) Copyright 2012 Lothar Waßmann <LW@KARO-electronics.de>
3  * based on ti81xx_nand.c
4  * (C) Copyright 2004-2008 Texas Instruments, <www.ti.com>
5  * Mansoor Ahamed <mansoor.ahamed@ti.com>
6  *
7  * Derived from work done by Rohit Choraria <rohitkc@ti.com> for omap
8  *
9  * See file CREDITS for list of people who contributed to this
10  * project.
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License as
14  * published by the Free Software Foundation; either version 2 of
15  * the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
25  * MA 02111-1307 USA
26  */
27 #include <common.h>
28 #include <asm/io.h>
29 #include <asm/errno.h>
30 #include <asm/arch/cpu.h>
31 #include <asm/arch/mem.h>
32 #include <asm/arch/nand.h>
33 #include <linux/mtd/nand_ecc.h>
34 #include <nand.h>
35
36 struct nand_bch_priv {
37         uint8_t type;
38         uint8_t nibbles;
39 };
40
41 /* bch types */
42 #define ECC_BCH4        0
43 #define ECC_BCH8        1
44 #define ECC_BCH16       2
45
46 /* BCH nibbles for diff bch levels */
47 #define ECC_BCH4_NIBBLES        13
48 #define ECC_BCH8_NIBBLES        26
49 #define ECC_BCH16_NIBBLES       52
50
51 static uint8_t cs;
52 #ifndef CONFIG_SPL_BUILD
53 static struct nand_ecclayout hw_nand_oob = GPMC_NAND_HW_ECC_LAYOUT_KERNEL;
54 static struct nand_ecclayout hw_bch4_nand_oob = GPMC_NAND_HW_BCH4_ECC_LAYOUT;
55 static struct nand_ecclayout hw_bch16_nand_oob = GPMC_NAND_HW_BCH16_ECC_LAYOUT;
56 #endif
57 static struct nand_ecclayout hw_bch8_nand_oob = GPMC_NAND_HW_BCH8_ECC_LAYOUT;
58
59 static struct gpmc *gpmc_cfg = (struct gpmc *)GPMC_BASE;
60
61 static struct nand_bch_priv bch_priv = {
62         .type = ECC_BCH8,
63         .nibbles = ECC_BCH8_NIBBLES
64 };
65
66 /*
67  * am33xx_read_bch8_result - Read BCH result for BCH8 level
68  *
69  * @mtd:        MTD device structure
70  * @big_endian: When set read register 3 first
71  * @ecc_code:   Read syndrome from BCH result registers
72  */
73 static void am33xx_read_bch8_result(struct mtd_info *mtd, uint8_t big_endian,
74                                 uint8_t *ecc_code)
75 {
76         uint32_t *ptr;
77         int8_t i = 0, j;
78
79         if (big_endian) {
80                 ptr = &gpmc_cfg->bch_result_0_3[0].bch_result_x[3];
81                 ecc_code[i++] = readl(ptr) & 0xFF;
82                 ptr--;
83                 for (j = 0; j < 3; j++) {
84                         ecc_code[i++] = (readl(ptr) >> 24) & 0xFF;
85                         ecc_code[i++] = (readl(ptr) >> 16) & 0xFF;
86                         ecc_code[i++] = (readl(ptr) >>  8) & 0xFF;
87                         ecc_code[i++] = readl(ptr) & 0xFF;
88                         ptr--;
89                 }
90         }
91         else {
92                 ptr = &gpmc_cfg->bch_result_0_3[0].bch_result_x[0];
93                 for (j = 0; j < 3; j++) {
94                         ecc_code[i++] = readl(ptr) & 0xFF;
95                         ecc_code[i++] = (readl(ptr) >>  8) & 0xFF;
96                         ecc_code[i++] = (readl(ptr) >> 16) & 0xFF;
97                         ecc_code[i++] = (readl(ptr) >> 24) & 0xFF;
98                         ptr++;
99                 }
100                 ecc_code[i++] = readl(ptr) & 0xFF;
101         }
102 }
103
104 /*
105  * am33xx_ecc_disable - Disable H/W ECC calculation
106  *
107  * @mtd:        MTD device structure
108  *
109  */
110 static void am33xx_ecc_disable(struct mtd_info *mtd) {
111
112         writel((readl(&gpmc_cfg->ecc_config) & ~0x1),
113                 &gpmc_cfg->ecc_config);
114 }
115
116 #if 0
117 /*
118  * am33xx_ecc_enable_bch - Enable BCH H/W ECC calculation
119  *
120  * @mtd:        MTD device structure
121  *
122  */
123 static void am33xx_ecc_enable_bch(struct mtd_info *mtd) {
124         uint32_t val;
125
126         val = readl(&gpmc_cfg->ecc_control);
127         val |= 0x00000100u;
128         writel(val, &gpmc_cfg->ecc_control); /* clear ECC outputs */
129
130         val = readl(&gpmc_cfg->ecc_control);
131         val &= ~0xF;
132         val |= 0x1;
133         writel(val, &gpmc_cfg->ecc_control);  /* reset ecc pointer to result 1 */
134
135         val = readl(&gpmc_cfg->ecc_config);
136         val |= 0x1;
137         writel(val, &gpmc_cfg->ecc_config); /* enable ecc */
138 }
139 #endif
140
141 /*
142  * am33xx_nand_hwcontrol - Set the address pointers correctly for the
143  *                      following address/data/command operation
144  */
145 static void am33xx_nand_hwcontrol(struct mtd_info *mtd, int32_t cmd,
146                                 uint32_t ctrl)
147 {
148         register struct nand_chip *this = mtd->priv;
149
150         /*
151          * Point the IO_ADDR to DATA and ADDRESS registers instead
152          * of chip address
153          */
154         switch (ctrl) {
155         case NAND_CTRL_CHANGE | NAND_CTRL_CLE:
156                 this->IO_ADDR_W = (void __iomem *)&gpmc_cfg->cs[cs].nand_cmd;
157                 break;
158         case NAND_CTRL_CHANGE | NAND_CTRL_ALE:
159                 this->IO_ADDR_W = (void __iomem *)&gpmc_cfg->cs[cs].nand_adr;
160                 break;
161         case NAND_CTRL_CHANGE | NAND_NCE:
162                 this->IO_ADDR_W = (void __iomem *)&gpmc_cfg->cs[cs].nand_dat;
163         }
164
165         if (cmd != NAND_CMD_NONE)
166                 writeb(cmd, this->IO_ADDR_W);
167 }
168
169 /*
170  * am33xx_hwecc_init_bch - Initialize the BCH Hardware ECC for NAND flash in
171  *                              GPMC controller
172  * @mtd:       MTD device structure
173  * @mode:       Read/Write mode
174  */
175 static void am33xx_hwecc_init_bch(struct nand_chip *chip, int32_t mode)
176 {
177         uint32_t val, dev_width = (chip->options & NAND_BUSWIDTH_16) >> 1;
178         uint32_t unused_length = 0;
179         struct nand_bch_priv *bch = chip->priv;
180
181         switch(bch->nibbles) {
182                 case ECC_BCH4_NIBBLES:
183                         unused_length = 3;
184                         break;
185                 case ECC_BCH8_NIBBLES:
186                         unused_length = 2;
187                         break;
188                 case ECC_BCH16_NIBBLES:
189                         unused_length = 0;
190         }
191
192         /* Clear the ecc result registers, select ecc reg as 1 */
193         writel(ECCCLEAR | ECCRESULTREG1, &gpmc_cfg->ecc_control);
194
195         switch (mode) {
196                 case NAND_ECC_WRITE:
197                         /* eccsize1 config */
198                         val = ((unused_length + bch->nibbles) << 22);
199                         break;
200
201                 case NAND_ECC_READ:
202                 default:
203                         /* by default eccsize0 selected for ecc1resultsize */
204                         /* eccsize0 config */
205                         val  = (bch->nibbles << 12);
206                         /* eccsize1 config */
207                         val |= (unused_length << 22);
208         }
209         /* ecc size configuration */
210         writel(val, &gpmc_cfg->ecc_size_config);
211         /* by default 512bytes sector page is selected */
212         /* set bch mode */
213         val  = (1 << 16);
214         /* bch4 / bch8 / bch16 */
215         val |= (bch->type << 12);
216         /* set wrap mode to 1 */
217         val |= (1 << 8);
218         val |= (dev_width << 7);
219         val |= (cs << 1);
220         /* enable ecc */
221         /* val |= (1); */ /* should not enable ECC just init i.e. config */
222         writel(val, &gpmc_cfg->ecc_config);
223 }
224
225
226 #ifndef CONFIG_SPL_BUILD
227 /*
228  * am33xx_hwecc_init - Initialize the Hardware ECC for NAND flash in
229  *                   GPMC controller
230  * @mtd:        MTD device structure
231  *
232  */
233 static void am33xx_hwecc_init(struct nand_chip *chip)
234 {
235         /*
236          * Init ECC Control Register
237          * Clear all ECC | Enable Reg1
238          */
239         writel(ECCCLEAR | ECCRESULTREG1, &gpmc_cfg->ecc_control);
240         writel(ECCSIZE1 | ECCSIZE0 | ECCSIZE0SEL, &gpmc_cfg->ecc_size_config);
241 }
242
243 /*
244  * gen_true_ecc - This function will generate true ECC value, which
245  * can be used when correcting data read from NAND flash memory core
246  *
247  * @ecc_buf:    buffer to store ecc code
248  *
249  * @return:     re-formatted ECC value
250  */
251 static uint32_t gen_true_ecc(uint8_t *ecc_buf)
252 {
253         return ecc_buf[0] | (ecc_buf[1] << 16) | ((ecc_buf[2] & 0xF0) << 20) |
254                 ((ecc_buf[2] & 0x0F) << 8);
255 }
256 #endif
257
258 /*
259  * am33xx_rotate_ecc_bch - Rotate the syndrome bytes
260  *
261  * @mtd:        MTD device structure
262  * @calc_ecc:   ECC read from ECC registers
263  * @syndrome:   Rotated syndrome will be retuned in this array
264  *
265  */
266 static void am33xx_rotate_ecc_bch(struct mtd_info *mtd, uint8_t *calc_ecc,
267                 uint8_t *syndrome)
268 {
269         struct nand_chip *chip = mtd->priv;
270         struct nand_bch_priv *bch = chip->priv;
271         uint8_t n_bytes = 0;
272         int8_t i,j;
273
274         switch(bch->type) {
275                 case ECC_BCH4:
276                         n_bytes = 8;
277                         break;
278
279                 case ECC_BCH16:
280                         n_bytes = 28;
281                         break;
282
283                 case ECC_BCH8:
284                 default:
285                         n_bytes = 13;
286         }
287
288         for (i = 0, j = (n_bytes-1); i < n_bytes; i++, j--)
289                 syndrome[i] =  calc_ecc[j];
290 }
291
292
293 /*
294  * am33xx_fix_errors_bch - Correct bch error in the data
295  *
296  * @mtd:        MTD device structure
297  * @data:       Data read from flash
298  * @error_count:Number of errors in data
299  * @error_loc:  Locations of errors in the data
300  *
301  */
302 static void am33xx_fix_errors_bch(struct mtd_info *mtd, uint8_t *data,
303                 uint32_t error_count, uint32_t *error_loc)
304 {
305         struct nand_chip *chip = mtd->priv;
306         struct nand_bch_priv *bch = chip->priv;
307         uint8_t count = 0;
308         uint32_t error_byte_pos;
309         uint32_t error_bit_mask;
310         uint32_t last_bit = (bch->nibbles * 4) - 1;
311
312         /* Flip all bits as specified by the error location array. */
313         /* FOR( each found error location flip the bit ) */
314         for (count = 0; count < error_count; count++) {
315                 if (error_loc[count] > last_bit) {
316                         /* Remove the ECC spare bits from correction. */
317                         error_loc[count] -= (last_bit + 1);
318                         /* Offset bit in data region */
319                         error_byte_pos = ((512 * 8) - (error_loc[count]) - 1) / 8;
320                         /* Error Bit mask */
321                         error_bit_mask = 0x1 << (error_loc[count] % 8);
322                         /* Toggle the error bit to make the correction. */
323                         data[error_byte_pos] ^= error_bit_mask;
324                 }
325         }
326 }
327
328 /*
329  * am33xx_correct_data_bch - Compares the ecc read from nand spare area
330  * with ECC registers values and corrects one bit error if it has occured
331  *
332  * @mtd:        MTD device structure
333  * @dat:        page data
334  * @read_ecc:   ecc read from nand flash (ignored)
335  * @calc_ecc:   ecc read from ECC registers
336  *
337  * @return 0 if data is OK or corrected, else returns -1
338  */
339 static int am33xx_correct_data_bch(struct mtd_info *mtd, uint8_t *dat,
340                                 uint8_t *read_ecc, uint8_t *calc_ecc)
341 {
342         struct nand_chip *chip = mtd->priv;
343         struct nand_bch_priv *bch = chip->priv;
344         uint8_t syndrome[28];
345         uint32_t error_count = 0;
346         uint32_t error_loc[8];
347         uint32_t i, ecc_flag;
348
349         ecc_flag = 0;
350         for (i = 0; i < (chip->ecc.bytes - 1); i++)
351                 if (read_ecc[i] != 0xff)
352                         ecc_flag = 1;
353
354         if (!ecc_flag)
355                 return 0;
356
357         elm_reset();
358         elm_config(bch->type);
359
360         /* while reading ECC result we read it in big endian.
361          * Hence while loading to ELM we have rotate to get the right endian.
362          */
363         am33xx_rotate_ecc_bch(mtd, calc_ecc, syndrome);
364
365 #ifdef DEBUG
366         {
367                 uint8_t i = 0;
368
369                 printf("ecc: ");
370                 for (i = 0; i < 13; i++)
371                         printf(" 0x%02x", syndrome[i]);
372                 printf("\n");
373         }
374 #endif
375
376
377         /* use elm module to check for errors */
378         if (elm_check_error(syndrome, bch->nibbles, &error_count, error_loc) != 0) {
379 #ifndef CONFIG_SPL_BUILD
380                 /* This currently sees all pages as being completely full of
381                  * uncorrectable errors.  The suspicion is that this is due
382                  * to limitations in the elm support we have in U-Boot today
383                  */
384                 printf("ECC: uncorrectable.\n");
385 #endif
386                 return -1;
387         }
388
389         /* correct bch error */
390         if (error_count > 0) {
391                 am33xx_fix_errors_bch(mtd, dat, error_count, error_loc);
392         }
393
394         return 0;
395 }
396
397 #ifndef CONFIG_SPL_BUILD
398 /*
399  * am33xx_correct_data - Compares the ecc read from nand spare area with ECC
400  * registers values and corrects one bit error if it has occured
401  * Further details can be had from Am33xx TRM and the following selected links:
402  * http://en.wikipedia.org/wiki/Hamming_code
403  * http://www.cs.utexas.edu/users/plaxton/c/337/05f/slides/ErrorCorrection-4.pdf
404  *
405  * @mtd:                 MTD device structure
406  * @dat:                 page data
407  * @read_ecc:            ecc read from nand flash
408  * @calc_ecc:            ecc read from ECC registers
409  *
410  * @return 0 if data is OK or corrected, else returns -1
411  */
412 static int am33xx_correct_data(struct mtd_info *mtd, uint8_t *dat,
413                                 uint8_t *read_ecc, uint8_t *calc_ecc)
414 {
415         uint32_t orig_ecc, new_ecc, res, hm;
416         uint16_t parity_bits, byte;
417         uint8_t bit;
418
419         /* Regenerate the orginal ECC */
420         orig_ecc = gen_true_ecc(read_ecc);
421         new_ecc = gen_true_ecc(calc_ecc);
422         /* Get the XOR of real ecc */
423         res = orig_ecc ^ new_ecc;
424         if (res) {
425                 /* Get the hamming width */
426                 hm = hweight32(res);
427                 /* Single bit errors can be corrected! */
428                 if (hm == 12) {
429                         /* Correctable data! */
430                         parity_bits = res >> 16;
431                         bit = (parity_bits & 0x7);
432                         byte = (parity_bits >> 3) & 0x1FF;
433                         /* Flip the bit to correct */
434                         dat[byte] ^= (0x1 << bit);
435                 } else if (hm == 1) {
436                         printf("am33xx_nand: Error: Corrupted ECC\n");
437                         /* ECC itself is corrupted */
438                         return 2;
439                 } else {
440                         /*
441                          * hm distance != parity pairs OR one, could mean 2 bit
442                          * error OR potentially be on a blank page..
443                          * orig_ecc: contains spare area data from nand flash.
444                          * new_ecc: generated ecc while reading data area.
445                          * Note: if the ecc = 0, all data bits from which it was
446                          * generated are 0xFF.
447                          * The 3 byte(24 bits) ecc is generated per 512byte
448                          * chunk of a page. If orig_ecc(from spare area)
449                          * is 0xFF && new_ecc(computed now from data area)=0x0,
450                          * this means that data area is 0xFF and spare area is
451                          * 0xFF. A sure sign of an erased page!
452                          */
453                         if ((orig_ecc == 0x0FFF0FFF) && (new_ecc == 0x00000000))
454                                 return 0;
455                         printf("am33xx_nand: Error: Multibit error detected; hm=%d\n",
456                                 hm);
457                         /* detected 2 bit error */
458                         return -1;
459                 }
460         }
461         return 0;
462 }
463 #endif
464
465 /*
466  *  am33xx_calculate_ecc_bch - Read BCH ECC result
467  *
468  *  @mtd:       MTD structure
469  *  @dat:       unused
470  *  @ecc_code:  ecc_code buffer
471  */
472 static int am33xx_calculate_ecc_bch(struct mtd_info *mtd, const uint8_t *dat,
473                                 uint8_t *ecc_code)
474 {
475         struct nand_chip *chip = mtd->priv;
476         struct nand_bch_priv *bch = chip->priv;
477         uint8_t big_endian = 1;
478         int8_t ret = 0;
479
480         if (bch->type == ECC_BCH8)
481                 am33xx_read_bch8_result(mtd, big_endian, ecc_code);
482         else /* BCH4 and BCH16 currently not supported */
483                 ret = -1;
484
485 #ifdef DEBUG
486         {
487                 int8_t i = 0;
488
489                 printf("ECC: ");
490                 for (i = 0; i < 13; i++)
491                         printf(" 0x%02x", ecc_code[i]);
492                 printf("\n");
493         }
494 #endif
495
496         /*
497          * Stop reading anymore ECC vals and clear old results
498          * enable will be called if more reads are required
499          */
500         am33xx_ecc_disable(mtd);
501
502         return ret;
503 }
504
505 #ifndef CONFIG_SPL_BUILD
506 /*
507  *  am33xx_calculate_ecc - Generate non-inverted ECC bytes.
508  *
509  *  Using noninverted ECC can be considered ugly since writing a blank
510  *  page ie. padding will clear the ECC bytes. This is no problem as
511  *  long nobody is trying to write data on the seemingly unused page.
512  *  Reading an erased page will produce an ECC mismatch between
513  *  generated and read ECC bytes that has to be dealt with separately.
514  *  E.g. if page is 0xFF (fresh erased), and if HW ECC engine within GPMC
515  *  is used, the result of read will be 0x0 while the ECC offsets of the
516  *  spare area will be 0xFF which will result in an ECC mismatch.
517  *  @mtd:       MTD structure
518  *  @dat:       unused
519  *  @ecc_code:  ecc_code buffer
520  */
521 static int am33xx_calculate_ecc(struct mtd_info *mtd, const uint8_t *dat,
522                                 uint8_t *ecc_code)
523 {
524         u_int32_t val;
525
526         /* Start Reading from HW ECC1_Result = 0x200 */
527         val = readl(&gpmc_cfg->ecc1_result);
528
529         ecc_code[0] = val & 0xFF;
530         ecc_code[1] = (val >> 16) & 0xFF;
531         ecc_code[2] = ((val >> 8) & 0x0F) | ((val >> 20) & 0xF0);
532
533         /*
534          * Stop reading anymore ECC vals and clear old results
535          * enable will be called if more reads are required
536          */
537         writel(0x000, &gpmc_cfg->ecc_config);
538
539         return 0;
540 }
541
542 /**
543  * am33xx_write_page_bch - [REPLACABLE] hardware ecc based page write function
544  * @mtd:        mtd info structure
545  * @chip:       nand chip info structure
546  * @buf:        data buffer
547  */
548 static void am33xx_write_page_bch(struct mtd_info *mtd,
549         struct nand_chip *chip, const uint8_t *buf)
550 {
551         int i, eccsize = chip->ecc.size;
552         int eccbytes = chip->ecc.bytes;
553         int eccsteps = chip->ecc.steps;
554         uint8_t *ecc_calc = chip->buffers->ecccalc;
555         const uint8_t *p = buf;
556         uint32_t *eccpos = chip->ecc.layout->eccpos;
557
558         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
559                 chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
560                 chip->write_buf(mtd, p, eccsize);
561                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
562         }
563
564         for (i = 0; i < chip->ecc.total; i++)
565                 chip->oob_poi[eccpos[i]] = ecc_calc[i];
566
567         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
568 }
569
570
571 /**
572  * am33xx_read_page_bch - hardware ecc based page read function
573  * @mtd:        mtd info structure
574  * @chip:       nand chip info structure
575  * @buf:        buffer to store read data
576  * @page:       page number to read
577  *
578  */
579 static int am33xx_read_page_bch(struct mtd_info *mtd, struct nand_chip *chip,
580                                 uint8_t *buf, int page)
581 {
582         int i, eccsize = chip->ecc.size;
583         int eccbytes = chip->ecc.bytes;
584         int eccsteps = chip->ecc.steps;
585         uint8_t *p = buf;
586         uint8_t *ecc_calc = chip->buffers->ecccalc;
587         uint8_t *ecc_code = chip->buffers->ecccode;
588         uint32_t *eccpos = chip->ecc.layout->eccpos;
589         uint8_t *oob = chip->oob_poi;
590         uint32_t data_pos;
591         uint32_t oob_pos;
592
593         data_pos = 0;
594         /* oob area start */
595         oob_pos = (eccsize * eccsteps) + chip->ecc.layout->eccpos[0];
596         //oob_pos = (eccsize * eccsteps) + 2;
597
598         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize,
599                                 oob += eccbytes) {
600                 chip->ecc.hwctl(mtd, NAND_ECC_READ);
601                 /* read data */
602                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, data_pos, page);
603                 chip->read_buf(mtd, p, eccsize);
604 #ifdef DEBUG
605                 {
606                         uint32_t j;
607
608                         printf("DATA: ");
609                         for (j = 0; j < 13; j++)
610                                 printf(" 0x%02x", p[j]);
611                         printf("\n");
612                 }
613 #endif
614
615                 /* read respective ecc from oob area */
616                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_pos, page);
617                 chip->read_buf(mtd, oob, eccbytes);
618 #ifdef DEBUG
619                 {
620                         uint32_t j;
621
622                         printf("OOB:  ");
623                         for (j = 0; j < 13; j++)
624                                 printf(" 0x%02x", oob[j]);
625                         printf("\n");
626                 }
627 #endif
628                 /* read syndrome */
629                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
630
631                 data_pos += eccsize;
632                 oob_pos += eccbytes;
633         }
634
635         for (i = 0; i < chip->ecc.total; i++)
636                 ecc_code[i] = chip->oob_poi[eccpos[i]];
637
638         eccsteps = chip->ecc.steps;
639         p = buf;
640
641         for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
642                 int stat;
643
644                 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
645                 if (stat < 0) {
646                         printf("am33xx_nand: uncorrectable ECC error in page %5d\n",
647                                 page);
648                         mtd->ecc_stats.failed++;
649                 } else {
650                         mtd->ecc_stats.corrected += stat;
651                 }
652         }
653         return 0;
654 }
655 #endif
656
657 /*
658  * am33xx_enable_ecc_bch- This function enables the bch h/w ecc functionality
659  * @mtd:        MTD device structure
660  * @mode:       Read/Write mode
661  *
662  */
663 static void am33xx_enable_ecc_bch(struct mtd_info *mtd, int32_t mode)
664 {
665         struct nand_chip *chip = mtd->priv;
666
667         am33xx_hwecc_init_bch(chip, mode);
668         /* enable ecc */
669         writel(readl(&gpmc_cfg->ecc_config) | 0x1, &gpmc_cfg->ecc_config);
670 }
671
672 #ifndef CONFIG_SPL_BUILD
673 /*
674  * am33xx_enable_ecc - This function enables the hardware ecc functionality
675  * @mtd:        MTD device structure
676  * @mode:       Read/Write mode
677  */
678 static void am33xx_enable_ecc(struct mtd_info *mtd, int32_t mode)
679 {
680         struct nand_chip *chip = mtd->priv;
681         uint32_t val, dev_width = (chip->options & NAND_BUSWIDTH_16) >> 1;
682
683         switch (mode) {
684         case NAND_ECC_READ:
685         case NAND_ECC_WRITE:
686                 /* Clear the ecc result registers, select ecc reg as 1 */
687                 writel(ECCCLEAR | ECCRESULTREG1, &gpmc_cfg->ecc_control);
688
689                 /*
690                  * Size 0 = 0xFF, Size1 is 0xFF - both are 512 bytes
691                  * tell all regs to generate size0 sized regs
692                  * we just have a single ECC engine for all CS
693                  */
694                 writel(ECCSIZE1 | ECCSIZE0 | ECCSIZE0SEL,
695                         &gpmc_cfg->ecc_size_config);
696                 val = (dev_width << 7) | (cs << 1) | (0x1);
697                 writel(val, &gpmc_cfg->ecc_config);
698                 break;
699         default:
700                 printf("Error: Unrecognized Mode[%d]!\n", mode);
701         }
702 }
703
704 /*
705  * __am33xx_nand_switch_ecc - switch the ECC operation ib/w h/w ecc
706  * (i.e. hamming / bch) and s/w ecc.
707  * The default is to come up on s/w ecc
708  *
709  * @nand:       NAND chip datastructure
710  * @hardware:  NAND_ECC_HW -switch to h/w ecc
711  *                              NAND_ECC_SOFT -switch to s/w ecc
712  *
713  * @mode:       0 - hamming code
714  *              1 - bch4
715  *              2 - bch8
716  *              3 - bch16
717  */
718 void __am33xx_nand_switch_ecc(struct nand_chip *nand,
719                 nand_ecc_modes_t hardware, int32_t mode)
720 {
721         struct nand_bch_priv *bch;
722
723         debug("switching ECC mode to %d %d\n", hardware, mode);
724
725         bch = nand->priv;
726         nand->options |= NAND_OWN_BUFFERS;
727
728         /* Reset ecc interface */
729         nand->ecc.read_page = NULL;
730         nand->ecc.write_page = NULL;
731         nand->ecc.read_oob = NULL;
732         nand->ecc.write_oob = NULL;
733         nand->ecc.hwctl = NULL;
734         nand->ecc.correct = NULL;
735         nand->ecc.calculate = NULL;
736
737         nand->ecc.mode = hardware;
738         /* Setup the ecc configurations again */
739         if (hardware == NAND_ECC_HW) {
740                 if (mode) {
741                         /* -1 for converting mode to bch type */
742                         bch->type = mode - 1;
743                         debug("HW ECC BCH");
744                         switch (bch->type) {
745                                 case ECC_BCH4:
746                                         nand->ecc.layout = &hw_bch4_nand_oob;
747                                         bch->nibbles = ECC_BCH4_NIBBLES;
748                                         nand->ecc.bytes = 8;
749                                         debug("4 not supported\n");
750                                         return;
751
752                                 case ECC_BCH16:
753                                         nand->ecc.bytes = 26;
754                                         nand->ecc.layout = &hw_bch16_nand_oob;
755                                         bch->nibbles = ECC_BCH16_NIBBLES;
756                                         debug("16 not supported\n");
757                                         return;
758
759                                 case ECC_BCH8:
760                                 default:
761                                         nand->ecc.bytes = 14;
762                                         nand->ecc.layout = &hw_bch8_nand_oob;
763                                         bch->nibbles = ECC_BCH8_NIBBLES;
764                                         debug("8 Selected\n");
765                         }
766                         nand->ecc.mode = NAND_ECC_HW_SYNDROME;
767                         nand->ecc.steps = 4;
768                         nand->ecc.size = 512;
769                         nand->ecc.total = nand->ecc.steps * nand->ecc.bytes;
770                         nand->ecc.write_page = am33xx_write_page_bch;
771                         nand->ecc.read_page = am33xx_read_page_bch;
772                         nand->ecc.hwctl = am33xx_enable_ecc_bch;
773                         nand->ecc.correct = am33xx_correct_data_bch;
774                         nand->ecc.calculate = am33xx_calculate_ecc_bch;
775                         am33xx_hwecc_init_bch(nand, NAND_ECC_READ);
776                 } else {
777                         nand->ecc.layout = &hw_nand_oob;
778                         nand->ecc.size = 512;
779                         nand->ecc.bytes = 3;
780                         nand->ecc.hwctl = am33xx_enable_ecc;
781                         nand->ecc.correct = am33xx_correct_data;
782                         nand->ecc.calculate = am33xx_calculate_ecc;
783                         am33xx_hwecc_init(nand);
784                         debug("HW ECC Hamming Code selected\n");
785                 }
786         } else if (hardware == NAND_ECC_SOFT) {
787                 /* Use mtd default settings */
788                 nand->ecc.layout = NULL;
789                 debug("SW ECC selected\n");
790         } else {
791                 debug("ECC Disabled\n");
792         }
793 }
794
795 /*
796  * am33xx_nand_switch_ecc - switch the ECC operation ib/w h/w ecc
797  * (i.e. hamming / bch) and s/w ecc.
798  * The default is to come up on s/w ecc
799  *
800  * @hardware -  NAND_ECC_HW -switch to h/w ecc
801  *                              NAND_ECC_SOFT -switch to s/w ecc
802  *
803  * @mode -      0 - hamming code
804  *              1 - bch4
805  *              2 - bch8
806  *              3 - bch16
807  */
808 void am33xx_nand_switch_ecc(nand_ecc_modes_t hardware, int32_t mode)
809 {
810         struct nand_chip *nand;
811         struct mtd_info *mtd;
812
813         if (nand_curr_device < 0 ||
814             nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE) {
815                 printf("Error: Can't switch ecc, no devices available\n");
816                 return;
817         }
818
819         mtd = &nand_info[nand_curr_device];
820         nand = mtd->priv;
821
822         __am33xx_nand_switch_ecc(nand, hardware, mode);
823
824         /* Update NAND handling after ECC mode switch */
825         nand_scan_tail(mtd);
826
827         nand->options &= ~NAND_OWN_BUFFERS;
828         return;
829 }
830
831 static int am33xx_scan_bbt(struct mtd_info *mtd)
832 {
833         int ret;
834
835         am33xx_nand_switch_ecc(NAND_ECC_HW, 0);
836         ret = nand_default_bbt(mtd);
837         am33xx_nand_switch_ecc(NAND_ECC_HW, 2);
838         return ret;
839 }
840 #else /* CONFIG_SPL_BUILD */
841 /* Check wait pin as dev ready indicator */
842 static int am33xx_spl_dev_ready(struct mtd_info *mtd)
843 {
844         return gpmc_cfg->status & (1 << 8);
845 }
846
847 static int am33xx_scan_bbt(struct mtd_info *mtd)
848 {
849         return 0;
850 }
851 #endif
852
853 /*
854  * Board-specific NAND initialization. The following members of the
855  * argument are board-specific:
856  * - IO_ADDR_R: address to read the 8 I/O lines of the flash device
857  * - IO_ADDR_W: address to write the 8 I/O lines of the flash device
858  * - cmd_ctrl: hardwarespecific function for accesing control-lines
859  * - waitfunc: hardwarespecific function for accesing device ready/busy line
860  * - ecc.hwctl: function to enable (reset) hardware ecc generator
861  * - ecc.mode: mode of ecc, see defines
862  * - chip_delay: chip dependent delay for transfering data from array to
863  *   read regs (tR)
864  * - options: various chip options. They can partly be set to inform
865  *   nand_scan about special functionality. See the defines for further
866  *   explanation
867  */
868 int board_nand_init(struct nand_chip *nand)
869 {
870         /* int32_t gpmc_config = 0; */
871         cs = 0;
872
873         /*
874          * xloader/Uboot's gpmc configuration would have configured GPMC for
875          * nand type of memory. The following logic scans and latches on to the
876          * first CS with NAND type memory.
877          * TBD: need to make this logic generic to handle multiple CS NAND
878          * devices.
879          */
880         while (cs < GPMC_MAX_CS) {
881                 /* Check if NAND type is set */
882                 if ((readl(&gpmc_cfg->cs[cs].config1) & 0xC00) == 0x800) {
883                         /* Found it!! */
884                         debug("Searching for NAND device @ GPMC CS:%d\n", cs);
885                         break;
886                 }
887                 cs++;
888         }
889         if (cs >= GPMC_MAX_CS) {
890                 printf("NAND: Unable to find NAND settings in "
891                         "GPMC Configuration - quitting\n");
892                 return -ENODEV;
893         }
894
895         nand->IO_ADDR_R = (void __iomem *)&gpmc_cfg->cs[cs].nand_dat;
896         nand->IO_ADDR_W = (void __iomem *)&gpmc_cfg->cs[cs].nand_cmd;
897
898         nand->cmd_ctrl = am33xx_nand_hwcontrol;
899         nand->options = NAND_NO_PADDING | NAND_CACHEPRG | NAND_NO_AUTOINCR;
900         nand->scan_bbt = am33xx_scan_bbt;
901
902         /* If we are 16 bit dev, our gpmc config tells us that */
903         if ((readl(&gpmc_cfg->cs[cs].config1) & 0x3000) == 0x1000) {
904                 nand->options |= NAND_BUSWIDTH_16;
905         }
906
907         nand->chip_delay = 100;
908
909         /* required in case of BCH */
910         elm_init();
911
912         /* BCH info that will be correct for SPL or overridden otherwise. */
913         nand->priv = &bch_priv;
914
915 #ifndef CONFIG_SPL_BUILD
916         /* For undocumented reasons we need to currently keep our environment
917          * in 1-bit ECC so we configure ourself thusly. */
918         nand_curr_device = 0;
919         am33xx_nand_switch_ecc(NAND_ECC_HW, 2);
920 #else
921         /* The NAND chip present requires that we have written data in with
922          * at least 4-bit ECC so we configure outself for that in SPL.
923          */
924         nand->ecc.mode = NAND_ECC_HW_SYNDROME;
925         nand->ecc.layout = &hw_bch8_nand_oob;
926         nand->ecc.size = CONFIG_SYS_NAND_ECCSIZE;
927         nand->ecc.bytes = CONFIG_SYS_NAND_ECCBYTES;
928         nand->ecc.steps = CONFIG_SYS_NAND_ECCSTEPS;
929         nand->ecc.total = CONFIG_SYS_NAND_ECCBYTES * CONFIG_SYS_NAND_ECCSTEPS;
930         nand->ecc.hwctl = am33xx_enable_ecc_bch;
931         nand->ecc.correct = am33xx_correct_data_bch;
932         nand->ecc.calculate = am33xx_calculate_ecc_bch;
933
934 #if 1
935         if (nand->options & NAND_BUSWIDTH_16)
936                 nand->read_buf = nand_read_buf16;
937         else
938                 nand->read_buf = nand_read_buf;
939 #else
940         nand_scan_ident(&nand_info[nand_curr_device], 1, NULL);
941 #endif
942         nand->dev_ready = am33xx_spl_dev_ready;
943
944         am33xx_hwecc_init_bch(nand, NAND_ECC_READ);
945 #endif
946
947         return 0;
948 }