5af213c75849d0615c022d1bceae7f8f2d2abcb4
[karo-tx-uboot.git] / drivers / mtd / nand / omap_gpmc.c
1 /*
2  * (C) Copyright 2004-2008 Texas Instruments, <www.ti.com>
3  * Rohit Choraria <rohitkc@ti.com>
4  *
5  * SPDX-License-Identifier:     GPL-2.0+
6  */
7
8 #include <common.h>
9 #include <asm/io.h>
10 #include <asm/errno.h>
11 #include <asm/arch/mem.h>
12 #include <asm/arch/cpu.h>
13 #include <asm/omap_gpmc.h>
14 #include <linux/mtd/nand_ecc.h>
15 #include <linux/bch.h>
16 #include <linux/compiler.h>
17 #include <nand.h>
18 #ifdef CONFIG_AM33XX
19 #include <asm/arch/elm.h>
20 #endif
21
22 static uint8_t cs;
23 static __maybe_unused struct nand_ecclayout hw_nand_oob =
24         GPMC_NAND_HW_ECC_LAYOUT;
25 static __maybe_unused struct nand_ecclayout hw_bch8_nand_oob =
26         GPMC_NAND_HW_BCH8_ECC_LAYOUT;
27
28 static struct gpmc __iomem *gpmc_cfg = (void __iomem *)GPMC_BASE;
29
30 #ifdef CONFIG_SYS_NAND_USE_FLASH_BBT
31 static uint8_t bbt_pattern[] = {'B', 'b', 't', '0' };
32 static uint8_t mirror_pattern[] = {'1', 't', 'b', 'B' };
33
34 static struct nand_bbt_descr bbt_main_descr = {
35         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE |
36                 NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
37         .offs = 0, /* may be overwritten depending on ECC layout */
38         .len = 4,
39         .veroffs = 4, /* may be overwritten depending on ECC layout */
40         .maxblocks = 4,
41         .pattern = bbt_pattern,
42 };
43
44 static struct nand_bbt_descr bbt_mirror_descr = {
45         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE |
46                 NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
47         .offs = 0, /* may be overwritten depending on ECC layout */
48         .len = 4,
49         .veroffs = 4, /* may be overwritten depending on ECC layout */
50         .maxblocks = 4,
51         .pattern = mirror_pattern,
52 };
53 #endif
54
55 #define PREFETCH_FIFOTHRESHOLD_MAX              0x40
56 #define PREFETCH_FIFOTHRESHOLD(val)             ((val) << 8)
57
58 #define PREFETCH_ENABLEOPTIMIZEDACCESS          (0x1 << 27)
59
60 #define GPMC_PREFETCH_STATUS_FIFO_CNT(val)      (((val) >> 24) & 0x7F)
61 #define GPMC_PREFETCH_STATUS_COUNT(val)         ((val) & 0x00003fff)
62
63 #define CS_NUM_SHIFT                            24
64 #define ENABLE_PREFETCH                         (0x1 << 7)
65 #define DMA_MPU_MODE                            2
66
67 #define OMAP_NAND_TIMEOUT_MS                    5000
68
69 #define PRINT_REG(x) debug("+++ %.15s (0x%08x)=0x%08x\n", #x, &gpmc_cfg->x, readl(&gpmc_cfg->x))
70
71 #ifdef CONFIG_SYS_GPMC_PREFETCH_ENABLE
72 /**
73  * gpmc_prefetch_enable - configures and starts prefetch transfer
74  * @cs: cs (chip select) number
75  * @fifo_th: fifo threshold to be used for read/ write
76  * @count: number of bytes to be transferred
77  * @is_write: prefetch read(0) or write post(1) mode
78  */
79 static inline void gpmc_prefetch_enable(int cs, int fifo_th,
80                                         unsigned int count, int is_write)
81 {
82         writel(count, &gpmc_cfg->pref_config2);
83
84         /* Set the prefetch read / post write and enable the engine.
85          * Set which cs is has requested for.
86          */
87         uint32_t val = (cs << CS_NUM_SHIFT) |
88                 PREFETCH_ENABLEOPTIMIZEDACCESS |
89                 PREFETCH_FIFOTHRESHOLD(fifo_th) |
90                 ENABLE_PREFETCH |
91                 !!is_write;
92         writel(val, &gpmc_cfg->pref_config1);
93
94         /*  Start the prefetch engine */
95         writel(0x1, &gpmc_cfg->pref_control);
96 }
97
98 /**
99  * gpmc_prefetch_reset - disables and stops the prefetch engine
100  */
101 static inline void gpmc_prefetch_reset(void)
102 {
103         /* Stop the PFPW engine */
104         writel(0x0, &gpmc_cfg->pref_control);
105
106         /* Reset/disable the PFPW engine */
107         writel(0x0, &gpmc_cfg->pref_config1);
108 }
109
110 //#define FIFO_IOADDR           (nand->IO_ADDR_R)
111 #define FIFO_IOADDR             PISMO1_NAND_BASE
112
113 /**
114  * read_buf_pref - read data from NAND controller into buffer
115  * @mtd: MTD device structure
116  * @buf: buffer to store date
117  * @len: number of bytes to read
118  */
119 static void read_buf_pref(struct mtd_info *mtd, u_char *buf, int len)
120 {
121         gpmc_prefetch_enable(cs, PREFETCH_FIFOTHRESHOLD_MAX, len, 0);
122         do {
123                 // Get number of bytes waiting in the FIFO
124                 uint32_t read_bytes = GPMC_PREFETCH_STATUS_FIFO_CNT(readl(&gpmc_cfg->pref_status));
125
126                 if (read_bytes == 0)
127                         continue;
128                 // Alignment of Destination Buffer
129                 while (read_bytes && ((unsigned int)buf & 3)) {
130                         *buf++ = readb(FIFO_IOADDR);
131                         read_bytes--;
132                         len--;
133                 }
134                 // Use maximum word size (32bit) inside this loop, because speed is limited by
135                 // GPMC bus arbitration with a maximum transfer rate of 3.000.000/sec.
136                 len -= read_bytes & ~3;
137                 while (read_bytes >= 4) {
138                         *((uint32_t*)buf) = readl(FIFO_IOADDR);
139                         buf += 4;
140                         read_bytes -= 4;
141                 }
142                 // Transfer the last (non-aligned) bytes only at the last iteration,
143                 // to maintain full speed up to the end of the transfer.
144                 if (read_bytes == len) {
145                         while (read_bytes) {
146                                 *buf++ = readb(FIFO_IOADDR);
147                                 read_bytes--;
148                         }
149                         len = 0;
150                 }
151         } while (len > 0);
152         gpmc_prefetch_reset();
153 }
154
155 /*
156  * write_buf_pref - write buffer to NAND controller
157  * @mtd: MTD device structure
158  * @buf: data buffer
159  * @len: number of bytes to write
160  */
161 static void write_buf_pref(struct mtd_info *mtd, const u_char *buf, int len)
162 {
163         /*  configure and start prefetch transfer */
164         gpmc_prefetch_enable(cs, PREFETCH_FIFOTHRESHOLD_MAX, len, 1);
165
166         while (len) {
167                 // Get number of free bytes in the FIFO
168                 uint32_t write_bytes = GPMC_PREFETCH_STATUS_FIFO_CNT(readl(&gpmc_cfg->pref_status));
169
170                 // don't write more bytes than requested
171                 if (write_bytes > len)
172                         write_bytes = len;
173
174                 // Alignment of Source Buffer
175                 while (write_bytes && ((unsigned int)buf & 3)) {
176                         writeb(*buf++, FIFO_IOADDR);
177                         write_bytes--;
178                         len--;
179                 }
180
181                 // Use maximum word size (32bit) inside this loop, because speed is limited by
182                 // GPMC bus arbitration with a maximum transfer rate of 3.000.000/sec.
183                 len -= write_bytes & ~3;
184                 while (write_bytes >= 4) {
185                         writel(*((uint32_t*)buf), FIFO_IOADDR);
186                         buf += 4;
187                         write_bytes -= 4;
188                 }
189
190                 // Transfer the last (non-aligned) bytes only at the last iteration,
191                 // to maintain full speed up to the end of the transfer.
192                 if (write_bytes == len) {
193                         while (write_bytes) {
194                                 writeb(*buf++, FIFO_IOADDR);
195                                 write_bytes--;
196                         }
197                         len = 0;
198                 }
199         }
200
201         /* wait for data to be flushed out before resetting the prefetch */
202         while ((len = GPMC_PREFETCH_STATUS_COUNT(readl(&gpmc_cfg->pref_status)))) {
203                 debug("%u bytes still in FIFO\n", PREFETCH_FIFOTHRESHOLD_MAX - len);
204                 ndelay(1);
205         }
206
207         /* disable and stop the PFPW engine */
208         gpmc_prefetch_reset();
209 }
210 #endif /* CONFIG_SYS_GPMC_PREFETCH_ENABLE */
211
212 /*
213  * omap_nand_hwcontrol - Set the address pointers corretly for the
214  *                      following address/data/command operation
215  */
216 static void omap_nand_hwcontrol(struct mtd_info *mtd, int32_t cmd,
217                                 uint32_t ctrl)
218 {
219         register struct nand_chip *this = mtd->priv;
220
221         /*
222          * Point the IO_ADDR to DATA and ADDRESS registers instead
223          * of chip address
224          */
225         switch (ctrl) {
226         case NAND_CTRL_CHANGE | NAND_CTRL_CLE:
227                 this->IO_ADDR_W = (void __iomem *)&gpmc_cfg->cs[cs].nand_cmd;
228                 break;
229         case NAND_CTRL_CHANGE | NAND_CTRL_ALE:
230                 this->IO_ADDR_W = (void __iomem *)&gpmc_cfg->cs[cs].nand_adr;
231                 break;
232         case NAND_CTRL_CHANGE | NAND_NCE:
233                 this->IO_ADDR_W = (void __iomem *)&gpmc_cfg->cs[cs].nand_dat;
234                 break;
235         }
236
237         if (cmd != NAND_CMD_NONE)
238                 writeb(cmd, this->IO_ADDR_W);
239 }
240
241 #ifdef CONFIG_SPL_BUILD
242 /* Check wait pin as dev ready indicator */
243 int omap_spl_dev_ready(struct mtd_info *mtd)
244 {
245         return readl(&gpmc_cfg->status) & (1 << 8);
246 }
247 #endif
248
249 /*
250  * omap_hwecc_init - Initialize the Hardware ECC for NAND flash in
251  *                   GPMC controller
252  * @mtd:        MTD device structure
253  *
254  */
255 static void __maybe_unused omap_hwecc_init(struct nand_chip *chip)
256 {
257         /*
258          * Init ECC Control Register
259          * Clear all ECC | Enable Reg1
260          */
261         writel(ECCCLEAR | ECCRESULTREG1, &gpmc_cfg->ecc_control);
262         writel(ECCSIZE1 | ECCSIZE0 | ECCSIZE0SEL, &gpmc_cfg->ecc_size_config);
263 }
264
265 /*
266  * gen_true_ecc - This function will generate true ECC value, which
267  * can be used when correcting data read from NAND flash memory core
268  *
269  * @ecc_buf:    buffer to store ecc code
270  *
271  * @return:     re-formatted ECC value
272  */
273 static uint32_t gen_true_ecc(uint8_t *ecc_buf)
274 {
275         return ecc_buf[0] | (ecc_buf[1] << 16) | ((ecc_buf[2] & 0xF0) << 20) |
276                 ((ecc_buf[2] & 0x0F) << 8);
277 }
278
279 /*
280  * omap_correct_data - Compares the ecc read from nand spare area with ECC
281  * registers values and corrects one bit error if it has occured
282  * Further details can be had from OMAP TRM and the following selected links:
283  * http://en.wikipedia.org/wiki/Hamming_code
284  * http://www.cs.utexas.edu/users/plaxton/c/337/05f/slides/ErrorCorrection-4.pdf
285  *
286  * @mtd:                 MTD device structure
287  * @dat:                 page data
288  * @read_ecc:            ecc read from nand flash
289  * @calc_ecc:            ecc read from ECC registers
290  *
291  * @return 0 if data is OK or corrected, else returns -1
292  */
293 static int __maybe_unused omap_correct_data(struct mtd_info *mtd, uint8_t *dat,
294                                 uint8_t *read_ecc, uint8_t *calc_ecc)
295 {
296         uint32_t orig_ecc, new_ecc, res, hm;
297         uint16_t parity_bits, byte;
298         uint8_t bit;
299
300         /* Regenerate the orginal ECC */
301         orig_ecc = gen_true_ecc(read_ecc);
302         new_ecc = gen_true_ecc(calc_ecc);
303         /* Get the XOR of real ecc */
304         res = orig_ecc ^ new_ecc;
305         if (res) {
306                 /* Get the hamming width */
307                 hm = hweight32(res);
308                 /* Single bit errors can be corrected! */
309                 if (hm == 12) {
310                         /* Correctable data! */
311                         parity_bits = res >> 16;
312                         bit = (parity_bits & 0x7);
313                         byte = (parity_bits >> 3) & 0x1FF;
314                         /* Flip the bit to correct */
315                         dat[byte] ^= (0x1 << bit);
316                 } else if (hm == 1) {
317                         printf("Error: Ecc is wrong\n");
318                         /* ECC itself is corrupted */
319                         return 2;
320                 } else {
321                         /*
322                          * hm distance != parity pairs OR one, could mean 2 bit
323                          * error OR potentially be on a blank page..
324                          * orig_ecc: contains spare area data from nand flash.
325                          * new_ecc: generated ecc while reading data area.
326                          * Note: if the ecc = 0, all data bits from which it was
327                          * generated are 0xFF.
328                          * The 3 byte(24 bits) ecc is generated per 512byte
329                          * chunk of a page. If orig_ecc(from spare area)
330                          * is 0xFF && new_ecc(computed now from data area)=0x0,
331                          * this means that data area is 0xFF and spare area is
332                          * 0xFF. A sure sign of a erased page!
333                          */
334                         if ((orig_ecc == 0x0FFF0FFF) && (new_ecc == 0x00000000))
335                                 return 0;
336                         printf("Error: Bad compare! failed\n");
337                         /* detected 2 bit error */
338                         return -1;
339                 }
340         }
341         return 0;
342 }
343
344 /*
345  *  omap_calculate_ecc - Generate non-inverted ECC bytes.
346  *
347  *  Using noninverted ECC can be considered ugly since writing a blank
348  *  page ie. padding will clear the ECC bytes. This is no problem as
349  *  long nobody is trying to write data on the seemingly unused page.
350  *  Reading an erased page will produce an ECC mismatch between
351  *  generated and read ECC bytes that has to be dealt with separately.
352  *  E.g. if page is 0xFF (fresh erased), and if HW ECC engine within GPMC
353  *  is used, the result of read will be 0x0 while the ECC offsets of the
354  *  spare area will be 0xFF which will result in an ECC mismatch.
355  *  @mtd:       MTD structure
356  *  @dat:       unused
357  *  @ecc_code:  ecc_code buffer
358  */
359 static int __maybe_unused omap_calculate_ecc(struct mtd_info *mtd,
360                 const uint8_t *dat, uint8_t *ecc_code)
361 {
362         u_int32_t val;
363
364         /* Start Reading from HW ECC1_Result = 0x200 */
365         val = readl(&gpmc_cfg->ecc1_result);
366
367         ecc_code[0] = val & 0xFF;
368         ecc_code[1] = (val >> 16) & 0xFF;
369         ecc_code[2] = ((val >> 8) & 0x0F) | ((val >> 20) & 0xF0);
370
371         /*
372          * Stop reading anymore ECC vals and clear old results
373          * enable will be called if more reads are required
374          */
375         writel(0x000, &gpmc_cfg->ecc_config);
376
377         return 0;
378 }
379
380 /*
381  * omap_enable_ecc - This function enables the hardware ecc functionality
382  * @mtd:        MTD device structure
383  * @mode:       Read/Write mode
384  */
385 static void __maybe_unused omap_enable_hwecc(struct mtd_info *mtd, int32_t mode)
386 {
387         struct nand_chip *chip = mtd->priv;
388         uint32_t val, dev_width = (chip->options & NAND_BUSWIDTH_16) >> 1;
389
390         switch (mode) {
391         case NAND_ECC_READ:
392         case NAND_ECC_WRITE:
393                 /* Clear the ecc result registers, select ecc reg as 1 */
394                 writel(ECCCLEAR | ECCRESULTREG1, &gpmc_cfg->ecc_control);
395
396                 /*
397                  * Size 0 = 0xFF, Size1 is 0xFF - both are 512 bytes
398                  * tell all regs to generate size0 sized regs
399                  * we just have a single ECC engine for all CS
400                  */
401                 writel(ECCSIZE1 | ECCSIZE0 | ECCSIZE0SEL,
402                         &gpmc_cfg->ecc_size_config);
403                 val = (dev_width << 7) | (cs << 1) | (1 << 0);
404                 writel(val, &gpmc_cfg->ecc_config);
405                 break;
406         default:
407                 printf("Error: Unrecognized Mode[%d]!\n", mode);
408         }
409 }
410
411 /*
412  * Generic BCH interface
413  */
414 struct nand_bch_priv {
415         uint8_t mode;
416         uint8_t type;
417         uint8_t nibbles;
418         struct bch_control *control;
419 };
420
421 /* bch types */
422 #define ECC_BCH4        0
423 #define ECC_BCH8        1
424 #define ECC_BCH16       2
425
426 /* GPMC ecc engine settings */
427 #define BCH_WRAPMODE_1          1       /* BCH wrap mode 1 */
428 #define BCH_WRAPMODE_6          6       /* BCH wrap mode 6 */
429
430 /* BCH nibbles for diff bch levels */
431 #define NAND_ECC_HW_BCH ((uint8_t)(NAND_ECC_HW_OOB_FIRST) + 1)
432 #define ECC_BCH4_NIBBLES        13
433 #define ECC_BCH8_NIBBLES        26
434 #define ECC_BCH16_NIBBLES       52
435
436 /*
437  * This can be a single instance cause all current users have only one NAND
438  * with nearly the same setup (BCH8, some with ELM and others with sw BCH
439  * library).
440  * When some users with other BCH strength will exists this have to change!
441  */
442 static __maybe_unused struct nand_bch_priv bch_priv = {
443         .mode = NAND_ECC_HW_BCH,
444         .type = ECC_BCH8,
445         .nibbles = ECC_BCH8_NIBBLES,
446         .control = NULL,
447 };
448
449 /*
450  * omap_hwecc_init_bch - Initialize the BCH Hardware ECC for NAND flash in
451  *                              GPMC controller
452  * @mtd:        MTD device structure
453  * @mode:       Read/Write mode
454  */
455 __maybe_unused
456 static void omap_hwecc_init_bch(struct nand_chip *chip, int32_t mode)
457 {
458         uint32_t val;
459         uint32_t dev_width = (chip->options & NAND_BUSWIDTH_16) >> 1;
460 #ifdef CONFIG_AM33XX
461         uint32_t unused_length = 0;
462 #endif
463         uint32_t wr_mode = BCH_WRAPMODE_6;
464         struct nand_bch_priv *bch = chip->priv;
465
466         /* Clear the ecc result registers, select ecc reg as 1 */
467         writel(ECCCLEAR | ECCRESULTREG1, &gpmc_cfg->ecc_control);
468
469 #ifdef CONFIG_AM33XX
470         wr_mode = BCH_WRAPMODE_1;
471
472         switch (bch->nibbles) {
473         case ECC_BCH4_NIBBLES:
474                 unused_length = 3;
475                 break;
476         case ECC_BCH8_NIBBLES:
477                 unused_length = 2;
478                 break;
479         case ECC_BCH16_NIBBLES:
480                 unused_length = 0;
481                 break;
482         }
483
484         /*
485          * This is ecc_size_config for ELM mode.
486          * Here we are using different settings for read and write access and
487          * also depending on BCH strength.
488          */
489         switch (mode) {
490         case NAND_ECC_WRITE:
491                 /* write access only setup eccsize1 config */
492                 val = ((unused_length + bch->nibbles) << 22);
493                 break;
494
495         case NAND_ECC_READ:
496         default:
497                 /*
498                  * by default eccsize0 selected for ecc1resultsize
499                  * eccsize0 config.
500                  */
501                 val  = (bch->nibbles << 12);
502                 /* eccsize1 config */
503                 val |= (unused_length << 22);
504                 break;
505         }
506 #else
507         /*
508          * This ecc_size_config setting is for BCH sw library.
509          *
510          * Note: we only support BCH8 currently with BCH sw library!
511          * Should be really easy to adopt to BCH4, however some omap3 have
512          * flaws with BCH4.
513          *
514          * Here we are using wrapping mode 6 both for reading and writing, with:
515          *  size0 = 0  (no additional protected byte in spare area)
516          *  size1 = 32 (skip 32 nibbles = 16 bytes per sector in spare area)
517          */
518         val = (32 << 22) | (0 << 12);
519 #endif
520         /* ecc size configuration */
521         writel(val, &gpmc_cfg->ecc_size_config);
522
523         /*
524          * Configure the ecc engine in gpmc
525          * We assume 512 Byte sector pages for access to NAND.
526          */
527         val  = 1 << 16;                 /* select BCH mode */
528         val |= bch->type << 12;         /* setup BCH type */
529         val |= wr_mode << 8;            /* setup wrapping mode */
530         val |= dev_width << 7;          /* setup device width (16 or 8 bit) */
531         val |= (chip->ecc.size / 512 - 1) << 4; /* set ECC size */
532         val |= cs << 1;                 /* setup chip select to work on */
533         val |= 1 << 0;                  /* enable ECC engine */
534
535         debug("set ECC_CONFIG=0x%08x\n", val);
536         writel(val, &gpmc_cfg->ecc_config);
537 }
538
539 /*
540  * omap_enable_ecc_bch - This function enables the bch h/w ecc functionality
541  * @mtd:        MTD device structure
542  * @mode:       Read/Write mode
543  */
544 __maybe_unused
545 static void omap_enable_ecc_bch(struct mtd_info *mtd, int32_t mode)
546 {
547         struct nand_chip *chip = mtd->priv;
548
549         omap_hwecc_init_bch(chip, mode);
550 }
551
552 /*
553  * omap_ecc_disable - Disable H/W ECC calculation
554  *
555  * @mtd:        MTD device structure
556  */
557 static void __maybe_unused omap_ecc_disable(struct mtd_info *mtd)
558 {
559         writel((readl(&gpmc_cfg->ecc_config) & ~0x1), &gpmc_cfg->ecc_config);
560 }
561
562 /*
563  * BCH8 support (needs ELM and thus AM33xx-only)
564  */
565 #ifdef CONFIG_AM33XX
566 /*
567  * omap_read_bch8_result - Read BCH result for BCH8 level
568  *
569  * @mtd:        MTD device structure
570  * @big_endian: When set read register 3 first
571  * @ecc_code:   Read syndrome from BCH result registers
572  */
573 static void omap_read_bch8_result(struct mtd_info *mtd, uint8_t big_endian,
574                                 uint8_t *ecc_code)
575 {
576         uint32_t *ptr;
577         int8_t i = 0, j, k;
578         struct nand_chip *chip = mtd->priv;
579         int num_steps = chip->ecc.size / 512;
580
581         for (k = 0; k < num_steps; k++) {
582                 if (big_endian) {
583                         ptr = &gpmc_cfg->bch_result_0_3[k].bch_result_x[3];
584                         ecc_code[i++] = readl(ptr) & 0xFF;
585                         ptr--;
586                         for (j = 0; j < 3; j++) {
587                                 ecc_code[i++] = (readl(ptr) >> 24) & 0xFF;
588                                 ecc_code[i++] = (readl(ptr) >> 16) & 0xFF;
589                                 ecc_code[i++] = (readl(ptr) >>  8) & 0xFF;
590                                 ecc_code[i++] = readl(ptr) & 0xFF;
591                                 ptr--;
592                         }
593                 } else {
594                         ptr = &gpmc_cfg->bch_result_0_3[k].bch_result_x[0];
595                         for (j = 0; j < 3; j++) {
596                                 ecc_code[i++] = readl(ptr) & 0xFF;
597                                 ecc_code[i++] = (readl(ptr) >>  8) & 0xFF;
598                                 ecc_code[i++] = (readl(ptr) >> 16) & 0xFF;
599                                 ecc_code[i++] = (readl(ptr) >> 24) & 0xFF;
600                                 ptr++;
601                         }
602                         ecc_code[i++] = readl(ptr) & 0xFF;
603                 }
604                 ecc_code[i++] = 0;      /* 14th byte is always zero */
605         }
606 }
607
608 /*
609  * omap_rotate_ecc_bch - Rotate the syndrome bytes
610  *
611  * @mtd:        MTD device structure
612  * @calc_ecc:   ECC read from ECC registers
613  * @syndrome:   Rotated syndrome will be returned in this array
614  *
615  */
616 static void omap_rotate_ecc_bch(struct mtd_info *mtd, uint8_t *calc_ecc,
617                 uint8_t *syndrome)
618 {
619         struct nand_chip *chip = mtd->priv;
620         struct nand_bch_priv *bch = chip->priv;
621         uint8_t n_bytes = 0;
622         int8_t i, j;
623
624         switch (bch->type) {
625         case ECC_BCH4:
626                 n_bytes = 8;
627                 break;
628
629         case ECC_BCH16:
630                 n_bytes = 28;
631                 break;
632
633         case ECC_BCH8:
634         default:
635                 n_bytes = 13;
636                 break;
637         }
638
639         for (i = 0, j = n_bytes - 1; i < n_bytes; i++, j--)
640                 syndrome[i] =  calc_ecc[j];
641 }
642
643 /*
644  *  omap_calculate_ecc_bch - Read BCH ECC result
645  *
646  *  @mtd:       MTD structure
647  *  @dat:       unused
648  *  @ecc_code:  ecc_code buffer
649  */
650 static int omap_calculate_ecc_bch(struct mtd_info *mtd, const uint8_t *dat,
651                                 uint8_t *ecc_code)
652 {
653         struct nand_chip *chip = mtd->priv;
654         struct nand_bch_priv *bch = chip->priv;
655         uint8_t big_endian = 1;
656         int8_t ret = 0;
657
658         if (bch->type == ECC_BCH8)
659                 omap_read_bch8_result(mtd, big_endian, ecc_code);
660         else /* BCH4 and BCH16 currently not supported */
661                 ret = -1;
662
663         /*
664          * Stop reading anymore ECC vals and clear old results
665          * enable will be called if more reads are required
666          */
667         omap_ecc_disable(mtd);
668
669         return ret;
670 }
671
672 /*
673  * omap_fix_errors_bch - Correct bch error in the data
674  *
675  * @mtd:        MTD device structure
676  * @data:       Data read from flash
677  * @error_count:Number of errors in data
678  * @error_loc:  Locations of errors in the data
679  *
680  */
681 static void omap_fix_errors_bch(struct mtd_info *mtd, uint8_t *data,
682                 uint32_t error_count, uint32_t *error_loc)
683 {
684         struct nand_chip *chip = mtd->priv;
685         struct nand_bch_priv *bch = chip->priv;
686         uint8_t count = 0;
687         uint32_t error_byte_pos;
688         uint32_t error_bit_mask;
689         uint32_t last_bit = (bch->nibbles * 4) - 1;
690
691         /* Flip all bits as specified by the error location array. */
692         /* FOR( each found error location flip the bit ) */
693         for (count = 0; count < error_count; count++) {
694                 if (error_loc[count] > last_bit) {
695                         /* Remove the ECC spare bits from correction. */
696                         error_loc[count] -= (last_bit + 1);
697                         /* Offset bit in data region */
698                         error_byte_pos = ((512 * 8) -
699                                         (error_loc[count]) - 1) / 8;
700                         /* Error Bit mask */
701                         error_bit_mask = 0x1 << (error_loc[count] % 8);
702                         /* Toggle the error bit to make the correction. */
703                         data[error_byte_pos] ^= error_bit_mask;
704                 }
705         }
706 }
707
708 /*
709  * omap_correct_data_bch - Compares the ecc read from nand spare area
710  * with ECC registers values and corrects one bit error if it has occured
711  *
712  * @mtd:        MTD device structure
713  * @dat:        page data
714  * @read_ecc:   ecc read from nand flash (ignored)
715  * @calc_ecc:   ecc read from ECC registers
716  *
717  * @return 0 if data is OK or corrected, else returns -1
718  */
719 static int omap_correct_data_bch(struct mtd_info *mtd, uint8_t *dat,
720                                 uint8_t *read_ecc, uint8_t *calc_ecc)
721 {
722         struct nand_chip *chip = mtd->priv;
723         struct nand_bch_priv *bch = chip->priv;
724         uint8_t syndrome[28];
725         uint32_t error_count = 0;
726         uint32_t error_loc[8];
727         uint32_t i, ecc_flag;
728         int k, ecc_bytes, num_steps;
729
730         num_steps = chip->ecc.size / 512;
731         ecc_bytes = chip->ecc.bytes / num_steps;
732
733         for (k = 0; k < num_steps; k++) {
734                 ecc_flag = 0;
735                 /* check if area is flashed */
736                 for (i = 0; i < chip->ecc.bytes && !ecc_flag; i++)
737                         if (read_ecc[i] != 0xff)
738                                 ecc_flag = 1;
739
740                 if (ecc_flag) {
741                         ecc_flag = 0;
742                         /* check if any ecc error */
743                         for (i = 0; (i < ecc_bytes) && !ecc_flag; i++)
744                                 if (calc_ecc[i] != 0)
745                                         ecc_flag = 1;
746                 }
747
748                 if (!ecc_flag)
749                         return 0;
750
751                 elm_reset();
752                 elm_config((enum bch_level)(bch->type));
753
754                 /*
755                  * while reading ECC result we read it in big endian.
756                  * Hence while loading to ELM we have rotate to get the right endian.
757                  */
758                 omap_rotate_ecc_bch(mtd, calc_ecc, syndrome);
759
760                 /* use elm module to check for errors */
761                 if (elm_check_error(syndrome, bch->nibbles, &error_count,
762                                         error_loc) != 0) {
763                         printf("ECC: uncorrectable.\n");
764                         return -1;
765                 }
766
767                 /* correct bch error */
768                 if (error_count > 0)
769                         omap_fix_errors_bch(mtd, dat, error_count, error_loc);
770                 dat += 512;
771                 read_ecc += ecc_bytes;
772                 calc_ecc += ecc_bytes;
773         }
774         return 0;
775 }
776
777 /**
778  * omap_read_page_bch - hardware ecc based page read function
779  * @mtd:        mtd info structure
780  * @chip:       nand chip info structure
781  * @buf:        buffer to store read data
782  * @oob_required: caller expects OOB data read to chip->oob_poi
783  * @page:       page number to read
784  *
785  */
786 static int omap_read_page_bch(struct mtd_info *mtd, struct nand_chip *chip,
787                                 uint8_t *buf, int oob_required, int page)
788 {
789         int i, eccsize = chip->ecc.size;
790         int eccbytes = chip->ecc.bytes;
791         int eccsteps = chip->ecc.steps;
792         uint8_t *p = buf;
793         uint8_t *ecc_calc = chip->buffers->ecccalc;
794         uint8_t *ecc_code = chip->buffers->ecccode;
795         uint32_t *eccpos = chip->ecc.layout->eccpos;
796         uint8_t *oob = &chip->oob_poi[eccpos[0]];
797         uint32_t data_pos;
798         uint32_t oob_pos;
799
800         data_pos = 0;
801         /* oob area start */
802         oob_pos = (eccsize * eccsteps) + eccpos[0];
803
804         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize,
805                                 oob += eccbytes) {
806                 chip->ecc.hwctl(mtd, NAND_ECC_READ);
807                 /* read data */
808                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, data_pos, page);
809                 chip->read_buf(mtd, p, eccsize);
810
811                 /* read respective ecc from oob area */
812                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_pos, page);
813                 chip->read_buf(mtd, oob, eccbytes);
814                 /* read syndrome */
815                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
816
817                 if (oob_required) {
818                         /* reread the OOB area to get the metadata */
819                         chip->cmdfunc(mtd, NAND_CMD_RNDOUT, mtd->writesize, page);
820                         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
821                 }
822
823                 data_pos += eccsize;
824                 oob_pos += eccbytes;
825         }
826
827         for (i = 0; i < chip->ecc.total; i++)
828                 ecc_code[i] = chip->oob_poi[eccpos[i]];
829
830         eccsteps = chip->ecc.steps;
831         p = buf;
832
833         for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
834                 int stat;
835
836                 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
837                 if (stat < 0)
838                         mtd->ecc_stats.failed++;
839                 else
840                         mtd->ecc_stats.corrected += stat;
841         }
842         return 0;
843 }
844 #endif /* CONFIG_AM33XX */
845
846 /*
847  * OMAP3 BCH8 support (with BCH library)
848  */
849 #ifdef CONFIG_NAND_OMAP_BCH8
850 /*
851  *  omap_calculate_ecc_bch - Read BCH ECC result
852  *
853  *  @mtd:       MTD device structure
854  *  @dat:       The pointer to data on which ecc is computed (unused here)
855  *  @ecc:       The ECC output buffer
856  */
857 static int omap_calculate_ecc_bch(struct mtd_info *mtd, const uint8_t *dat,
858                                 uint8_t *ecc)
859 {
860         int ret = 0;
861         size_t i;
862         unsigned long nsectors, val1, val2, val3, val4;
863
864         nsectors = ((readl(&gpmc_cfg->ecc_config) >> 4) & 0x7) + 1;
865
866         for (i = 0; i < nsectors; i++) {
867                 /* Read hw-computed remainder */
868                 val1 = readl(&gpmc_cfg->bch_result_0_3[i].bch_result_x[0]);
869                 val2 = readl(&gpmc_cfg->bch_result_0_3[i].bch_result_x[1]);
870                 val3 = readl(&gpmc_cfg->bch_result_0_3[i].bch_result_x[2]);
871                 val4 = readl(&gpmc_cfg->bch_result_0_3[i].bch_result_x[3]);
872
873                 /*
874                  * Add constant polynomial to remainder, in order to get an ecc
875                  * sequence of 0xFFs for a buffer filled with 0xFFs.
876                  */
877                 *ecc++ = 0xef ^ (val4 & 0xFF);
878                 *ecc++ = 0x51 ^ ((val3 >> 24) & 0xFF);
879                 *ecc++ = 0x2e ^ ((val3 >> 16) & 0xFF);
880                 *ecc++ = 0x09 ^ ((val3 >> 8) & 0xFF);
881                 *ecc++ = 0xed ^ (val3 & 0xFF);
882                 *ecc++ = 0x93 ^ ((val2 >> 24) & 0xFF);
883                 *ecc++ = 0x9a ^ ((val2 >> 16) & 0xFF);
884                 *ecc++ = 0xc2 ^ ((val2 >> 8) & 0xFF);
885                 *ecc++ = 0x97 ^ (val2 & 0xFF);
886                 *ecc++ = 0x79 ^ ((val1 >> 24) & 0xFF);
887                 *ecc++ = 0xe5 ^ ((val1 >> 16) & 0xFF);
888                 *ecc++ = 0x24 ^ ((val1 >> 8) & 0xFF);
889                 *ecc++ = 0xb5 ^ (val1 & 0xFF);
890         }
891
892         /*
893          * Stop reading anymore ECC vals and clear old results
894          * enable will be called if more reads are required
895          */
896         omap_ecc_disable(mtd);
897
898         return ret;
899 }
900
901 /**
902  * omap_correct_data_bch - Decode received data and correct errors
903  * @mtd: MTD device structure
904  * @data: page data
905  * @read_ecc: ecc read from nand flash
906  * @calc_ecc: ecc read from HW ECC registers
907  */
908 static int omap_correct_data_bch(struct mtd_info *mtd, u_char *data,
909                                  u_char *read_ecc, u_char *calc_ecc)
910 {
911         int i, count;
912         /* cannot correct more than 8 errors */
913         unsigned int errloc[8];
914         struct nand_chip *chip = mtd->priv;
915         struct nand_bch_priv *chip_priv = chip->priv;
916         struct bch_control *bch = chip_priv->control;
917
918         count = decode_bch(bch, NULL, 512, read_ecc, calc_ecc, NULL, errloc);
919         if (count > 0) {
920                 /* correct errors */
921                 for (i = 0; i < count; i++) {
922                         /* correct data only, not ecc bytes */
923                         if (errloc[i] < 8*512)
924                                 data[errloc[i]/8] ^= 1 << (errloc[i] & 7);
925                         printf("corrected bitflip %u\n", errloc[i]);
926 #ifdef DEBUG
927                         printf("read_ecc: ");
928                         /*
929                          * BCH8 have 13 bytes of ECC; BCH4 needs adoption
930                          * here!
931                          */
932                         for (i = 0; i < 13; i++)
933                                 printf("%02x ", read_ecc[i]);
934                         printf("\n");
935                         printf("calc_ecc: ");
936                         for (i = 0; i < 13; i++)
937                                 printf("%02x ", calc_ecc[i]);
938                         printf("\n");
939 #endif
940                 }
941         } else if (count < 0) {
942                 printf("ecc unrecoverable error\n");
943         }
944         return count;
945 }
946
947 /**
948  * omap_free_bch - Release BCH ecc resources
949  * @mtd: MTD device structure
950  */
951 static void __maybe_unused omap_free_bch(struct mtd_info *mtd)
952 {
953         struct nand_chip *chip = mtd->priv;
954         struct nand_bch_priv *chip_priv = chip->priv;
955         struct bch_control *bch = NULL;
956
957         if (chip_priv)
958                 bch = chip_priv->control;
959
960         if (bch) {
961                 free_bch(bch);
962                 chip_priv->control = NULL;
963         }
964 }
965 #endif /* CONFIG_NAND_OMAP_BCH8 */
966
967 #ifndef CONFIG_SPL_BUILD
968 /*
969  * omap_nand_switch_ecc - switch the ECC operation between different engines
970  * (h/w and s/w) and different algorithms (hamming and BCHx)
971  *
972  * @hardware            - true if one of the HW engines should be used
973  * @eccstrength         - the number of bits that could be corrected
974  *                        (1 - hamming, 4 - BCH4, 8 - BCH8, 16 - BCH16)
975  */
976 void omap_nand_switch_ecc(uint32_t hardware, uint32_t eccstrength)
977 {
978         struct nand_chip *nand;
979         struct mtd_info *mtd;
980
981         if (nand_curr_device < 0 ||
982             nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE ||
983             !nand_info[nand_curr_device].name) {
984                 printf("Error: Can't switch ecc, no devices available\n");
985                 return;
986         }
987
988         mtd = &nand_info[nand_curr_device];
989         nand = mtd->priv;
990
991         nand->options |= NAND_OWN_BUFFERS;
992
993         /* Reset ecc interface */
994         nand->ecc.mode = NAND_ECC_NONE;
995         nand->ecc.read_page = NULL;
996         nand->ecc.write_page = NULL;
997         nand->ecc.read_oob = NULL;
998         nand->ecc.write_oob = NULL;
999         nand->ecc.hwctl = NULL;
1000         nand->ecc.correct = NULL;
1001         nand->ecc.calculate = NULL;
1002         nand->ecc.strength = eccstrength;
1003
1004         /* Setup the ecc configurations again */
1005         if (hardware) {
1006                 if (eccstrength == 1) {
1007                         nand->ecc.mode = NAND_ECC_HW;
1008                         nand->ecc.layout = &hw_nand_oob;
1009                         nand->ecc.size = 512;
1010                         nand->ecc.bytes = 3;
1011                         nand->ecc.hwctl = omap_enable_hwecc;
1012                         nand->ecc.correct = omap_correct_data;
1013                         nand->ecc.calculate = omap_calculate_ecc;
1014                         omap_hwecc_init(nand);
1015                         printf("1-bit hamming HW ECC selected\n");
1016                 }
1017 #if defined(CONFIG_AM33XX) || defined(CONFIG_NAND_OMAP_BCH8)
1018                 else if (eccstrength == 8) {
1019                         nand->ecc.mode = NAND_ECC_HW;
1020                         nand->ecc.layout = &hw_bch8_nand_oob;
1021                         nand->ecc.size = 512;
1022 #ifdef CONFIG_AM33XX
1023                         nand->ecc.bytes = 14;
1024                         nand->ecc.read_page = omap_read_page_bch;
1025 #else
1026                         nand->ecc.bytes = 13;
1027 #endif
1028                         nand->ecc.hwctl = omap_enable_ecc_bch;
1029                         nand->ecc.correct = omap_correct_data_bch;
1030                         nand->ecc.calculate = omap_calculate_ecc_bch;
1031                         omap_hwecc_init_bch(nand, NAND_ECC_READ);
1032                         printf("8-bit BCH HW ECC selected\n");
1033                 }
1034 #endif
1035         } else {
1036                 nand->ecc.mode = NAND_ECC_SOFT;
1037                 /* Use mtd default settings */
1038                 nand->ecc.layout = NULL;
1039                 nand->ecc.size = 0;
1040                 printf("SW ECC selected\n");
1041         }
1042
1043         /* Update NAND handling after ECC mode switch */
1044         nand_scan_tail(mtd);
1045
1046         nand->options &= ~NAND_OWN_BUFFERS;
1047 }
1048 #endif /* CONFIG_SPL_BUILD */
1049
1050 /*
1051  * Board-specific NAND initialization. The following members of the
1052  * argument are board-specific:
1053  * - IO_ADDR_R: address to read the 8 I/O lines of the flash device
1054  * - IO_ADDR_W: address to write the 8 I/O lines of the flash device
1055  * - cmd_ctrl: hardwarespecific function for accesing control-lines
1056  * - waitfunc: hardwarespecific function for accesing device ready/busy line
1057  * - ecc.hwctl: function to enable (reset) hardware ecc generator
1058  * - ecc.mode: mode of ecc, see defines
1059  * - chip_delay: chip dependent delay for transfering data from array to
1060  *   read regs (tR)
1061  * - options: various chip options. They can partly be set to inform
1062  *   nand_scan about special functionality. See the defines for further
1063  *   explanation
1064  */
1065 int board_nand_init(struct nand_chip *nand)
1066 {
1067         int32_t gpmc_config = 0;
1068         cs = 0;
1069
1070         /*
1071          * xloader/Uboot's gpmc configuration would have configured GPMC for
1072          * nand type of memory. The following logic scans and latches on to the
1073          * first CS with NAND type memory.
1074          * TBD: need to make this logic generic to handle multiple CS NAND
1075          * devices.
1076          */
1077         while (cs < GPMC_MAX_CS) {
1078                 /* Check if NAND type is set */
1079                 if ((readl(&gpmc_cfg->cs[cs].config1) & 0xC00) == 0x800) {
1080                         /* Found it!! */
1081                         break;
1082                 }
1083                 cs++;
1084         }
1085         if (cs >= GPMC_MAX_CS) {
1086                 printf("NAND: Unable to find NAND settings in "
1087                         "GPMC Configuration - quitting\n");
1088                 return -ENODEV;
1089         }
1090
1091         gpmc_config = readl(&gpmc_cfg->config);
1092         /* Disable Write protect */
1093         gpmc_config |= 0x10;
1094         writel(gpmc_config, &gpmc_cfg->config);
1095
1096         nand->IO_ADDR_R = (void __iomem *)&gpmc_cfg->cs[cs].nand_dat;
1097         nand->IO_ADDR_W = (void __iomem *)&gpmc_cfg->cs[cs].nand_cmd;
1098
1099         nand->cmd_ctrl = omap_nand_hwcontrol;
1100         nand->options = NAND_NO_PADDING | NAND_CACHEPRG | NAND_NO_SUBPAGE_WRITE;
1101         /* If we are 16 bit dev, our gpmc config tells us that */
1102         if ((readl(&gpmc_cfg->cs[cs].config1) & 0x3000) == 0x1000)
1103                 nand->options |= NAND_BUSWIDTH_16;
1104
1105         nand->chip_delay = 100;
1106
1107 #if defined(CONFIG_AM33XX) || defined(CONFIG_NAND_OMAP_BCH8)
1108 #ifdef CONFIG_AM33XX
1109         /* AM33xx uses the ELM */
1110         /* required in case of BCH */
1111         elm_init();
1112 #else
1113         /*
1114          * Whereas other OMAP based SoC do not have the ELM, they use the BCH
1115          * SW library.
1116          */
1117         bch_priv.control = init_bch(13, 8, 0x201b /* hw polynominal */);
1118         if (!bch_priv.control) {
1119                 printf("Failed to initialize BCH engine\n");
1120                 return -ENODEV;
1121         }
1122 #endif
1123         /* BCH info that will be correct for SPL or overridden otherwise. */
1124         nand->priv = &bch_priv;
1125 #endif
1126
1127         /* Default ECC mode */
1128 #if defined(CONFIG_AM33XX) || defined(CONFIG_NAND_OMAP_BCH8)
1129         nand->ecc.mode = NAND_ECC_HW;
1130         nand->ecc.layout = &hw_bch8_nand_oob;
1131 #ifdef CONFIG_SYS_GPMC_PREFETCH_ENABLE
1132         nand->ecc.size = CONFIG_SYS_NAND_ECCSIZE * 4;
1133         nand->ecc.bytes = CONFIG_SYS_NAND_ECCBYTES * 4;
1134 #else
1135         nand->ecc.size = CONFIG_SYS_NAND_ECCSIZE;
1136         nand->ecc.bytes = CONFIG_SYS_NAND_ECCBYTES;
1137 #endif
1138         nand->ecc.strength = 8;
1139         nand->ecc.hwctl = omap_enable_ecc_bch;
1140         nand->ecc.correct = omap_correct_data_bch;
1141         nand->ecc.calculate = omap_calculate_ecc_bch;
1142 #ifdef CONFIG_AM33XX
1143         nand->ecc.read_page = omap_read_page_bch;
1144 #endif
1145         omap_hwecc_init_bch(nand, NAND_ECC_READ);
1146 #else
1147 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_NAND_SOFTECC)
1148         nand->ecc.mode = NAND_ECC_SOFT;
1149 #else
1150         nand->ecc.mode = NAND_ECC_HW;
1151         nand->ecc.layout = &hw_nand_oob;
1152         nand->ecc.size = CONFIG_SYS_NAND_ECCSIZE;
1153         nand->ecc.bytes = CONFIG_SYS_NAND_ECCBYTES;
1154         nand->ecc.hwctl = omap_enable_hwecc;
1155         nand->ecc.correct = omap_correct_data;
1156         nand->ecc.calculate = omap_calculate_ecc;
1157         nand->ecc.strength = 1;
1158         omap_hwecc_init(nand);
1159 #endif
1160 #endif
1161 #ifdef CONFIG_SYS_NAND_USE_FLASH_BBT
1162         if (nand->ecc.layout) {
1163                 bbt_main_descr.offs = nand->ecc.layout->oobfree[0].offset;
1164                 bbt_main_descr.veroffs = bbt_main_descr.offs +
1165                         sizeof(bbt_pattern);
1166
1167                 bbt_mirror_descr.offs = nand->ecc.layout->oobfree[0].offset;
1168                 bbt_mirror_descr.veroffs = bbt_mirror_descr.offs +
1169                         sizeof(mirror_pattern);
1170         }
1171
1172         nand->bbt_options |= NAND_BBT_USE_FLASH;
1173         nand->bbt_td = &bbt_main_descr;
1174         nand->bbt_md = &bbt_mirror_descr;
1175 #endif
1176
1177 #ifdef CONFIG_SPL_BUILD
1178         if (nand->options & NAND_BUSWIDTH_16)
1179                 nand->read_buf = nand_read_buf16;
1180         else
1181                 nand->read_buf = nand_read_buf;
1182         nand->dev_ready = omap_spl_dev_ready;
1183 #else
1184 #ifdef CONFIG_SYS_GPMC_PREFETCH_ENABLE
1185         nand->write_buf = write_buf_pref;
1186         nand->read_buf = read_buf_pref;
1187 #endif /* CONFIG_SYS_GPMC_PREFETCH_ENABLE */
1188 #endif /* CONFIG_SPL_BUILD */
1189
1190         return 0;
1191 }