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