?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
arm: Add devicetree fixup machine function
[linux/fpc-iii.git] / drivers / mtd / nand / pxa3xx_nand.c
blob96b0b1d27df1b23846d09e81be2065ea59c66b7b
1 /*
2 * drivers/mtd/nand/pxa3xx_nand.c
3 *
4 * Copyright © 2005 Intel Corporation
5 * Copyright © 2006 Marvell International Ltd.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 *
11 * See Documentation/mtd/nand/pxa3xx-nand.txt for more details.
12 */
13
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/interrupt.h>
17 #include <linux/platform_device.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/delay.h>
20 #include <linux/clk.h>
21 #include <linux/mtd/mtd.h>
22 #include <linux/mtd/nand.h>
23 #include <linux/mtd/partitions.h>
24 #include <linux/io.h>
25 #include <linux/irq.h>
26 #include <linux/slab.h>
27 #include <linux/of.h>
28 #include <linux/of_device.h>
29 #include <linux/of_mtd.h>
30
31 #if defined(CONFIG_ARCH_PXA) || defined(CONFIG_ARCH_MMP)
32 #define ARCH_HAS_DMA
33 #endif
34
35 #ifdef ARCH_HAS_DMA
36 #include <mach/dma.h>
37 #endif
38
39 #include <linux/platform_data/mtd-nand-pxa3xx.h>
40
41 #define CHIP_DELAY_TIMEOUT (2 * HZ/10)
42 #define NAND_STOP_DELAY (2 * HZ/50)
43 #define PAGE_CHUNK_SIZE (2048)
44
45 /*
46 * Define a buffer size for the initial command that detects the flash device:
47 * STATUS, READID and PARAM. The largest of these is the PARAM command,
48 * needing 256 bytes.
49 */
50 #define INIT_BUFFER_SIZE 256
51
52 /* registers and bit definitions */
53 #define NDCR (0x00) /* Control register */
54 #define NDTR0CS0 (0x04) /* Timing Parameter 0 for CS0 */
55 #define NDTR1CS0 (0x0C) /* Timing Parameter 1 for CS0 */
56 #define NDSR (0x14) /* Status Register */
57 #define NDPCR (0x18) /* Page Count Register */
58 #define NDBDR0 (0x1C) /* Bad Block Register 0 */
59 #define NDBDR1 (0x20) /* Bad Block Register 1 */
60 #define NDECCCTRL (0x28) /* ECC control */
61 #define NDDB (0x40) /* Data Buffer */
62 #define NDCB0 (0x48) /* Command Buffer0 */
63 #define NDCB1 (0x4C) /* Command Buffer1 */
64 #define NDCB2 (0x50) /* Command Buffer2 */
65
66 #define NDCR_SPARE_EN (0x1 << 31)
67 #define NDCR_ECC_EN (0x1 << 30)
68 #define NDCR_DMA_EN (0x1 << 29)
69 #define NDCR_ND_RUN (0x1 << 28)
70 #define NDCR_DWIDTH_C (0x1 << 27)
71 #define NDCR_DWIDTH_M (0x1 << 26)
72 #define NDCR_PAGE_SZ (0x1 << 24)
73 #define NDCR_NCSX (0x1 << 23)
74 #define NDCR_ND_MODE (0x3 << 21)
75 #define NDCR_NAND_MODE (0x0)
76 #define NDCR_CLR_PG_CNT (0x1 << 20)
77 #define NDCR_STOP_ON_UNCOR (0x1 << 19)
78 #define NDCR_RD_ID_CNT_MASK (0x7 << 16)
79 #define NDCR_RD_ID_CNT(x) (((x) << 16) & NDCR_RD_ID_CNT_MASK)
80
81 #define NDCR_RA_START (0x1 << 15)
82 #define NDCR_PG_PER_BLK (0x1 << 14)
83 #define NDCR_ND_ARB_EN (0x1 << 12)
84 #define NDCR_INT_MASK (0xFFF)
85
86 #define NDSR_MASK (0xfff)
87 #define NDSR_ERR_CNT_OFF (16)
88 #define NDSR_ERR_CNT_MASK (0x1f)
89 #define NDSR_ERR_CNT(sr) ((sr >> NDSR_ERR_CNT_OFF) & NDSR_ERR_CNT_MASK)
90 #define NDSR_RDY (0x1 << 12)
91 #define NDSR_FLASH_RDY (0x1 << 11)
92 #define NDSR_CS0_PAGED (0x1 << 10)
93 #define NDSR_CS1_PAGED (0x1 << 9)
94 #define NDSR_CS0_CMDD (0x1 << 8)
95 #define NDSR_CS1_CMDD (0x1 << 7)
96 #define NDSR_CS0_BBD (0x1 << 6)
97 #define NDSR_CS1_BBD (0x1 << 5)
98 #define NDSR_UNCORERR (0x1 << 4)
99 #define NDSR_CORERR (0x1 << 3)
100 #define NDSR_WRDREQ (0x1 << 2)
101 #define NDSR_RDDREQ (0x1 << 1)
102 #define NDSR_WRCMDREQ (0x1)
103
104 #define NDCB0_LEN_OVRD (0x1 << 28)
105 #define NDCB0_ST_ROW_EN (0x1 << 26)
106 #define NDCB0_AUTO_RS (0x1 << 25)
107 #define NDCB0_CSEL (0x1 << 24)
108 #define NDCB0_EXT_CMD_TYPE_MASK (0x7 << 29)
109 #define NDCB0_EXT_CMD_TYPE(x) (((x) << 29) & NDCB0_EXT_CMD_TYPE_MASK)
110 #define NDCB0_CMD_TYPE_MASK (0x7 << 21)
111 #define NDCB0_CMD_TYPE(x) (((x) << 21) & NDCB0_CMD_TYPE_MASK)
112 #define NDCB0_NC (0x1 << 20)
113 #define NDCB0_DBC (0x1 << 19)
114 #define NDCB0_ADDR_CYC_MASK (0x7 << 16)
115 #define NDCB0_ADDR_CYC(x) (((x) << 16) & NDCB0_ADDR_CYC_MASK)
116 #define NDCB0_CMD2_MASK (0xff << 8)
117 #define NDCB0_CMD1_MASK (0xff)
118 #define NDCB0_ADDR_CYC_SHIFT (16)
119
120 #define EXT_CMD_TYPE_DISPATCH 6 /* Command dispatch */
121 #define EXT_CMD_TYPE_NAKED_RW 5 /* Naked read or Naked write */
122 #define EXT_CMD_TYPE_READ 4 /* Read */
123 #define EXT_CMD_TYPE_DISP_WR 4 /* Command dispatch with write */
124 #define EXT_CMD_TYPE_FINAL 3 /* Final command */
125 #define EXT_CMD_TYPE_LAST_RW 1 /* Last naked read/write */
126 #define EXT_CMD_TYPE_MONO 0 /* Monolithic read/write */
127
128 /* macros for registers read/write */
129 #define nand_writel(info, off, val) \
130 writel_relaxed((val), (info)->mmio_base + (off))
131
132 #define nand_readl(info, off) \
133 readl_relaxed((info)->mmio_base + (off))
134
135 /* error code and state */
136 enum {
137 ERR_NONE = 0,
138 ERR_DMABUSERR = -1,
139 ERR_SENDCMD = -2,
140 ERR_UNCORERR = -3,
141 ERR_BBERR = -4,
142 ERR_CORERR = -5,
143 };
144
145 enum {
146 STATE_IDLE = 0,
147 STATE_PREPARED,
148 STATE_CMD_HANDLE,
149 STATE_DMA_READING,
150 STATE_DMA_WRITING,
151 STATE_DMA_DONE,
152 STATE_PIO_READING,
153 STATE_PIO_WRITING,
154 STATE_CMD_DONE,
155 STATE_READY,
156 };
157
158 enum pxa3xx_nand_variant {
159 PXA3XX_NAND_VARIANT_PXA,
160 PXA3XX_NAND_VARIANT_ARMADA370,
161 };
162
163 struct pxa3xx_nand_host {
164 struct nand_chip chip;
165 struct mtd_info *mtd;
166 void *info_data;
167
168 /* page size of attached chip */
169 int use_ecc;
170 int cs;
171
172 /* calculated from pxa3xx_nand_flash data */
173 unsigned int col_addr_cycles;
174 unsigned int row_addr_cycles;
175 size_t read_id_bytes;
176
177 };
178
179 struct pxa3xx_nand_info {
180 struct nand_hw_control controller;
181 struct platform_device *pdev;
182
183 struct clk *clk;
184 void __iomem *mmio_base;
185 unsigned long mmio_phys;
186 struct completion cmd_complete, dev_ready;
187
188 unsigned int buf_start;
189 unsigned int buf_count;
190 unsigned int buf_size;
191 unsigned int data_buff_pos;
192 unsigned int oob_buff_pos;
193
194 /* DMA information */
195 int drcmr_dat;
196 int drcmr_cmd;
197
198 unsigned char *data_buff;
199 unsigned char *oob_buff;
200 dma_addr_t data_buff_phys;
201 int data_dma_ch;
202 struct pxa_dma_desc *data_desc;
203 dma_addr_t data_desc_addr;
204
205 struct pxa3xx_nand_host *host[NUM_CHIP_SELECT];
206 unsigned int state;
207
208 /*
209 * This driver supports NFCv1 (as found in PXA SoC)
210 * and NFCv2 (as found in Armada 370/XP SoC).
211 */
212 enum pxa3xx_nand_variant variant;
213
214 int cs;
215 int use_ecc; /* use HW ECC ? */
216 int ecc_bch; /* using BCH ECC? */
217 int use_dma; /* use DMA ? */
218 int use_spare; /* use spare ? */
219 int need_wait;
220
221 unsigned int data_size; /* data to be read from FIFO */
222 unsigned int chunk_size; /* split commands chunk size */
223 unsigned int oob_size;
224 unsigned int spare_size;
225 unsigned int ecc_size;
226 unsigned int ecc_err_cnt;
227 unsigned int max_bitflips;
228 int retcode;
229
230 /* cached register value */
231 uint32_t reg_ndcr;
232 uint32_t ndtr0cs0;
233 uint32_t ndtr1cs0;
234
235 /* generated NDCBx register values */
236 uint32_t ndcb0;
237 uint32_t ndcb1;
238 uint32_t ndcb2;
239 uint32_t ndcb3;
240 };
241
242 static bool use_dma = 1;
243 module_param(use_dma, bool, 0444);
244 MODULE_PARM_DESC(use_dma, "enable DMA for data transferring to/from NAND HW");
245
246 static struct pxa3xx_nand_timing timing[] = {
247 { 40, 80, 60, 100, 80, 100, 90000, 400, 40, },
248 { 10, 0, 20, 40, 30, 40, 11123, 110, 10, },
249 { 10, 25, 15, 25, 15, 30, 25000, 60, 10, },
250 { 10, 35, 15, 25, 15, 25, 25000, 60, 10, },
251 };
252
253 static struct pxa3xx_nand_flash builtin_flash_types[] = {
254 { "DEFAULT FLASH", 0, 0, 2048, 8, 8, 0, &timing[0] },
255 { "64MiB 16-bit", 0x46ec, 32, 512, 16, 16, 4096, &timing[1] },
256 { "256MiB 8-bit", 0xdaec, 64, 2048, 8, 8, 2048, &timing[1] },
257 { "4GiB 8-bit", 0xd7ec, 128, 4096, 8, 8, 8192, &timing[1] },
258 { "128MiB 8-bit", 0xa12c, 64, 2048, 8, 8, 1024, &timing[2] },
259 { "128MiB 16-bit", 0xb12c, 64, 2048, 16, 16, 1024, &timing[2] },
260 { "512MiB 8-bit", 0xdc2c, 64, 2048, 8, 8, 4096, &timing[2] },
261 { "512MiB 16-bit", 0xcc2c, 64, 2048, 16, 16, 4096, &timing[2] },
262 { "256MiB 16-bit", 0xba20, 64, 2048, 16, 16, 2048, &timing[3] },
263 };
264
265 static u8 bbt_pattern[] = {'M', 'V', 'B', 'b', 't', '0' };
266 static u8 bbt_mirror_pattern[] = {'1', 't', 'b', 'B', 'V', 'M' };
267
268 static struct nand_bbt_descr bbt_main_descr = {
269 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
270 | NAND_BBT_2BIT | NAND_BBT_VERSION,
271 .offs = 8,
272 .len = 6,
273 .veroffs = 14,
274 .maxblocks = 8, /* Last 8 blocks in each chip */
275 .pattern = bbt_pattern
276 };
277
278 static struct nand_bbt_descr bbt_mirror_descr = {
279 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
280 | NAND_BBT_2BIT | NAND_BBT_VERSION,
281 .offs = 8,
282 .len = 6,
283 .veroffs = 14,
284 .maxblocks = 8, /* Last 8 blocks in each chip */
285 .pattern = bbt_mirror_pattern
286 };
287
288 static struct nand_ecclayout ecc_layout_2KB_bch4bit = {
289 .eccbytes = 32,
290 .eccpos = {
291 32, 33, 34, 35, 36, 37, 38, 39,
292 40, 41, 42, 43, 44, 45, 46, 47,
293 48, 49, 50, 51, 52, 53, 54, 55,
294 56, 57, 58, 59, 60, 61, 62, 63},
295 .oobfree = { {2, 30} }
296 };
297
298 static struct nand_ecclayout ecc_layout_4KB_bch4bit = {
299 .eccbytes = 64,
300 .eccpos = {
301 32, 33, 34, 35, 36, 37, 38, 39,
302 40, 41, 42, 43, 44, 45, 46, 47,
303 48, 49, 50, 51, 52, 53, 54, 55,
304 56, 57, 58, 59, 60, 61, 62, 63,
305 96, 97, 98, 99, 100, 101, 102, 103,
306 104, 105, 106, 107, 108, 109, 110, 111,
307 112, 113, 114, 115, 116, 117, 118, 119,
308 120, 121, 122, 123, 124, 125, 126, 127},
309 /* Bootrom looks in bytes 0 & 5 for bad blocks */
310 .oobfree = { {6, 26}, { 64, 32} }
311 };
312
313 static struct nand_ecclayout ecc_layout_4KB_bch8bit = {
314 .eccbytes = 128,
315 .eccpos = {
316 32, 33, 34, 35, 36, 37, 38, 39,
317 40, 41, 42, 43, 44, 45, 46, 47,
318 48, 49, 50, 51, 52, 53, 54, 55,
319 56, 57, 58, 59, 60, 61, 62, 63},
320 .oobfree = { }
321 };
322
323 /* Define a default flash type setting serve as flash detecting only */
324 #define DEFAULT_FLASH_TYPE (&builtin_flash_types[0])
325
326 #define NDTR0_tCH(c) (min((c), 7) << 19)
327 #define NDTR0_tCS(c) (min((c), 7) << 16)
328 #define NDTR0_tWH(c) (min((c), 7) << 11)
329 #define NDTR0_tWP(c) (min((c), 7) << 8)
330 #define NDTR0_tRH(c) (min((c), 7) << 3)
331 #define NDTR0_tRP(c) (min((c), 7) << 0)
332
333 #define NDTR1_tR(c) (min((c), 65535) << 16)
334 #define NDTR1_tWHR(c) (min((c), 15) << 4)
335 #define NDTR1_tAR(c) (min((c), 15) << 0)
336
337 /* convert nano-seconds to nand flash controller clock cycles */
338 #define ns2cycle(ns, clk) (int)((ns) * (clk / 1000000) / 1000)
339
340 static const struct of_device_id pxa3xx_nand_dt_ids[] = {
341 {
342 .compatible = "marvell,pxa3xx-nand",
343 .data = (void *)PXA3XX_NAND_VARIANT_PXA,
344 },
345 {
346 .compatible = "marvell,armada370-nand",
347 .data = (void *)PXA3XX_NAND_VARIANT_ARMADA370,
348 },
349 {}
350 };
351 MODULE_DEVICE_TABLE(of, pxa3xx_nand_dt_ids);
352
353 static enum pxa3xx_nand_variant
354 pxa3xx_nand_get_variant(struct platform_device *pdev)
355 {
356 const struct of_device_id *of_id =
357 of_match_device(pxa3xx_nand_dt_ids, &pdev->dev);
358 if (!of_id)
359 return PXA3XX_NAND_VARIANT_PXA;
360 return (enum pxa3xx_nand_variant)of_id->data;
361 }
362
363 static void pxa3xx_nand_set_timing(struct pxa3xx_nand_host *host,
364 const struct pxa3xx_nand_timing *t)
365 {
366 struct pxa3xx_nand_info *info = host->info_data;
367 unsigned long nand_clk = clk_get_rate(info->clk);
368 uint32_t ndtr0, ndtr1;
369
370 ndtr0 = NDTR0_tCH(ns2cycle(t->tCH, nand_clk)) |
371 NDTR0_tCS(ns2cycle(t->tCS, nand_clk)) |
372 NDTR0_tWH(ns2cycle(t->tWH, nand_clk)) |
373 NDTR0_tWP(ns2cycle(t->tWP, nand_clk)) |
374 NDTR0_tRH(ns2cycle(t->tRH, nand_clk)) |
375 NDTR0_tRP(ns2cycle(t->tRP, nand_clk));
376
377 ndtr1 = NDTR1_tR(ns2cycle(t->tR, nand_clk)) |
378 NDTR1_tWHR(ns2cycle(t->tWHR, nand_clk)) |
379 NDTR1_tAR(ns2cycle(t->tAR, nand_clk));
380
381 info->ndtr0cs0 = ndtr0;
382 info->ndtr1cs0 = ndtr1;
383 nand_writel(info, NDTR0CS0, ndtr0);
384 nand_writel(info, NDTR1CS0, ndtr1);
385 }
386
387 /*
388 * Set the data and OOB size, depending on the selected
389 * spare and ECC configuration.
390 * Only applicable to READ0, READOOB and PAGEPROG commands.
391 */
392 static void pxa3xx_set_datasize(struct pxa3xx_nand_info *info,
393 struct mtd_info *mtd)
394 {
395 int oob_enable = info->reg_ndcr & NDCR_SPARE_EN;
396
397 info->data_size = mtd->writesize;
398 if (!oob_enable)
399 return;
400
401 info->oob_size = info->spare_size;
402 if (!info->use_ecc)
403 info->oob_size += info->ecc_size;
404 }
405
406 /**
407 * NOTE: it is a must to set ND_RUN firstly, then write
408 * command buffer, otherwise, it does not work.
409 * We enable all the interrupt at the same time, and
410 * let pxa3xx_nand_irq to handle all logic.
411 */
412 static void pxa3xx_nand_start(struct pxa3xx_nand_info *info)
413 {
414 uint32_t ndcr;
415
416 ndcr = info->reg_ndcr;
417
418 if (info->use_ecc) {
419 ndcr |= NDCR_ECC_EN;
420 if (info->ecc_bch)
421 nand_writel(info, NDECCCTRL, 0x1);
422 } else {
423 ndcr &= ~NDCR_ECC_EN;
424 if (info->ecc_bch)
425 nand_writel(info, NDECCCTRL, 0x0);
426 }
427
428 if (info->use_dma)
429 ndcr |= NDCR_DMA_EN;
430 else
431 ndcr &= ~NDCR_DMA_EN;
432
433 if (info->use_spare)
434 ndcr |= NDCR_SPARE_EN;
435 else
436 ndcr &= ~NDCR_SPARE_EN;
437
438 ndcr |= NDCR_ND_RUN;
439
440 /* clear status bits and run */
441 nand_writel(info, NDCR, 0);
442 nand_writel(info, NDSR, NDSR_MASK);
443 nand_writel(info, NDCR, ndcr);
444 }
445
446 static void pxa3xx_nand_stop(struct pxa3xx_nand_info *info)
447 {
448 uint32_t ndcr;
449 int timeout = NAND_STOP_DELAY;
450
451 /* wait RUN bit in NDCR become 0 */
452 ndcr = nand_readl(info, NDCR);
453 while ((ndcr & NDCR_ND_RUN) && (timeout-- > 0)) {
454 ndcr = nand_readl(info, NDCR);
455 udelay(1);
456 }
457
458 if (timeout <= 0) {
459 ndcr &= ~NDCR_ND_RUN;
460 nand_writel(info, NDCR, ndcr);
461 }
462 /* clear status bits */
463 nand_writel(info, NDSR, NDSR_MASK);
464 }
465
466 static void __maybe_unused
467 enable_int(struct pxa3xx_nand_info *info, uint32_t int_mask)
468 {
469 uint32_t ndcr;
470
471 ndcr = nand_readl(info, NDCR);
472 nand_writel(info, NDCR, ndcr & ~int_mask);
473 }
474
475 static void disable_int(struct pxa3xx_nand_info *info, uint32_t int_mask)
476 {
477 uint32_t ndcr;
478
479 ndcr = nand_readl(info, NDCR);
480 nand_writel(info, NDCR, ndcr | int_mask);
481 }
482
483 static void handle_data_pio(struct pxa3xx_nand_info *info)
484 {
485 unsigned int do_bytes = min(info->data_size, info->chunk_size);
486
487 switch (info->state) {
488 case STATE_PIO_WRITING:
489 __raw_writesl(info->mmio_base + NDDB,
490 info->data_buff + info->data_buff_pos,
491 DIV_ROUND_UP(do_bytes, 4));
492
493 if (info->oob_size > 0)
494 __raw_writesl(info->mmio_base + NDDB,
495 info->oob_buff + info->oob_buff_pos,
496 DIV_ROUND_UP(info->oob_size, 4));
497 break;
498 case STATE_PIO_READING:
499 __raw_readsl(info->mmio_base + NDDB,
500 info->data_buff + info->data_buff_pos,
501 DIV_ROUND_UP(do_bytes, 4));
502
503 if (info->oob_size > 0)
504 __raw_readsl(info->mmio_base + NDDB,
505 info->oob_buff + info->oob_buff_pos,
506 DIV_ROUND_UP(info->oob_size, 4));
507 break;
508 default:
509 dev_err(&info->pdev->dev, "%s: invalid state %d\n", __func__,
510 info->state);
511 BUG();
512 }
513
514 /* Update buffer pointers for multi-page read/write */
515 info->data_buff_pos += do_bytes;
516 info->oob_buff_pos += info->oob_size;
517 info->data_size -= do_bytes;
518 }
519
520 #ifdef ARCH_HAS_DMA
521 static void start_data_dma(struct pxa3xx_nand_info *info)
522 {
523 struct pxa_dma_desc *desc = info->data_desc;
524 int dma_len = ALIGN(info->data_size + info->oob_size, 32);
525
526 desc->ddadr = DDADR_STOP;
527 desc->dcmd = DCMD_ENDIRQEN | DCMD_WIDTH4 | DCMD_BURST32 | dma_len;
528
529 switch (info->state) {
530 case STATE_DMA_WRITING:
531 desc->dsadr = info->data_buff_phys;
532 desc->dtadr = info->mmio_phys + NDDB;
533 desc->dcmd |= DCMD_INCSRCADDR | DCMD_FLOWTRG;
534 break;
535 case STATE_DMA_READING:
536 desc->dtadr = info->data_buff_phys;
537 desc->dsadr = info->mmio_phys + NDDB;
538 desc->dcmd |= DCMD_INCTRGADDR | DCMD_FLOWSRC;
539 break;
540 default:
541 dev_err(&info->pdev->dev, "%s: invalid state %d\n", __func__,
542 info->state);
543 BUG();
544 }
545
546 DRCMR(info->drcmr_dat) = DRCMR_MAPVLD | info->data_dma_ch;
547 DDADR(info->data_dma_ch) = info->data_desc_addr;
548 DCSR(info->data_dma_ch) |= DCSR_RUN;
549 }
550
551 static void pxa3xx_nand_data_dma_irq(int channel, void *data)
552 {
553 struct pxa3xx_nand_info *info = data;
554 uint32_t dcsr;
555
556 dcsr = DCSR(channel);
557 DCSR(channel) = dcsr;
558
559 if (dcsr & DCSR_BUSERR) {
560 info->retcode = ERR_DMABUSERR;
561 }
562
563 info->state = STATE_DMA_DONE;
564 enable_int(info, NDCR_INT_MASK);
565 nand_writel(info, NDSR, NDSR_WRDREQ | NDSR_RDDREQ);
566 }
567 #else
568 static void start_data_dma(struct pxa3xx_nand_info *info)
569 {}
570 #endif
571
572 static irqreturn_t pxa3xx_nand_irq(int irq, void *devid)
573 {
574 struct pxa3xx_nand_info *info = devid;
575 unsigned int status, is_completed = 0, is_ready = 0;
576 unsigned int ready, cmd_done;
577
578 if (info->cs == 0) {
579 ready = NDSR_FLASH_RDY;
580 cmd_done = NDSR_CS0_CMDD;
581 } else {
582 ready = NDSR_RDY;
583 cmd_done = NDSR_CS1_CMDD;
584 }
585
586 status = nand_readl(info, NDSR);
587
588 if (status & NDSR_UNCORERR)
589 info->retcode = ERR_UNCORERR;
590 if (status & NDSR_CORERR) {
591 info->retcode = ERR_CORERR;
592 if (info->variant == PXA3XX_NAND_VARIANT_ARMADA370 &&
593 info->ecc_bch)
594 info->ecc_err_cnt = NDSR_ERR_CNT(status);
595 else
596 info->ecc_err_cnt = 1;
597
598 /*
599 * Each chunk composing a page is corrected independently,
600 * and we need to store maximum number of corrected bitflips
601 * to return it to the MTD layer in ecc.read_page().
602 */
603 info->max_bitflips = max_t(unsigned int,
604 info->max_bitflips,
605 info->ecc_err_cnt);
606 }
607 if (status & (NDSR_RDDREQ | NDSR_WRDREQ)) {
608 /* whether use dma to transfer data */
609 if (info->use_dma) {
610 disable_int(info, NDCR_INT_MASK);
611 info->state = (status & NDSR_RDDREQ) ?
612 STATE_DMA_READING : STATE_DMA_WRITING;
613 start_data_dma(info);
614 goto NORMAL_IRQ_EXIT;
615 } else {
616 info->state = (status & NDSR_RDDREQ) ?
617 STATE_PIO_READING : STATE_PIO_WRITING;
618 handle_data_pio(info);
619 }
620 }
621 if (status & cmd_done) {
622 info->state = STATE_CMD_DONE;
623 is_completed = 1;
624 }
625 if (status & ready) {
626 info->state = STATE_READY;
627 is_ready = 1;
628 }
629
630 if (status & NDSR_WRCMDREQ) {
631 nand_writel(info, NDSR, NDSR_WRCMDREQ);
632 status &= ~NDSR_WRCMDREQ;
633 info->state = STATE_CMD_HANDLE;
634
635 /*
636 * Command buffer registers NDCB{0-2} (and optionally NDCB3)
637 * must be loaded by writing directly either 12 or 16
638 * bytes directly to NDCB0, four bytes at a time.
639 *
640 * Direct write access to NDCB1, NDCB2 and NDCB3 is ignored
641 * but each NDCBx register can be read.
642 */
643 nand_writel(info, NDCB0, info->ndcb0);
644 nand_writel(info, NDCB0, info->ndcb1);
645 nand_writel(info, NDCB0, info->ndcb2);
646
647 /* NDCB3 register is available in NFCv2 (Armada 370/XP SoC) */
648 if (info->variant == PXA3XX_NAND_VARIANT_ARMADA370)
649 nand_writel(info, NDCB0, info->ndcb3);
650 }
651
652 /* clear NDSR to let the controller exit the IRQ */
653 nand_writel(info, NDSR, status);
654 if (is_completed)
655 complete(&info->cmd_complete);
656 if (is_ready)
657 complete(&info->dev_ready);
658 NORMAL_IRQ_EXIT:
659 return IRQ_HANDLED;
660 }
661
662 static inline int is_buf_blank(uint8_t *buf, size_t len)
663 {
664 for (; len > 0; len--)
665 if (*buf++ != 0xff)
666 return 0;
667 return 1;
668 }
669
670 static void set_command_address(struct pxa3xx_nand_info *info,
671 unsigned int page_size, uint16_t column, int page_addr)
672 {
673 /* small page addr setting */
674 if (page_size < PAGE_CHUNK_SIZE) {
675 info->ndcb1 = ((page_addr & 0xFFFFFF) << 8)
676 | (column & 0xFF);
677
678 info->ndcb2 = 0;
679 } else {
680 info->ndcb1 = ((page_addr & 0xFFFF) << 16)
681 | (column & 0xFFFF);
682
683 if (page_addr & 0xFF0000)
684 info->ndcb2 = (page_addr & 0xFF0000) >> 16;
685 else
686 info->ndcb2 = 0;
687 }
688 }
689
690 static void prepare_start_command(struct pxa3xx_nand_info *info, int command)
691 {
692 struct pxa3xx_nand_host *host = info->host[info->cs];
693 struct mtd_info *mtd = host->mtd;
694
695 /* reset data and oob column point to handle data */
696 info->buf_start = 0;
697 info->buf_count = 0;
698 info->oob_size = 0;
699 info->data_buff_pos = 0;
700 info->oob_buff_pos = 0;
701 info->use_ecc = 0;
702 info->use_spare = 1;
703 info->retcode = ERR_NONE;
704 info->ecc_err_cnt = 0;
705 info->ndcb3 = 0;
706 info->need_wait = 0;
707
708 switch (command) {
709 case NAND_CMD_READ0:
710 case NAND_CMD_PAGEPROG:
711 info->use_ecc = 1;
712 case NAND_CMD_READOOB:
713 pxa3xx_set_datasize(info, mtd);
714 break;
715 case NAND_CMD_PARAM:
716 info->use_spare = 0;
717 break;
718 default:
719 info->ndcb1 = 0;
720 info->ndcb2 = 0;
721 break;
722 }
723
724 /*
725 * If we are about to issue a read command, or about to set
726 * the write address, then clean the data buffer.
727 */
728 if (command == NAND_CMD_READ0 ||
729 command == NAND_CMD_READOOB ||
730 command == NAND_CMD_SEQIN) {
731
732 info->buf_count = mtd->writesize + mtd->oobsize;
733 memset(info->data_buff, 0xFF, info->buf_count);
734 }
735
736 }
737
738 static int prepare_set_command(struct pxa3xx_nand_info *info, int command,
739 int ext_cmd_type, uint16_t column, int page_addr)
740 {
741 int addr_cycle, exec_cmd;
742 struct pxa3xx_nand_host *host;
743 struct mtd_info *mtd;
744
745 host = info->host[info->cs];
746 mtd = host->mtd;
747 addr_cycle = 0;
748 exec_cmd = 1;
749
750 if (info->cs != 0)
751 info->ndcb0 = NDCB0_CSEL;
752 else
753 info->ndcb0 = 0;
754
755 if (command == NAND_CMD_SEQIN)
756 exec_cmd = 0;
757
758 addr_cycle = NDCB0_ADDR_CYC(host->row_addr_cycles
759 + host->col_addr_cycles);
760
761 switch (command) {
762 case NAND_CMD_READOOB:
763 case NAND_CMD_READ0:
764 info->buf_start = column;
765 info->ndcb0 |= NDCB0_CMD_TYPE(0)
766 | addr_cycle
767 | NAND_CMD_READ0;
768
769 if (command == NAND_CMD_READOOB)
770 info->buf_start += mtd->writesize;
771
772 /*
773 * Multiple page read needs an 'extended command type' field,
774 * which is either naked-read or last-read according to the
775 * state.
776 */
777 if (mtd->writesize == PAGE_CHUNK_SIZE) {
778 info->ndcb0 |= NDCB0_DBC | (NAND_CMD_READSTART << 8);
779 } else if (mtd->writesize > PAGE_CHUNK_SIZE) {
780 info->ndcb0 |= NDCB0_DBC | (NAND_CMD_READSTART << 8)
781 | NDCB0_LEN_OVRD
782 | NDCB0_EXT_CMD_TYPE(ext_cmd_type);
783 info->ndcb3 = info->chunk_size +
784 info->oob_size;
785 }
786
787 set_command_address(info, mtd->writesize, column, page_addr);
788 break;
789
790 case NAND_CMD_SEQIN:
791
792 info->buf_start = column;
793 set_command_address(info, mtd->writesize, 0, page_addr);
794
795 /*
796 * Multiple page programming needs to execute the initial
797 * SEQIN command that sets the page address.
798 */
799 if (mtd->writesize > PAGE_CHUNK_SIZE) {
800 info->ndcb0 |= NDCB0_CMD_TYPE(0x1)
801 | NDCB0_EXT_CMD_TYPE(ext_cmd_type)
802 | addr_cycle
803 | command;
804 /* No data transfer in this case */
805 info->data_size = 0;
806 exec_cmd = 1;
807 }
808 break;
809
810 case NAND_CMD_PAGEPROG:
811 if (is_buf_blank(info->data_buff,
812 (mtd->writesize + mtd->oobsize))) {
813 exec_cmd = 0;
814 break;
815 }
816
817 /* Second command setting for large pages */
818 if (mtd->writesize > PAGE_CHUNK_SIZE) {
819 /*
820 * Multiple page write uses the 'extended command'
821 * field. This can be used to issue a command dispatch
822 * or a naked-write depending on the current stage.
823 */
824 info->ndcb0 |= NDCB0_CMD_TYPE(0x1)
825 | NDCB0_LEN_OVRD
826 | NDCB0_EXT_CMD_TYPE(ext_cmd_type);
827 info->ndcb3 = info->chunk_size +
828 info->oob_size;
829
830 /*
831 * This is the command dispatch that completes a chunked
832 * page program operation.
833 */
834 if (info->data_size == 0) {
835 info->ndcb0 = NDCB0_CMD_TYPE(0x1)
836 | NDCB0_EXT_CMD_TYPE(ext_cmd_type)
837 | command;
838 info->ndcb1 = 0;
839 info->ndcb2 = 0;
840 info->ndcb3 = 0;
841 }
842 } else {
843 info->ndcb0 |= NDCB0_CMD_TYPE(0x1)
844 | NDCB0_AUTO_RS
845 | NDCB0_ST_ROW_EN
846 | NDCB0_DBC
847 | (NAND_CMD_PAGEPROG << 8)
848 | NAND_CMD_SEQIN
849 | addr_cycle;
850 }
851 break;
852
853 case NAND_CMD_PARAM:
854 info->buf_count = 256;
855 info->ndcb0 |= NDCB0_CMD_TYPE(0)
856 | NDCB0_ADDR_CYC(1)
857 | NDCB0_LEN_OVRD
858 | command;
859 info->ndcb1 = (column & 0xFF);
860 info->ndcb3 = 256;
861 info->data_size = 256;
862 break;
863
864 case NAND_CMD_READID:
865 info->buf_count = host->read_id_bytes;
866 info->ndcb0 |= NDCB0_CMD_TYPE(3)
867 | NDCB0_ADDR_CYC(1)
868 | command;
869 info->ndcb1 = (column & 0xFF);
870
871 info->data_size = 8;
872 break;
873 case NAND_CMD_STATUS:
874 info->buf_count = 1;
875 info->ndcb0 |= NDCB0_CMD_TYPE(4)
876 | NDCB0_ADDR_CYC(1)
877 | command;
878
879 info->data_size = 8;
880 break;
881
882 case NAND_CMD_ERASE1:
883 info->ndcb0 |= NDCB0_CMD_TYPE(2)
884 | NDCB0_AUTO_RS
885 | NDCB0_ADDR_CYC(3)
886 | NDCB0_DBC
887 | (NAND_CMD_ERASE2 << 8)
888 | NAND_CMD_ERASE1;
889 info->ndcb1 = page_addr;
890 info->ndcb2 = 0;
891
892 break;
893 case NAND_CMD_RESET:
894 info->ndcb0 |= NDCB0_CMD_TYPE(5)
895 | command;
896
897 break;
898
899 case NAND_CMD_ERASE2:
900 exec_cmd = 0;
901 break;
902
903 default:
904 exec_cmd = 0;
905 dev_err(&info->pdev->dev, "non-supported command %x\n",
906 command);
907 break;
908 }
909
910 return exec_cmd;
911 }
912
913 static void nand_cmdfunc(struct mtd_info *mtd, unsigned command,
914 int column, int page_addr)
915 {
916 struct pxa3xx_nand_host *host = mtd->priv;
917 struct pxa3xx_nand_info *info = host->info_data;
918 int ret, exec_cmd;
919
920 /*
921 * if this is a x16 device ,then convert the input
922 * "byte" address into a "word" address appropriate
923 * for indexing a word-oriented device
924 */
925 if (info->reg_ndcr & NDCR_DWIDTH_M)
926 column /= 2;
927
928 /*
929 * There may be different NAND chip hooked to
930 * different chip select, so check whether
931 * chip select has been changed, if yes, reset the timing
932 */
933 if (info->cs != host->cs) {
934 info->cs = host->cs;
935 nand_writel(info, NDTR0CS0, info->ndtr0cs0);
936 nand_writel(info, NDTR1CS0, info->ndtr1cs0);
937 }
938
939 prepare_start_command(info, command);
940
941 info->state = STATE_PREPARED;
942 exec_cmd = prepare_set_command(info, command, 0, column, page_addr);
943
944 if (exec_cmd) {
945 init_completion(&info->cmd_complete);
946 init_completion(&info->dev_ready);
947 info->need_wait = 1;
948 pxa3xx_nand_start(info);
949
950 ret = wait_for_completion_timeout(&info->cmd_complete,
951 CHIP_DELAY_TIMEOUT);
952 if (!ret) {
953 dev_err(&info->pdev->dev, "Wait time out!!!\n");
954 /* Stop State Machine for next command cycle */
955 pxa3xx_nand_stop(info);
956 }
957 }
958 info->state = STATE_IDLE;
959 }
960
961 static void nand_cmdfunc_extended(struct mtd_info *mtd,
962 const unsigned command,
963 int column, int page_addr)
964 {
965 struct pxa3xx_nand_host *host = mtd->priv;
966 struct pxa3xx_nand_info *info = host->info_data;
967 int ret, exec_cmd, ext_cmd_type;
968
969 /*
970 * if this is a x16 device then convert the input
971 * "byte" address into a "word" address appropriate
972 * for indexing a word-oriented device
973 */
974 if (info->reg_ndcr & NDCR_DWIDTH_M)
975 column /= 2;
976
977 /*
978 * There may be different NAND chip hooked to
979 * different chip select, so check whether
980 * chip select has been changed, if yes, reset the timing
981 */
982 if (info->cs != host->cs) {
983 info->cs = host->cs;
984 nand_writel(info, NDTR0CS0, info->ndtr0cs0);
985 nand_writel(info, NDTR1CS0, info->ndtr1cs0);
986 }
987
988 /* Select the extended command for the first command */
989 switch (command) {
990 case NAND_CMD_READ0:
991 case NAND_CMD_READOOB:
992 ext_cmd_type = EXT_CMD_TYPE_MONO;
993 break;
994 case NAND_CMD_SEQIN:
995 ext_cmd_type = EXT_CMD_TYPE_DISPATCH;
996 break;
997 case NAND_CMD_PAGEPROG:
998 ext_cmd_type = EXT_CMD_TYPE_NAKED_RW;
999 break;
1000 default:
1001 ext_cmd_type = 0;
1002 break;
1003 }
1004
1005 prepare_start_command(info, command);
1006
1007 /*
1008 * Prepare the "is ready" completion before starting a command
1009 * transaction sequence. If the command is not executed the
1010 * completion will be completed, see below.
1011 *
1012 * We can do that inside the loop because the command variable
1013 * is invariant and thus so is the exec_cmd.
1014 */
1015 info->need_wait = 1;
1016 init_completion(&info->dev_ready);
1017 do {
1018 info->state = STATE_PREPARED;
1019 exec_cmd = prepare_set_command(info, command, ext_cmd_type,
1020 column, page_addr);
1021 if (!exec_cmd) {
1022 info->need_wait = 0;
1023 complete(&info->dev_ready);
1024 break;
1025 }
1026
1027 init_completion(&info->cmd_complete);
1028 pxa3xx_nand_start(info);
1029
1030 ret = wait_for_completion_timeout(&info->cmd_complete,
1031 CHIP_DELAY_TIMEOUT);
1032 if (!ret) {
1033 dev_err(&info->pdev->dev, "Wait time out!!!\n");
1034 /* Stop State Machine for next command cycle */
1035 pxa3xx_nand_stop(info);
1036 break;
1037 }
1038
1039 /* Check if the sequence is complete */
1040 if (info->data_size == 0 && command != NAND_CMD_PAGEPROG)
1041 break;
1042
1043 /*
1044 * After a splitted program command sequence has issued
1045 * the command dispatch, the command sequence is complete.
1046 */
1047 if (info->data_size == 0 &&
1048 command == NAND_CMD_PAGEPROG &&
1049 ext_cmd_type == EXT_CMD_TYPE_DISPATCH)
1050 break;
1051
1052 if (command == NAND_CMD_READ0 || command == NAND_CMD_READOOB) {
1053 /* Last read: issue a 'last naked read' */
1054 if (info->data_size == info->chunk_size)
1055 ext_cmd_type = EXT_CMD_TYPE_LAST_RW;
1056 else
1057 ext_cmd_type = EXT_CMD_TYPE_NAKED_RW;
1058
1059 /*
1060 * If a splitted program command has no more data to transfer,
1061 * the command dispatch must be issued to complete.
1062 */
1063 } else if (command == NAND_CMD_PAGEPROG &&
1064 info->data_size == 0) {
1065 ext_cmd_type = EXT_CMD_TYPE_DISPATCH;
1066 }
1067 } while (1);
1068
1069 info->state = STATE_IDLE;
1070 }
1071
1072 static int pxa3xx_nand_write_page_hwecc(struct mtd_info *mtd,
1073 struct nand_chip *chip, const uint8_t *buf, int oob_required)
1074 {
1075 chip->write_buf(mtd, buf, mtd->writesize);
1076 chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
1077
1078 return 0;
1079 }
1080
1081 static int pxa3xx_nand_read_page_hwecc(struct mtd_info *mtd,
1082 struct nand_chip *chip, uint8_t *buf, int oob_required,
1083 int page)
1084 {
1085 struct pxa3xx_nand_host *host = mtd->priv;
1086 struct pxa3xx_nand_info *info = host->info_data;
1087
1088 chip->read_buf(mtd, buf, mtd->writesize);
1089 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
1090
1091 if (info->retcode == ERR_CORERR && info->use_ecc) {
1092 mtd->ecc_stats.corrected += info->ecc_err_cnt;
1093
1094 } else if (info->retcode == ERR_UNCORERR) {
1095 /*
1096 * for blank page (all 0xff), HW will calculate its ECC as
1097 * 0, which is different from the ECC information within
1098 * OOB, ignore such uncorrectable errors
1099 */
1100 if (is_buf_blank(buf, mtd->writesize))
1101 info->retcode = ERR_NONE;
1102 else
1103 mtd->ecc_stats.failed++;
1104 }
1105
1106 return info->max_bitflips;
1107 }
1108
1109 static uint8_t pxa3xx_nand_read_byte(struct mtd_info *mtd)
1110 {
1111 struct pxa3xx_nand_host *host = mtd->priv;
1112 struct pxa3xx_nand_info *info = host->info_data;
1113 char retval = 0xFF;
1114
1115 if (info->buf_start < info->buf_count)
1116 /* Has just send a new command? */
1117 retval = info->data_buff[info->buf_start++];
1118
1119 return retval;
1120 }
1121
1122 static u16 pxa3xx_nand_read_word(struct mtd_info *mtd)
1123 {
1124 struct pxa3xx_nand_host *host = mtd->priv;
1125 struct pxa3xx_nand_info *info = host->info_data;
1126 u16 retval = 0xFFFF;
1127
1128 if (!(info->buf_start & 0x01) && info->buf_start < info->buf_count) {
1129 retval = *((u16 *)(info->data_buff+info->buf_start));
1130 info->buf_start += 2;
1131 }
1132 return retval;
1133 }
1134
1135 static void pxa3xx_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
1136 {
1137 struct pxa3xx_nand_host *host = mtd->priv;
1138 struct pxa3xx_nand_info *info = host->info_data;
1139 int real_len = min_t(size_t, len, info->buf_count - info->buf_start);
1140
1141 memcpy(buf, info->data_buff + info->buf_start, real_len);
1142 info->buf_start += real_len;
1143 }
1144
1145 static void pxa3xx_nand_write_buf(struct mtd_info *mtd,
1146 const uint8_t *buf, int len)
1147 {
1148 struct pxa3xx_nand_host *host = mtd->priv;
1149 struct pxa3xx_nand_info *info = host->info_data;
1150 int real_len = min_t(size_t, len, info->buf_count - info->buf_start);
1151
1152 memcpy(info->data_buff + info->buf_start, buf, real_len);
1153 info->buf_start += real_len;
1154 }
1155
1156 static void pxa3xx_nand_select_chip(struct mtd_info *mtd, int chip)
1157 {
1158 return;
1159 }
1160
1161 static int pxa3xx_nand_waitfunc(struct mtd_info *mtd, struct nand_chip *this)
1162 {
1163 struct pxa3xx_nand_host *host = mtd->priv;
1164 struct pxa3xx_nand_info *info = host->info_data;
1165 int ret;
1166
1167 if (info->need_wait) {
1168 ret = wait_for_completion_timeout(&info->dev_ready,
1169 CHIP_DELAY_TIMEOUT);
1170 info->need_wait = 0;
1171 if (!ret) {
1172 dev_err(&info->pdev->dev, "Ready time out!!!\n");
1173 return NAND_STATUS_FAIL;
1174 }
1175 }
1176
1177 /* pxa3xx_nand_send_command has waited for command complete */
1178 if (this->state == FL_WRITING || this->state == FL_ERASING) {
1179 if (info->retcode == ERR_NONE)
1180 return 0;
1181 else
1182 return NAND_STATUS_FAIL;
1183 }
1184
1185 return NAND_STATUS_READY;
1186 }
1187
1188 static int pxa3xx_nand_config_flash(struct pxa3xx_nand_info *info,
1189 const struct pxa3xx_nand_flash *f)
1190 {
1191 struct platform_device *pdev = info->pdev;
1192 struct pxa3xx_nand_platform_data *pdata = dev_get_platdata(&pdev->dev);
1193 struct pxa3xx_nand_host *host = info->host[info->cs];
1194 uint32_t ndcr = 0x0; /* enable all interrupts */
1195
1196 if (f->page_size != 2048 && f->page_size != 512) {
1197 dev_err(&pdev->dev, "Current only support 2048 and 512 size\n");
1198 return -EINVAL;
1199 }
1200
1201 if (f->flash_width != 16 && f->flash_width != 8) {
1202 dev_err(&pdev->dev, "Only support 8bit and 16 bit!\n");
1203 return -EINVAL;
1204 }
1205
1206 /* calculate flash information */
1207 host->read_id_bytes = (f->page_size == 2048) ? 4 : 2;
1208
1209 /* calculate addressing information */
1210 host->col_addr_cycles = (f->page_size == 2048) ? 2 : 1;
1211
1212 if (f->num_blocks * f->page_per_block > 65536)
1213 host->row_addr_cycles = 3;
1214 else
1215 host->row_addr_cycles = 2;
1216
1217 ndcr |= (pdata->enable_arbiter) ? NDCR_ND_ARB_EN : 0;
1218 ndcr |= (host->col_addr_cycles == 2) ? NDCR_RA_START : 0;
1219 ndcr |= (f->page_per_block == 64) ? NDCR_PG_PER_BLK : 0;
1220 ndcr |= (f->page_size == 2048) ? NDCR_PAGE_SZ : 0;
1221 ndcr |= (f->flash_width == 16) ? NDCR_DWIDTH_M : 0;
1222 ndcr |= (f->dfc_width == 16) ? NDCR_DWIDTH_C : 0;
1223
1224 ndcr |= NDCR_RD_ID_CNT(host->read_id_bytes);
1225 ndcr |= NDCR_SPARE_EN; /* enable spare by default */
1226
1227 info->reg_ndcr = ndcr;
1228
1229 pxa3xx_nand_set_timing(host, f->timing);
1230 return 0;
1231 }
1232
1233 static int pxa3xx_nand_detect_config(struct pxa3xx_nand_info *info)
1234 {
1235 /*
1236 * We set 0 by hard coding here, for we don't support keep_config
1237 * when there is more than one chip attached to the controller
1238 */
1239 struct pxa3xx_nand_host *host = info->host[0];
1240 uint32_t ndcr = nand_readl(info, NDCR);
1241
1242 if (ndcr & NDCR_PAGE_SZ) {
1243 /* Controller's FIFO size */
1244 info->chunk_size = 2048;
1245 host->read_id_bytes = 4;
1246 } else {
1247 info->chunk_size = 512;
1248 host->read_id_bytes = 2;
1249 }
1250
1251 /* Set an initial chunk size */
1252 info->reg_ndcr = ndcr & ~NDCR_INT_MASK;
1253 info->ndtr0cs0 = nand_readl(info, NDTR0CS0);
1254 info->ndtr1cs0 = nand_readl(info, NDTR1CS0);
1255 return 0;
1256 }
1257
1258 #ifdef ARCH_HAS_DMA
1259 static int pxa3xx_nand_init_buff(struct pxa3xx_nand_info *info)
1260 {
1261 struct platform_device *pdev = info->pdev;
1262 int data_desc_offset = info->buf_size - sizeof(struct pxa_dma_desc);
1263
1264 if (use_dma == 0) {
1265 info->data_buff = kmalloc(info->buf_size, GFP_KERNEL);
1266 if (info->data_buff == NULL)
1267 return -ENOMEM;
1268 return 0;
1269 }
1270
1271 info->data_buff = dma_alloc_coherent(&pdev->dev, info->buf_size,
1272 &info->data_buff_phys, GFP_KERNEL);
1273 if (info->data_buff == NULL) {
1274 dev_err(&pdev->dev, "failed to allocate dma buffer\n");
1275 return -ENOMEM;
1276 }
1277
1278 info->data_desc = (void *)info->data_buff + data_desc_offset;
1279 info->data_desc_addr = info->data_buff_phys + data_desc_offset;
1280
1281 info->data_dma_ch = pxa_request_dma("nand-data", DMA_PRIO_LOW,
1282 pxa3xx_nand_data_dma_irq, info);
1283 if (info->data_dma_ch < 0) {
1284 dev_err(&pdev->dev, "failed to request data dma\n");
1285 dma_free_coherent(&pdev->dev, info->buf_size,
1286 info->data_buff, info->data_buff_phys);
1287 return info->data_dma_ch;
1288 }
1289
1290 /*
1291 * Now that DMA buffers are allocated we turn on
1292 * DMA proper for I/O operations.
1293 */
1294 info->use_dma = 1;
1295 return 0;
1296 }
1297
1298 static void pxa3xx_nand_free_buff(struct pxa3xx_nand_info *info)
1299 {
1300 struct platform_device *pdev = info->pdev;
1301 if (info->use_dma) {
1302 pxa_free_dma(info->data_dma_ch);
1303 dma_free_coherent(&pdev->dev, info->buf_size,
1304 info->data_buff, info->data_buff_phys);
1305 } else {
1306 kfree(info->data_buff);
1307 }
1308 }
1309 #else
1310 static int pxa3xx_nand_init_buff(struct pxa3xx_nand_info *info)
1311 {
1312 info->data_buff = kmalloc(info->buf_size, GFP_KERNEL);
1313 if (info->data_buff == NULL)
1314 return -ENOMEM;
1315 return 0;
1316 }
1317
1318 static void pxa3xx_nand_free_buff(struct pxa3xx_nand_info *info)
1319 {
1320 kfree(info->data_buff);
1321 }
1322 #endif
1323
1324 static int pxa3xx_nand_sensing(struct pxa3xx_nand_info *info)
1325 {
1326 struct mtd_info *mtd;
1327 struct nand_chip *chip;
1328 int ret;
1329
1330 mtd = info->host[info->cs]->mtd;
1331 chip = mtd->priv;
1332
1333 /* use the common timing to make a try */
1334 ret = pxa3xx_nand_config_flash(info, &builtin_flash_types[0]);
1335 if (ret)
1336 return ret;
1337
1338 chip->cmdfunc(mtd, NAND_CMD_RESET, 0, 0);
1339 ret = chip->waitfunc(mtd, chip);
1340 if (ret & NAND_STATUS_FAIL)
1341 return -ENODEV;
1342
1343 return 0;
1344 }
1345
1346 static int pxa_ecc_init(struct pxa3xx_nand_info *info,
1347 struct nand_ecc_ctrl *ecc,
1348 int strength, int ecc_stepsize, int page_size)
1349 {
1350 if (strength == 1 && ecc_stepsize == 512 && page_size == 2048) {
1351 info->chunk_size = 2048;
1352 info->spare_size = 40;
1353 info->ecc_size = 24;
1354 ecc->mode = NAND_ECC_HW;
1355 ecc->size = 512;
1356 ecc->strength = 1;
1357
1358 } else if (strength == 1 && ecc_stepsize == 512 && page_size == 512) {
1359 info->chunk_size = 512;
1360 info->spare_size = 8;
1361 info->ecc_size = 8;
1362 ecc->mode = NAND_ECC_HW;
1363 ecc->size = 512;
1364 ecc->strength = 1;
1365
1366 /*
1367 * Required ECC: 4-bit correction per 512 bytes
1368 * Select: 16-bit correction per 2048 bytes
1369 */
1370 } else if (strength == 4 && ecc_stepsize == 512 && page_size == 2048) {
1371 info->ecc_bch = 1;
1372 info->chunk_size = 2048;
1373 info->spare_size = 32;
1374 info->ecc_size = 32;
1375 ecc->mode = NAND_ECC_HW;
1376 ecc->size = info->chunk_size;
1377 ecc->layout = &ecc_layout_2KB_bch4bit;
1378 ecc->strength = 16;
1379
1380 } else if (strength == 4 && ecc_stepsize == 512 && page_size == 4096) {
1381 info->ecc_bch = 1;
1382 info->chunk_size = 2048;
1383 info->spare_size = 32;
1384 info->ecc_size = 32;
1385 ecc->mode = NAND_ECC_HW;
1386 ecc->size = info->chunk_size;
1387 ecc->layout = &ecc_layout_4KB_bch4bit;
1388 ecc->strength = 16;
1389
1390 /*
1391 * Required ECC: 8-bit correction per 512 bytes
1392 * Select: 16-bit correction per 1024 bytes
1393 */
1394 } else if (strength == 8 && ecc_stepsize == 512 && page_size == 4096) {
1395 info->ecc_bch = 1;
1396 info->chunk_size = 1024;
1397 info->spare_size = 0;
1398 info->ecc_size = 32;
1399 ecc->mode = NAND_ECC_HW;
1400 ecc->size = info->chunk_size;
1401 ecc->layout = &ecc_layout_4KB_bch8bit;
1402 ecc->strength = 16;
1403 } else {
1404 dev_err(&info->pdev->dev,
1405 "ECC strength %d at page size %d is not supported\n",
1406 strength, page_size);
1407 return -ENODEV;
1408 }
1409
1410 dev_info(&info->pdev->dev, "ECC strength %d, ECC step size %d\n",
1411 ecc->strength, ecc->size);
1412 return 0;
1413 }
1414
1415 static int pxa3xx_nand_scan(struct mtd_info *mtd)
1416 {
1417 struct pxa3xx_nand_host *host = mtd->priv;
1418 struct pxa3xx_nand_info *info = host->info_data;
1419 struct platform_device *pdev = info->pdev;
1420 struct pxa3xx_nand_platform_data *pdata = dev_get_platdata(&pdev->dev);
1421 struct nand_flash_dev pxa3xx_flash_ids[2], *def = NULL;
1422 const struct pxa3xx_nand_flash *f = NULL;
1423 struct nand_chip *chip = mtd->priv;
1424 uint32_t id = -1;
1425 uint64_t chipsize;
1426 int i, ret, num;
1427 uint16_t ecc_strength, ecc_step;
1428
1429 if (pdata->keep_config && !pxa3xx_nand_detect_config(info))
1430 goto KEEP_CONFIG;
1431
1432 ret = pxa3xx_nand_sensing(info);
1433 if (ret) {
1434 dev_info(&info->pdev->dev, "There is no chip on cs %d!\n",
1435 info->cs);
1436
1437 return ret;
1438 }
1439
1440 chip->cmdfunc(mtd, NAND_CMD_READID, 0, 0);
1441 id = *((uint16_t *)(info->data_buff));
1442 if (id != 0)
1443 dev_info(&info->pdev->dev, "Detect a flash id %x\n", id);
1444 else {
1445 dev_warn(&info->pdev->dev,
1446 "Read out ID 0, potential timing set wrong!!\n");
1447
1448 return -EINVAL;
1449 }
1450
1451 num = ARRAY_SIZE(builtin_flash_types) + pdata->num_flash - 1;
1452 for (i = 0; i < num; i++) {
1453 if (i < pdata->num_flash)
1454 f = pdata->flash + i;
1455 else
1456 f = &builtin_flash_types[i - pdata->num_flash + 1];
1457
1458 /* find the chip in default list */
1459 if (f->chip_id == id)
1460 break;
1461 }
1462
1463 if (i >= (ARRAY_SIZE(builtin_flash_types) + pdata->num_flash - 1)) {
1464 dev_err(&info->pdev->dev, "ERROR!! flash not defined!!!\n");
1465
1466 return -EINVAL;
1467 }
1468
1469 ret = pxa3xx_nand_config_flash(info, f);
1470 if (ret) {
1471 dev_err(&info->pdev->dev, "ERROR! Configure failed\n");
1472 return ret;
1473 }
1474
1475 pxa3xx_flash_ids[0].name = f->name;
1476 pxa3xx_flash_ids[0].dev_id = (f->chip_id >> 8) & 0xffff;
1477 pxa3xx_flash_ids[0].pagesize = f->page_size;
1478 chipsize = (uint64_t)f->num_blocks * f->page_per_block * f->page_size;
1479 pxa3xx_flash_ids[0].chipsize = chipsize >> 20;
1480 pxa3xx_flash_ids[0].erasesize = f->page_size * f->page_per_block;
1481 if (f->flash_width == 16)
1482 pxa3xx_flash_ids[0].options = NAND_BUSWIDTH_16;
1483 pxa3xx_flash_ids[1].name = NULL;
1484 def = pxa3xx_flash_ids;
1485 KEEP_CONFIG:
1486 if (info->reg_ndcr & NDCR_DWIDTH_M)
1487 chip->options |= NAND_BUSWIDTH_16;
1488
1489 /* Device detection must be done with ECC disabled */
1490 if (info->variant == PXA3XX_NAND_VARIANT_ARMADA370)
1491 nand_writel(info, NDECCCTRL, 0x0);
1492
1493 if (nand_scan_ident(mtd, 1, def))
1494 return -ENODEV;
1495
1496 if (pdata->flash_bbt) {
1497 /*
1498 * We'll use a bad block table stored in-flash and don't
1499 * allow writing the bad block marker to the flash.
1500 */
1501 chip->bbt_options |= NAND_BBT_USE_FLASH |
1502 NAND_BBT_NO_OOB_BBM;
1503 chip->bbt_td = &bbt_main_descr;
1504 chip->bbt_md = &bbt_mirror_descr;
1505 }
1506
1507 /*
1508 * If the page size is bigger than the FIFO size, let's check
1509 * we are given the right variant and then switch to the extended
1510 * (aka splitted) command handling,
1511 */
1512 if (mtd->writesize > PAGE_CHUNK_SIZE) {
1513 if (info->variant == PXA3XX_NAND_VARIANT_ARMADA370) {
1514 chip->cmdfunc = nand_cmdfunc_extended;
1515 } else {
1516 dev_err(&info->pdev->dev,
1517 "unsupported page size on this variant\n");
1518 return -ENODEV;
1519 }
1520 }
1521
1522 if (pdata->ecc_strength && pdata->ecc_step_size) {
1523 ecc_strength = pdata->ecc_strength;
1524 ecc_step = pdata->ecc_step_size;
1525 } else {
1526 ecc_strength = chip->ecc_strength_ds;
1527 ecc_step = chip->ecc_step_ds;
1528 }
1529
1530 /* Set default ECC strength requirements on non-ONFI devices */
1531 if (ecc_strength < 1 && ecc_step < 1) {
1532 ecc_strength = 1;
1533 ecc_step = 512;
1534 }
1535
1536 ret = pxa_ecc_init(info, &chip->ecc, ecc_strength,
1537 ecc_step, mtd->writesize);
1538 if (ret)
1539 return ret;
1540
1541 /* calculate addressing information */
1542 if (mtd->writesize >= 2048)
1543 host->col_addr_cycles = 2;
1544 else
1545 host->col_addr_cycles = 1;
1546
1547 /* release the initial buffer */
1548 kfree(info->data_buff);
1549
1550 /* allocate the real data + oob buffer */
1551 info->buf_size = mtd->writesize + mtd->oobsize;
1552 ret = pxa3xx_nand_init_buff(info);
1553 if (ret)
1554 return ret;
1555 info->oob_buff = info->data_buff + mtd->writesize;
1556
1557 if ((mtd->size >> chip->page_shift) > 65536)
1558 host->row_addr_cycles = 3;
1559 else
1560 host->row_addr_cycles = 2;
1561 return nand_scan_tail(mtd);
1562 }
1563
1564 static int alloc_nand_resource(struct platform_device *pdev)
1565 {
1566 struct pxa3xx_nand_platform_data *pdata;
1567 struct pxa3xx_nand_info *info;
1568 struct pxa3xx_nand_host *host;
1569 struct nand_chip *chip = NULL;
1570 struct mtd_info *mtd;
1571 struct resource *r;
1572 int ret, irq, cs;
1573
1574 pdata = dev_get_platdata(&pdev->dev);
1575 info = devm_kzalloc(&pdev->dev, sizeof(*info) + (sizeof(*mtd) +
1576 sizeof(*host)) * pdata->num_cs, GFP_KERNEL);
1577 if (!info)
1578 return -ENOMEM;
1579
1580 info->pdev = pdev;
1581 info->variant = pxa3xx_nand_get_variant(pdev);
1582 for (cs = 0; cs < pdata->num_cs; cs++) {
1583 mtd = (struct mtd_info *)((unsigned int)&info[1] +
1584 (sizeof(*mtd) + sizeof(*host)) * cs);
1585 chip = (struct nand_chip *)(&mtd[1]);
1586 host = (struct pxa3xx_nand_host *)chip;
1587 info->host[cs] = host;
1588 host->mtd = mtd;
1589 host->cs = cs;
1590 host->info_data = info;
1591 mtd->priv = host;
1592 mtd->owner = THIS_MODULE;
1593
1594 chip->ecc.read_page = pxa3xx_nand_read_page_hwecc;
1595 chip->ecc.write_page = pxa3xx_nand_write_page_hwecc;
1596 chip->controller = &info->controller;
1597 chip->waitfunc = pxa3xx_nand_waitfunc;
1598 chip->select_chip = pxa3xx_nand_select_chip;
1599 chip->read_word = pxa3xx_nand_read_word;
1600 chip->read_byte = pxa3xx_nand_read_byte;
1601 chip->read_buf = pxa3xx_nand_read_buf;
1602 chip->write_buf = pxa3xx_nand_write_buf;
1603 chip->options |= NAND_NO_SUBPAGE_WRITE;
1604 chip->cmdfunc = nand_cmdfunc;
1605 }
1606
1607 spin_lock_init(&chip->controller->lock);
1608 init_waitqueue_head(&chip->controller->wq);
1609 info->clk = devm_clk_get(&pdev->dev, NULL);
1610 if (IS_ERR(info->clk)) {
1611 dev_err(&pdev->dev, "failed to get nand clock\n");
1612 return PTR_ERR(info->clk);
1613 }
1614 ret = clk_prepare_enable(info->clk);
1615 if (ret < 0)
1616 return ret;
1617
1618 if (use_dma) {
1619 /*
1620 * This is a dirty hack to make this driver work from
1621 * devicetree bindings. It can be removed once we have
1622 * a prober DMA controller framework for DT.
1623 */
1624 if (pdev->dev.of_node &&
1625 of_machine_is_compatible("marvell,pxa3xx")) {
1626 info->drcmr_dat = 97;
1627 info->drcmr_cmd = 99;
1628 } else {
1629 r = platform_get_resource(pdev, IORESOURCE_DMA, 0);
1630 if (r == NULL) {
1631 dev_err(&pdev->dev,
1632 "no resource defined for data DMA\n");
1633 ret = -ENXIO;
1634 goto fail_disable_clk;
1635 }
1636 info->drcmr_dat = r->start;
1637
1638 r = platform_get_resource(pdev, IORESOURCE_DMA, 1);
1639 if (r == NULL) {
1640 dev_err(&pdev->dev,
1641 "no resource defined for cmd DMA\n");
1642 ret = -ENXIO;
1643 goto fail_disable_clk;
1644 }
1645 info->drcmr_cmd = r->start;
1646 }
1647 }
1648
1649 irq = platform_get_irq(pdev, 0);
1650 if (irq < 0) {
1651 dev_err(&pdev->dev, "no IRQ resource defined\n");
1652 ret = -ENXIO;
1653 goto fail_disable_clk;
1654 }
1655
1656 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1657 info->mmio_base = devm_ioremap_resource(&pdev->dev, r);
1658 if (IS_ERR(info->mmio_base)) {
1659 ret = PTR_ERR(info->mmio_base);
1660 goto fail_disable_clk;
1661 }
1662 info->mmio_phys = r->start;
1663
1664 /* Allocate a buffer to allow flash detection */
1665 info->buf_size = INIT_BUFFER_SIZE;
1666 info->data_buff = kmalloc(info->buf_size, GFP_KERNEL);
1667 if (info->data_buff == NULL) {
1668 ret = -ENOMEM;
1669 goto fail_disable_clk;
1670 }
1671
1672 /* initialize all interrupts to be disabled */
1673 disable_int(info, NDSR_MASK);
1674
1675 ret = request_irq(irq, pxa3xx_nand_irq, 0, pdev->name, info);
1676 if (ret < 0) {
1677 dev_err(&pdev->dev, "failed to request IRQ\n");
1678 goto fail_free_buf;
1679 }
1680
1681 platform_set_drvdata(pdev, info);
1682
1683 return 0;
1684
1685 fail_free_buf:
1686 free_irq(irq, info);
1687 kfree(info->data_buff);
1688 fail_disable_clk:
1689 clk_disable_unprepare(info->clk);
1690 return ret;
1691 }
1692
1693 static int pxa3xx_nand_remove(struct platform_device *pdev)
1694 {
1695 struct pxa3xx_nand_info *info = platform_get_drvdata(pdev);
1696 struct pxa3xx_nand_platform_data *pdata;
1697 int irq, cs;
1698
1699 if (!info)
1700 return 0;
1701
1702 pdata = dev_get_platdata(&pdev->dev);
1703
1704 irq = platform_get_irq(pdev, 0);
1705 if (irq >= 0)
1706 free_irq(irq, info);
1707 pxa3xx_nand_free_buff(info);
1708
1709 clk_disable_unprepare(info->clk);
1710
1711 for (cs = 0; cs < pdata->num_cs; cs++)
1712 nand_release(info->host[cs]->mtd);
1713 return 0;
1714 }
1715
1716 static int pxa3xx_nand_probe_dt(struct platform_device *pdev)
1717 {
1718 struct pxa3xx_nand_platform_data *pdata;
1719 struct device_node *np = pdev->dev.of_node;
1720 const struct of_device_id *of_id =
1721 of_match_device(pxa3xx_nand_dt_ids, &pdev->dev);
1722
1723 if (!of_id)
1724 return 0;
1725
1726 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
1727 if (!pdata)
1728 return -ENOMEM;
1729
1730 if (of_get_property(np, "marvell,nand-enable-arbiter", NULL))
1731 pdata->enable_arbiter = 1;
1732 if (of_get_property(np, "marvell,nand-keep-config", NULL))
1733 pdata->keep_config = 1;
1734 of_property_read_u32(np, "num-cs", &pdata->num_cs);
1735 pdata->flash_bbt = of_get_nand_on_flash_bbt(np);
1736
1737 pdata->ecc_strength = of_get_nand_ecc_strength(np);
1738 if (pdata->ecc_strength < 0)
1739 pdata->ecc_strength = 0;
1740
1741 pdata->ecc_step_size = of_get_nand_ecc_step_size(np);
1742 if (pdata->ecc_step_size < 0)
1743 pdata->ecc_step_size = 0;
1744
1745 pdev->dev.platform_data = pdata;
1746
1747 return 0;
1748 }
1749
1750 static int pxa3xx_nand_probe(struct platform_device *pdev)
1751 {
1752 struct pxa3xx_nand_platform_data *pdata;
1753 struct mtd_part_parser_data ppdata = {};
1754 struct pxa3xx_nand_info *info;
1755 int ret, cs, probe_success;
1756
1757 #ifndef ARCH_HAS_DMA
1758 if (use_dma) {
1759 use_dma = 0;
1760 dev_warn(&pdev->dev,
1761 "This platform can't do DMA on this device\n");
1762 }
1763 #endif
1764 ret = pxa3xx_nand_probe_dt(pdev);
1765 if (ret)
1766 return ret;
1767
1768 pdata = dev_get_platdata(&pdev->dev);
1769 if (!pdata) {
1770 dev_err(&pdev->dev, "no platform data defined\n");
1771 return -ENODEV;
1772 }
1773
1774 ret = alloc_nand_resource(pdev);
1775 if (ret) {
1776 dev_err(&pdev->dev, "alloc nand resource failed\n");
1777 return ret;
1778 }
1779
1780 info = platform_get_drvdata(pdev);
1781 probe_success = 0;
1782 for (cs = 0; cs < pdata->num_cs; cs++) {
1783 struct mtd_info *mtd = info->host[cs]->mtd;
1784
1785 /*
1786 * The mtd name matches the one used in 'mtdparts' kernel
1787 * parameter. This name cannot be changed or otherwise
1788 * user's mtd partitions configuration would get broken.
1789 */
1790 mtd->name = "pxa3xx_nand-0";
1791 info->cs = cs;
1792 ret = pxa3xx_nand_scan(mtd);
1793 if (ret) {
1794 dev_warn(&pdev->dev, "failed to scan nand at cs %d\n",
1795 cs);
1796 continue;
1797 }
1798
1799 ppdata.of_node = pdev->dev.of_node;
1800 ret = mtd_device_parse_register(mtd, NULL,
1801 &ppdata, pdata->parts[cs],
1802 pdata->nr_parts[cs]);
1803 if (!ret)
1804 probe_success = 1;
1805 }
1806
1807 if (!probe_success) {
1808 pxa3xx_nand_remove(pdev);
1809 return -ENODEV;
1810 }
1811
1812 return 0;
1813 }
1814
1815 #ifdef CONFIG_PM
1816 static int pxa3xx_nand_suspend(struct platform_device *pdev, pm_message_t state)
1817 {
1818 struct pxa3xx_nand_info *info = platform_get_drvdata(pdev);
1819 struct pxa3xx_nand_platform_data *pdata;
1820 struct mtd_info *mtd;
1821 int cs;
1822
1823 pdata = dev_get_platdata(&pdev->dev);
1824 if (info->state) {
1825 dev_err(&pdev->dev, "driver busy, state = %d\n", info->state);
1826 return -EAGAIN;
1827 }
1828
1829 for (cs = 0; cs < pdata->num_cs; cs++) {
1830 mtd = info->host[cs]->mtd;
1831 mtd_suspend(mtd);
1832 }
1833
1834 return 0;
1835 }
1836
1837 static int pxa3xx_nand_resume(struct platform_device *pdev)
1838 {
1839 struct pxa3xx_nand_info *info = platform_get_drvdata(pdev);
1840 struct pxa3xx_nand_platform_data *pdata;
1841 struct mtd_info *mtd;
1842 int cs;
1843
1844 pdata = dev_get_platdata(&pdev->dev);
1845 /* We don't want to handle interrupt without calling mtd routine */
1846 disable_int(info, NDCR_INT_MASK);
1847
1848 /*
1849 * Directly set the chip select to a invalid value,
1850 * then the driver would reset the timing according
1851 * to current chip select at the beginning of cmdfunc
1852 */
1853 info->cs = 0xff;
1854
1855 /*
1856 * As the spec says, the NDSR would be updated to 0x1800 when
1857 * doing the nand_clk disable/enable.
1858 * To prevent it damaging state machine of the driver, clear
1859 * all status before resume
1860 */
1861 nand_writel(info, NDSR, NDSR_MASK);
1862 for (cs = 0; cs < pdata->num_cs; cs++) {
1863 mtd = info->host[cs]->mtd;
1864 mtd_resume(mtd);
1865 }
1866
1867 return 0;
1868 }
1869 #else
1870 #define pxa3xx_nand_suspend NULL
1871 #define pxa3xx_nand_resume NULL
1872 #endif
1873
1874 static struct platform_driver pxa3xx_nand_driver = {
1875 .driver = {
1876 .name = "pxa3xx-nand",
1877 .of_match_table = pxa3xx_nand_dt_ids,
1878 },
1879 .probe = pxa3xx_nand_probe,
1880 .remove = pxa3xx_nand_remove,
1881 .suspend = pxa3xx_nand_suspend,
1882 .resume = pxa3xx_nand_resume,
1883 };
1884
1885 module_platform_driver(pxa3xx_nand_driver);
1886
1887 MODULE_LICENSE("GPL");
1888 MODULE_DESCRIPTION("PXA3xx NAND controller driver");
Linux with added FPC-III support