1 /* Freescale Enhanced Local Bus Controller NAND driver
3 * Copyright (c) 2006-2007 Freescale Semiconductor
5 * Authors: Nick Spence <nick.spence@freescale.com>,
6 * Scott Wood <scottwood@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/string.h>
28 #include <linux/ioport.h>
29 #include <linux/of_platform.h>
30 #include <linux/slab.h>
31 #include <linux/interrupt.h>
33 #include <linux/mtd/mtd.h>
34 #include <linux/mtd/nand.h>
35 #include <linux/mtd/nand_ecc.h>
36 #include <linux/mtd/partitions.h>
39 #include <asm/fsl_lbc.h>
42 #define ERR_BYTE 0xFF /* Value returned for read bytes when read failed */
43 #define FCM_TIMEOUT_MSECS 500 /* Maximum number of mSecs to wait for FCM */
47 /* mtd information per set */
51 struct nand_chip chip
;
52 struct fsl_elbc_ctrl
*ctrl
;
55 int bank
; /* Chip select bank number */
56 u8 __iomem
*vbase
; /* Chip select base virtual address */
57 int page_size
; /* NAND page size (0=512, 1=2048) */
58 unsigned int fmr
; /* FCM Flash Mode Register value */
61 /* overview of the fsl elbc controller */
63 struct fsl_elbc_ctrl
{
64 struct nand_hw_control controller
;
65 struct fsl_elbc_mtd
*chips
[MAX_BANKS
];
69 struct fsl_lbc_regs __iomem
*regs
;
71 wait_queue_head_t irq_wait
;
72 unsigned int irq_status
; /* status read from LTESR by irq handler */
73 u8 __iomem
*addr
; /* Address of assigned FCM buffer */
74 unsigned int page
; /* Last page written to / read from */
75 unsigned int read_bytes
; /* Number of bytes read during command */
76 unsigned int column
; /* Saved column from SEQIN */
77 unsigned int index
; /* Pointer to next byte to 'read' */
78 unsigned int status
; /* status read from LTESR after last op */
79 unsigned int mdr
; /* UPM/FCM Data Register value */
80 unsigned int use_mdr
; /* Non zero if the MDR is to be set */
81 unsigned int oob
; /* Non zero if operating on OOB data */
82 char *oob_poi
; /* Place to write ECC after read back */
85 /* These map to the positions used by the FCM hardware ECC generator */
87 /* Small Page FLASH with FMR[ECCM] = 0 */
88 static struct nand_ecclayout fsl_elbc_oob_sp_eccm0
= {
91 .oobfree
= { {0, 5}, {9, 7} },
95 /* Small Page FLASH with FMR[ECCM] = 1 */
96 static struct nand_ecclayout fsl_elbc_oob_sp_eccm1
= {
99 .oobfree
= { {0, 5}, {6, 2}, {11, 5} },
103 /* Large Page FLASH with FMR[ECCM] = 0 */
104 static struct nand_ecclayout fsl_elbc_oob_lp_eccm0
= {
106 .eccpos
= {6, 7, 8, 22, 23, 24, 38, 39, 40, 54, 55, 56},
107 .oobfree
= { {1, 5}, {9, 13}, {25, 13}, {41, 13}, {57, 7} },
111 /* Large Page FLASH with FMR[ECCM] = 1 */
112 static struct nand_ecclayout fsl_elbc_oob_lp_eccm1
= {
114 .eccpos
= {8, 9, 10, 24, 25, 26, 40, 41, 42, 56, 57, 58},
115 .oobfree
= { {1, 7}, {11, 13}, {27, 13}, {43, 13}, {59, 5} },
119 /*=================================*/
122 * Set up the FCM hardware block and page address fields, and the fcm
123 * structure addr field to point to the correct FCM buffer in memory
125 static void set_addr(struct mtd_info
*mtd
, int column
, int page_addr
, int oob
)
127 struct nand_chip
*chip
= mtd
->priv
;
128 struct fsl_elbc_mtd
*priv
= chip
->priv
;
129 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
130 struct fsl_lbc_regs __iomem
*lbc
= ctrl
->regs
;
133 ctrl
->page
= page_addr
;
136 page_addr
>> (chip
->phys_erase_shift
- chip
->page_shift
));
138 if (priv
->page_size
) {
140 ((page_addr
<< FPAR_LP_PI_SHIFT
) & FPAR_LP_PI
) |
141 (oob
? FPAR_LP_MS
: 0) | column
);
142 buf_num
= (page_addr
& 1) << 2;
145 ((page_addr
<< FPAR_SP_PI_SHIFT
) & FPAR_SP_PI
) |
146 (oob
? FPAR_SP_MS
: 0) | column
);
147 buf_num
= page_addr
& 7;
150 ctrl
->addr
= priv
->vbase
+ buf_num
* 1024;
151 ctrl
->index
= column
;
153 /* for OOB data point to the second half of the buffer */
155 ctrl
->index
+= priv
->page_size
? 2048 : 512;
157 dev_vdbg(ctrl
->dev
, "set_addr: bank=%d, ctrl->addr=0x%p (0x%p), "
158 "index %x, pes %d ps %d\n",
159 buf_num
, ctrl
->addr
, priv
->vbase
, ctrl
->index
,
160 chip
->phys_erase_shift
, chip
->page_shift
);
164 * execute FCM command and wait for it to complete
166 static int fsl_elbc_run_command(struct mtd_info
*mtd
)
168 struct nand_chip
*chip
= mtd
->priv
;
169 struct fsl_elbc_mtd
*priv
= chip
->priv
;
170 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
171 struct fsl_lbc_regs __iomem
*lbc
= ctrl
->regs
;
173 /* Setup the FMR[OP] to execute without write protection */
174 out_be32(&lbc
->fmr
, priv
->fmr
| 3);
176 out_be32(&lbc
->mdr
, ctrl
->mdr
);
179 "fsl_elbc_run_command: fmr=%08x fir=%08x fcr=%08x\n",
180 in_be32(&lbc
->fmr
), in_be32(&lbc
->fir
), in_be32(&lbc
->fcr
));
182 "fsl_elbc_run_command: fbar=%08x fpar=%08x "
183 "fbcr=%08x bank=%d\n",
184 in_be32(&lbc
->fbar
), in_be32(&lbc
->fpar
),
185 in_be32(&lbc
->fbcr
), priv
->bank
);
187 /* execute special operation */
188 out_be32(&lbc
->lsor
, priv
->bank
);
190 /* wait for FCM complete flag or timeout */
191 ctrl
->irq_status
= 0;
192 wait_event_timeout(ctrl
->irq_wait
, ctrl
->irq_status
,
193 FCM_TIMEOUT_MSECS
* HZ
/1000);
194 ctrl
->status
= ctrl
->irq_status
;
196 /* store mdr value in case it was needed */
198 ctrl
->mdr
= in_be32(&lbc
->mdr
);
203 "fsl_elbc_run_command: stat=%08x mdr=%08x fmr=%08x\n",
204 ctrl
->status
, ctrl
->mdr
, in_be32(&lbc
->fmr
));
206 /* returns 0 on success otherwise non-zero) */
207 return ctrl
->status
== LTESR_CC
? 0 : -EIO
;
210 static void fsl_elbc_do_read(struct nand_chip
*chip
, int oob
)
212 struct fsl_elbc_mtd
*priv
= chip
->priv
;
213 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
214 struct fsl_lbc_regs __iomem
*lbc
= ctrl
->regs
;
216 if (priv
->page_size
) {
218 (FIR_OP_CW0
<< FIR_OP0_SHIFT
) |
219 (FIR_OP_CA
<< FIR_OP1_SHIFT
) |
220 (FIR_OP_PA
<< FIR_OP2_SHIFT
) |
221 (FIR_OP_CW1
<< FIR_OP3_SHIFT
) |
222 (FIR_OP_RBW
<< FIR_OP4_SHIFT
));
224 out_be32(&lbc
->fcr
, (NAND_CMD_READ0
<< FCR_CMD0_SHIFT
) |
225 (NAND_CMD_READSTART
<< FCR_CMD1_SHIFT
));
228 (FIR_OP_CW0
<< FIR_OP0_SHIFT
) |
229 (FIR_OP_CA
<< FIR_OP1_SHIFT
) |
230 (FIR_OP_PA
<< FIR_OP2_SHIFT
) |
231 (FIR_OP_RBW
<< FIR_OP3_SHIFT
));
234 out_be32(&lbc
->fcr
, NAND_CMD_READOOB
<< FCR_CMD0_SHIFT
);
236 out_be32(&lbc
->fcr
, NAND_CMD_READ0
<< FCR_CMD0_SHIFT
);
240 /* cmdfunc send commands to the FCM */
241 static void fsl_elbc_cmdfunc(struct mtd_info
*mtd
, unsigned int command
,
242 int column
, int page_addr
)
244 struct nand_chip
*chip
= mtd
->priv
;
245 struct fsl_elbc_mtd
*priv
= chip
->priv
;
246 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
247 struct fsl_lbc_regs __iomem
*lbc
= ctrl
->regs
;
251 /* clear the read buffer */
252 ctrl
->read_bytes
= 0;
253 if (command
!= NAND_CMD_PAGEPROG
)
257 /* READ0 and READ1 read the entire buffer to use hardware ECC. */
264 "fsl_elbc_cmdfunc: NAND_CMD_READ0, page_addr:"
265 " 0x%x, column: 0x%x.\n", page_addr
, column
);
268 out_be32(&lbc
->fbcr
, 0); /* read entire page to enable ECC */
269 set_addr(mtd
, 0, page_addr
, 0);
271 ctrl
->read_bytes
= mtd
->writesize
+ mtd
->oobsize
;
272 ctrl
->index
+= column
;
274 fsl_elbc_do_read(chip
, 0);
275 fsl_elbc_run_command(mtd
);
278 /* READOOB reads only the OOB because no ECC is performed. */
279 case NAND_CMD_READOOB
:
281 "fsl_elbc_cmdfunc: NAND_CMD_READOOB, page_addr:"
282 " 0x%x, column: 0x%x.\n", page_addr
, column
);
284 out_be32(&lbc
->fbcr
, mtd
->oobsize
- column
);
285 set_addr(mtd
, column
, page_addr
, 1);
287 ctrl
->read_bytes
= mtd
->writesize
+ mtd
->oobsize
;
289 fsl_elbc_do_read(chip
, 1);
290 fsl_elbc_run_command(mtd
);
293 /* READID must read all 5 possible bytes while CEB is active */
294 case NAND_CMD_READID
:
295 dev_vdbg(ctrl
->dev
, "fsl_elbc_cmdfunc: NAND_CMD_READID.\n");
297 out_be32(&lbc
->fir
, (FIR_OP_CW0
<< FIR_OP0_SHIFT
) |
298 (FIR_OP_UA
<< FIR_OP1_SHIFT
) |
299 (FIR_OP_RBW
<< FIR_OP2_SHIFT
));
300 out_be32(&lbc
->fcr
, NAND_CMD_READID
<< FCR_CMD0_SHIFT
);
301 /* 5 bytes for manuf, device and exts */
302 out_be32(&lbc
->fbcr
, 5);
303 ctrl
->read_bytes
= 5;
307 set_addr(mtd
, 0, 0, 0);
308 fsl_elbc_run_command(mtd
);
311 /* ERASE1 stores the block and page address */
312 case NAND_CMD_ERASE1
:
314 "fsl_elbc_cmdfunc: NAND_CMD_ERASE1, "
315 "page_addr: 0x%x.\n", page_addr
);
316 set_addr(mtd
, 0, page_addr
, 0);
319 /* ERASE2 uses the block and page address from ERASE1 */
320 case NAND_CMD_ERASE2
:
321 dev_vdbg(ctrl
->dev
, "fsl_elbc_cmdfunc: NAND_CMD_ERASE2.\n");
324 (FIR_OP_CW0
<< FIR_OP0_SHIFT
) |
325 (FIR_OP_PA
<< FIR_OP1_SHIFT
) |
326 (FIR_OP_CM1
<< FIR_OP2_SHIFT
));
329 (NAND_CMD_ERASE1
<< FCR_CMD0_SHIFT
) |
330 (NAND_CMD_ERASE2
<< FCR_CMD1_SHIFT
));
332 out_be32(&lbc
->fbcr
, 0);
333 ctrl
->read_bytes
= 0;
335 fsl_elbc_run_command(mtd
);
338 /* SEQIN sets up the addr buffer and all registers except the length */
339 case NAND_CMD_SEQIN
: {
342 "fsl_elbc_cmdfunc: NAND_CMD_SEQIN/PAGE_PROG, "
343 "page_addr: 0x%x, column: 0x%x.\n",
346 ctrl
->column
= column
;
349 if (priv
->page_size
) {
350 fcr
= (NAND_CMD_SEQIN
<< FCR_CMD0_SHIFT
) |
351 (NAND_CMD_PAGEPROG
<< FCR_CMD1_SHIFT
);
354 (FIR_OP_CW0
<< FIR_OP0_SHIFT
) |
355 (FIR_OP_CA
<< FIR_OP1_SHIFT
) |
356 (FIR_OP_PA
<< FIR_OP2_SHIFT
) |
357 (FIR_OP_WB
<< FIR_OP3_SHIFT
) |
358 (FIR_OP_CW1
<< FIR_OP4_SHIFT
));
360 fcr
= (NAND_CMD_PAGEPROG
<< FCR_CMD1_SHIFT
) |
361 (NAND_CMD_SEQIN
<< FCR_CMD2_SHIFT
);
364 (FIR_OP_CW0
<< FIR_OP0_SHIFT
) |
365 (FIR_OP_CM2
<< FIR_OP1_SHIFT
) |
366 (FIR_OP_CA
<< FIR_OP2_SHIFT
) |
367 (FIR_OP_PA
<< FIR_OP3_SHIFT
) |
368 (FIR_OP_WB
<< FIR_OP4_SHIFT
) |
369 (FIR_OP_CW1
<< FIR_OP5_SHIFT
));
371 if (column
>= mtd
->writesize
) {
372 /* OOB area --> READOOB */
373 column
-= mtd
->writesize
;
374 fcr
|= NAND_CMD_READOOB
<< FCR_CMD0_SHIFT
;
376 } else if (column
< 256) {
377 /* First 256 bytes --> READ0 */
378 fcr
|= NAND_CMD_READ0
<< FCR_CMD0_SHIFT
;
380 /* Second 256 bytes --> READ1 */
381 fcr
|= NAND_CMD_READ1
<< FCR_CMD0_SHIFT
;
385 out_be32(&lbc
->fcr
, fcr
);
386 set_addr(mtd
, column
, page_addr
, ctrl
->oob
);
390 /* PAGEPROG reuses all of the setup from SEQIN and adds the length */
391 case NAND_CMD_PAGEPROG
: {
394 "fsl_elbc_cmdfunc: NAND_CMD_PAGEPROG "
395 "writing %d bytes.\n", ctrl
->index
);
397 /* if the write did not start at 0 or is not a full page
398 * then set the exact length, otherwise use a full page
399 * write so the HW generates the ECC.
401 if (ctrl
->oob
|| ctrl
->column
!= 0 ||
402 ctrl
->index
!= mtd
->writesize
+ mtd
->oobsize
) {
403 out_be32(&lbc
->fbcr
, ctrl
->index
);
406 out_be32(&lbc
->fbcr
, 0);
410 fsl_elbc_run_command(mtd
);
412 /* Read back the page in order to fill in the ECC for the
413 * caller. Is this really needed?
415 if (full_page
&& ctrl
->oob_poi
) {
416 out_be32(&lbc
->fbcr
, 3);
417 set_addr(mtd
, 6, page_addr
, 1);
419 ctrl
->read_bytes
= mtd
->writesize
+ 9;
421 fsl_elbc_do_read(chip
, 1);
422 fsl_elbc_run_command(mtd
);
424 memcpy_fromio(ctrl
->oob_poi
+ 6,
425 &ctrl
->addr
[ctrl
->index
], 3);
429 ctrl
->oob_poi
= NULL
;
433 /* CMD_STATUS must read the status byte while CEB is active */
434 /* Note - it does not wait for the ready line */
435 case NAND_CMD_STATUS
:
437 (FIR_OP_CM0
<< FIR_OP0_SHIFT
) |
438 (FIR_OP_RBW
<< FIR_OP1_SHIFT
));
439 out_be32(&lbc
->fcr
, NAND_CMD_STATUS
<< FCR_CMD0_SHIFT
);
440 out_be32(&lbc
->fbcr
, 1);
441 set_addr(mtd
, 0, 0, 0);
442 ctrl
->read_bytes
= 1;
444 fsl_elbc_run_command(mtd
);
446 /* The chip always seems to report that it is
447 * write-protected, even when it is not.
449 setbits8(ctrl
->addr
, NAND_STATUS_WP
);
452 /* RESET without waiting for the ready line */
454 dev_dbg(ctrl
->dev
, "fsl_elbc_cmdfunc: NAND_CMD_RESET.\n");
455 out_be32(&lbc
->fir
, FIR_OP_CM0
<< FIR_OP0_SHIFT
);
456 out_be32(&lbc
->fcr
, NAND_CMD_RESET
<< FCR_CMD0_SHIFT
);
457 fsl_elbc_run_command(mtd
);
462 "fsl_elbc_cmdfunc: error, unsupported command 0x%x.\n",
467 static void fsl_elbc_select_chip(struct mtd_info
*mtd
, int chip
)
469 /* The hardware does not seem to support multiple
475 * Write buf to the FCM Controller Data Buffer
477 static void fsl_elbc_write_buf(struct mtd_info
*mtd
, const u8
*buf
, int len
)
479 struct nand_chip
*chip
= mtd
->priv
;
480 struct fsl_elbc_mtd
*priv
= chip
->priv
;
481 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
482 unsigned int bufsize
= mtd
->writesize
+ mtd
->oobsize
;
485 dev_err(ctrl
->dev
, "write_buf of %d bytes", len
);
490 if ((unsigned int)len
> bufsize
- ctrl
->index
) {
492 "write_buf beyond end of buffer "
493 "(%d requested, %u available)\n",
494 len
, bufsize
- ctrl
->index
);
495 len
= bufsize
- ctrl
->index
;
498 memcpy_toio(&ctrl
->addr
[ctrl
->index
], buf
, len
);
503 * read a byte from either the FCM hardware buffer if it has any data left
504 * otherwise issue a command to read a single byte.
506 static u8
fsl_elbc_read_byte(struct mtd_info
*mtd
)
508 struct nand_chip
*chip
= mtd
->priv
;
509 struct fsl_elbc_mtd
*priv
= chip
->priv
;
510 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
512 /* If there are still bytes in the FCM, then use the next byte. */
513 if (ctrl
->index
< ctrl
->read_bytes
)
514 return in_8(&ctrl
->addr
[ctrl
->index
++]);
516 dev_err(ctrl
->dev
, "read_byte beyond end of buffer\n");
521 * Read from the FCM Controller Data Buffer
523 static void fsl_elbc_read_buf(struct mtd_info
*mtd
, u8
*buf
, int len
)
525 struct nand_chip
*chip
= mtd
->priv
;
526 struct fsl_elbc_mtd
*priv
= chip
->priv
;
527 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
533 avail
= min((unsigned int)len
, ctrl
->read_bytes
- ctrl
->index
);
534 memcpy_fromio(buf
, &ctrl
->addr
[ctrl
->index
], avail
);
535 ctrl
->index
+= avail
;
539 "read_buf beyond end of buffer "
540 "(%d requested, %d available)\n",
545 * Verify buffer against the FCM Controller Data Buffer
547 static int fsl_elbc_verify_buf(struct mtd_info
*mtd
, const u_char
*buf
, int len
)
549 struct nand_chip
*chip
= mtd
->priv
;
550 struct fsl_elbc_mtd
*priv
= chip
->priv
;
551 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
555 dev_err(ctrl
->dev
, "write_buf of %d bytes", len
);
559 if ((unsigned int)len
> ctrl
->read_bytes
- ctrl
->index
) {
561 "verify_buf beyond end of buffer "
562 "(%d requested, %u available)\n",
563 len
, ctrl
->read_bytes
- ctrl
->index
);
565 ctrl
->index
= ctrl
->read_bytes
;
569 for (i
= 0; i
< len
; i
++)
570 if (in_8(&ctrl
->addr
[ctrl
->index
+ i
]) != buf
[i
])
574 return i
== len
&& ctrl
->status
== LTESR_CC
? 0 : -EIO
;
577 /* This function is called after Program and Erase Operations to
578 * check for success or failure.
580 static int fsl_elbc_wait(struct mtd_info
*mtd
, struct nand_chip
*chip
)
582 struct fsl_elbc_mtd
*priv
= chip
->priv
;
583 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
584 struct fsl_lbc_regs __iomem
*lbc
= ctrl
->regs
;
586 if (ctrl
->status
!= LTESR_CC
)
587 return NAND_STATUS_FAIL
;
589 /* Use READ_STATUS command, but wait for the device to be ready */
592 (FIR_OP_CW0
<< FIR_OP0_SHIFT
) |
593 (FIR_OP_RBW
<< FIR_OP1_SHIFT
));
594 out_be32(&lbc
->fcr
, NAND_CMD_STATUS
<< FCR_CMD0_SHIFT
);
595 out_be32(&lbc
->fbcr
, 1);
596 set_addr(mtd
, 0, 0, 0);
597 ctrl
->read_bytes
= 1;
599 fsl_elbc_run_command(mtd
);
601 if (ctrl
->status
!= LTESR_CC
)
602 return NAND_STATUS_FAIL
;
604 /* The chip always seems to report that it is
605 * write-protected, even when it is not.
607 setbits8(ctrl
->addr
, NAND_STATUS_WP
);
608 return fsl_elbc_read_byte(mtd
);
611 static int fsl_elbc_chip_init_tail(struct mtd_info
*mtd
)
613 struct nand_chip
*chip
= mtd
->priv
;
614 struct fsl_elbc_mtd
*priv
= chip
->priv
;
615 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
616 struct fsl_lbc_regs __iomem
*lbc
= ctrl
->regs
;
619 /* calculate FMR Address Length field */
621 if (chip
->pagemask
& 0xffff0000)
623 if (chip
->pagemask
& 0xff000000)
626 /* add to ECCM mode set in fsl_elbc_init */
627 priv
->fmr
|= (12 << FMR_CWTO_SHIFT
) | /* Timeout > 12 ms */
628 (al
<< FMR_AL_SHIFT
);
630 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->numchips = %d\n",
632 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->chipsize = %ld\n",
634 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->pagemask = %8x\n",
636 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->chip_delay = %d\n",
638 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->badblockpos = %d\n",
640 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->chip_shift = %d\n",
642 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->page_shift = %d\n",
644 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->phys_erase_shift = %d\n",
645 chip
->phys_erase_shift
);
646 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->ecclayout = %p\n",
648 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->ecc.mode = %d\n",
650 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->ecc.steps = %d\n",
652 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->ecc.bytes = %d\n",
654 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->ecc.total = %d\n",
656 dev_dbg(ctrl
->dev
, "fsl_elbc_init: nand->ecc.layout = %p\n",
658 dev_dbg(ctrl
->dev
, "fsl_elbc_init: mtd->flags = %08x\n", mtd
->flags
);
659 dev_dbg(ctrl
->dev
, "fsl_elbc_init: mtd->size = %d\n", mtd
->size
);
660 dev_dbg(ctrl
->dev
, "fsl_elbc_init: mtd->erasesize = %d\n",
662 dev_dbg(ctrl
->dev
, "fsl_elbc_init: mtd->writesize = %d\n",
664 dev_dbg(ctrl
->dev
, "fsl_elbc_init: mtd->oobsize = %d\n",
667 /* adjust Option Register and ECC to match Flash page size */
668 if (mtd
->writesize
== 512) {
670 clrbits32(&lbc
->bank
[priv
->bank
].or, ~OR_FCM_PGS
);
671 } else if (mtd
->writesize
== 2048) {
673 setbits32(&lbc
->bank
[priv
->bank
].or, OR_FCM_PGS
);
674 /* adjust ecc setup if needed */
675 if ((in_be32(&lbc
->bank
[priv
->bank
].br
) & BR_DECC
) ==
677 chip
->ecc
.size
= 512;
678 chip
->ecc
.layout
= (priv
->fmr
& FMR_ECCM
) ?
679 &fsl_elbc_oob_lp_eccm1
:
680 &fsl_elbc_oob_lp_eccm0
;
681 mtd
->ecclayout
= chip
->ecc
.layout
;
682 mtd
->oobavail
= chip
->ecc
.layout
->oobavail
;
686 "fsl_elbc_init: page size %d is not supported\n",
691 /* The default u-boot configuration on MPC8313ERDB causes errors;
692 * more delay is needed. This should be safe for other boards
695 setbits32(&lbc
->bank
[priv
->bank
].or, 0x70);
699 static int fsl_elbc_read_page(struct mtd_info
*mtd
,
700 struct nand_chip
*chip
,
703 fsl_elbc_read_buf(mtd
, buf
, mtd
->writesize
);
704 fsl_elbc_read_buf(mtd
, chip
->oob_poi
, mtd
->oobsize
);
706 if (fsl_elbc_wait(mtd
, chip
) & NAND_STATUS_FAIL
)
707 mtd
->ecc_stats
.failed
++;
712 /* ECC will be calculated automatically, and errors will be detected in
715 static void fsl_elbc_write_page(struct mtd_info
*mtd
,
716 struct nand_chip
*chip
,
719 struct fsl_elbc_mtd
*priv
= chip
->priv
;
720 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
722 fsl_elbc_write_buf(mtd
, buf
, mtd
->writesize
);
723 fsl_elbc_write_buf(mtd
, chip
->oob_poi
, mtd
->oobsize
);
725 ctrl
->oob_poi
= chip
->oob_poi
;
728 static int fsl_elbc_chip_init(struct fsl_elbc_mtd
*priv
)
730 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
731 struct fsl_lbc_regs __iomem
*lbc
= ctrl
->regs
;
732 struct nand_chip
*chip
= &priv
->chip
;
734 dev_dbg(priv
->dev
, "eLBC Set Information for bank %d\n", priv
->bank
);
736 /* Fill in fsl_elbc_mtd structure */
737 priv
->mtd
.priv
= chip
;
738 priv
->mtd
.owner
= THIS_MODULE
;
739 priv
->fmr
= 0; /* rest filled in later */
741 /* fill in nand_chip structure */
742 /* set up function call table */
743 chip
->read_byte
= fsl_elbc_read_byte
;
744 chip
->write_buf
= fsl_elbc_write_buf
;
745 chip
->read_buf
= fsl_elbc_read_buf
;
746 chip
->verify_buf
= fsl_elbc_verify_buf
;
747 chip
->select_chip
= fsl_elbc_select_chip
;
748 chip
->cmdfunc
= fsl_elbc_cmdfunc
;
749 chip
->waitfunc
= fsl_elbc_wait
;
751 /* set up nand options */
752 chip
->options
= NAND_NO_READRDY
| NAND_NO_AUTOINCR
;
754 chip
->controller
= &ctrl
->controller
;
757 chip
->ecc
.read_page
= fsl_elbc_read_page
;
758 chip
->ecc
.write_page
= fsl_elbc_write_page
;
760 /* If CS Base Register selects full hardware ECC then use it */
761 if ((in_be32(&lbc
->bank
[priv
->bank
].br
) & BR_DECC
) ==
763 chip
->ecc
.mode
= NAND_ECC_HW
;
764 /* put in small page settings and adjust later if needed */
765 chip
->ecc
.layout
= (priv
->fmr
& FMR_ECCM
) ?
766 &fsl_elbc_oob_sp_eccm1
: &fsl_elbc_oob_sp_eccm0
;
767 chip
->ecc
.size
= 512;
770 /* otherwise fall back to default software ECC */
771 chip
->ecc
.mode
= NAND_ECC_SOFT
;
777 static int fsl_elbc_chip_remove(struct fsl_elbc_mtd
*priv
)
779 struct fsl_elbc_ctrl
*ctrl
= priv
->ctrl
;
781 nand_release(&priv
->mtd
);
783 kfree(priv
->mtd
.name
);
786 iounmap(priv
->vbase
);
788 ctrl
->chips
[priv
->bank
] = NULL
;
794 static int fsl_elbc_chip_probe(struct fsl_elbc_ctrl
*ctrl
,
795 struct device_node
*node
)
797 struct fsl_lbc_regs __iomem
*lbc
= ctrl
->regs
;
798 struct fsl_elbc_mtd
*priv
;
800 #ifdef CONFIG_MTD_PARTITIONS
801 static const char *part_probe_types
[]
802 = { "cmdlinepart", "RedBoot", NULL
};
803 struct mtd_partition
*parts
;
808 /* get, allocate and map the memory resource */
809 ret
= of_address_to_resource(node
, 0, &res
);
811 dev_err(ctrl
->dev
, "failed to get resource\n");
815 /* find which chip select it is connected to */
816 for (bank
= 0; bank
< MAX_BANKS
; bank
++)
817 if ((in_be32(&lbc
->bank
[bank
].br
) & BR_V
) &&
818 (in_be32(&lbc
->bank
[bank
].br
) & BR_MSEL
) == BR_MS_FCM
&&
819 (in_be32(&lbc
->bank
[bank
].br
) &
820 in_be32(&lbc
->bank
[bank
].or) & BR_BA
)
824 if (bank
>= MAX_BANKS
) {
825 dev_err(ctrl
->dev
, "address did not match any chip selects\n");
829 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
833 ctrl
->chips
[bank
] = priv
;
836 priv
->dev
= ctrl
->dev
;
838 priv
->vbase
= ioremap(res
.start
, res
.end
- res
.start
+ 1);
840 dev_err(ctrl
->dev
, "failed to map chip region\n");
845 priv
->mtd
.name
= kasprintf(GFP_KERNEL
, "%x.flash", res
.start
);
846 if (!priv
->mtd
.name
) {
851 ret
= fsl_elbc_chip_init(priv
);
855 ret
= nand_scan_ident(&priv
->mtd
, 1);
859 ret
= fsl_elbc_chip_init_tail(&priv
->mtd
);
863 ret
= nand_scan_tail(&priv
->mtd
);
867 #ifdef CONFIG_MTD_PARTITIONS
868 /* First look for RedBoot table or partitions on the command
869 * line, these take precedence over device tree information */
870 ret
= parse_mtd_partitions(&priv
->mtd
, part_probe_types
, &parts
, 0);
874 #ifdef CONFIG_MTD_OF_PARTS
876 ret
= of_mtd_parse_partitions(priv
->dev
, &priv
->mtd
,
884 add_mtd_partitions(&priv
->mtd
, parts
, ret
);
887 add_mtd_device(&priv
->mtd
);
889 printk(KERN_INFO
"eLBC NAND device at 0x%zx, bank %d\n",
890 res
.start
, priv
->bank
);
894 fsl_elbc_chip_remove(priv
);
898 static int __devinit
fsl_elbc_ctrl_init(struct fsl_elbc_ctrl
*ctrl
)
900 struct fsl_lbc_regs __iomem
*lbc
= ctrl
->regs
;
902 /* clear event registers */
903 setbits32(&lbc
->ltesr
, LTESR_NAND_MASK
);
904 out_be32(&lbc
->lteatr
, 0);
906 /* Enable interrupts for any detected events */
907 out_be32(&lbc
->lteir
, LTESR_NAND_MASK
);
909 ctrl
->read_bytes
= 0;
916 static int __devexit
fsl_elbc_ctrl_remove(struct of_device
*ofdev
)
918 struct fsl_elbc_ctrl
*ctrl
= dev_get_drvdata(&ofdev
->dev
);
921 for (i
= 0; i
< MAX_BANKS
; i
++)
923 fsl_elbc_chip_remove(ctrl
->chips
[i
]);
926 free_irq(ctrl
->irq
, ctrl
);
931 dev_set_drvdata(&ofdev
->dev
, NULL
);
936 /* NOTE: This interrupt is also used to report other localbus events,
937 * such as transaction errors on other chipselects. If we want to
938 * capture those, we'll need to move the IRQ code into a shared
942 static irqreturn_t
fsl_elbc_ctrl_irq(int irqno
, void *data
)
944 struct fsl_elbc_ctrl
*ctrl
= data
;
945 struct fsl_lbc_regs __iomem
*lbc
= ctrl
->regs
;
946 __be32 status
= in_be32(&lbc
->ltesr
) & LTESR_NAND_MASK
;
949 out_be32(&lbc
->ltesr
, status
);
950 out_be32(&lbc
->lteatr
, 0);
952 ctrl
->irq_status
= status
;
954 wake_up(&ctrl
->irq_wait
);
962 /* fsl_elbc_ctrl_probe
964 * called by device layer when it finds a device matching
965 * one our driver can handled. This code allocates all of
966 * the resources needed for the controller only. The
967 * resources for the NAND banks themselves are allocated
968 * in the chip probe function.
971 static int __devinit
fsl_elbc_ctrl_probe(struct of_device
*ofdev
,
972 const struct of_device_id
*match
)
974 struct device_node
*child
;
975 struct fsl_elbc_ctrl
*ctrl
;
978 ctrl
= kzalloc(sizeof(*ctrl
), GFP_KERNEL
);
982 dev_set_drvdata(&ofdev
->dev
, ctrl
);
984 spin_lock_init(&ctrl
->controller
.lock
);
985 init_waitqueue_head(&ctrl
->controller
.wq
);
986 init_waitqueue_head(&ctrl
->irq_wait
);
988 ctrl
->regs
= of_iomap(ofdev
->node
, 0);
990 dev_err(&ofdev
->dev
, "failed to get memory region\n");
995 ctrl
->irq
= of_irq_to_resource(ofdev
->node
, 0, NULL
);
996 if (ctrl
->irq
== NO_IRQ
) {
997 dev_err(&ofdev
->dev
, "failed to get irq resource\n");
1002 ctrl
->dev
= &ofdev
->dev
;
1004 ret
= fsl_elbc_ctrl_init(ctrl
);
1008 ret
= request_irq(ctrl
->irq
, fsl_elbc_ctrl_irq
, 0, "fsl-elbc", ctrl
);
1010 dev_err(&ofdev
->dev
, "failed to install irq (%d)\n",
1016 for_each_child_of_node(ofdev
->node
, child
)
1017 if (of_device_is_compatible(child
, "fsl,elbc-fcm-nand"))
1018 fsl_elbc_chip_probe(ctrl
, child
);
1023 fsl_elbc_ctrl_remove(ofdev
);
1027 static const struct of_device_id fsl_elbc_match
[] = {
1029 .compatible
= "fsl,elbc",
1034 static struct of_platform_driver fsl_elbc_ctrl_driver
= {
1038 .match_table
= fsl_elbc_match
,
1039 .probe
= fsl_elbc_ctrl_probe
,
1040 .remove
= __devexit_p(fsl_elbc_ctrl_remove
),
1043 static int __init
fsl_elbc_init(void)
1045 return of_register_platform_driver(&fsl_elbc_ctrl_driver
);
1048 static void __exit
fsl_elbc_exit(void)
1050 of_unregister_platform_driver(&fsl_elbc_ctrl_driver
);
1053 module_init(fsl_elbc_init
);
1054 module_exit(fsl_elbc_exit
);
1056 MODULE_LICENSE("GPL");
1057 MODULE_AUTHOR("Freescale");
1058 MODULE_DESCRIPTION("Freescale Enhanced Local Bus Controller MTD NAND driver");