2 * Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
3 * Copyright 2008 Sascha Hauer, kernel@pengutronix.de
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
20 #include <linux/delay.h>
21 #include <linux/slab.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/mtd/mtd.h>
25 #include <linux/mtd/nand.h>
26 #include <linux/mtd/partitions.h>
27 #include <linux/interrupt.h>
28 #include <linux/device.h>
29 #include <linux/platform_device.h>
30 #include <linux/clk.h>
31 #include <linux/err.h>
34 #include <asm/mach/flash.h>
35 #include <mach/mxc_nand.h>
37 #define DRIVER_NAME "mxc_nand"
39 /* Addresses for NFC registers */
40 #define NFC_BUF_SIZE 0xE00
41 #define NFC_BUF_ADDR 0xE04
42 #define NFC_FLASH_ADDR 0xE06
43 #define NFC_FLASH_CMD 0xE08
44 #define NFC_CONFIG 0xE0A
45 #define NFC_ECC_STATUS_RESULT 0xE0C
46 #define NFC_RSLTMAIN_AREA 0xE0E
47 #define NFC_RSLTSPARE_AREA 0xE10
48 #define NFC_WRPROT 0xE12
49 #define NFC_UNLOCKSTART_BLKADDR 0xE14
50 #define NFC_UNLOCKEND_BLKADDR 0xE16
51 #define NFC_NF_WRPRST 0xE18
52 #define NFC_CONFIG1 0xE1A
53 #define NFC_CONFIG2 0xE1C
55 /* Addresses for NFC RAM BUFFER Main area 0 */
56 #define MAIN_AREA0 0x000
57 #define MAIN_AREA1 0x200
58 #define MAIN_AREA2 0x400
59 #define MAIN_AREA3 0x600
61 /* Addresses for NFC SPARE BUFFER Spare area 0 */
62 #define SPARE_AREA0 0x800
63 #define SPARE_AREA1 0x810
64 #define SPARE_AREA2 0x820
65 #define SPARE_AREA3 0x830
67 /* Set INT to 0, FCMD to 1, rest to 0 in NFC_CONFIG2 Register
68 * for Command operation */
71 /* Set INT to 0, FADD to 1, rest to 0 in NFC_CONFIG2 Register
72 * for Address operation */
75 /* Set INT to 0, FDI to 1, rest to 0 in NFC_CONFIG2 Register
76 * for Input operation */
79 /* Set INT to 0, FDO to 001, rest to 0 in NFC_CONFIG2 Register
80 * for Data Output operation */
81 #define NFC_OUTPUT 0x8
83 /* Set INT to 0, FD0 to 010, rest to 0 in NFC_CONFIG2 Register
84 * for Read ID operation */
87 /* Set INT to 0, FDO to 100, rest to 0 in NFC_CONFIG2 Register
88 * for Read Status operation */
89 #define NFC_STATUS 0x20
91 /* Set INT to 1, rest to 0 in NFC_CONFIG2 Register for Read
93 #define NFC_INT 0x8000
95 #define NFC_SP_EN (1 << 2)
96 #define NFC_ECC_EN (1 << 3)
97 #define NFC_INT_MSK (1 << 4)
98 #define NFC_BIG (1 << 5)
99 #define NFC_RST (1 << 6)
100 #define NFC_CE (1 << 7)
101 #define NFC_ONE_CYCLE (1 << 8)
103 struct mxc_nand_host
{
105 struct nand_chip nand
;
106 struct mtd_partition
*parts
;
116 wait_queue_head_t irq_waitq
;
119 unsigned int buf_start
;
123 /* Define delays in microsec for NAND device operations */
124 #define TROP_US_DELAY 2000
125 /* Macros to get byte and bit positions of ECC */
126 #define COLPOS(x) ((x) >> 3)
127 #define BITPOS(x) ((x) & 0xf)
129 /* Define single bit Error positions in Main & Spare area */
130 #define MAIN_SINGLEBIT_ERROR 0x4
131 #define SPARE_SINGLEBIT_ERROR 0x1
133 /* OOB placement block for use with hardware ecc generation */
134 static struct nand_ecclayout nand_hw_eccoob_smallpage
= {
136 .eccpos
= {6, 7, 8, 9, 10},
137 .oobfree
= {{0, 5}, {12, 4}, }
140 static struct nand_ecclayout nand_hw_eccoob_largepage
= {
142 .eccpos
= {6, 7, 8, 9, 10, 22, 23, 24, 25, 26,
143 38, 39, 40, 41, 42, 54, 55, 56, 57, 58},
144 .oobfree
= {{2, 4}, {11, 10}, {27, 10}, {43, 10}, {59, 5}, }
147 #ifdef CONFIG_MTD_PARTITIONS
148 static const char *part_probes
[] = { "RedBoot", "cmdlinepart", NULL
};
151 static irqreturn_t
mxc_nfc_irq(int irq
, void *dev_id
)
153 struct mxc_nand_host
*host
= dev_id
;
157 tmp
= readw(host
->regs
+ NFC_CONFIG1
);
158 tmp
|= NFC_INT_MSK
; /* Disable interrupt */
159 writew(tmp
, host
->regs
+ NFC_CONFIG1
);
161 wake_up(&host
->irq_waitq
);
166 /* This function polls the NANDFC to wait for the basic operation to
167 * complete by checking the INT bit of config2 register.
169 static void wait_op_done(struct mxc_nand_host
*host
, int max_retries
,
175 if ((readw(host
->regs
+ NFC_CONFIG2
) & NFC_INT
) == 0) {
177 tmp
= readw(host
->regs
+ NFC_CONFIG1
);
178 tmp
&= ~NFC_INT_MSK
; /* Enable interrupt */
179 writew(tmp
, host
->regs
+ NFC_CONFIG1
);
181 wait_event(host
->irq_waitq
,
182 readw(host
->regs
+ NFC_CONFIG2
) & NFC_INT
);
184 tmp
= readw(host
->regs
+ NFC_CONFIG2
);
186 writew(tmp
, host
->regs
+ NFC_CONFIG2
);
189 while (max_retries
-- > 0) {
190 if (readw(host
->regs
+ NFC_CONFIG2
) & NFC_INT
) {
191 tmp
= readw(host
->regs
+ NFC_CONFIG2
);
193 writew(tmp
, host
->regs
+ NFC_CONFIG2
);
199 DEBUG(MTD_DEBUG_LEVEL0
, "%s: INT not set\n",
204 /* This function issues the specified command to the NAND device and
205 * waits for completion. */
206 static void send_cmd(struct mxc_nand_host
*host
, uint16_t cmd
, int useirq
)
208 DEBUG(MTD_DEBUG_LEVEL3
, "send_cmd(host, 0x%x, %d)\n", cmd
, useirq
);
210 writew(cmd
, host
->regs
+ NFC_FLASH_CMD
);
211 writew(NFC_CMD
, host
->regs
+ NFC_CONFIG2
);
213 /* Wait for operation to complete */
214 wait_op_done(host
, TROP_US_DELAY
, useirq
);
217 /* This function sends an address (or partial address) to the
218 * NAND device. The address is used to select the source/destination for
220 static void send_addr(struct mxc_nand_host
*host
, uint16_t addr
, int islast
)
222 DEBUG(MTD_DEBUG_LEVEL3
, "send_addr(host, 0x%x %d)\n", addr
, islast
);
224 writew(addr
, host
->regs
+ NFC_FLASH_ADDR
);
225 writew(NFC_ADDR
, host
->regs
+ NFC_CONFIG2
);
227 /* Wait for operation to complete */
228 wait_op_done(host
, TROP_US_DELAY
, islast
);
231 static void send_page(struct mxc_nand_host
*host
, unsigned int ops
)
235 if (host
->pagesize_2k
)
240 for (i
= 0; i
< bufs
; i
++) {
242 /* NANDFC buffer 0 is used for page read/write */
243 writew(i
, host
->regs
+ NFC_BUF_ADDR
);
245 writew(ops
, host
->regs
+ NFC_CONFIG2
);
247 /* Wait for operation to complete */
248 wait_op_done(host
, TROP_US_DELAY
, true);
252 /* Request the NANDFC to perform a read of the NAND device ID. */
253 static void send_read_id(struct mxc_nand_host
*host
)
255 struct nand_chip
*this = &host
->nand
;
258 /* NANDFC buffer 0 is used for device ID output */
259 writew(0x0, host
->regs
+ NFC_BUF_ADDR
);
261 /* Read ID into main buffer */
262 tmp
= readw(host
->regs
+ NFC_CONFIG1
);
264 writew(tmp
, host
->regs
+ NFC_CONFIG1
);
266 writew(NFC_ID
, host
->regs
+ NFC_CONFIG2
);
268 /* Wait for operation to complete */
269 wait_op_done(host
, TROP_US_DELAY
, true);
271 if (this->options
& NAND_BUSWIDTH_16
) {
272 void __iomem
*main_buf
= host
->regs
+ MAIN_AREA0
;
273 /* compress the ID info */
274 writeb(readb(main_buf
+ 2), main_buf
+ 1);
275 writeb(readb(main_buf
+ 4), main_buf
+ 2);
276 writeb(readb(main_buf
+ 6), main_buf
+ 3);
277 writeb(readb(main_buf
+ 8), main_buf
+ 4);
278 writeb(readb(main_buf
+ 10), main_buf
+ 5);
280 memcpy(host
->data_buf
, host
->regs
+ MAIN_AREA0
, 16);
283 /* This function requests the NANDFC to perform a read of the
284 * NAND device status and returns the current status. */
285 static uint16_t get_dev_status(struct mxc_nand_host
*host
)
287 void __iomem
*main_buf
= host
->regs
+ MAIN_AREA1
;
290 /* Issue status request to NAND device */
292 /* store the main area1 first word, later do recovery */
293 store
= readl(main_buf
);
294 /* NANDFC buffer 1 is used for device status to prevent
295 * corruption of read/write buffer on status requests. */
296 writew(1, host
->regs
+ NFC_BUF_ADDR
);
298 /* Read status into main buffer */
299 tmp
= readw(host
->regs
+ NFC_CONFIG1
);
301 writew(tmp
, host
->regs
+ NFC_CONFIG1
);
303 writew(NFC_STATUS
, host
->regs
+ NFC_CONFIG2
);
305 /* Wait for operation to complete */
306 wait_op_done(host
, TROP_US_DELAY
, true);
308 /* Status is placed in first word of main buffer */
309 /* get status, then recovery area 1 data */
310 ret
= readw(main_buf
);
311 writel(store
, main_buf
);
316 /* This functions is used by upper layer to checks if device is ready */
317 static int mxc_nand_dev_ready(struct mtd_info
*mtd
)
320 * NFC handles R/B internally. Therefore, this function
321 * always returns status as ready.
326 static void mxc_nand_enable_hwecc(struct mtd_info
*mtd
, int mode
)
329 * If HW ECC is enabled, we turn it on during init. There is
330 * no need to enable again here.
334 static int mxc_nand_correct_data(struct mtd_info
*mtd
, u_char
*dat
,
335 u_char
*read_ecc
, u_char
*calc_ecc
)
337 struct nand_chip
*nand_chip
= mtd
->priv
;
338 struct mxc_nand_host
*host
= nand_chip
->priv
;
341 * 1-Bit errors are automatically corrected in HW. No need for
342 * additional correction. 2-Bit errors cannot be corrected by
343 * HW ECC, so we need to return failure
345 uint16_t ecc_status
= readw(host
->regs
+ NFC_ECC_STATUS_RESULT
);
347 if (((ecc_status
& 0x3) == 2) || ((ecc_status
>> 2) == 2)) {
348 DEBUG(MTD_DEBUG_LEVEL0
,
349 "MXC_NAND: HWECC uncorrectable 2-bit ECC error\n");
356 static int mxc_nand_calculate_ecc(struct mtd_info
*mtd
, const u_char
*dat
,
362 static u_char
mxc_nand_read_byte(struct mtd_info
*mtd
)
364 struct nand_chip
*nand_chip
= mtd
->priv
;
365 struct mxc_nand_host
*host
= nand_chip
->priv
;
368 /* Check for status request */
369 if (host
->status_request
)
370 return get_dev_status(host
) & 0xFF;
372 ret
= *(uint8_t *)(host
->data_buf
+ host
->buf_start
);
378 static uint16_t mxc_nand_read_word(struct mtd_info
*mtd
)
380 struct nand_chip
*nand_chip
= mtd
->priv
;
381 struct mxc_nand_host
*host
= nand_chip
->priv
;
384 ret
= *(uint16_t *)(host
->data_buf
+ host
->buf_start
);
385 host
->buf_start
+= 2;
390 /* Write data of length len to buffer buf. The data to be
391 * written on NAND Flash is first copied to RAMbuffer. After the Data Input
392 * Operation by the NFC, the data is written to NAND Flash */
393 static void mxc_nand_write_buf(struct mtd_info
*mtd
,
394 const u_char
*buf
, int len
)
396 struct nand_chip
*nand_chip
= mtd
->priv
;
397 struct mxc_nand_host
*host
= nand_chip
->priv
;
398 u16 col
= host
->buf_start
;
399 int n
= mtd
->oobsize
+ mtd
->writesize
- col
;
403 memcpy(host
->data_buf
+ col
, buf
, n
);
405 host
->buf_start
+= n
;
408 /* Read the data buffer from the NAND Flash. To read the data from NAND
409 * Flash first the data output cycle is initiated by the NFC, which copies
410 * the data to RAMbuffer. This data of length len is then copied to buffer buf.
412 static void mxc_nand_read_buf(struct mtd_info
*mtd
, u_char
*buf
, int len
)
414 struct nand_chip
*nand_chip
= mtd
->priv
;
415 struct mxc_nand_host
*host
= nand_chip
->priv
;
416 u16 col
= host
->buf_start
;
417 int n
= mtd
->oobsize
+ mtd
->writesize
- col
;
421 memcpy(buf
, host
->data_buf
+ col
, len
);
423 host
->buf_start
+= len
;
426 /* Used by the upper layer to verify the data in NAND Flash
427 * with the data in the buf. */
428 static int mxc_nand_verify_buf(struct mtd_info
*mtd
,
429 const u_char
*buf
, int len
)
434 /* This function is used by upper layer for select and
435 * deselect of the NAND chip */
436 static void mxc_nand_select_chip(struct mtd_info
*mtd
, int chip
)
438 struct nand_chip
*nand_chip
= mtd
->priv
;
439 struct mxc_nand_host
*host
= nand_chip
->priv
;
443 /* Disable the NFC clock */
445 clk_disable(host
->clk
);
450 /* Enable the NFC clock */
451 if (!host
->clk_act
) {
452 clk_enable(host
->clk
);
463 * Function to transfer data to/from spare area.
465 static void copy_spare(struct mtd_info
*mtd
, bool bfrom
)
467 struct nand_chip
*this = mtd
->priv
;
468 struct mxc_nand_host
*host
= this->priv
;
470 u16 n
= mtd
->writesize
>> 9;
471 u8
*d
= host
->data_buf
+ mtd
->writesize
;
472 u8
*s
= host
->regs
+ SPARE_AREA0
;
473 u16 t
= host
->spare_len
;
475 j
= (mtd
->oobsize
/ n
>> 1) << 1;
478 for (i
= 0; i
< n
- 1; i
++)
479 memcpy(d
+ i
* j
, s
+ i
* t
, j
);
481 /* the last section */
482 memcpy(d
+ i
* j
, s
+ i
* t
, mtd
->oobsize
- i
* j
);
484 for (i
= 0; i
< n
- 1; i
++)
485 memcpy(&s
[i
* t
], &d
[i
* j
], j
);
487 /* the last section */
488 memcpy(&s
[i
* t
], &d
[i
* j
], mtd
->oobsize
- i
* j
);
492 static void mxc_do_addr_cycle(struct mtd_info
*mtd
, int column
, int page_addr
)
494 struct nand_chip
*nand_chip
= mtd
->priv
;
495 struct mxc_nand_host
*host
= nand_chip
->priv
;
497 /* Write out column address, if necessary */
500 * MXC NANDFC can only perform full page+spare or
501 * spare-only read/write. When the upper layers
502 * layers perform a read/write buf operation,
503 * we will used the saved column adress to index into
506 send_addr(host
, 0, page_addr
== -1);
507 if (host
->pagesize_2k
)
508 /* another col addr cycle for 2k page */
509 send_addr(host
, 0, false);
512 /* Write out page address, if necessary */
513 if (page_addr
!= -1) {
514 /* paddr_0 - p_addr_7 */
515 send_addr(host
, (page_addr
& 0xff), false);
517 if (host
->pagesize_2k
) {
518 if (mtd
->size
>= 0x10000000) {
519 /* paddr_8 - paddr_15 */
520 send_addr(host
, (page_addr
>> 8) & 0xff, false);
521 send_addr(host
, (page_addr
>> 16) & 0xff, true);
523 /* paddr_8 - paddr_15 */
524 send_addr(host
, (page_addr
>> 8) & 0xff, true);
526 /* One more address cycle for higher density devices */
527 if (mtd
->size
>= 0x4000000) {
528 /* paddr_8 - paddr_15 */
529 send_addr(host
, (page_addr
>> 8) & 0xff, false);
530 send_addr(host
, (page_addr
>> 16) & 0xff, true);
532 /* paddr_8 - paddr_15 */
533 send_addr(host
, (page_addr
>> 8) & 0xff, true);
538 /* Used by the upper layer to write command to NAND Flash for
539 * different operations to be carried out on NAND Flash */
540 static void mxc_nand_command(struct mtd_info
*mtd
, unsigned command
,
541 int column
, int page_addr
)
543 struct nand_chip
*nand_chip
= mtd
->priv
;
544 struct mxc_nand_host
*host
= nand_chip
->priv
;
546 DEBUG(MTD_DEBUG_LEVEL3
,
547 "mxc_nand_command (cmd = 0x%x, col = 0x%x, page = 0x%x)\n",
548 command
, column
, page_addr
);
550 /* Reset command state information */
551 host
->status_request
= false;
553 /* Command pre-processing step */
556 case NAND_CMD_STATUS
:
558 host
->status_request
= true;
560 send_cmd(host
, command
, true);
561 mxc_do_addr_cycle(mtd
, column
, page_addr
);
565 case NAND_CMD_READOOB
:
566 if (command
== NAND_CMD_READ0
)
567 host
->buf_start
= column
;
569 host
->buf_start
= column
+ mtd
->writesize
;
571 if (host
->pagesize_2k
)
572 command
= NAND_CMD_READ0
; /* only READ0 is valid */
574 send_cmd(host
, command
, false);
575 mxc_do_addr_cycle(mtd
, column
, page_addr
);
577 if (host
->pagesize_2k
)
578 send_cmd(host
, NAND_CMD_READSTART
, true);
580 send_page(host
, NFC_OUTPUT
);
582 memcpy(host
->data_buf
, host
->regs
+ MAIN_AREA0
, mtd
->writesize
);
583 copy_spare(mtd
, true);
587 if (column
>= mtd
->writesize
) {
589 * FIXME: before send SEQIN command for write OOB,
590 * We must read one page out.
591 * For K9F1GXX has no READ1 command to set current HW
592 * pointer to spare area, we must write the whole page
593 * including OOB together.
595 if (host
->pagesize_2k
)
596 /* call ourself to read a page */
597 mxc_nand_command(mtd
, NAND_CMD_READ0
, 0,
600 host
->buf_start
= column
;
602 /* Set program pointer to spare region */
603 if (!host
->pagesize_2k
)
604 send_cmd(host
, NAND_CMD_READOOB
, false);
606 host
->buf_start
= column
;
608 /* Set program pointer to page start */
609 if (!host
->pagesize_2k
)
610 send_cmd(host
, NAND_CMD_READ0
, false);
613 send_cmd(host
, command
, false);
614 mxc_do_addr_cycle(mtd
, column
, page_addr
);
617 case NAND_CMD_PAGEPROG
:
618 memcpy(host
->regs
+ MAIN_AREA0
, host
->data_buf
, mtd
->writesize
);
619 copy_spare(mtd
, false);
620 send_page(host
, NFC_INPUT
);
621 send_cmd(host
, command
, true);
622 mxc_do_addr_cycle(mtd
, column
, page_addr
);
625 case NAND_CMD_READID
:
626 send_cmd(host
, command
, true);
627 mxc_do_addr_cycle(mtd
, column
, page_addr
);
631 case NAND_CMD_ERASE1
:
632 case NAND_CMD_ERASE2
:
633 send_cmd(host
, command
, false);
634 mxc_do_addr_cycle(mtd
, column
, page_addr
);
640 static int __init
mxcnd_probe(struct platform_device
*pdev
)
642 struct nand_chip
*this;
643 struct mtd_info
*mtd
;
644 struct mxc_nand_platform_data
*pdata
= pdev
->dev
.platform_data
;
645 struct mxc_nand_host
*host
;
646 struct resource
*res
;
648 int err
= 0, nr_parts
= 0;
650 /* Allocate memory for MTD device structure and private data */
651 host
= kzalloc(sizeof(struct mxc_nand_host
) + NAND_MAX_PAGESIZE
+
652 NAND_MAX_OOBSIZE
, GFP_KERNEL
);
656 host
->data_buf
= (uint8_t *)(host
+ 1);
657 host
->spare_len
= 16;
659 host
->dev
= &pdev
->dev
;
660 /* structures must be linked */
664 mtd
->owner
= THIS_MODULE
;
665 mtd
->dev
.parent
= &pdev
->dev
;
666 mtd
->name
= "mxc_nand";
668 /* 50 us command delay time */
669 this->chip_delay
= 5;
672 this->dev_ready
= mxc_nand_dev_ready
;
673 this->cmdfunc
= mxc_nand_command
;
674 this->select_chip
= mxc_nand_select_chip
;
675 this->read_byte
= mxc_nand_read_byte
;
676 this->read_word
= mxc_nand_read_word
;
677 this->write_buf
= mxc_nand_write_buf
;
678 this->read_buf
= mxc_nand_read_buf
;
679 this->verify_buf
= mxc_nand_verify_buf
;
681 host
->clk
= clk_get(&pdev
->dev
, "nfc");
682 if (IS_ERR(host
->clk
)) {
683 err
= PTR_ERR(host
->clk
);
687 clk_enable(host
->clk
);
690 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
696 host
->regs
= ioremap(res
->start
, resource_size(res
));
702 tmp
= readw(host
->regs
+ NFC_CONFIG1
);
704 writew(tmp
, host
->regs
+ NFC_CONFIG1
);
706 init_waitqueue_head(&host
->irq_waitq
);
708 host
->irq
= platform_get_irq(pdev
, 0);
710 err
= request_irq(host
->irq
, mxc_nfc_irq
, 0, "mxc_nd", host
);
715 this->cmdfunc(mtd
, NAND_CMD_RESET
, -1, -1);
717 /* preset operation */
718 /* Unlock the internal RAM Buffer */
719 writew(0x2, host
->regs
+ NFC_CONFIG
);
721 /* Blocks to be unlocked */
722 writew(0x0, host
->regs
+ NFC_UNLOCKSTART_BLKADDR
);
723 writew(0x4000, host
->regs
+ NFC_UNLOCKEND_BLKADDR
);
725 /* Unlock Block Command for given address range */
726 writew(0x4, host
->regs
+ NFC_WRPROT
);
728 this->ecc
.size
= 512;
730 this->ecc
.layout
= &nand_hw_eccoob_smallpage
;
733 this->ecc
.calculate
= mxc_nand_calculate_ecc
;
734 this->ecc
.hwctl
= mxc_nand_enable_hwecc
;
735 this->ecc
.correct
= mxc_nand_correct_data
;
736 this->ecc
.mode
= NAND_ECC_HW
;
737 tmp
= readw(host
->regs
+ NFC_CONFIG1
);
739 writew(tmp
, host
->regs
+ NFC_CONFIG1
);
741 this->ecc
.mode
= NAND_ECC_SOFT
;
742 tmp
= readw(host
->regs
+ NFC_CONFIG1
);
744 writew(tmp
, host
->regs
+ NFC_CONFIG1
);
747 /* NAND bus width determines access funtions used by upper layer */
748 if (pdata
->width
== 2)
749 this->options
|= NAND_BUSWIDTH_16
;
751 /* first scan to find the device and get the page size */
752 if (nand_scan_ident(mtd
, 1)) {
757 if (mtd
->writesize
== 2048) {
758 host
->pagesize_2k
= 1;
759 this->ecc
.layout
= &nand_hw_eccoob_largepage
;
762 /* second phase scan */
763 if (nand_scan_tail(mtd
)) {
768 /* Register the partitions */
769 #ifdef CONFIG_MTD_PARTITIONS
771 parse_mtd_partitions(mtd
, part_probes
, &host
->parts
, 0);
773 add_mtd_partitions(mtd
, host
->parts
, nr_parts
);
777 pr_info("Registering %s as whole device\n", mtd
->name
);
781 platform_set_drvdata(pdev
, host
);
786 free_irq(host
->irq
, host
);
797 static int __exit
mxcnd_remove(struct platform_device
*pdev
)
799 struct mxc_nand_host
*host
= platform_get_drvdata(pdev
);
803 platform_set_drvdata(pdev
, NULL
);
805 nand_release(&host
->mtd
);
806 free_irq(host
->irq
, host
);
814 static int mxcnd_suspend(struct platform_device
*pdev
, pm_message_t state
)
816 struct mtd_info
*mtd
= platform_get_drvdata(pdev
);
817 struct nand_chip
*nand_chip
= mtd
->priv
;
818 struct mxc_nand_host
*host
= nand_chip
->priv
;
821 DEBUG(MTD_DEBUG_LEVEL0
, "MXC_ND : NAND suspend\n");
823 ret
= mtd
->suspend(mtd
);
824 /* Disable the NFC clock */
825 clk_disable(host
->clk
);
831 static int mxcnd_resume(struct platform_device
*pdev
)
833 struct mtd_info
*mtd
= platform_get_drvdata(pdev
);
834 struct nand_chip
*nand_chip
= mtd
->priv
;
835 struct mxc_nand_host
*host
= nand_chip
->priv
;
838 DEBUG(MTD_DEBUG_LEVEL0
, "MXC_ND : NAND resume\n");
841 /* Enable the NFC clock */
842 clk_enable(host
->clk
);
850 # define mxcnd_suspend NULL
851 # define mxcnd_resume NULL
852 #endif /* CONFIG_PM */
854 static struct platform_driver mxcnd_driver
= {
858 .remove
= __exit_p(mxcnd_remove
),
859 .suspend
= mxcnd_suspend
,
860 .resume
= mxcnd_resume
,
863 static int __init
mxc_nd_init(void)
865 return platform_driver_probe(&mxcnd_driver
, mxcnd_probe
);
868 static void __exit
mxc_nd_cleanup(void)
870 /* Unregister the device structure */
871 platform_driver_unregister(&mxcnd_driver
);
874 module_init(mxc_nd_init
);
875 module_exit(mxc_nd_cleanup
);
877 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
878 MODULE_DESCRIPTION("MXC NAND MTD driver");
879 MODULE_LICENSE("GPL");