2 * Freescale Integrated Flash Controller NAND driver
4 * Copyright 2011-2012 Freescale Semiconductor, Inc
6 * Author: Dipen Dudhat <Dipen.Dudhat@freescale.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/module.h>
24 #include <linux/types.h>
25 #include <linux/init.h>
26 #include <linux/kernel.h>
27 #include <linux/of_address.h>
28 #include <linux/slab.h>
29 #include <linux/mtd/mtd.h>
30 #include <linux/mtd/nand.h>
31 #include <linux/mtd/partitions.h>
32 #include <linux/mtd/nand_ecc.h>
33 #include <asm/fsl_ifc.h>
35 #define FSL_IFC_V1_1_0 0x01010000
36 #define ERR_BYTE 0xFF /* Value returned for read
37 bytes when read failed */
38 #define IFC_TIMEOUT_MSECS 500 /* Maximum number of mSecs to wait
39 for IFC NAND Machine */
43 /* mtd information per set */
46 struct nand_chip chip
;
47 struct fsl_ifc_ctrl
*ctrl
;
50 int bank
; /* Chip select bank number */
51 unsigned int bufnum_mask
; /* bufnum = page & bufnum_mask */
52 u8 __iomem
*vbase
; /* Chip select base virtual address */
55 /* overview of the fsl ifc controller */
56 struct fsl_ifc_nand_ctrl
{
57 struct nand_hw_control controller
;
58 struct fsl_ifc_mtd
*chips
[FSL_IFC_BANK_COUNT
];
60 u8 __iomem
*addr
; /* Address of assigned IFC buffer */
61 unsigned int page
; /* Last page written to / read from */
62 unsigned int read_bytes
;/* Number of bytes read during command */
63 unsigned int column
; /* Saved column from SEQIN */
64 unsigned int index
; /* Pointer to next byte to 'read' */
65 unsigned int oob
; /* Non zero if operating on OOB data */
66 unsigned int eccread
; /* Non zero for a full-page ECC read */
67 unsigned int counter
; /* counter for the initializations */
68 unsigned int max_bitflips
; /* Saved during READ0 cmd */
71 static struct fsl_ifc_nand_ctrl
*ifc_nand_ctrl
;
73 /* 512-byte page with 4-bit ECC, 8-bit */
74 static struct nand_ecclayout oob_512_8bit_ecc4
= {
76 .eccpos
= {8, 9, 10, 11, 12, 13, 14, 15},
77 .oobfree
= { {0, 5}, {6, 2} },
80 /* 512-byte page with 4-bit ECC, 16-bit */
81 static struct nand_ecclayout oob_512_16bit_ecc4
= {
83 .eccpos
= {8, 9, 10, 11, 12, 13, 14, 15},
84 .oobfree
= { {2, 6}, },
87 /* 2048-byte page size with 4-bit ECC */
88 static struct nand_ecclayout oob_2048_ecc4
= {
91 8, 9, 10, 11, 12, 13, 14, 15,
92 16, 17, 18, 19, 20, 21, 22, 23,
93 24, 25, 26, 27, 28, 29, 30, 31,
94 32, 33, 34, 35, 36, 37, 38, 39,
96 .oobfree
= { {2, 6}, {40, 24} },
99 /* 4096-byte page size with 4-bit ECC */
100 static struct nand_ecclayout oob_4096_ecc4
= {
103 8, 9, 10, 11, 12, 13, 14, 15,
104 16, 17, 18, 19, 20, 21, 22, 23,
105 24, 25, 26, 27, 28, 29, 30, 31,
106 32, 33, 34, 35, 36, 37, 38, 39,
107 40, 41, 42, 43, 44, 45, 46, 47,
108 48, 49, 50, 51, 52, 53, 54, 55,
109 56, 57, 58, 59, 60, 61, 62, 63,
110 64, 65, 66, 67, 68, 69, 70, 71,
112 .oobfree
= { {2, 6}, {72, 56} },
115 /* 4096-byte page size with 8-bit ECC -- requires 218-byte OOB */
116 static struct nand_ecclayout oob_4096_ecc8
= {
119 8, 9, 10, 11, 12, 13, 14, 15,
120 16, 17, 18, 19, 20, 21, 22, 23,
121 24, 25, 26, 27, 28, 29, 30, 31,
122 32, 33, 34, 35, 36, 37, 38, 39,
123 40, 41, 42, 43, 44, 45, 46, 47,
124 48, 49, 50, 51, 52, 53, 54, 55,
125 56, 57, 58, 59, 60, 61, 62, 63,
126 64, 65, 66, 67, 68, 69, 70, 71,
127 72, 73, 74, 75, 76, 77, 78, 79,
128 80, 81, 82, 83, 84, 85, 86, 87,
129 88, 89, 90, 91, 92, 93, 94, 95,
130 96, 97, 98, 99, 100, 101, 102, 103,
131 104, 105, 106, 107, 108, 109, 110, 111,
132 112, 113, 114, 115, 116, 117, 118, 119,
133 120, 121, 122, 123, 124, 125, 126, 127,
134 128, 129, 130, 131, 132, 133, 134, 135,
136 .oobfree
= { {2, 6}, {136, 82} },
139 /* 8192-byte page size with 4-bit ECC */
140 static struct nand_ecclayout oob_8192_ecc4
= {
143 8, 9, 10, 11, 12, 13, 14, 15,
144 16, 17, 18, 19, 20, 21, 22, 23,
145 24, 25, 26, 27, 28, 29, 30, 31,
146 32, 33, 34, 35, 36, 37, 38, 39,
147 40, 41, 42, 43, 44, 45, 46, 47,
148 48, 49, 50, 51, 52, 53, 54, 55,
149 56, 57, 58, 59, 60, 61, 62, 63,
150 64, 65, 66, 67, 68, 69, 70, 71,
151 72, 73, 74, 75, 76, 77, 78, 79,
152 80, 81, 82, 83, 84, 85, 86, 87,
153 88, 89, 90, 91, 92, 93, 94, 95,
154 96, 97, 98, 99, 100, 101, 102, 103,
155 104, 105, 106, 107, 108, 109, 110, 111,
156 112, 113, 114, 115, 116, 117, 118, 119,
157 120, 121, 122, 123, 124, 125, 126, 127,
158 128, 129, 130, 131, 132, 133, 134, 135,
160 .oobfree
= { {2, 6}, {136, 208} },
163 /* 8192-byte page size with 8-bit ECC -- requires 218-byte OOB */
164 static struct nand_ecclayout oob_8192_ecc8
= {
167 8, 9, 10, 11, 12, 13, 14, 15,
168 16, 17, 18, 19, 20, 21, 22, 23,
169 24, 25, 26, 27, 28, 29, 30, 31,
170 32, 33, 34, 35, 36, 37, 38, 39,
171 40, 41, 42, 43, 44, 45, 46, 47,
172 48, 49, 50, 51, 52, 53, 54, 55,
173 56, 57, 58, 59, 60, 61, 62, 63,
174 64, 65, 66, 67, 68, 69, 70, 71,
175 72, 73, 74, 75, 76, 77, 78, 79,
176 80, 81, 82, 83, 84, 85, 86, 87,
177 88, 89, 90, 91, 92, 93, 94, 95,
178 96, 97, 98, 99, 100, 101, 102, 103,
179 104, 105, 106, 107, 108, 109, 110, 111,
180 112, 113, 114, 115, 116, 117, 118, 119,
181 120, 121, 122, 123, 124, 125, 126, 127,
182 128, 129, 130, 131, 132, 133, 134, 135,
183 136, 137, 138, 139, 140, 141, 142, 143,
184 144, 145, 146, 147, 148, 149, 150, 151,
185 152, 153, 154, 155, 156, 157, 158, 159,
186 160, 161, 162, 163, 164, 165, 166, 167,
187 168, 169, 170, 171, 172, 173, 174, 175,
188 176, 177, 178, 179, 180, 181, 182, 183,
189 184, 185, 186, 187, 188, 189, 190, 191,
190 192, 193, 194, 195, 196, 197, 198, 199,
191 200, 201, 202, 203, 204, 205, 206, 207,
192 208, 209, 210, 211, 212, 213, 214, 215,
193 216, 217, 218, 219, 220, 221, 222, 223,
194 224, 225, 226, 227, 228, 229, 230, 231,
195 232, 233, 234, 235, 236, 237, 238, 239,
196 240, 241, 242, 243, 244, 245, 246, 247,
197 248, 249, 250, 251, 252, 253, 254, 255,
198 256, 257, 258, 259, 260, 261, 262, 263,
200 .oobfree
= { {2, 6}, {264, 80} },
204 * Generic flash bbt descriptors
206 static u8 bbt_pattern
[] = {'B', 'b', 't', '0' };
207 static u8 mirror_pattern
[] = {'1', 't', 'b', 'B' };
209 static struct nand_bbt_descr bbt_main_descr
= {
210 .options
= NAND_BBT_LASTBLOCK
| NAND_BBT_CREATE
| NAND_BBT_WRITE
|
211 NAND_BBT_2BIT
| NAND_BBT_VERSION
,
212 .offs
= 2, /* 0 on 8-bit small page */
216 .pattern
= bbt_pattern
,
219 static struct nand_bbt_descr bbt_mirror_descr
= {
220 .options
= NAND_BBT_LASTBLOCK
| NAND_BBT_CREATE
| NAND_BBT_WRITE
|
221 NAND_BBT_2BIT
| NAND_BBT_VERSION
,
222 .offs
= 2, /* 0 on 8-bit small page */
226 .pattern
= mirror_pattern
,
230 * Set up the IFC hardware block and page address fields, and the ifc nand
231 * structure addr field to point to the correct IFC buffer in memory
233 static void set_addr(struct mtd_info
*mtd
, int column
, int page_addr
, int oob
)
235 struct nand_chip
*chip
= mtd
->priv
;
236 struct fsl_ifc_mtd
*priv
= chip
->priv
;
237 struct fsl_ifc_ctrl
*ctrl
= priv
->ctrl
;
238 struct fsl_ifc_regs __iomem
*ifc
= ctrl
->regs
;
241 ifc_nand_ctrl
->page
= page_addr
;
242 /* Program ROW0/COL0 */
243 iowrite32be(page_addr
, &ifc
->ifc_nand
.row0
);
244 iowrite32be((oob
? IFC_NAND_COL_MS
: 0) | column
, &ifc
->ifc_nand
.col0
);
246 buf_num
= page_addr
& priv
->bufnum_mask
;
248 ifc_nand_ctrl
->addr
= priv
->vbase
+ buf_num
* (mtd
->writesize
* 2);
249 ifc_nand_ctrl
->index
= column
;
251 /* for OOB data point to the second half of the buffer */
253 ifc_nand_ctrl
->index
+= mtd
->writesize
;
256 static int is_blank(struct mtd_info
*mtd
, unsigned int bufnum
)
258 struct nand_chip
*chip
= mtd
->priv
;
259 struct fsl_ifc_mtd
*priv
= chip
->priv
;
260 u8 __iomem
*addr
= priv
->vbase
+ bufnum
* (mtd
->writesize
* 2);
261 u32 __iomem
*mainarea
= (u32 __iomem
*)addr
;
262 u8 __iomem
*oob
= addr
+ mtd
->writesize
;
265 for (i
= 0; i
< mtd
->writesize
/ 4; i
++) {
266 if (__raw_readl(&mainarea
[i
]) != 0xffffffff)
270 for (i
= 0; i
< chip
->ecc
.layout
->eccbytes
; i
++) {
271 int pos
= chip
->ecc
.layout
->eccpos
[i
];
273 if (__raw_readb(&oob
[pos
]) != 0xff)
280 /* returns nonzero if entire page is blank */
281 static int check_read_ecc(struct mtd_info
*mtd
, struct fsl_ifc_ctrl
*ctrl
,
282 u32
*eccstat
, unsigned int bufnum
)
284 u32 reg
= eccstat
[bufnum
/ 4];
287 errors
= (reg
>> ((3 - bufnum
% 4) * 8)) & 15;
293 * execute IFC NAND command and wait for it to complete
295 static void fsl_ifc_run_command(struct mtd_info
*mtd
)
297 struct nand_chip
*chip
= mtd
->priv
;
298 struct fsl_ifc_mtd
*priv
= chip
->priv
;
299 struct fsl_ifc_ctrl
*ctrl
= priv
->ctrl
;
300 struct fsl_ifc_nand_ctrl
*nctrl
= ifc_nand_ctrl
;
301 struct fsl_ifc_regs __iomem
*ifc
= ctrl
->regs
;
305 /* set the chip select for NAND Transaction */
306 iowrite32be(priv
->bank
<< IFC_NAND_CSEL_SHIFT
,
307 &ifc
->ifc_nand
.nand_csel
);
310 "%s: fir0=%08x fcr0=%08x\n",
312 ioread32be(&ifc
->ifc_nand
.nand_fir0
),
313 ioread32be(&ifc
->ifc_nand
.nand_fcr0
));
317 /* start read/write seq */
318 iowrite32be(IFC_NAND_SEQ_STRT_FIR_STRT
, &ifc
->ifc_nand
.nandseq_strt
);
320 /* wait for command complete flag or timeout */
321 wait_event_timeout(ctrl
->nand_wait
, ctrl
->nand_stat
,
322 IFC_TIMEOUT_MSECS
* HZ
/1000);
324 /* ctrl->nand_stat will be updated from IRQ context */
325 if (!ctrl
->nand_stat
)
326 dev_err(priv
->dev
, "Controller is not responding\n");
327 if (ctrl
->nand_stat
& IFC_NAND_EVTER_STAT_FTOER
)
328 dev_err(priv
->dev
, "NAND Flash Timeout Error\n");
329 if (ctrl
->nand_stat
& IFC_NAND_EVTER_STAT_WPER
)
330 dev_err(priv
->dev
, "NAND Flash Write Protect Error\n");
332 nctrl
->max_bitflips
= 0;
334 if (nctrl
->eccread
) {
336 int bufnum
= nctrl
->page
& priv
->bufnum_mask
;
337 int sector
= bufnum
* chip
->ecc
.steps
;
338 int sector_end
= sector
+ chip
->ecc
.steps
- 1;
340 for (i
= sector
/ 4; i
<= sector_end
/ 4; i
++)
341 eccstat
[i
] = ioread32be(&ifc
->ifc_nand
.nand_eccstat
[i
]);
343 for (i
= sector
; i
<= sector_end
; i
++) {
344 errors
= check_read_ecc(mtd
, ctrl
, eccstat
, i
);
348 * Uncorrectable error.
349 * OK only if the whole page is blank.
351 * We disable ECCER reporting due to...
352 * erratum IFC-A002770 -- so report it now if we
353 * see an uncorrectable error in ECCSTAT.
355 if (!is_blank(mtd
, bufnum
))
357 IFC_NAND_EVTER_STAT_ECCER
;
361 mtd
->ecc_stats
.corrected
+= errors
;
362 nctrl
->max_bitflips
= max_t(unsigned int,
371 static void fsl_ifc_do_read(struct nand_chip
*chip
,
373 struct mtd_info
*mtd
)
375 struct fsl_ifc_mtd
*priv
= chip
->priv
;
376 struct fsl_ifc_ctrl
*ctrl
= priv
->ctrl
;
377 struct fsl_ifc_regs __iomem
*ifc
= ctrl
->regs
;
379 /* Program FIR/IFC_NAND_FCR0 for Small/Large page */
380 if (mtd
->writesize
> 512) {
381 iowrite32be((IFC_FIR_OP_CW0
<< IFC_NAND_FIR0_OP0_SHIFT
) |
382 (IFC_FIR_OP_CA0
<< IFC_NAND_FIR0_OP1_SHIFT
) |
383 (IFC_FIR_OP_RA0
<< IFC_NAND_FIR0_OP2_SHIFT
) |
384 (IFC_FIR_OP_CMD1
<< IFC_NAND_FIR0_OP3_SHIFT
) |
385 (IFC_FIR_OP_RBCD
<< IFC_NAND_FIR0_OP4_SHIFT
),
386 &ifc
->ifc_nand
.nand_fir0
);
387 iowrite32be(0x0, &ifc
->ifc_nand
.nand_fir1
);
389 iowrite32be((NAND_CMD_READ0
<< IFC_NAND_FCR0_CMD0_SHIFT
) |
390 (NAND_CMD_READSTART
<< IFC_NAND_FCR0_CMD1_SHIFT
),
391 &ifc
->ifc_nand
.nand_fcr0
);
393 iowrite32be((IFC_FIR_OP_CW0
<< IFC_NAND_FIR0_OP0_SHIFT
) |
394 (IFC_FIR_OP_CA0
<< IFC_NAND_FIR0_OP1_SHIFT
) |
395 (IFC_FIR_OP_RA0
<< IFC_NAND_FIR0_OP2_SHIFT
) |
396 (IFC_FIR_OP_RBCD
<< IFC_NAND_FIR0_OP3_SHIFT
),
397 &ifc
->ifc_nand
.nand_fir0
);
398 iowrite32be(0x0, &ifc
->ifc_nand
.nand_fir1
);
401 iowrite32be(NAND_CMD_READOOB
<<
402 IFC_NAND_FCR0_CMD0_SHIFT
,
403 &ifc
->ifc_nand
.nand_fcr0
);
405 iowrite32be(NAND_CMD_READ0
<<
406 IFC_NAND_FCR0_CMD0_SHIFT
,
407 &ifc
->ifc_nand
.nand_fcr0
);
411 /* cmdfunc send commands to the IFC NAND Machine */
412 static void fsl_ifc_cmdfunc(struct mtd_info
*mtd
, unsigned int command
,
413 int column
, int page_addr
) {
414 struct nand_chip
*chip
= mtd
->priv
;
415 struct fsl_ifc_mtd
*priv
= chip
->priv
;
416 struct fsl_ifc_ctrl
*ctrl
= priv
->ctrl
;
417 struct fsl_ifc_regs __iomem
*ifc
= ctrl
->regs
;
419 /* clear the read buffer */
420 ifc_nand_ctrl
->read_bytes
= 0;
421 if (command
!= NAND_CMD_PAGEPROG
)
422 ifc_nand_ctrl
->index
= 0;
425 /* READ0 read the entire buffer to use hardware ECC. */
427 iowrite32be(0, &ifc
->ifc_nand
.nand_fbcr
);
428 set_addr(mtd
, 0, page_addr
, 0);
430 ifc_nand_ctrl
->read_bytes
= mtd
->writesize
+ mtd
->oobsize
;
431 ifc_nand_ctrl
->index
+= column
;
433 if (chip
->ecc
.mode
== NAND_ECC_HW
)
434 ifc_nand_ctrl
->eccread
= 1;
436 fsl_ifc_do_read(chip
, 0, mtd
);
437 fsl_ifc_run_command(mtd
);
440 /* READOOB reads only the OOB because no ECC is performed. */
441 case NAND_CMD_READOOB
:
442 iowrite32be(mtd
->oobsize
- column
, &ifc
->ifc_nand
.nand_fbcr
);
443 set_addr(mtd
, column
, page_addr
, 1);
445 ifc_nand_ctrl
->read_bytes
= mtd
->writesize
+ mtd
->oobsize
;
447 fsl_ifc_do_read(chip
, 1, mtd
);
448 fsl_ifc_run_command(mtd
);
452 case NAND_CMD_READID
:
453 case NAND_CMD_PARAM
: {
454 int timing
= IFC_FIR_OP_RB
;
455 if (command
== NAND_CMD_PARAM
)
456 timing
= IFC_FIR_OP_RBCD
;
458 iowrite32be((IFC_FIR_OP_CW0
<< IFC_NAND_FIR0_OP0_SHIFT
) |
459 (IFC_FIR_OP_UA
<< IFC_NAND_FIR0_OP1_SHIFT
) |
460 (timing
<< IFC_NAND_FIR0_OP2_SHIFT
),
461 &ifc
->ifc_nand
.nand_fir0
);
462 iowrite32be(command
<< IFC_NAND_FCR0_CMD0_SHIFT
,
463 &ifc
->ifc_nand
.nand_fcr0
);
464 iowrite32be(column
, &ifc
->ifc_nand
.row3
);
467 * although currently it's 8 bytes for READID, we always read
468 * the maximum 256 bytes(for PARAM)
470 iowrite32be(256, &ifc
->ifc_nand
.nand_fbcr
);
471 ifc_nand_ctrl
->read_bytes
= 256;
473 set_addr(mtd
, 0, 0, 0);
474 fsl_ifc_run_command(mtd
);
478 /* ERASE1 stores the block and page address */
479 case NAND_CMD_ERASE1
:
480 set_addr(mtd
, 0, page_addr
, 0);
483 /* ERASE2 uses the block and page address from ERASE1 */
484 case NAND_CMD_ERASE2
:
485 iowrite32be((IFC_FIR_OP_CW0
<< IFC_NAND_FIR0_OP0_SHIFT
) |
486 (IFC_FIR_OP_RA0
<< IFC_NAND_FIR0_OP1_SHIFT
) |
487 (IFC_FIR_OP_CMD1
<< IFC_NAND_FIR0_OP2_SHIFT
),
488 &ifc
->ifc_nand
.nand_fir0
);
490 iowrite32be((NAND_CMD_ERASE1
<< IFC_NAND_FCR0_CMD0_SHIFT
) |
491 (NAND_CMD_ERASE2
<< IFC_NAND_FCR0_CMD1_SHIFT
),
492 &ifc
->ifc_nand
.nand_fcr0
);
494 iowrite32be(0, &ifc
->ifc_nand
.nand_fbcr
);
495 ifc_nand_ctrl
->read_bytes
= 0;
496 fsl_ifc_run_command(mtd
);
499 /* SEQIN sets up the addr buffer and all registers except the length */
500 case NAND_CMD_SEQIN
: {
502 ifc_nand_ctrl
->column
= column
;
503 ifc_nand_ctrl
->oob
= 0;
505 if (mtd
->writesize
> 512) {
507 (NAND_CMD_SEQIN
<< IFC_NAND_FCR0_CMD0_SHIFT
) |
508 (NAND_CMD_STATUS
<< IFC_NAND_FCR0_CMD1_SHIFT
) |
509 (NAND_CMD_PAGEPROG
<< IFC_NAND_FCR0_CMD2_SHIFT
);
512 (IFC_FIR_OP_CW0
<< IFC_NAND_FIR0_OP0_SHIFT
) |
513 (IFC_FIR_OP_CA0
<< IFC_NAND_FIR0_OP1_SHIFT
) |
514 (IFC_FIR_OP_RA0
<< IFC_NAND_FIR0_OP2_SHIFT
) |
515 (IFC_FIR_OP_WBCD
<< IFC_NAND_FIR0_OP3_SHIFT
) |
516 (IFC_FIR_OP_CMD2
<< IFC_NAND_FIR0_OP4_SHIFT
),
517 &ifc
->ifc_nand
.nand_fir0
);
519 (IFC_FIR_OP_CW1
<< IFC_NAND_FIR1_OP5_SHIFT
) |
520 (IFC_FIR_OP_RDSTAT
<<
521 IFC_NAND_FIR1_OP6_SHIFT
) |
522 (IFC_FIR_OP_NOP
<< IFC_NAND_FIR1_OP7_SHIFT
),
523 &ifc
->ifc_nand
.nand_fir1
);
525 nand_fcr0
= ((NAND_CMD_PAGEPROG
<<
526 IFC_NAND_FCR0_CMD1_SHIFT
) |
528 IFC_NAND_FCR0_CMD2_SHIFT
) |
530 IFC_NAND_FCR0_CMD3_SHIFT
));
533 (IFC_FIR_OP_CW0
<< IFC_NAND_FIR0_OP0_SHIFT
) |
534 (IFC_FIR_OP_CMD2
<< IFC_NAND_FIR0_OP1_SHIFT
) |
535 (IFC_FIR_OP_CA0
<< IFC_NAND_FIR0_OP2_SHIFT
) |
536 (IFC_FIR_OP_RA0
<< IFC_NAND_FIR0_OP3_SHIFT
) |
537 (IFC_FIR_OP_WBCD
<< IFC_NAND_FIR0_OP4_SHIFT
),
538 &ifc
->ifc_nand
.nand_fir0
);
540 (IFC_FIR_OP_CMD1
<< IFC_NAND_FIR1_OP5_SHIFT
) |
541 (IFC_FIR_OP_CW3
<< IFC_NAND_FIR1_OP6_SHIFT
) |
542 (IFC_FIR_OP_RDSTAT
<<
543 IFC_NAND_FIR1_OP7_SHIFT
) |
544 (IFC_FIR_OP_NOP
<< IFC_NAND_FIR1_OP8_SHIFT
),
545 &ifc
->ifc_nand
.nand_fir1
);
547 if (column
>= mtd
->writesize
)
549 NAND_CMD_READOOB
<< IFC_NAND_FCR0_CMD0_SHIFT
;
552 NAND_CMD_READ0
<< IFC_NAND_FCR0_CMD0_SHIFT
;
555 if (column
>= mtd
->writesize
) {
556 /* OOB area --> READOOB */
557 column
-= mtd
->writesize
;
558 ifc_nand_ctrl
->oob
= 1;
560 iowrite32be(nand_fcr0
, &ifc
->ifc_nand
.nand_fcr0
);
561 set_addr(mtd
, column
, page_addr
, ifc_nand_ctrl
->oob
);
565 /* PAGEPROG reuses all of the setup from SEQIN and adds the length */
566 case NAND_CMD_PAGEPROG
: {
567 if (ifc_nand_ctrl
->oob
) {
568 iowrite32be(ifc_nand_ctrl
->index
-
569 ifc_nand_ctrl
->column
,
570 &ifc
->ifc_nand
.nand_fbcr
);
572 iowrite32be(0, &ifc
->ifc_nand
.nand_fbcr
);
575 fsl_ifc_run_command(mtd
);
579 case NAND_CMD_STATUS
:
580 iowrite32be((IFC_FIR_OP_CW0
<< IFC_NAND_FIR0_OP0_SHIFT
) |
581 (IFC_FIR_OP_RB
<< IFC_NAND_FIR0_OP1_SHIFT
),
582 &ifc
->ifc_nand
.nand_fir0
);
583 iowrite32be(NAND_CMD_STATUS
<< IFC_NAND_FCR0_CMD0_SHIFT
,
584 &ifc
->ifc_nand
.nand_fcr0
);
585 iowrite32be(1, &ifc
->ifc_nand
.nand_fbcr
);
586 set_addr(mtd
, 0, 0, 0);
587 ifc_nand_ctrl
->read_bytes
= 1;
589 fsl_ifc_run_command(mtd
);
592 * The chip always seems to report that it is
593 * write-protected, even when it is not.
595 setbits8(ifc_nand_ctrl
->addr
, NAND_STATUS_WP
);
599 iowrite32be(IFC_FIR_OP_CW0
<< IFC_NAND_FIR0_OP0_SHIFT
,
600 &ifc
->ifc_nand
.nand_fir0
);
601 iowrite32be(NAND_CMD_RESET
<< IFC_NAND_FCR0_CMD0_SHIFT
,
602 &ifc
->ifc_nand
.nand_fcr0
);
603 fsl_ifc_run_command(mtd
);
607 dev_err(priv
->dev
, "%s: error, unsupported command 0x%x.\n",
612 static void fsl_ifc_select_chip(struct mtd_info
*mtd
, int chip
)
614 /* The hardware does not seem to support multiple
620 * Write buf to the IFC NAND Controller Data Buffer
622 static void fsl_ifc_write_buf(struct mtd_info
*mtd
, const u8
*buf
, int len
)
624 struct nand_chip
*chip
= mtd
->priv
;
625 struct fsl_ifc_mtd
*priv
= chip
->priv
;
626 unsigned int bufsize
= mtd
->writesize
+ mtd
->oobsize
;
629 dev_err(priv
->dev
, "%s: len %d bytes", __func__
, len
);
633 if ((unsigned int)len
> bufsize
- ifc_nand_ctrl
->index
) {
635 "%s: beyond end of buffer (%d requested, %u available)\n",
636 __func__
, len
, bufsize
- ifc_nand_ctrl
->index
);
637 len
= bufsize
- ifc_nand_ctrl
->index
;
640 memcpy_toio(&ifc_nand_ctrl
->addr
[ifc_nand_ctrl
->index
], buf
, len
);
641 ifc_nand_ctrl
->index
+= len
;
645 * Read a byte from either the IFC hardware buffer
646 * read function for 8-bit buswidth
648 static uint8_t fsl_ifc_read_byte(struct mtd_info
*mtd
)
650 struct nand_chip
*chip
= mtd
->priv
;
651 struct fsl_ifc_mtd
*priv
= chip
->priv
;
654 * If there are still bytes in the IFC buffer, then use the
657 if (ifc_nand_ctrl
->index
< ifc_nand_ctrl
->read_bytes
)
658 return in_8(&ifc_nand_ctrl
->addr
[ifc_nand_ctrl
->index
++]);
660 dev_err(priv
->dev
, "%s: beyond end of buffer\n", __func__
);
665 * Read two bytes from the IFC hardware buffer
666 * read function for 16-bit buswith
668 static uint8_t fsl_ifc_read_byte16(struct mtd_info
*mtd
)
670 struct nand_chip
*chip
= mtd
->priv
;
671 struct fsl_ifc_mtd
*priv
= chip
->priv
;
675 * If there are still bytes in the IFC buffer, then use the
678 if (ifc_nand_ctrl
->index
< ifc_nand_ctrl
->read_bytes
) {
679 data
= in_be16((uint16_t __iomem
*)&ifc_nand_ctrl
->
680 addr
[ifc_nand_ctrl
->index
]);
681 ifc_nand_ctrl
->index
+= 2;
682 return (uint8_t) data
;
685 dev_err(priv
->dev
, "%s: beyond end of buffer\n", __func__
);
690 * Read from the IFC Controller Data Buffer
692 static void fsl_ifc_read_buf(struct mtd_info
*mtd
, u8
*buf
, int len
)
694 struct nand_chip
*chip
= mtd
->priv
;
695 struct fsl_ifc_mtd
*priv
= chip
->priv
;
699 dev_err(priv
->dev
, "%s: len %d bytes", __func__
, len
);
703 avail
= min((unsigned int)len
,
704 ifc_nand_ctrl
->read_bytes
- ifc_nand_ctrl
->index
);
705 memcpy_fromio(buf
, &ifc_nand_ctrl
->addr
[ifc_nand_ctrl
->index
], avail
);
706 ifc_nand_ctrl
->index
+= avail
;
710 "%s: beyond end of buffer (%d requested, %d available)\n",
711 __func__
, len
, avail
);
715 * This function is called after Program and Erase Operations to
716 * check for success or failure.
718 static int fsl_ifc_wait(struct mtd_info
*mtd
, struct nand_chip
*chip
)
720 struct fsl_ifc_mtd
*priv
= chip
->priv
;
721 struct fsl_ifc_ctrl
*ctrl
= priv
->ctrl
;
722 struct fsl_ifc_regs __iomem
*ifc
= ctrl
->regs
;
725 /* Use READ_STATUS command, but wait for the device to be ready */
726 iowrite32be((IFC_FIR_OP_CW0
<< IFC_NAND_FIR0_OP0_SHIFT
) |
727 (IFC_FIR_OP_RDSTAT
<< IFC_NAND_FIR0_OP1_SHIFT
),
728 &ifc
->ifc_nand
.nand_fir0
);
729 iowrite32be(NAND_CMD_STATUS
<< IFC_NAND_FCR0_CMD0_SHIFT
,
730 &ifc
->ifc_nand
.nand_fcr0
);
731 iowrite32be(1, &ifc
->ifc_nand
.nand_fbcr
);
732 set_addr(mtd
, 0, 0, 0);
733 ifc_nand_ctrl
->read_bytes
= 1;
735 fsl_ifc_run_command(mtd
);
737 nand_fsr
= ioread32be(&ifc
->ifc_nand
.nand_fsr
);
740 * The chip always seems to report that it is
741 * write-protected, even when it is not.
743 return nand_fsr
| NAND_STATUS_WP
;
746 static int fsl_ifc_read_page(struct mtd_info
*mtd
, struct nand_chip
*chip
,
747 uint8_t *buf
, int oob_required
, int page
)
749 struct fsl_ifc_mtd
*priv
= chip
->priv
;
750 struct fsl_ifc_ctrl
*ctrl
= priv
->ctrl
;
751 struct fsl_ifc_nand_ctrl
*nctrl
= ifc_nand_ctrl
;
753 fsl_ifc_read_buf(mtd
, buf
, mtd
->writesize
);
755 fsl_ifc_read_buf(mtd
, chip
->oob_poi
, mtd
->oobsize
);
757 if (ctrl
->nand_stat
& IFC_NAND_EVTER_STAT_ECCER
)
758 dev_err(priv
->dev
, "NAND Flash ECC Uncorrectable Error\n");
760 if (ctrl
->nand_stat
!= IFC_NAND_EVTER_STAT_OPC
)
761 mtd
->ecc_stats
.failed
++;
763 return nctrl
->max_bitflips
;
766 /* ECC will be calculated automatically, and errors will be detected in
769 static int fsl_ifc_write_page(struct mtd_info
*mtd
, struct nand_chip
*chip
,
770 const uint8_t *buf
, int oob_required
)
772 fsl_ifc_write_buf(mtd
, buf
, mtd
->writesize
);
773 fsl_ifc_write_buf(mtd
, chip
->oob_poi
, mtd
->oobsize
);
778 static int fsl_ifc_chip_init_tail(struct mtd_info
*mtd
)
780 struct nand_chip
*chip
= mtd
->priv
;
781 struct fsl_ifc_mtd
*priv
= chip
->priv
;
783 dev_dbg(priv
->dev
, "%s: nand->numchips = %d\n", __func__
,
785 dev_dbg(priv
->dev
, "%s: nand->chipsize = %lld\n", __func__
,
787 dev_dbg(priv
->dev
, "%s: nand->pagemask = %8x\n", __func__
,
789 dev_dbg(priv
->dev
, "%s: nand->chip_delay = %d\n", __func__
,
791 dev_dbg(priv
->dev
, "%s: nand->badblockpos = %d\n", __func__
,
793 dev_dbg(priv
->dev
, "%s: nand->chip_shift = %d\n", __func__
,
795 dev_dbg(priv
->dev
, "%s: nand->page_shift = %d\n", __func__
,
797 dev_dbg(priv
->dev
, "%s: nand->phys_erase_shift = %d\n", __func__
,
798 chip
->phys_erase_shift
);
799 dev_dbg(priv
->dev
, "%s: nand->ecc.mode = %d\n", __func__
,
801 dev_dbg(priv
->dev
, "%s: nand->ecc.steps = %d\n", __func__
,
803 dev_dbg(priv
->dev
, "%s: nand->ecc.bytes = %d\n", __func__
,
805 dev_dbg(priv
->dev
, "%s: nand->ecc.total = %d\n", __func__
,
807 dev_dbg(priv
->dev
, "%s: nand->ecc.layout = %p\n", __func__
,
809 dev_dbg(priv
->dev
, "%s: mtd->flags = %08x\n", __func__
, mtd
->flags
);
810 dev_dbg(priv
->dev
, "%s: mtd->size = %lld\n", __func__
, mtd
->size
);
811 dev_dbg(priv
->dev
, "%s: mtd->erasesize = %d\n", __func__
,
813 dev_dbg(priv
->dev
, "%s: mtd->writesize = %d\n", __func__
,
815 dev_dbg(priv
->dev
, "%s: mtd->oobsize = %d\n", __func__
,
821 static void fsl_ifc_sram_init(struct fsl_ifc_mtd
*priv
)
823 struct fsl_ifc_ctrl
*ctrl
= priv
->ctrl
;
824 struct fsl_ifc_regs __iomem
*ifc
= ctrl
->regs
;
825 uint32_t csor
= 0, csor_8k
= 0, csor_ext
= 0;
826 uint32_t cs
= priv
->bank
;
828 /* Save CSOR and CSOR_ext */
829 csor
= ioread32be(&ifc
->csor_cs
[cs
].csor
);
830 csor_ext
= ioread32be(&ifc
->csor_cs
[cs
].csor_ext
);
832 /* chage PageSize 8K and SpareSize 1K*/
833 csor_8k
= (csor
& ~(CSOR_NAND_PGS_MASK
)) | 0x0018C000;
834 iowrite32be(csor_8k
, &ifc
->csor_cs
[cs
].csor
);
835 iowrite32be(0x0000400, &ifc
->csor_cs
[cs
].csor_ext
);
838 iowrite32be((IFC_FIR_OP_CW0
<< IFC_NAND_FIR0_OP0_SHIFT
) |
839 (IFC_FIR_OP_UA
<< IFC_NAND_FIR0_OP1_SHIFT
) |
840 (IFC_FIR_OP_RB
<< IFC_NAND_FIR0_OP2_SHIFT
),
841 &ifc
->ifc_nand
.nand_fir0
);
842 iowrite32be(NAND_CMD_READID
<< IFC_NAND_FCR0_CMD0_SHIFT
,
843 &ifc
->ifc_nand
.nand_fcr0
);
844 iowrite32be(0x0, &ifc
->ifc_nand
.row3
);
846 iowrite32be(0x0, &ifc
->ifc_nand
.nand_fbcr
);
848 /* Program ROW0/COL0 */
849 iowrite32be(0x0, &ifc
->ifc_nand
.row0
);
850 iowrite32be(0x0, &ifc
->ifc_nand
.col0
);
852 /* set the chip select for NAND Transaction */
853 iowrite32be(cs
<< IFC_NAND_CSEL_SHIFT
, &ifc
->ifc_nand
.nand_csel
);
856 iowrite32be(IFC_NAND_SEQ_STRT_FIR_STRT
, &ifc
->ifc_nand
.nandseq_strt
);
858 /* wait for command complete flag or timeout */
859 wait_event_timeout(ctrl
->nand_wait
, ctrl
->nand_stat
,
860 IFC_TIMEOUT_MSECS
* HZ
/1000);
862 if (ctrl
->nand_stat
!= IFC_NAND_EVTER_STAT_OPC
)
863 printk(KERN_ERR
"fsl-ifc: Failed to Initialise SRAM\n");
865 /* Restore CSOR and CSOR_ext */
866 iowrite32be(csor
, &ifc
->csor_cs
[cs
].csor
);
867 iowrite32be(csor_ext
, &ifc
->csor_cs
[cs
].csor_ext
);
870 static int fsl_ifc_chip_init(struct fsl_ifc_mtd
*priv
)
872 struct fsl_ifc_ctrl
*ctrl
= priv
->ctrl
;
873 struct fsl_ifc_regs __iomem
*ifc
= ctrl
->regs
;
874 struct nand_chip
*chip
= &priv
->chip
;
875 struct nand_ecclayout
*layout
;
878 /* Fill in fsl_ifc_mtd structure */
879 priv
->mtd
.priv
= chip
;
880 priv
->mtd
.owner
= THIS_MODULE
;
882 /* fill in nand_chip structure */
883 /* set up function call table */
884 if ((ioread32be(&ifc
->cspr_cs
[priv
->bank
].cspr
)) & CSPR_PORT_SIZE_16
)
885 chip
->read_byte
= fsl_ifc_read_byte16
;
887 chip
->read_byte
= fsl_ifc_read_byte
;
889 chip
->write_buf
= fsl_ifc_write_buf
;
890 chip
->read_buf
= fsl_ifc_read_buf
;
891 chip
->select_chip
= fsl_ifc_select_chip
;
892 chip
->cmdfunc
= fsl_ifc_cmdfunc
;
893 chip
->waitfunc
= fsl_ifc_wait
;
895 chip
->bbt_td
= &bbt_main_descr
;
896 chip
->bbt_md
= &bbt_mirror_descr
;
898 iowrite32be(0x0, &ifc
->ifc_nand
.ncfgr
);
900 /* set up nand options */
901 chip
->bbt_options
= NAND_BBT_USE_FLASH
;
902 chip
->options
= NAND_NO_SUBPAGE_WRITE
;
904 if (ioread32be(&ifc
->cspr_cs
[priv
->bank
].cspr
) & CSPR_PORT_SIZE_16
) {
905 chip
->read_byte
= fsl_ifc_read_byte16
;
906 chip
->options
|= NAND_BUSWIDTH_16
;
908 chip
->read_byte
= fsl_ifc_read_byte
;
911 chip
->controller
= &ifc_nand_ctrl
->controller
;
914 chip
->ecc
.read_page
= fsl_ifc_read_page
;
915 chip
->ecc
.write_page
= fsl_ifc_write_page
;
917 csor
= ioread32be(&ifc
->csor_cs
[priv
->bank
].csor
);
919 /* Hardware generates ECC per 512 Bytes */
920 chip
->ecc
.size
= 512;
922 chip
->ecc
.strength
= 4;
924 switch (csor
& CSOR_NAND_PGS_MASK
) {
925 case CSOR_NAND_PGS_512
:
926 if (chip
->options
& NAND_BUSWIDTH_16
) {
927 layout
= &oob_512_16bit_ecc4
;
929 layout
= &oob_512_8bit_ecc4
;
931 /* Avoid conflict with bad block marker */
932 bbt_main_descr
.offs
= 0;
933 bbt_mirror_descr
.offs
= 0;
936 priv
->bufnum_mask
= 15;
939 case CSOR_NAND_PGS_2K
:
940 layout
= &oob_2048_ecc4
;
941 priv
->bufnum_mask
= 3;
944 case CSOR_NAND_PGS_4K
:
945 if ((csor
& CSOR_NAND_ECC_MODE_MASK
) ==
946 CSOR_NAND_ECC_MODE_4
) {
947 layout
= &oob_4096_ecc4
;
949 layout
= &oob_4096_ecc8
;
950 chip
->ecc
.bytes
= 16;
951 chip
->ecc
.strength
= 8;
954 priv
->bufnum_mask
= 1;
957 case CSOR_NAND_PGS_8K
:
958 if ((csor
& CSOR_NAND_ECC_MODE_MASK
) ==
959 CSOR_NAND_ECC_MODE_4
) {
960 layout
= &oob_8192_ecc4
;
962 layout
= &oob_8192_ecc8
;
963 chip
->ecc
.bytes
= 16;
964 chip
->ecc
.strength
= 8;
967 priv
->bufnum_mask
= 0;
971 dev_err(priv
->dev
, "bad csor %#x: bad page size\n", csor
);
975 /* Must also set CSOR_NAND_ECC_ENC_EN if DEC_EN set */
976 if (csor
& CSOR_NAND_ECC_DEC_EN
) {
977 chip
->ecc
.mode
= NAND_ECC_HW
;
978 chip
->ecc
.layout
= layout
;
980 chip
->ecc
.mode
= NAND_ECC_SOFT
;
983 ver
= ioread32be(&ifc
->ifc_rev
);
984 if (ver
== FSL_IFC_V1_1_0
)
985 fsl_ifc_sram_init(priv
);
990 static int fsl_ifc_chip_remove(struct fsl_ifc_mtd
*priv
)
992 nand_release(&priv
->mtd
);
994 kfree(priv
->mtd
.name
);
997 iounmap(priv
->vbase
);
999 ifc_nand_ctrl
->chips
[priv
->bank
] = NULL
;
1004 static int match_bank(struct fsl_ifc_regs __iomem
*ifc
, int bank
,
1007 u32 cspr
= ioread32be(&ifc
->cspr_cs
[bank
].cspr
);
1009 if (!(cspr
& CSPR_V
))
1011 if ((cspr
& CSPR_MSEL
) != CSPR_MSEL_NAND
)
1014 return (cspr
& CSPR_BA
) == convert_ifc_address(addr
);
1017 static DEFINE_MUTEX(fsl_ifc_nand_mutex
);
1019 static int fsl_ifc_nand_probe(struct platform_device
*dev
)
1021 struct fsl_ifc_regs __iomem
*ifc
;
1022 struct fsl_ifc_mtd
*priv
;
1023 struct resource res
;
1024 static const char *part_probe_types
[]
1025 = { "cmdlinepart", "RedBoot", "ofpart", NULL
};
1028 struct device_node
*node
= dev
->dev
.of_node
;
1029 struct mtd_part_parser_data ppdata
;
1031 ppdata
.of_node
= dev
->dev
.of_node
;
1032 if (!fsl_ifc_ctrl_dev
|| !fsl_ifc_ctrl_dev
->regs
)
1034 ifc
= fsl_ifc_ctrl_dev
->regs
;
1036 /* get, allocate and map the memory resource */
1037 ret
= of_address_to_resource(node
, 0, &res
);
1039 dev_err(&dev
->dev
, "%s: failed to get resource\n", __func__
);
1043 /* find which chip select it is connected to */
1044 for (bank
= 0; bank
< FSL_IFC_BANK_COUNT
; bank
++) {
1045 if (match_bank(ifc
, bank
, res
.start
))
1049 if (bank
>= FSL_IFC_BANK_COUNT
) {
1050 dev_err(&dev
->dev
, "%s: address did not match any chip selects\n",
1055 priv
= devm_kzalloc(&dev
->dev
, sizeof(*priv
), GFP_KERNEL
);
1059 mutex_lock(&fsl_ifc_nand_mutex
);
1060 if (!fsl_ifc_ctrl_dev
->nand
) {
1061 ifc_nand_ctrl
= kzalloc(sizeof(*ifc_nand_ctrl
), GFP_KERNEL
);
1062 if (!ifc_nand_ctrl
) {
1063 dev_err(&dev
->dev
, "failed to allocate memory\n");
1064 mutex_unlock(&fsl_ifc_nand_mutex
);
1068 ifc_nand_ctrl
->read_bytes
= 0;
1069 ifc_nand_ctrl
->index
= 0;
1070 ifc_nand_ctrl
->addr
= NULL
;
1071 fsl_ifc_ctrl_dev
->nand
= ifc_nand_ctrl
;
1073 spin_lock_init(&ifc_nand_ctrl
->controller
.lock
);
1074 init_waitqueue_head(&ifc_nand_ctrl
->controller
.wq
);
1076 ifc_nand_ctrl
= fsl_ifc_ctrl_dev
->nand
;
1078 mutex_unlock(&fsl_ifc_nand_mutex
);
1080 ifc_nand_ctrl
->chips
[bank
] = priv
;
1082 priv
->ctrl
= fsl_ifc_ctrl_dev
;
1083 priv
->dev
= &dev
->dev
;
1085 priv
->vbase
= ioremap(res
.start
, resource_size(&res
));
1087 dev_err(priv
->dev
, "%s: failed to map chip region\n", __func__
);
1092 dev_set_drvdata(priv
->dev
, priv
);
1094 iowrite32be(IFC_NAND_EVTER_EN_OPC_EN
|
1095 IFC_NAND_EVTER_EN_FTOER_EN
|
1096 IFC_NAND_EVTER_EN_WPER_EN
,
1097 &ifc
->ifc_nand
.nand_evter_en
);
1099 /* enable NAND Machine Interrupts */
1100 iowrite32be(IFC_NAND_EVTER_INTR_OPCIR_EN
|
1101 IFC_NAND_EVTER_INTR_FTOERIR_EN
|
1102 IFC_NAND_EVTER_INTR_WPERIR_EN
,
1103 &ifc
->ifc_nand
.nand_evter_intr_en
);
1104 priv
->mtd
.name
= kasprintf(GFP_KERNEL
, "%x.flash", (unsigned)res
.start
);
1105 if (!priv
->mtd
.name
) {
1110 ret
= fsl_ifc_chip_init(priv
);
1114 ret
= nand_scan_ident(&priv
->mtd
, 1, NULL
);
1118 ret
= fsl_ifc_chip_init_tail(&priv
->mtd
);
1122 ret
= nand_scan_tail(&priv
->mtd
);
1126 /* First look for RedBoot table or partitions on the command
1127 * line, these take precedence over device tree information */
1128 mtd_device_parse_register(&priv
->mtd
, part_probe_types
, &ppdata
,
1131 dev_info(priv
->dev
, "IFC NAND device at 0x%llx, bank %d\n",
1132 (unsigned long long)res
.start
, priv
->bank
);
1136 fsl_ifc_chip_remove(priv
);
1140 static int fsl_ifc_nand_remove(struct platform_device
*dev
)
1142 struct fsl_ifc_mtd
*priv
= dev_get_drvdata(&dev
->dev
);
1144 fsl_ifc_chip_remove(priv
);
1146 mutex_lock(&fsl_ifc_nand_mutex
);
1147 ifc_nand_ctrl
->counter
--;
1148 if (!ifc_nand_ctrl
->counter
) {
1149 fsl_ifc_ctrl_dev
->nand
= NULL
;
1150 kfree(ifc_nand_ctrl
);
1152 mutex_unlock(&fsl_ifc_nand_mutex
);
1157 static const struct of_device_id fsl_ifc_nand_match
[] = {
1159 .compatible
= "fsl,ifc-nand",
1164 static struct platform_driver fsl_ifc_nand_driver
= {
1166 .name
= "fsl,ifc-nand",
1167 .owner
= THIS_MODULE
,
1168 .of_match_table
= fsl_ifc_nand_match
,
1170 .probe
= fsl_ifc_nand_probe
,
1171 .remove
= fsl_ifc_nand_remove
,
1174 module_platform_driver(fsl_ifc_nand_driver
);
1176 MODULE_LICENSE("GPL");
1177 MODULE_AUTHOR("Freescale");
1178 MODULE_DESCRIPTION("Freescale Integrated Flash Controller MTD NAND driver");