ad51f8ef0d4fcd82ad26345133e9dd764cc82206
[~shefty/rdma-dev.git] / drivers / mtd / nand / davinci_nand.c
1 /*
2  * davinci_nand.c - NAND Flash Driver for DaVinci family chips
3  *
4  * Copyright © 2006 Texas Instruments.
5  *
6  * Port to 2.6.23 Copyright © 2008 by:
7  *   Sander Huijsen <Shuijsen@optelecom-nkf.com>
8  *   Troy Kisky <troy.kisky@boundarydevices.com>
9  *   Dirk Behme <Dirk.Behme@gmail.com>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (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., 675 Mass Ave, Cambridge, MA 02139, USA.
24  */
25
26 #include <linux/kernel.h>
27 #include <linux/init.h>
28 #include <linux/module.h>
29 #include <linux/platform_device.h>
30 #include <linux/err.h>
31 #include <linux/clk.h>
32 #include <linux/io.h>
33 #include <linux/mtd/nand.h>
34 #include <linux/mtd/partitions.h>
35 #include <linux/slab.h>
36
37 #include <mach/nand.h>
38
39 #include <asm/mach-types.h>
40
41
42 /*
43  * This is a device driver for the NAND flash controller found on the
44  * various DaVinci family chips.  It handles up to four SoC chipselects,
45  * and some flavors of secondary chipselect (e.g. based on A12) as used
46  * with multichip packages.
47  *
48  * The 1-bit ECC hardware is supported, as well as the newer 4-bit ECC
49  * available on chips like the DM355 and OMAP-L137 and needed with the
50  * more error-prone MLC NAND chips.
51  *
52  * This driver assumes EM_WAIT connects all the NAND devices' RDY/nBUSY
53  * outputs in a "wire-AND" configuration, with no per-chip signals.
54  */
55 struct davinci_nand_info {
56         struct mtd_info         mtd;
57         struct nand_chip        chip;
58         struct nand_ecclayout   ecclayout;
59
60         struct device           *dev;
61         struct clk              *clk;
62         bool                    partitioned;
63
64         bool                    is_readmode;
65
66         void __iomem            *base;
67         void __iomem            *vaddr;
68
69         uint32_t                ioaddr;
70         uint32_t                current_cs;
71
72         uint32_t                mask_chipsel;
73         uint32_t                mask_ale;
74         uint32_t                mask_cle;
75
76         uint32_t                core_chipsel;
77 };
78
79 static DEFINE_SPINLOCK(davinci_nand_lock);
80 static bool ecc4_busy;
81
82 #define to_davinci_nand(m) container_of(m, struct davinci_nand_info, mtd)
83
84
85 static inline unsigned int davinci_nand_readl(struct davinci_nand_info *info,
86                 int offset)
87 {
88         return __raw_readl(info->base + offset);
89 }
90
91 static inline void davinci_nand_writel(struct davinci_nand_info *info,
92                 int offset, unsigned long value)
93 {
94         __raw_writel(value, info->base + offset);
95 }
96
97 /*----------------------------------------------------------------------*/
98
99 /*
100  * Access to hardware control lines:  ALE, CLE, secondary chipselect.
101  */
102
103 static void nand_davinci_hwcontrol(struct mtd_info *mtd, int cmd,
104                                    unsigned int ctrl)
105 {
106         struct davinci_nand_info        *info = to_davinci_nand(mtd);
107         uint32_t                        addr = info->current_cs;
108         struct nand_chip                *nand = mtd->priv;
109
110         /* Did the control lines change? */
111         if (ctrl & NAND_CTRL_CHANGE) {
112                 if ((ctrl & NAND_CTRL_CLE) == NAND_CTRL_CLE)
113                         addr |= info->mask_cle;
114                 else if ((ctrl & NAND_CTRL_ALE) == NAND_CTRL_ALE)
115                         addr |= info->mask_ale;
116
117                 nand->IO_ADDR_W = (void __iomem __force *)addr;
118         }
119
120         if (cmd != NAND_CMD_NONE)
121                 iowrite8(cmd, nand->IO_ADDR_W);
122 }
123
124 static void nand_davinci_select_chip(struct mtd_info *mtd, int chip)
125 {
126         struct davinci_nand_info        *info = to_davinci_nand(mtd);
127         uint32_t                        addr = info->ioaddr;
128
129         /* maybe kick in a second chipselect */
130         if (chip > 0)
131                 addr |= info->mask_chipsel;
132         info->current_cs = addr;
133
134         info->chip.IO_ADDR_W = (void __iomem __force *)addr;
135         info->chip.IO_ADDR_R = info->chip.IO_ADDR_W;
136 }
137
138 /*----------------------------------------------------------------------*/
139
140 /*
141  * 1-bit hardware ECC ... context maintained for each core chipselect
142  */
143
144 static inline uint32_t nand_davinci_readecc_1bit(struct mtd_info *mtd)
145 {
146         struct davinci_nand_info *info = to_davinci_nand(mtd);
147
148         return davinci_nand_readl(info, NANDF1ECC_OFFSET
149                         + 4 * info->core_chipsel);
150 }
151
152 static void nand_davinci_hwctl_1bit(struct mtd_info *mtd, int mode)
153 {
154         struct davinci_nand_info *info;
155         uint32_t nandcfr;
156         unsigned long flags;
157
158         info = to_davinci_nand(mtd);
159
160         /* Reset ECC hardware */
161         nand_davinci_readecc_1bit(mtd);
162
163         spin_lock_irqsave(&davinci_nand_lock, flags);
164
165         /* Restart ECC hardware */
166         nandcfr = davinci_nand_readl(info, NANDFCR_OFFSET);
167         nandcfr |= BIT(8 + info->core_chipsel);
168         davinci_nand_writel(info, NANDFCR_OFFSET, nandcfr);
169
170         spin_unlock_irqrestore(&davinci_nand_lock, flags);
171 }
172
173 /*
174  * Read hardware ECC value and pack into three bytes
175  */
176 static int nand_davinci_calculate_1bit(struct mtd_info *mtd,
177                                       const u_char *dat, u_char *ecc_code)
178 {
179         unsigned int ecc_val = nand_davinci_readecc_1bit(mtd);
180         unsigned int ecc24 = (ecc_val & 0x0fff) | ((ecc_val & 0x0fff0000) >> 4);
181
182         /* invert so that erased block ecc is correct */
183         ecc24 = ~ecc24;
184         ecc_code[0] = (u_char)(ecc24);
185         ecc_code[1] = (u_char)(ecc24 >> 8);
186         ecc_code[2] = (u_char)(ecc24 >> 16);
187
188         return 0;
189 }
190
191 static int nand_davinci_correct_1bit(struct mtd_info *mtd, u_char *dat,
192                                      u_char *read_ecc, u_char *calc_ecc)
193 {
194         struct nand_chip *chip = mtd->priv;
195         uint32_t eccNand = read_ecc[0] | (read_ecc[1] << 8) |
196                                           (read_ecc[2] << 16);
197         uint32_t eccCalc = calc_ecc[0] | (calc_ecc[1] << 8) |
198                                           (calc_ecc[2] << 16);
199         uint32_t diff = eccCalc ^ eccNand;
200
201         if (diff) {
202                 if ((((diff >> 12) ^ diff) & 0xfff) == 0xfff) {
203                         /* Correctable error */
204                         if ((diff >> (12 + 3)) < chip->ecc.size) {
205                                 dat[diff >> (12 + 3)] ^= BIT((diff >> 12) & 7);
206                                 return 1;
207                         } else {
208                                 return -1;
209                         }
210                 } else if (!(diff & (diff - 1))) {
211                         /* Single bit ECC error in the ECC itself,
212                          * nothing to fix */
213                         return 1;
214                 } else {
215                         /* Uncorrectable error */
216                         return -1;
217                 }
218
219         }
220         return 0;
221 }
222
223 /*----------------------------------------------------------------------*/
224
225 /*
226  * 4-bit hardware ECC ... context maintained over entire AEMIF
227  *
228  * This is a syndrome engine, but we avoid NAND_ECC_HW_SYNDROME
229  * since that forces use of a problematic "infix OOB" layout.
230  * Among other things, it trashes manufacturer bad block markers.
231  * Also, and specific to this hardware, it ECC-protects the "prepad"
232  * in the OOB ... while having ECC protection for parts of OOB would
233  * seem useful, the current MTD stack sometimes wants to update the
234  * OOB without recomputing ECC.
235  */
236
237 static void nand_davinci_hwctl_4bit(struct mtd_info *mtd, int mode)
238 {
239         struct davinci_nand_info *info = to_davinci_nand(mtd);
240         unsigned long flags;
241         u32 val;
242
243         spin_lock_irqsave(&davinci_nand_lock, flags);
244
245         /* Start 4-bit ECC calculation for read/write */
246         val = davinci_nand_readl(info, NANDFCR_OFFSET);
247         val &= ~(0x03 << 4);
248         val |= (info->core_chipsel << 4) | BIT(12);
249         davinci_nand_writel(info, NANDFCR_OFFSET, val);
250
251         info->is_readmode = (mode == NAND_ECC_READ);
252
253         spin_unlock_irqrestore(&davinci_nand_lock, flags);
254 }
255
256 /* Read raw ECC code after writing to NAND. */
257 static void
258 nand_davinci_readecc_4bit(struct davinci_nand_info *info, u32 code[4])
259 {
260         const u32 mask = 0x03ff03ff;
261
262         code[0] = davinci_nand_readl(info, NAND_4BIT_ECC1_OFFSET) & mask;
263         code[1] = davinci_nand_readl(info, NAND_4BIT_ECC2_OFFSET) & mask;
264         code[2] = davinci_nand_readl(info, NAND_4BIT_ECC3_OFFSET) & mask;
265         code[3] = davinci_nand_readl(info, NAND_4BIT_ECC4_OFFSET) & mask;
266 }
267
268 /* Terminate read ECC; or return ECC (as bytes) of data written to NAND. */
269 static int nand_davinci_calculate_4bit(struct mtd_info *mtd,
270                 const u_char *dat, u_char *ecc_code)
271 {
272         struct davinci_nand_info *info = to_davinci_nand(mtd);
273         u32 raw_ecc[4], *p;
274         unsigned i;
275
276         /* After a read, terminate ECC calculation by a dummy read
277          * of some 4-bit ECC register.  ECC covers everything that
278          * was read; correct() just uses the hardware state, so
279          * ecc_code is not needed.
280          */
281         if (info->is_readmode) {
282                 davinci_nand_readl(info, NAND_4BIT_ECC1_OFFSET);
283                 return 0;
284         }
285
286         /* Pack eight raw 10-bit ecc values into ten bytes, making
287          * two passes which each convert four values (in upper and
288          * lower halves of two 32-bit words) into five bytes.  The
289          * ROM boot loader uses this same packing scheme.
290          */
291         nand_davinci_readecc_4bit(info, raw_ecc);
292         for (i = 0, p = raw_ecc; i < 2; i++, p += 2) {
293                 *ecc_code++ =   p[0]        & 0xff;
294                 *ecc_code++ = ((p[0] >>  8) & 0x03) | ((p[0] >> 14) & 0xfc);
295                 *ecc_code++ = ((p[0] >> 22) & 0x0f) | ((p[1] <<  4) & 0xf0);
296                 *ecc_code++ = ((p[1] >>  4) & 0x3f) | ((p[1] >> 10) & 0xc0);
297                 *ecc_code++ =  (p[1] >> 18) & 0xff;
298         }
299
300         return 0;
301 }
302
303 /* Correct up to 4 bits in data we just read, using state left in the
304  * hardware plus the ecc_code computed when it was first written.
305  */
306 static int nand_davinci_correct_4bit(struct mtd_info *mtd,
307                 u_char *data, u_char *ecc_code, u_char *null)
308 {
309         int i;
310         struct davinci_nand_info *info = to_davinci_nand(mtd);
311         unsigned short ecc10[8];
312         unsigned short *ecc16;
313         u32 syndrome[4];
314         u32 ecc_state;
315         unsigned num_errors, corrected;
316         unsigned long timeo;
317
318         /* All bytes 0xff?  It's an erased page; ignore its ECC. */
319         for (i = 0; i < 10; i++) {
320                 if (ecc_code[i] != 0xff)
321                         goto compare;
322         }
323         return 0;
324
325 compare:
326         /* Unpack ten bytes into eight 10 bit values.  We know we're
327          * little-endian, and use type punning for less shifting/masking.
328          */
329         if (WARN_ON(0x01 & (unsigned) ecc_code))
330                 return -EINVAL;
331         ecc16 = (unsigned short *)ecc_code;
332
333         ecc10[0] =  (ecc16[0] >>  0) & 0x3ff;
334         ecc10[1] = ((ecc16[0] >> 10) & 0x3f) | ((ecc16[1] << 6) & 0x3c0);
335         ecc10[2] =  (ecc16[1] >>  4) & 0x3ff;
336         ecc10[3] = ((ecc16[1] >> 14) & 0x3)  | ((ecc16[2] << 2) & 0x3fc);
337         ecc10[4] =  (ecc16[2] >>  8)         | ((ecc16[3] << 8) & 0x300);
338         ecc10[5] =  (ecc16[3] >>  2) & 0x3ff;
339         ecc10[6] = ((ecc16[3] >> 12) & 0xf)  | ((ecc16[4] << 4) & 0x3f0);
340         ecc10[7] =  (ecc16[4] >>  6) & 0x3ff;
341
342         /* Tell ECC controller about the expected ECC codes. */
343         for (i = 7; i >= 0; i--)
344                 davinci_nand_writel(info, NAND_4BIT_ECC_LOAD_OFFSET, ecc10[i]);
345
346         /* Allow time for syndrome calculation ... then read it.
347          * A syndrome of all zeroes 0 means no detected errors.
348          */
349         davinci_nand_readl(info, NANDFSR_OFFSET);
350         nand_davinci_readecc_4bit(info, syndrome);
351         if (!(syndrome[0] | syndrome[1] | syndrome[2] | syndrome[3]))
352                 return 0;
353
354         /*
355          * Clear any previous address calculation by doing a dummy read of an
356          * error address register.
357          */
358         davinci_nand_readl(info, NAND_ERR_ADD1_OFFSET);
359
360         /* Start address calculation, and wait for it to complete.
361          * We _could_ start reading more data while this is working,
362          * to speed up the overall page read.
363          */
364         davinci_nand_writel(info, NANDFCR_OFFSET,
365                         davinci_nand_readl(info, NANDFCR_OFFSET) | BIT(13));
366
367         /*
368          * ECC_STATE field reads 0x3 (Error correction complete) immediately
369          * after setting the 4BITECC_ADD_CALC_START bit. So if you immediately
370          * begin trying to poll for the state, you may fall right out of your
371          * loop without any of the correction calculations having taken place.
372          * The recommendation from the hardware team is to initially delay as
373          * long as ECC_STATE reads less than 4. After that, ECC HW has entered
374          * correction state.
375          */
376         timeo = jiffies + usecs_to_jiffies(100);
377         do {
378                 ecc_state = (davinci_nand_readl(info,
379                                 NANDFSR_OFFSET) >> 8) & 0x0f;
380                 cpu_relax();
381         } while ((ecc_state < 4) && time_before(jiffies, timeo));
382
383         for (;;) {
384                 u32     fsr = davinci_nand_readl(info, NANDFSR_OFFSET);
385
386                 switch ((fsr >> 8) & 0x0f) {
387                 case 0:         /* no error, should not happen */
388                         davinci_nand_readl(info, NAND_ERR_ERRVAL1_OFFSET);
389                         return 0;
390                 case 1:         /* five or more errors detected */
391                         davinci_nand_readl(info, NAND_ERR_ERRVAL1_OFFSET);
392                         return -EIO;
393                 case 2:         /* error addresses computed */
394                 case 3:
395                         num_errors = 1 + ((fsr >> 16) & 0x03);
396                         goto correct;
397                 default:        /* still working on it */
398                         cpu_relax();
399                         continue;
400                 }
401         }
402
403 correct:
404         /* correct each error */
405         for (i = 0, corrected = 0; i < num_errors; i++) {
406                 int error_address, error_value;
407
408                 if (i > 1) {
409                         error_address = davinci_nand_readl(info,
410                                                 NAND_ERR_ADD2_OFFSET);
411                         error_value = davinci_nand_readl(info,
412                                                 NAND_ERR_ERRVAL2_OFFSET);
413                 } else {
414                         error_address = davinci_nand_readl(info,
415                                                 NAND_ERR_ADD1_OFFSET);
416                         error_value = davinci_nand_readl(info,
417                                                 NAND_ERR_ERRVAL1_OFFSET);
418                 }
419
420                 if (i & 1) {
421                         error_address >>= 16;
422                         error_value >>= 16;
423                 }
424                 error_address &= 0x3ff;
425                 error_address = (512 + 7) - error_address;
426
427                 if (error_address < 512) {
428                         data[error_address] ^= error_value;
429                         corrected++;
430                 }
431         }
432
433         return corrected;
434 }
435
436 /*----------------------------------------------------------------------*/
437
438 /*
439  * NOTE:  NAND boot requires ALE == EM_A[1], CLE == EM_A[2], so that's
440  * how these chips are normally wired.  This translates to both 8 and 16
441  * bit busses using ALE == BIT(3) in byte addresses, and CLE == BIT(4).
442  *
443  * For now we assume that configuration, or any other one which ignores
444  * the two LSBs for NAND access ... so we can issue 32-bit reads/writes
445  * and have that transparently morphed into multiple NAND operations.
446  */
447 static void nand_davinci_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
448 {
449         struct nand_chip *chip = mtd->priv;
450
451         if ((0x03 & ((unsigned)buf)) == 0 && (0x03 & len) == 0)
452                 ioread32_rep(chip->IO_ADDR_R, buf, len >> 2);
453         else if ((0x01 & ((unsigned)buf)) == 0 && (0x01 & len) == 0)
454                 ioread16_rep(chip->IO_ADDR_R, buf, len >> 1);
455         else
456                 ioread8_rep(chip->IO_ADDR_R, buf, len);
457 }
458
459 static void nand_davinci_write_buf(struct mtd_info *mtd,
460                 const uint8_t *buf, int len)
461 {
462         struct nand_chip *chip = mtd->priv;
463
464         if ((0x03 & ((unsigned)buf)) == 0 && (0x03 & len) == 0)
465                 iowrite32_rep(chip->IO_ADDR_R, buf, len >> 2);
466         else if ((0x01 & ((unsigned)buf)) == 0 && (0x01 & len) == 0)
467                 iowrite16_rep(chip->IO_ADDR_R, buf, len >> 1);
468         else
469                 iowrite8_rep(chip->IO_ADDR_R, buf, len);
470 }
471
472 /*
473  * Check hardware register for wait status. Returns 1 if device is ready,
474  * 0 if it is still busy.
475  */
476 static int nand_davinci_dev_ready(struct mtd_info *mtd)
477 {
478         struct davinci_nand_info *info = to_davinci_nand(mtd);
479
480         return davinci_nand_readl(info, NANDFSR_OFFSET) & BIT(0);
481 }
482
483 static void __init nand_dm6446evm_flash_init(struct davinci_nand_info *info)
484 {
485         uint32_t regval, a1cr;
486
487         /*
488          * NAND FLASH timings @ PLL1 == 459 MHz
489          *  - AEMIF.CLK freq   = PLL1/6 = 459/6 = 76.5 MHz
490          *  - AEMIF.CLK period = 1/76.5 MHz = 13.1 ns
491          */
492         regval = 0
493                 | (0 << 31)           /* selectStrobe */
494                 | (0 << 30)           /* extWait (never with NAND) */
495                 | (1 << 26)           /* writeSetup      10 ns */
496                 | (3 << 20)           /* writeStrobe     40 ns */
497                 | (1 << 17)           /* writeHold       10 ns */
498                 | (0 << 13)           /* readSetup       10 ns */
499                 | (3 << 7)            /* readStrobe      60 ns */
500                 | (0 << 4)            /* readHold        10 ns */
501                 | (3 << 2)            /* turnAround      ?? ns */
502                 | (0 << 0)            /* asyncSize       8-bit bus */
503                 ;
504         a1cr = davinci_nand_readl(info, A1CR_OFFSET);
505         if (a1cr != regval) {
506                 dev_dbg(info->dev, "Warning: NAND config: Set A1CR " \
507                        "reg to 0x%08x, was 0x%08x, should be done by " \
508                        "bootloader.\n", regval, a1cr);
509                 davinci_nand_writel(info, A1CR_OFFSET, regval);
510         }
511 }
512
513 /*----------------------------------------------------------------------*/
514
515 /* An ECC layout for using 4-bit ECC with small-page flash, storing
516  * ten ECC bytes plus the manufacturer's bad block marker byte, and
517  * and not overlapping the default BBT markers.
518  */
519 static struct nand_ecclayout hwecc4_small __initconst = {
520         .eccbytes = 10,
521         .eccpos = { 0, 1, 2, 3, 4,
522                 /* offset 5 holds the badblock marker */
523                 6, 7,
524                 13, 14, 15, },
525         .oobfree = {
526                 {.offset = 8, .length = 5, },
527                 {.offset = 16, },
528         },
529 };
530
531 /* An ECC layout for using 4-bit ECC with large-page (2048bytes) flash,
532  * storing ten ECC bytes plus the manufacturer's bad block marker byte,
533  * and not overlapping the default BBT markers.
534  */
535 static struct nand_ecclayout hwecc4_2048 __initconst = {
536         .eccbytes = 40,
537         .eccpos = {
538                 /* at the end of spare sector */
539                 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
540                 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
541                 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
542                 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
543                 },
544         .oobfree = {
545                 /* 2 bytes at offset 0 hold manufacturer badblock markers */
546                 {.offset = 2, .length = 22, },
547                 /* 5 bytes at offset 8 hold BBT markers */
548                 /* 8 bytes at offset 16 hold JFFS2 clean markers */
549         },
550 };
551
552 static int __init nand_davinci_probe(struct platform_device *pdev)
553 {
554         struct davinci_nand_pdata       *pdata = pdev->dev.platform_data;
555         struct davinci_nand_info        *info;
556         struct resource                 *res1;
557         struct resource                 *res2;
558         void __iomem                    *vaddr;
559         void __iomem                    *base;
560         int                             ret;
561         uint32_t                        val;
562         nand_ecc_modes_t                ecc_mode;
563
564         /* insist on board-specific configuration */
565         if (!pdata)
566                 return -ENODEV;
567
568         /* which external chipselect will we be managing? */
569         if (pdev->id < 0 || pdev->id > 3)
570                 return -ENODEV;
571
572         info = kzalloc(sizeof(*info), GFP_KERNEL);
573         if (!info) {
574                 dev_err(&pdev->dev, "unable to allocate memory\n");
575                 ret = -ENOMEM;
576                 goto err_nomem;
577         }
578
579         platform_set_drvdata(pdev, info);
580
581         res1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
582         res2 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
583         if (!res1 || !res2) {
584                 dev_err(&pdev->dev, "resource missing\n");
585                 ret = -EINVAL;
586                 goto err_nomem;
587         }
588
589         vaddr = ioremap(res1->start, resource_size(res1));
590         base = ioremap(res2->start, resource_size(res2));
591         if (!vaddr || !base) {
592                 dev_err(&pdev->dev, "ioremap failed\n");
593                 ret = -EINVAL;
594                 goto err_ioremap;
595         }
596
597         info->dev               = &pdev->dev;
598         info->base              = base;
599         info->vaddr             = vaddr;
600
601         info->mtd.priv          = &info->chip;
602         info->mtd.name          = dev_name(&pdev->dev);
603         info->mtd.owner         = THIS_MODULE;
604
605         info->mtd.dev.parent    = &pdev->dev;
606
607         info->chip.IO_ADDR_R    = vaddr;
608         info->chip.IO_ADDR_W    = vaddr;
609         info->chip.chip_delay   = 0;
610         info->chip.select_chip  = nand_davinci_select_chip;
611
612         /* options such as NAND_USE_FLASH_BBT or 16-bit widths */
613         info->chip.options      = pdata->options;
614         info->chip.bbt_td       = pdata->bbt_td;
615         info->chip.bbt_md       = pdata->bbt_md;
616
617         info->ioaddr            = (uint32_t __force) vaddr;
618
619         info->current_cs        = info->ioaddr;
620         info->core_chipsel      = pdev->id;
621         info->mask_chipsel      = pdata->mask_chipsel;
622
623         /* use nandboot-capable ALE/CLE masks by default */
624         info->mask_ale          = pdata->mask_ale ? : MASK_ALE;
625         info->mask_cle          = pdata->mask_cle ? : MASK_CLE;
626
627         /* Set address of hardware control function */
628         info->chip.cmd_ctrl     = nand_davinci_hwcontrol;
629         info->chip.dev_ready    = nand_davinci_dev_ready;
630
631         /* Speed up buffer I/O */
632         info->chip.read_buf     = nand_davinci_read_buf;
633         info->chip.write_buf    = nand_davinci_write_buf;
634
635         /* Use board-specific ECC config */
636         ecc_mode                = pdata->ecc_mode;
637
638         ret = -EINVAL;
639         switch (ecc_mode) {
640         case NAND_ECC_NONE:
641         case NAND_ECC_SOFT:
642                 pdata->ecc_bits = 0;
643                 break;
644         case NAND_ECC_HW:
645                 if (pdata->ecc_bits == 4) {
646                         /* No sanity checks:  CPUs must support this,
647                          * and the chips may not use NAND_BUSWIDTH_16.
648                          */
649
650                         /* No sharing 4-bit hardware between chipselects yet */
651                         spin_lock_irq(&davinci_nand_lock);
652                         if (ecc4_busy)
653                                 ret = -EBUSY;
654                         else
655                                 ecc4_busy = true;
656                         spin_unlock_irq(&davinci_nand_lock);
657
658                         if (ret == -EBUSY)
659                                 goto err_ecc;
660
661                         info->chip.ecc.calculate = nand_davinci_calculate_4bit;
662                         info->chip.ecc.correct = nand_davinci_correct_4bit;
663                         info->chip.ecc.hwctl = nand_davinci_hwctl_4bit;
664                         info->chip.ecc.bytes = 10;
665                 } else {
666                         info->chip.ecc.calculate = nand_davinci_calculate_1bit;
667                         info->chip.ecc.correct = nand_davinci_correct_1bit;
668                         info->chip.ecc.hwctl = nand_davinci_hwctl_1bit;
669                         info->chip.ecc.bytes = 3;
670                 }
671                 info->chip.ecc.size = 512;
672                 break;
673         default:
674                 ret = -EINVAL;
675                 goto err_ecc;
676         }
677         info->chip.ecc.mode = ecc_mode;
678
679         info->clk = clk_get(&pdev->dev, "aemif");
680         if (IS_ERR(info->clk)) {
681                 ret = PTR_ERR(info->clk);
682                 dev_dbg(&pdev->dev, "unable to get AEMIF clock, err %d\n", ret);
683                 goto err_clk;
684         }
685
686         ret = clk_enable(info->clk);
687         if (ret < 0) {
688                 dev_dbg(&pdev->dev, "unable to enable AEMIF clock, err %d\n",
689                         ret);
690                 goto err_clk_enable;
691         }
692
693         /* EMIF timings should normally be set by the boot loader,
694          * especially after boot-from-NAND.  The *only* reason to
695          * have this special casing for the DM6446 EVM is to work
696          * with boot-from-NOR ... with CS0 manually re-jumpered
697          * (after startup) so it addresses the NAND flash, not NOR.
698          * Even for dev boards, that's unusually rude...
699          */
700         if (machine_is_davinci_evm())
701                 nand_dm6446evm_flash_init(info);
702
703         spin_lock_irq(&davinci_nand_lock);
704
705         /* put CSxNAND into NAND mode */
706         val = davinci_nand_readl(info, NANDFCR_OFFSET);
707         val |= BIT(info->core_chipsel);
708         davinci_nand_writel(info, NANDFCR_OFFSET, val);
709
710         spin_unlock_irq(&davinci_nand_lock);
711
712         /* Scan to find existence of the device(s) */
713         ret = nand_scan_ident(&info->mtd, pdata->mask_chipsel ? 2 : 1, NULL);
714         if (ret < 0) {
715                 dev_dbg(&pdev->dev, "no NAND chip(s) found\n");
716                 goto err_scan;
717         }
718
719         /* Update ECC layout if needed ... for 1-bit HW ECC, the default
720          * is OK, but it allocates 6 bytes when only 3 are needed (for
721          * each 512 bytes).  For the 4-bit HW ECC, that default is not
722          * usable:  10 bytes are needed, not 6.
723          */
724         if (pdata->ecc_bits == 4) {
725                 int     chunks = info->mtd.writesize / 512;
726
727                 if (!chunks || info->mtd.oobsize < 16) {
728                         dev_dbg(&pdev->dev, "too small\n");
729                         ret = -EINVAL;
730                         goto err_scan;
731                 }
732
733                 /* For small page chips, preserve the manufacturer's
734                  * badblock marking data ... and make sure a flash BBT
735                  * table marker fits in the free bytes.
736                  */
737                 if (chunks == 1) {
738                         info->ecclayout = hwecc4_small;
739                         info->ecclayout.oobfree[1].length =
740                                 info->mtd.oobsize - 16;
741                         goto syndrome_done;
742                 }
743                 if (chunks == 4) {
744                         info->ecclayout = hwecc4_2048;
745                         info->chip.ecc.mode = NAND_ECC_HW_OOB_FIRST;
746                         goto syndrome_done;
747                 }
748
749                 /* 4KiB page chips are not yet supported. The eccpos from
750                  * nand_ecclayout cannot hold 80 bytes and change to eccpos[]
751                  * breaks userspace ioctl interface with mtd-utils. Once we
752                  * resolve this issue, NAND_ECC_HW_OOB_FIRST mode can be used
753                  * for the 4KiB page chips.
754                  *
755                  * TODO: Note that nand_ecclayout has now been expanded and can
756                  *  hold plenty of OOB entries.
757                  */
758                 dev_warn(&pdev->dev, "no 4-bit ECC support yet "
759                                 "for 4KiB-page NAND\n");
760                 ret = -EIO;
761                 goto err_scan;
762
763 syndrome_done:
764                 info->chip.ecc.layout = &info->ecclayout;
765         }
766
767         ret = nand_scan_tail(&info->mtd);
768         if (ret < 0)
769                 goto err_scan;
770
771         if (mtd_has_partitions()) {
772                 struct mtd_partition    *mtd_parts = NULL;
773                 int                     mtd_parts_nb = 0;
774
775                 if (mtd_has_cmdlinepart()) {
776                         static const char *probes[] __initconst =
777                                 { "cmdlinepart", NULL };
778
779                         mtd_parts_nb = parse_mtd_partitions(&info->mtd, probes,
780                                                             &mtd_parts, 0);
781                 }
782
783                 if (mtd_parts_nb <= 0) {
784                         mtd_parts = pdata->parts;
785                         mtd_parts_nb = pdata->nr_parts;
786                 }
787
788                 /* Register any partitions */
789                 if (mtd_parts_nb > 0) {
790                         ret = add_mtd_partitions(&info->mtd,
791                                         mtd_parts, mtd_parts_nb);
792                         if (ret == 0)
793                                 info->partitioned = true;
794                 }
795
796         } else if (pdata->nr_parts) {
797                 dev_warn(&pdev->dev, "ignoring %d default partitions on %s\n",
798                                 pdata->nr_parts, info->mtd.name);
799         }
800
801         /* If there's no partition info, just package the whole chip
802          * as a single MTD device.
803          */
804         if (!info->partitioned)
805                 ret = add_mtd_device(&info->mtd) ? -ENODEV : 0;
806
807         if (ret < 0)
808                 goto err_scan;
809
810         val = davinci_nand_readl(info, NRCSR_OFFSET);
811         dev_info(&pdev->dev, "controller rev. %d.%d\n",
812                (val >> 8) & 0xff, val & 0xff);
813
814         return 0;
815
816 err_scan:
817         clk_disable(info->clk);
818
819 err_clk_enable:
820         clk_put(info->clk);
821
822         spin_lock_irq(&davinci_nand_lock);
823         if (ecc_mode == NAND_ECC_HW_SYNDROME)
824                 ecc4_busy = false;
825         spin_unlock_irq(&davinci_nand_lock);
826
827 err_ecc:
828 err_clk:
829 err_ioremap:
830         if (base)
831                 iounmap(base);
832         if (vaddr)
833                 iounmap(vaddr);
834
835 err_nomem:
836         kfree(info);
837         return ret;
838 }
839
840 static int __exit nand_davinci_remove(struct platform_device *pdev)
841 {
842         struct davinci_nand_info *info = platform_get_drvdata(pdev);
843         int status;
844
845         if (mtd_has_partitions() && info->partitioned)
846                 status = del_mtd_partitions(&info->mtd);
847         else
848                 status = del_mtd_device(&info->mtd);
849
850         spin_lock_irq(&davinci_nand_lock);
851         if (info->chip.ecc.mode == NAND_ECC_HW_SYNDROME)
852                 ecc4_busy = false;
853         spin_unlock_irq(&davinci_nand_lock);
854
855         iounmap(info->base);
856         iounmap(info->vaddr);
857
858         nand_release(&info->mtd);
859
860         clk_disable(info->clk);
861         clk_put(info->clk);
862
863         kfree(info);
864
865         return 0;
866 }
867
868 static struct platform_driver nand_davinci_driver = {
869         .remove         = __exit_p(nand_davinci_remove),
870         .driver         = {
871                 .name   = "davinci_nand",
872         },
873 };
874 MODULE_ALIAS("platform:davinci_nand");
875
876 static int __init nand_davinci_init(void)
877 {
878         return platform_driver_probe(&nand_davinci_driver, nand_davinci_probe);
879 }
880 module_init(nand_davinci_init);
881
882 static void __exit nand_davinci_exit(void)
883 {
884         platform_driver_unregister(&nand_davinci_driver);
885 }
886 module_exit(nand_davinci_exit);
887
888 MODULE_LICENSE("GPL");
889 MODULE_AUTHOR("Texas Instruments");
890 MODULE_DESCRIPTION("Davinci NAND flash driver");
891