2008-02-14 07:48:23 +00:00
|
|
|
/*
|
|
|
|
* drivers/mtd/nand/pxa3xx_nand.c
|
|
|
|
*
|
|
|
|
* Copyright © 2005 Intel Corporation
|
|
|
|
* Copyright © 2006 Marvell International Ltd.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
2009-09-11 11:33:58 +00:00
|
|
|
#include <linux/kernel.h>
|
2008-02-14 07:48:23 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/clk.h>
|
|
|
|
#include <linux/mtd/mtd.h>
|
|
|
|
#include <linux/mtd/nand.h>
|
|
|
|
#include <linux/mtd/partitions.h>
|
2008-04-22 19:39:43 +00:00
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/irq.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2008-02-14 07:48:23 +00:00
|
|
|
|
2008-12-01 03:43:08 +00:00
|
|
|
#include <mach/dma.h>
|
2009-09-10 05:55:23 +00:00
|
|
|
#include <plat/pxa3xx_nand.h>
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
#define CHIP_DELAY_TIMEOUT (2 * HZ/10)
|
2011-02-28 02:32:11 +00:00
|
|
|
#define NAND_STOP_DELAY (2 * HZ/50)
|
2011-02-28 02:32:13 +00:00
|
|
|
#define PAGE_CHUNK_SIZE (2048)
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
/* registers and bit definitions */
|
|
|
|
#define NDCR (0x00) /* Control register */
|
|
|
|
#define NDTR0CS0 (0x04) /* Timing Parameter 0 for CS0 */
|
|
|
|
#define NDTR1CS0 (0x0C) /* Timing Parameter 1 for CS0 */
|
|
|
|
#define NDSR (0x14) /* Status Register */
|
|
|
|
#define NDPCR (0x18) /* Page Count Register */
|
|
|
|
#define NDBDR0 (0x1C) /* Bad Block Register 0 */
|
|
|
|
#define NDBDR1 (0x20) /* Bad Block Register 1 */
|
|
|
|
#define NDDB (0x40) /* Data Buffer */
|
|
|
|
#define NDCB0 (0x48) /* Command Buffer0 */
|
|
|
|
#define NDCB1 (0x4C) /* Command Buffer1 */
|
|
|
|
#define NDCB2 (0x50) /* Command Buffer2 */
|
|
|
|
|
|
|
|
#define NDCR_SPARE_EN (0x1 << 31)
|
|
|
|
#define NDCR_ECC_EN (0x1 << 30)
|
|
|
|
#define NDCR_DMA_EN (0x1 << 29)
|
|
|
|
#define NDCR_ND_RUN (0x1 << 28)
|
|
|
|
#define NDCR_DWIDTH_C (0x1 << 27)
|
|
|
|
#define NDCR_DWIDTH_M (0x1 << 26)
|
|
|
|
#define NDCR_PAGE_SZ (0x1 << 24)
|
|
|
|
#define NDCR_NCSX (0x1 << 23)
|
|
|
|
#define NDCR_ND_MODE (0x3 << 21)
|
|
|
|
#define NDCR_NAND_MODE (0x0)
|
|
|
|
#define NDCR_CLR_PG_CNT (0x1 << 20)
|
2011-02-28 02:32:11 +00:00
|
|
|
#define NDCR_STOP_ON_UNCOR (0x1 << 19)
|
2008-02-14 07:48:23 +00:00
|
|
|
#define NDCR_RD_ID_CNT_MASK (0x7 << 16)
|
|
|
|
#define NDCR_RD_ID_CNT(x) (((x) << 16) & NDCR_RD_ID_CNT_MASK)
|
|
|
|
|
|
|
|
#define NDCR_RA_START (0x1 << 15)
|
|
|
|
#define NDCR_PG_PER_BLK (0x1 << 14)
|
|
|
|
#define NDCR_ND_ARB_EN (0x1 << 12)
|
2011-02-28 02:32:11 +00:00
|
|
|
#define NDCR_INT_MASK (0xFFF)
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
#define NDSR_MASK (0xfff)
|
2011-02-28 02:32:11 +00:00
|
|
|
#define NDSR_RDY (0x1 << 12)
|
|
|
|
#define NDSR_FLASH_RDY (0x1 << 11)
|
2008-02-14 07:48:23 +00:00
|
|
|
#define NDSR_CS0_PAGED (0x1 << 10)
|
|
|
|
#define NDSR_CS1_PAGED (0x1 << 9)
|
|
|
|
#define NDSR_CS0_CMDD (0x1 << 8)
|
|
|
|
#define NDSR_CS1_CMDD (0x1 << 7)
|
|
|
|
#define NDSR_CS0_BBD (0x1 << 6)
|
|
|
|
#define NDSR_CS1_BBD (0x1 << 5)
|
|
|
|
#define NDSR_DBERR (0x1 << 4)
|
|
|
|
#define NDSR_SBERR (0x1 << 3)
|
|
|
|
#define NDSR_WRDREQ (0x1 << 2)
|
|
|
|
#define NDSR_RDDREQ (0x1 << 1)
|
|
|
|
#define NDSR_WRCMDREQ (0x1)
|
|
|
|
|
2011-02-28 02:32:13 +00:00
|
|
|
#define NDCB0_ST_ROW_EN (0x1 << 26)
|
2008-02-14 07:48:23 +00:00
|
|
|
#define NDCB0_AUTO_RS (0x1 << 25)
|
|
|
|
#define NDCB0_CSEL (0x1 << 24)
|
|
|
|
#define NDCB0_CMD_TYPE_MASK (0x7 << 21)
|
|
|
|
#define NDCB0_CMD_TYPE(x) (((x) << 21) & NDCB0_CMD_TYPE_MASK)
|
|
|
|
#define NDCB0_NC (0x1 << 20)
|
|
|
|
#define NDCB0_DBC (0x1 << 19)
|
|
|
|
#define NDCB0_ADDR_CYC_MASK (0x7 << 16)
|
|
|
|
#define NDCB0_ADDR_CYC(x) (((x) << 16) & NDCB0_ADDR_CYC_MASK)
|
|
|
|
#define NDCB0_CMD2_MASK (0xff << 8)
|
|
|
|
#define NDCB0_CMD1_MASK (0xff)
|
|
|
|
#define NDCB0_ADDR_CYC_SHIFT (16)
|
|
|
|
|
|
|
|
/* macros for registers read/write */
|
|
|
|
#define nand_writel(info, off, val) \
|
|
|
|
__raw_writel((val), (info)->mmio_base + (off))
|
|
|
|
|
|
|
|
#define nand_readl(info, off) \
|
|
|
|
__raw_readl((info)->mmio_base + (off))
|
|
|
|
|
|
|
|
/* error code and state */
|
|
|
|
enum {
|
|
|
|
ERR_NONE = 0,
|
|
|
|
ERR_DMABUSERR = -1,
|
|
|
|
ERR_SENDCMD = -2,
|
|
|
|
ERR_DBERR = -3,
|
|
|
|
ERR_BBERR = -4,
|
2009-07-01 15:11:35 +00:00
|
|
|
ERR_SBERR = -5,
|
2008-02-14 07:48:23 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
2011-02-28 02:32:11 +00:00
|
|
|
STATE_IDLE = 0,
|
2008-02-14 07:48:23 +00:00
|
|
|
STATE_CMD_HANDLE,
|
|
|
|
STATE_DMA_READING,
|
|
|
|
STATE_DMA_WRITING,
|
|
|
|
STATE_DMA_DONE,
|
|
|
|
STATE_PIO_READING,
|
|
|
|
STATE_PIO_WRITING,
|
2011-02-28 02:32:11 +00:00
|
|
|
STATE_CMD_DONE,
|
|
|
|
STATE_READY,
|
2008-02-14 07:48:23 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct pxa3xx_nand_info {
|
|
|
|
struct nand_chip nand_chip;
|
|
|
|
|
|
|
|
struct platform_device *pdev;
|
2010-08-17 09:25:57 +00:00
|
|
|
struct pxa3xx_nand_cmdset *cmdset;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
struct clk *clk;
|
|
|
|
void __iomem *mmio_base;
|
2009-09-10 06:11:44 +00:00
|
|
|
unsigned long mmio_phys;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
unsigned int buf_start;
|
|
|
|
unsigned int buf_count;
|
|
|
|
|
2011-03-03 03:08:30 +00:00
|
|
|
struct mtd_info *mtd;
|
2008-02-14 07:48:23 +00:00
|
|
|
/* DMA information */
|
|
|
|
int drcmr_dat;
|
|
|
|
int drcmr_cmd;
|
|
|
|
|
|
|
|
unsigned char *data_buff;
|
2010-08-17 09:25:57 +00:00
|
|
|
unsigned char *oob_buff;
|
2008-02-14 07:48:23 +00:00
|
|
|
dma_addr_t data_buff_phys;
|
|
|
|
size_t data_buff_size;
|
|
|
|
int data_dma_ch;
|
|
|
|
struct pxa_dma_desc *data_desc;
|
|
|
|
dma_addr_t data_desc_addr;
|
|
|
|
|
|
|
|
uint32_t reg_ndcr;
|
|
|
|
|
|
|
|
/* saved column/page_addr during CMD_SEQIN */
|
|
|
|
int seqin_column;
|
|
|
|
int seqin_page_addr;
|
|
|
|
|
|
|
|
/* relate to the command */
|
|
|
|
unsigned int state;
|
|
|
|
|
|
|
|
int use_ecc; /* use HW ECC ? */
|
|
|
|
int use_dma; /* use DMA ? */
|
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
unsigned int page_size; /* page size of attached chip */
|
|
|
|
unsigned int data_size; /* data size in FIFO */
|
2008-02-14 07:48:23 +00:00
|
|
|
int retcode;
|
|
|
|
struct completion cmd_complete;
|
|
|
|
|
|
|
|
/* generated NDCBx register values */
|
|
|
|
uint32_t ndcb0;
|
|
|
|
uint32_t ndcb1;
|
|
|
|
uint32_t ndcb2;
|
2008-08-29 10:59:51 +00:00
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
/* timing calcuted from setting */
|
|
|
|
uint32_t ndtr0cs0;
|
|
|
|
uint32_t ndtr1cs0;
|
|
|
|
|
2008-08-29 10:59:51 +00:00
|
|
|
/* calculated from pxa3xx_nand_flash data */
|
|
|
|
size_t oob_size;
|
|
|
|
size_t read_id_bytes;
|
|
|
|
|
|
|
|
unsigned int col_addr_cycles;
|
|
|
|
unsigned int row_addr_cycles;
|
2008-02-14 07:48:23 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int use_dma = 1;
|
|
|
|
module_param(use_dma, bool, 0444);
|
|
|
|
MODULE_PARM_DESC(use_dma, "enable DMA for data transfering to/from NAND HW");
|
|
|
|
|
2009-02-17 11:54:47 +00:00
|
|
|
/*
|
|
|
|
* Default NAND flash controller configuration setup by the
|
|
|
|
* bootloader. This configuration is used only when pdata->keep_config is set
|
|
|
|
*/
|
2010-08-17 05:50:23 +00:00
|
|
|
static struct pxa3xx_nand_cmdset default_cmdset = {
|
2008-02-14 07:48:23 +00:00
|
|
|
.read1 = 0x3000,
|
|
|
|
.read2 = 0x0050,
|
|
|
|
.program = 0x1080,
|
|
|
|
.read_status = 0x0070,
|
|
|
|
.read_id = 0x0090,
|
|
|
|
.erase = 0xD060,
|
|
|
|
.reset = 0x00FF,
|
|
|
|
.lock = 0x002A,
|
|
|
|
.unlock = 0x2423,
|
|
|
|
.lock_status = 0x007A,
|
|
|
|
};
|
|
|
|
|
2010-08-17 05:50:23 +00:00
|
|
|
static struct pxa3xx_nand_timing timing[] = {
|
2010-08-18 10:00:03 +00:00
|
|
|
{ 40, 80, 60, 100, 80, 100, 90000, 400, 40, },
|
|
|
|
{ 10, 0, 20, 40, 30, 40, 11123, 110, 10, },
|
|
|
|
{ 10, 25, 15, 25, 15, 30, 25000, 60, 10, },
|
|
|
|
{ 10, 35, 15, 25, 15, 25, 25000, 60, 10, },
|
2009-09-10 06:33:30 +00:00
|
|
|
};
|
|
|
|
|
2010-08-17 05:50:23 +00:00
|
|
|
static struct pxa3xx_nand_flash builtin_flash_types[] = {
|
2010-08-18 10:00:03 +00:00
|
|
|
{ 0, 0, 2048, 8, 8, 0, &default_cmdset, &timing[0] },
|
|
|
|
{ 0x46ec, 32, 512, 16, 16, 4096, &default_cmdset, &timing[1] },
|
|
|
|
{ 0xdaec, 64, 2048, 8, 8, 2048, &default_cmdset, &timing[1] },
|
|
|
|
{ 0xd7ec, 128, 4096, 8, 8, 8192, &default_cmdset, &timing[1] },
|
|
|
|
{ 0xa12c, 64, 2048, 8, 8, 1024, &default_cmdset, &timing[2] },
|
|
|
|
{ 0xb12c, 64, 2048, 16, 16, 1024, &default_cmdset, &timing[2] },
|
|
|
|
{ 0xdc2c, 64, 2048, 8, 8, 4096, &default_cmdset, &timing[2] },
|
|
|
|
{ 0xcc2c, 64, 2048, 16, 16, 4096, &default_cmdset, &timing[2] },
|
|
|
|
{ 0xba20, 64, 2048, 16, 16, 2048, &default_cmdset, &timing[3] },
|
2009-09-10 06:33:30 +00:00
|
|
|
};
|
|
|
|
|
2010-08-18 10:00:03 +00:00
|
|
|
/* Define a default flash type setting serve as flash detecting only */
|
|
|
|
#define DEFAULT_FLASH_TYPE (&builtin_flash_types[0])
|
|
|
|
|
2008-02-14 07:48:23 +00:00
|
|
|
#define NDTR0_tCH(c) (min((c), 7) << 19)
|
|
|
|
#define NDTR0_tCS(c) (min((c), 7) << 16)
|
|
|
|
#define NDTR0_tWH(c) (min((c), 7) << 11)
|
|
|
|
#define NDTR0_tWP(c) (min((c), 7) << 8)
|
|
|
|
#define NDTR0_tRH(c) (min((c), 7) << 3)
|
|
|
|
#define NDTR0_tRP(c) (min((c), 7) << 0)
|
|
|
|
|
|
|
|
#define NDTR1_tR(c) (min((c), 65535) << 16)
|
|
|
|
#define NDTR1_tWHR(c) (min((c), 15) << 4)
|
|
|
|
#define NDTR1_tAR(c) (min((c), 15) << 0)
|
|
|
|
|
|
|
|
/* convert nano-seconds to nand flash controller clock cycles */
|
2010-08-16 08:09:09 +00:00
|
|
|
#define ns2cycle(ns, clk) (int)((ns) * (clk / 1000000) / 1000)
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
static void pxa3xx_nand_set_timing(struct pxa3xx_nand_info *info,
|
2008-08-29 10:59:50 +00:00
|
|
|
const struct pxa3xx_nand_timing *t)
|
2008-02-14 07:48:23 +00:00
|
|
|
{
|
|
|
|
unsigned long nand_clk = clk_get_rate(info->clk);
|
|
|
|
uint32_t ndtr0, ndtr1;
|
|
|
|
|
|
|
|
ndtr0 = NDTR0_tCH(ns2cycle(t->tCH, nand_clk)) |
|
|
|
|
NDTR0_tCS(ns2cycle(t->tCS, nand_clk)) |
|
|
|
|
NDTR0_tWH(ns2cycle(t->tWH, nand_clk)) |
|
|
|
|
NDTR0_tWP(ns2cycle(t->tWP, nand_clk)) |
|
|
|
|
NDTR0_tRH(ns2cycle(t->tRH, nand_clk)) |
|
|
|
|
NDTR0_tRP(ns2cycle(t->tRP, nand_clk));
|
|
|
|
|
|
|
|
ndtr1 = NDTR1_tR(ns2cycle(t->tR, nand_clk)) |
|
|
|
|
NDTR1_tWHR(ns2cycle(t->tWHR, nand_clk)) |
|
|
|
|
NDTR1_tAR(ns2cycle(t->tAR, nand_clk));
|
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
info->ndtr0cs0 = ndtr0;
|
|
|
|
info->ndtr1cs0 = ndtr1;
|
2008-02-14 07:48:23 +00:00
|
|
|
nand_writel(info, NDTR0CS0, ndtr0);
|
|
|
|
nand_writel(info, NDTR1CS0, ndtr1);
|
|
|
|
}
|
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
static void pxa3xx_set_datasize(struct pxa3xx_nand_info *info)
|
2008-02-14 07:48:23 +00:00
|
|
|
{
|
2010-08-17 06:09:30 +00:00
|
|
|
int oob_enable = info->reg_ndcr & NDCR_SPARE_EN;
|
|
|
|
|
|
|
|
info->data_size = info->page_size;
|
|
|
|
if (!oob_enable) {
|
|
|
|
info->oob_size = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
switch (info->page_size) {
|
2008-02-14 07:48:23 +00:00
|
|
|
case 2048:
|
2010-08-17 06:09:30 +00:00
|
|
|
info->oob_size = (info->use_ecc) ? 40 : 64;
|
2008-02-14 07:48:23 +00:00
|
|
|
break;
|
|
|
|
case 512:
|
2010-08-17 06:09:30 +00:00
|
|
|
info->oob_size = (info->use_ecc) ? 8 : 16;
|
2008-02-14 07:48:23 +00:00
|
|
|
break;
|
|
|
|
}
|
2010-08-17 09:25:57 +00:00
|
|
|
}
|
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
/**
|
|
|
|
* NOTE: it is a must to set ND_RUN firstly, then write
|
|
|
|
* command buffer, otherwise, it does not work.
|
|
|
|
* We enable all the interrupt at the same time, and
|
|
|
|
* let pxa3xx_nand_irq to handle all logic.
|
|
|
|
*/
|
|
|
|
static void pxa3xx_nand_start(struct pxa3xx_nand_info *info)
|
|
|
|
{
|
|
|
|
uint32_t ndcr;
|
|
|
|
|
|
|
|
ndcr = info->reg_ndcr;
|
|
|
|
ndcr |= info->use_ecc ? NDCR_ECC_EN : 0;
|
|
|
|
ndcr |= info->use_dma ? NDCR_DMA_EN : 0;
|
|
|
|
ndcr |= NDCR_ND_RUN;
|
|
|
|
|
|
|
|
/* clear status bits and run */
|
|
|
|
nand_writel(info, NDCR, 0);
|
|
|
|
nand_writel(info, NDSR, NDSR_MASK);
|
|
|
|
nand_writel(info, NDCR, ndcr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa3xx_nand_stop(struct pxa3xx_nand_info *info)
|
|
|
|
{
|
|
|
|
uint32_t ndcr;
|
|
|
|
int timeout = NAND_STOP_DELAY;
|
|
|
|
|
|
|
|
/* wait RUN bit in NDCR become 0 */
|
|
|
|
ndcr = nand_readl(info, NDCR);
|
|
|
|
while ((ndcr & NDCR_ND_RUN) && (timeout-- > 0)) {
|
|
|
|
ndcr = nand_readl(info, NDCR);
|
|
|
|
udelay(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (timeout <= 0) {
|
|
|
|
ndcr &= ~NDCR_ND_RUN;
|
|
|
|
nand_writel(info, NDCR, ndcr);
|
|
|
|
}
|
|
|
|
/* clear status bits */
|
|
|
|
nand_writel(info, NDSR, NDSR_MASK);
|
|
|
|
}
|
|
|
|
|
2008-02-14 07:48:23 +00:00
|
|
|
static void enable_int(struct pxa3xx_nand_info *info, uint32_t int_mask)
|
|
|
|
{
|
|
|
|
uint32_t ndcr;
|
|
|
|
|
|
|
|
ndcr = nand_readl(info, NDCR);
|
|
|
|
nand_writel(info, NDCR, ndcr & ~int_mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void disable_int(struct pxa3xx_nand_info *info, uint32_t int_mask)
|
|
|
|
{
|
|
|
|
uint32_t ndcr;
|
|
|
|
|
|
|
|
ndcr = nand_readl(info, NDCR);
|
|
|
|
nand_writel(info, NDCR, ndcr | int_mask);
|
|
|
|
}
|
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
static void handle_data_pio(struct pxa3xx_nand_info *info)
|
2008-02-14 07:48:23 +00:00
|
|
|
{
|
|
|
|
switch (info->state) {
|
|
|
|
case STATE_PIO_WRITING:
|
|
|
|
__raw_writesl(info->mmio_base + NDDB, info->data_buff,
|
2009-09-11 11:33:58 +00:00
|
|
|
DIV_ROUND_UP(info->data_size, 4));
|
2010-08-17 06:09:30 +00:00
|
|
|
if (info->oob_size > 0)
|
|
|
|
__raw_writesl(info->mmio_base + NDDB, info->oob_buff,
|
|
|
|
DIV_ROUND_UP(info->oob_size, 4));
|
2008-02-14 07:48:23 +00:00
|
|
|
break;
|
|
|
|
case STATE_PIO_READING:
|
|
|
|
__raw_readsl(info->mmio_base + NDDB, info->data_buff,
|
2009-09-11 11:33:58 +00:00
|
|
|
DIV_ROUND_UP(info->data_size, 4));
|
2010-08-17 06:09:30 +00:00
|
|
|
if (info->oob_size > 0)
|
|
|
|
__raw_readsl(info->mmio_base + NDDB, info->oob_buff,
|
|
|
|
DIV_ROUND_UP(info->oob_size, 4));
|
2008-02-14 07:48:23 +00:00
|
|
|
break;
|
|
|
|
default:
|
2008-04-22 19:39:43 +00:00
|
|
|
printk(KERN_ERR "%s: invalid state %d\n", __func__,
|
2008-02-14 07:48:23 +00:00
|
|
|
info->state);
|
2011-02-28 02:32:11 +00:00
|
|
|
BUG();
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
static void start_data_dma(struct pxa3xx_nand_info *info)
|
2008-02-14 07:48:23 +00:00
|
|
|
{
|
|
|
|
struct pxa_dma_desc *desc = info->data_desc;
|
2010-08-17 06:09:30 +00:00
|
|
|
int dma_len = ALIGN(info->data_size + info->oob_size, 32);
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
desc->ddadr = DDADR_STOP;
|
|
|
|
desc->dcmd = DCMD_ENDIRQEN | DCMD_WIDTH4 | DCMD_BURST32 | dma_len;
|
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
switch (info->state) {
|
|
|
|
case STATE_DMA_WRITING:
|
2008-02-14 07:48:23 +00:00
|
|
|
desc->dsadr = info->data_buff_phys;
|
2009-09-10 06:11:44 +00:00
|
|
|
desc->dtadr = info->mmio_phys + NDDB;
|
2008-02-14 07:48:23 +00:00
|
|
|
desc->dcmd |= DCMD_INCSRCADDR | DCMD_FLOWTRG;
|
2011-02-28 02:32:11 +00:00
|
|
|
break;
|
|
|
|
case STATE_DMA_READING:
|
2008-02-14 07:48:23 +00:00
|
|
|
desc->dtadr = info->data_buff_phys;
|
2009-09-10 06:11:44 +00:00
|
|
|
desc->dsadr = info->mmio_phys + NDDB;
|
2008-02-14 07:48:23 +00:00
|
|
|
desc->dcmd |= DCMD_INCTRGADDR | DCMD_FLOWSRC;
|
2011-02-28 02:32:11 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_ERR "%s: invalid state %d\n", __func__,
|
|
|
|
info->state);
|
|
|
|
BUG();
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
DRCMR(info->drcmr_dat) = DRCMR_MAPVLD | info->data_dma_ch;
|
|
|
|
DDADR(info->data_dma_ch) = info->data_desc_addr;
|
|
|
|
DCSR(info->data_dma_ch) |= DCSR_RUN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa3xx_nand_data_dma_irq(int channel, void *data)
|
|
|
|
{
|
|
|
|
struct pxa3xx_nand_info *info = data;
|
|
|
|
uint32_t dcsr;
|
|
|
|
|
|
|
|
dcsr = DCSR(channel);
|
|
|
|
DCSR(channel) = dcsr;
|
|
|
|
|
|
|
|
if (dcsr & DCSR_BUSERR) {
|
|
|
|
info->retcode = ERR_DMABUSERR;
|
|
|
|
}
|
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
info->state = STATE_DMA_DONE;
|
|
|
|
enable_int(info, NDCR_INT_MASK);
|
|
|
|
nand_writel(info, NDSR, NDSR_WRDREQ | NDSR_RDDREQ);
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t pxa3xx_nand_irq(int irq, void *devid)
|
|
|
|
{
|
|
|
|
struct pxa3xx_nand_info *info = devid;
|
2011-02-28 02:32:11 +00:00
|
|
|
unsigned int status, is_completed = 0;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
status = nand_readl(info, NDSR);
|
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
if (status & NDSR_DBERR)
|
|
|
|
info->retcode = ERR_DBERR;
|
|
|
|
if (status & NDSR_SBERR)
|
|
|
|
info->retcode = ERR_SBERR;
|
|
|
|
if (status & (NDSR_RDDREQ | NDSR_WRDREQ)) {
|
|
|
|
/* whether use dma to transfer data */
|
2008-02-14 07:48:23 +00:00
|
|
|
if (info->use_dma) {
|
2011-02-28 02:32:11 +00:00
|
|
|
disable_int(info, NDCR_INT_MASK);
|
|
|
|
info->state = (status & NDSR_RDDREQ) ?
|
|
|
|
STATE_DMA_READING : STATE_DMA_WRITING;
|
|
|
|
start_data_dma(info);
|
|
|
|
goto NORMAL_IRQ_EXIT;
|
2008-02-14 07:48:23 +00:00
|
|
|
} else {
|
2011-02-28 02:32:11 +00:00
|
|
|
info->state = (status & NDSR_RDDREQ) ?
|
|
|
|
STATE_PIO_READING : STATE_PIO_WRITING;
|
|
|
|
handle_data_pio(info);
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
|
|
|
}
|
2011-02-28 02:32:11 +00:00
|
|
|
if (status & NDSR_CS0_CMDD) {
|
|
|
|
info->state = STATE_CMD_DONE;
|
|
|
|
is_completed = 1;
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
2011-02-28 02:32:11 +00:00
|
|
|
if (status & NDSR_FLASH_RDY)
|
|
|
|
info->state = STATE_READY;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
if (status & NDSR_WRCMDREQ) {
|
|
|
|
nand_writel(info, NDSR, NDSR_WRCMDREQ);
|
|
|
|
status &= ~NDSR_WRCMDREQ;
|
|
|
|
info->state = STATE_CMD_HANDLE;
|
|
|
|
nand_writel(info, NDCB0, info->ndcb0);
|
|
|
|
nand_writel(info, NDCB0, info->ndcb1);
|
|
|
|
nand_writel(info, NDCB0, info->ndcb2);
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
/* clear NDSR to let the controller exit the IRQ */
|
|
|
|
nand_writel(info, NDSR, status);
|
|
|
|
if (is_completed)
|
|
|
|
complete(&info->cmd_complete);
|
|
|
|
NORMAL_IRQ_EXIT:
|
|
|
|
return IRQ_HANDLED;
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int pxa3xx_nand_dev_ready(struct mtd_info *mtd)
|
|
|
|
{
|
|
|
|
struct pxa3xx_nand_info *info = mtd->priv;
|
|
|
|
return (nand_readl(info, NDSR) & NDSR_RDY) ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_buf_blank(uint8_t *buf, size_t len)
|
|
|
|
{
|
|
|
|
for (; len > 0; len--)
|
|
|
|
if (*buf++ != 0xff)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-02-28 02:32:13 +00:00
|
|
|
static int prepare_command_pool(struct pxa3xx_nand_info *info, int command,
|
|
|
|
uint16_t column, int page_addr)
|
2008-02-14 07:48:23 +00:00
|
|
|
{
|
2011-02-28 02:32:13 +00:00
|
|
|
uint16_t cmd;
|
|
|
|
int addr_cycle, exec_cmd, ndcb0;
|
|
|
|
struct mtd_info *mtd = info->mtd;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
2011-02-28 02:32:13 +00:00
|
|
|
ndcb0 = 0;
|
|
|
|
addr_cycle = 0;
|
|
|
|
exec_cmd = 1;
|
|
|
|
|
|
|
|
/* reset data and oob column point to handle data */
|
|
|
|
info->buf_start = 0;
|
|
|
|
info->buf_count = 0;
|
|
|
|
info->oob_size = 0;
|
|
|
|
info->use_ecc = 0;
|
|
|
|
info->retcode = ERR_NONE;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
switch (command) {
|
2011-02-28 02:32:13 +00:00
|
|
|
case NAND_CMD_READ0:
|
|
|
|
case NAND_CMD_PAGEPROG:
|
|
|
|
info->use_ecc = 1;
|
2008-02-14 07:48:23 +00:00
|
|
|
case NAND_CMD_READOOB:
|
2011-02-28 02:32:13 +00:00
|
|
|
pxa3xx_set_datasize(info);
|
2008-02-14 07:48:23 +00:00
|
|
|
break;
|
2011-02-28 02:32:13 +00:00
|
|
|
case NAND_CMD_SEQIN:
|
|
|
|
exec_cmd = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
info->ndcb1 = 0;
|
|
|
|
info->ndcb2 = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
info->ndcb0 = ndcb0;
|
|
|
|
addr_cycle = NDCB0_ADDR_CYC(info->row_addr_cycles
|
|
|
|
+ info->col_addr_cycles);
|
2008-02-14 07:48:23 +00:00
|
|
|
|
2011-02-28 02:32:13 +00:00
|
|
|
switch (command) {
|
|
|
|
case NAND_CMD_READOOB:
|
2008-02-14 07:48:23 +00:00
|
|
|
case NAND_CMD_READ0:
|
2011-02-28 02:32:13 +00:00
|
|
|
cmd = info->cmdset->read1;
|
|
|
|
if (command == NAND_CMD_READOOB)
|
|
|
|
info->buf_start = mtd->writesize + column;
|
|
|
|
else
|
|
|
|
info->buf_start = column;
|
|
|
|
|
|
|
|
if (unlikely(info->page_size < PAGE_CHUNK_SIZE))
|
|
|
|
info->ndcb0 |= NDCB0_CMD_TYPE(0)
|
|
|
|
| addr_cycle
|
|
|
|
| (cmd & NDCB0_CMD1_MASK);
|
|
|
|
else
|
|
|
|
info->ndcb0 |= NDCB0_CMD_TYPE(0)
|
|
|
|
| NDCB0_DBC
|
|
|
|
| addr_cycle
|
|
|
|
| cmd;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
case NAND_CMD_SEQIN:
|
2011-02-28 02:32:13 +00:00
|
|
|
/* small page addr setting */
|
|
|
|
if (unlikely(info->page_size < PAGE_CHUNK_SIZE)) {
|
|
|
|
info->ndcb1 = ((page_addr & 0xFFFFFF) << 8)
|
|
|
|
| (column & 0xFF);
|
|
|
|
|
|
|
|
info->ndcb2 = 0;
|
|
|
|
} else {
|
|
|
|
info->ndcb1 = ((page_addr & 0xFFFF) << 16)
|
|
|
|
| (column & 0xFFFF);
|
|
|
|
|
|
|
|
if (page_addr & 0xFF0000)
|
|
|
|
info->ndcb2 = (page_addr & 0xFF0000) >> 16;
|
|
|
|
else
|
|
|
|
info->ndcb2 = 0;
|
|
|
|
}
|
|
|
|
|
2008-02-14 07:48:23 +00:00
|
|
|
info->buf_count = mtd->writesize + mtd->oobsize;
|
2011-02-28 02:32:13 +00:00
|
|
|
memset(info->data_buff, 0xFF, info->buf_count);
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
break;
|
2011-02-28 02:32:13 +00:00
|
|
|
|
2008-02-14 07:48:23 +00:00
|
|
|
case NAND_CMD_PAGEPROG:
|
2011-02-28 02:32:13 +00:00
|
|
|
if (is_buf_blank(info->data_buff,
|
|
|
|
(mtd->writesize + mtd->oobsize))) {
|
|
|
|
exec_cmd = 0;
|
|
|
|
break;
|
|
|
|
}
|
2008-02-14 07:48:23 +00:00
|
|
|
|
2011-02-28 02:32:13 +00:00
|
|
|
cmd = info->cmdset->program;
|
|
|
|
info->ndcb0 |= NDCB0_CMD_TYPE(0x1)
|
|
|
|
| NDCB0_AUTO_RS
|
|
|
|
| NDCB0_ST_ROW_EN
|
|
|
|
| NDCB0_DBC
|
|
|
|
| cmd
|
|
|
|
| addr_cycle;
|
2008-02-14 07:48:23 +00:00
|
|
|
break;
|
2011-02-28 02:32:13 +00:00
|
|
|
|
2008-02-14 07:48:23 +00:00
|
|
|
case NAND_CMD_READID:
|
2011-02-28 02:32:13 +00:00
|
|
|
cmd = info->cmdset->read_id;
|
|
|
|
info->buf_count = info->read_id_bytes;
|
|
|
|
info->ndcb0 |= NDCB0_CMD_TYPE(3)
|
|
|
|
| NDCB0_ADDR_CYC(1)
|
|
|
|
| cmd;
|
|
|
|
|
|
|
|
info->data_size = 8;
|
|
|
|
break;
|
2008-02-14 07:48:23 +00:00
|
|
|
case NAND_CMD_STATUS:
|
2011-02-28 02:32:13 +00:00
|
|
|
cmd = info->cmdset->read_status;
|
|
|
|
info->buf_count = 1;
|
|
|
|
info->ndcb0 |= NDCB0_CMD_TYPE(4)
|
|
|
|
| NDCB0_ADDR_CYC(1)
|
|
|
|
| cmd;
|
|
|
|
|
|
|
|
info->data_size = 8;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NAND_CMD_ERASE1:
|
|
|
|
cmd = info->cmdset->erase;
|
|
|
|
info->ndcb0 |= NDCB0_CMD_TYPE(2)
|
|
|
|
| NDCB0_AUTO_RS
|
|
|
|
| NDCB0_ADDR_CYC(3)
|
|
|
|
| NDCB0_DBC
|
|
|
|
| cmd;
|
|
|
|
info->ndcb1 = page_addr;
|
|
|
|
info->ndcb2 = 0;
|
|
|
|
|
2008-02-14 07:48:23 +00:00
|
|
|
break;
|
|
|
|
case NAND_CMD_RESET:
|
2011-02-28 02:32:13 +00:00
|
|
|
cmd = info->cmdset->reset;
|
|
|
|
info->ndcb0 |= NDCB0_CMD_TYPE(5)
|
|
|
|
| cmd;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NAND_CMD_ERASE2:
|
|
|
|
exec_cmd = 0;
|
2008-02-14 07:48:23 +00:00
|
|
|
break;
|
2011-02-28 02:32:13 +00:00
|
|
|
|
2008-02-14 07:48:23 +00:00
|
|
|
default:
|
2011-02-28 02:32:13 +00:00
|
|
|
exec_cmd = 0;
|
|
|
|
printk(KERN_ERR "pxa3xx-nand: non-supported"
|
|
|
|
" command %x\n", command);
|
2008-02-14 07:48:23 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-02-28 02:32:13 +00:00
|
|
|
return exec_cmd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa3xx_nand_cmdfunc(struct mtd_info *mtd, unsigned command,
|
|
|
|
int column, int page_addr)
|
|
|
|
{
|
|
|
|
struct pxa3xx_nand_info *info = mtd->priv;
|
|
|
|
int ret, exec_cmd;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if this is a x16 device ,then convert the input
|
|
|
|
* "byte" address into a "word" address appropriate
|
|
|
|
* for indexing a word-oriented device
|
|
|
|
*/
|
|
|
|
if (info->reg_ndcr & NDCR_DWIDTH_M)
|
|
|
|
column /= 2;
|
|
|
|
|
|
|
|
exec_cmd = prepare_command_pool(info, command, column, page_addr);
|
2011-02-28 02:32:11 +00:00
|
|
|
if (exec_cmd) {
|
|
|
|
init_completion(&info->cmd_complete);
|
|
|
|
pxa3xx_nand_start(info);
|
|
|
|
|
|
|
|
ret = wait_for_completion_timeout(&info->cmd_complete,
|
|
|
|
CHIP_DELAY_TIMEOUT);
|
|
|
|
if (!ret) {
|
|
|
|
printk(KERN_ERR "Wait time out!!!\n");
|
|
|
|
/* Stop State Machine for next command cycle */
|
|
|
|
pxa3xx_nand_stop(info);
|
|
|
|
}
|
|
|
|
info->state = STATE_IDLE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa3xx_nand_write_page_hwecc(struct mtd_info *mtd,
|
|
|
|
struct nand_chip *chip, const uint8_t *buf)
|
|
|
|
{
|
|
|
|
chip->write_buf(mtd, buf, mtd->writesize);
|
|
|
|
chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pxa3xx_nand_read_page_hwecc(struct mtd_info *mtd,
|
|
|
|
struct nand_chip *chip, uint8_t *buf, int page)
|
|
|
|
{
|
|
|
|
struct pxa3xx_nand_info *info = mtd->priv;
|
|
|
|
|
|
|
|
chip->read_buf(mtd, buf, mtd->writesize);
|
|
|
|
chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
|
|
|
|
|
|
|
|
if (info->retcode == ERR_SBERR) {
|
|
|
|
switch (info->use_ecc) {
|
|
|
|
case 1:
|
|
|
|
mtd->ecc_stats.corrected++;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (info->retcode == ERR_DBERR) {
|
|
|
|
/*
|
|
|
|
* for blank page (all 0xff), HW will calculate its ECC as
|
|
|
|
* 0, which is different from the ECC information within
|
|
|
|
* OOB, ignore such double bit errors
|
|
|
|
*/
|
|
|
|
if (is_buf_blank(buf, mtd->writesize))
|
|
|
|
mtd->ecc_stats.failed++;
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
2011-02-28 02:32:11 +00:00
|
|
|
|
|
|
|
return 0;
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static uint8_t pxa3xx_nand_read_byte(struct mtd_info *mtd)
|
|
|
|
{
|
|
|
|
struct pxa3xx_nand_info *info = mtd->priv;
|
|
|
|
char retval = 0xFF;
|
|
|
|
|
|
|
|
if (info->buf_start < info->buf_count)
|
|
|
|
/* Has just send a new command? */
|
|
|
|
retval = info->data_buff[info->buf_start++];
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u16 pxa3xx_nand_read_word(struct mtd_info *mtd)
|
|
|
|
{
|
|
|
|
struct pxa3xx_nand_info *info = mtd->priv;
|
|
|
|
u16 retval = 0xFFFF;
|
|
|
|
|
|
|
|
if (!(info->buf_start & 0x01) && info->buf_start < info->buf_count) {
|
|
|
|
retval = *((u16 *)(info->data_buff+info->buf_start));
|
|
|
|
info->buf_start += 2;
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa3xx_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
|
|
|
|
{
|
|
|
|
struct pxa3xx_nand_info *info = mtd->priv;
|
|
|
|
int real_len = min_t(size_t, len, info->buf_count - info->buf_start);
|
|
|
|
|
|
|
|
memcpy(buf, info->data_buff + info->buf_start, real_len);
|
|
|
|
info->buf_start += real_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa3xx_nand_write_buf(struct mtd_info *mtd,
|
|
|
|
const uint8_t *buf, int len)
|
|
|
|
{
|
|
|
|
struct pxa3xx_nand_info *info = mtd->priv;
|
|
|
|
int real_len = min_t(size_t, len, info->buf_count - info->buf_start);
|
|
|
|
|
|
|
|
memcpy(info->data_buff + info->buf_start, buf, real_len);
|
|
|
|
info->buf_start += real_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pxa3xx_nand_verify_buf(struct mtd_info *mtd,
|
|
|
|
const uint8_t *buf, int len)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa3xx_nand_select_chip(struct mtd_info *mtd, int chip)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pxa3xx_nand_waitfunc(struct mtd_info *mtd, struct nand_chip *this)
|
|
|
|
{
|
|
|
|
struct pxa3xx_nand_info *info = mtd->priv;
|
|
|
|
|
|
|
|
/* pxa3xx_nand_send_command has waited for command complete */
|
|
|
|
if (this->state == FL_WRITING || this->state == FL_ERASING) {
|
|
|
|
if (info->retcode == ERR_NONE)
|
|
|
|
return 0;
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* any error make it return 0x01 which will tell
|
|
|
|
* the caller the erase and write fail
|
|
|
|
*/
|
|
|
|
return 0x01;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pxa3xx_nand_config_flash(struct pxa3xx_nand_info *info,
|
2008-08-29 10:59:51 +00:00
|
|
|
const struct pxa3xx_nand_flash *f)
|
2008-02-14 07:48:23 +00:00
|
|
|
{
|
|
|
|
struct platform_device *pdev = info->pdev;
|
|
|
|
struct pxa3xx_nand_platform_data *pdata = pdev->dev.platform_data;
|
2011-02-28 02:32:11 +00:00
|
|
|
uint32_t ndcr = 0x0; /* enable all interrupts */
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
if (f->page_size != 2048 && f->page_size != 512)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (f->flash_width != 16 && f->flash_width != 8)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* calculate flash information */
|
2010-08-17 09:25:57 +00:00
|
|
|
info->cmdset = f->cmdset;
|
|
|
|
info->page_size = f->page_size;
|
|
|
|
info->oob_buff = info->data_buff + f->page_size;
|
2008-08-29 10:59:51 +00:00
|
|
|
info->read_id_bytes = (f->page_size == 2048) ? 4 : 2;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
/* calculate addressing information */
|
2008-08-29 10:59:51 +00:00
|
|
|
info->col_addr_cycles = (f->page_size == 2048) ? 2 : 1;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
if (f->num_blocks * f->page_per_block > 65536)
|
2008-08-29 10:59:51 +00:00
|
|
|
info->row_addr_cycles = 3;
|
2008-02-14 07:48:23 +00:00
|
|
|
else
|
2008-08-29 10:59:51 +00:00
|
|
|
info->row_addr_cycles = 2;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
ndcr |= (pdata->enable_arbiter) ? NDCR_ND_ARB_EN : 0;
|
2008-08-29 10:59:51 +00:00
|
|
|
ndcr |= (info->col_addr_cycles == 2) ? NDCR_RA_START : 0;
|
2008-02-14 07:48:23 +00:00
|
|
|
ndcr |= (f->page_per_block == 64) ? NDCR_PG_PER_BLK : 0;
|
|
|
|
ndcr |= (f->page_size == 2048) ? NDCR_PAGE_SZ : 0;
|
|
|
|
ndcr |= (f->flash_width == 16) ? NDCR_DWIDTH_M : 0;
|
|
|
|
ndcr |= (f->dfc_width == 16) ? NDCR_DWIDTH_C : 0;
|
|
|
|
|
2008-08-29 10:59:51 +00:00
|
|
|
ndcr |= NDCR_RD_ID_CNT(info->read_id_bytes);
|
2008-02-14 07:48:23 +00:00
|
|
|
ndcr |= NDCR_SPARE_EN; /* enable spare by default */
|
|
|
|
|
|
|
|
info->reg_ndcr = ndcr;
|
|
|
|
|
|
|
|
pxa3xx_nand_set_timing(info, f->timing);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-17 11:54:47 +00:00
|
|
|
static int pxa3xx_nand_detect_config(struct pxa3xx_nand_info *info)
|
|
|
|
{
|
|
|
|
uint32_t ndcr = nand_readl(info, NDCR);
|
|
|
|
struct nand_flash_dev *type = NULL;
|
2010-08-17 09:25:57 +00:00
|
|
|
uint32_t id = -1, page_per_block, num_blocks;
|
2009-02-17 11:54:47 +00:00
|
|
|
int i;
|
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
page_per_block = ndcr & NDCR_PG_PER_BLK ? 64 : 32;
|
|
|
|
info->page_size = ndcr & NDCR_PAGE_SZ ? 2048 : 512;
|
2011-02-28 02:32:12 +00:00
|
|
|
/* set info fields needed to read id */
|
2010-08-17 09:25:57 +00:00
|
|
|
info->read_id_bytes = (info->page_size == 2048) ? 4 : 2;
|
2009-02-17 11:54:47 +00:00
|
|
|
info->reg_ndcr = ndcr;
|
2011-01-06 14:05:36 +00:00
|
|
|
info->cmdset = &default_cmdset;
|
2009-02-17 11:54:47 +00:00
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
pxa3xx_nand_cmdfunc(info->mtd, NAND_CMD_READID, 0, 0);
|
|
|
|
id = *((uint16_t *)(info->data_buff));
|
|
|
|
if (id == 0)
|
2009-02-17 11:54:47 +00:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* Lookup the flash id */
|
|
|
|
for (i = 0; nand_flash_ids[i].name != NULL; i++) {
|
|
|
|
if (id == nand_flash_ids[i].id) {
|
|
|
|
type = &nand_flash_ids[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!type)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* fill the missing flash information */
|
2010-08-17 09:25:57 +00:00
|
|
|
i = __ffs(page_per_block * info->page_size);
|
|
|
|
num_blocks = type->chipsize << (20 - i);
|
2009-02-17 11:54:47 +00:00
|
|
|
|
|
|
|
/* calculate addressing information */
|
2010-08-17 09:25:57 +00:00
|
|
|
info->col_addr_cycles = (info->page_size == 2048) ? 2 : 1;
|
2009-02-17 11:54:47 +00:00
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
if (num_blocks * page_per_block > 65536)
|
2009-02-17 11:54:47 +00:00
|
|
|
info->row_addr_cycles = 3;
|
|
|
|
else
|
|
|
|
info->row_addr_cycles = 2;
|
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
info->ndtr0cs0 = nand_readl(info, NDTR0CS0);
|
|
|
|
info->ndtr1cs0 = nand_readl(info, NDTR1CS0);
|
2009-02-17 11:54:47 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-29 10:59:48 +00:00
|
|
|
static int pxa3xx_nand_detect_flash(struct pxa3xx_nand_info *info,
|
|
|
|
const struct pxa3xx_nand_platform_data *pdata)
|
2008-02-14 07:48:23 +00:00
|
|
|
{
|
2008-08-29 10:59:51 +00:00
|
|
|
const struct pxa3xx_nand_flash *f;
|
2008-08-29 10:59:52 +00:00
|
|
|
uint32_t id = -1;
|
2008-02-14 07:48:23 +00:00
|
|
|
int i;
|
|
|
|
|
2009-02-17 11:54:47 +00:00
|
|
|
if (pdata->keep_config)
|
|
|
|
if (pxa3xx_nand_detect_config(info) == 0)
|
|
|
|
return 0;
|
|
|
|
|
2010-08-18 10:00:03 +00:00
|
|
|
/* we use default timing to detect id */
|
|
|
|
f = DEFAULT_FLASH_TYPE;
|
|
|
|
pxa3xx_nand_config_flash(info, f);
|
2011-02-28 02:32:11 +00:00
|
|
|
pxa3xx_nand_cmdfunc(info->mtd, NAND_CMD_READID, 0, 0);
|
|
|
|
id = *((uint16_t *)(info->data_buff));
|
2010-08-18 10:00:03 +00:00
|
|
|
|
|
|
|
for (i=0; i<ARRAY_SIZE(builtin_flash_types) + pdata->num_flash - 1; i++) {
|
|
|
|
/* we first choose the flash definition from platfrom */
|
|
|
|
if (i < pdata->num_flash)
|
|
|
|
f = pdata->flash + i;
|
|
|
|
else
|
|
|
|
f = &builtin_flash_types[i - pdata->num_flash + 1];
|
|
|
|
if (f->chip_id == id) {
|
|
|
|
dev_info(&info->pdev->dev, "detect chip id: 0x%x\n", id);
|
|
|
|
pxa3xx_nand_config_flash(info, f);
|
2008-02-14 07:48:23 +00:00
|
|
|
return 0;
|
2010-08-18 10:00:03 +00:00
|
|
|
}
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
|
|
|
|
2008-08-29 10:59:52 +00:00
|
|
|
dev_warn(&info->pdev->dev,
|
|
|
|
"failed to detect configured nand flash; found %04x instead of\n",
|
|
|
|
id);
|
2008-02-14 07:48:23 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* the maximum possible buffer size for large page with OOB data
|
|
|
|
* is: 2048 + 64 = 2112 bytes, allocate a page here for both the
|
|
|
|
* data buffer and the DMA descriptor
|
|
|
|
*/
|
|
|
|
#define MAX_BUFF_SIZE PAGE_SIZE
|
|
|
|
|
|
|
|
static int pxa3xx_nand_init_buff(struct pxa3xx_nand_info *info)
|
|
|
|
{
|
|
|
|
struct platform_device *pdev = info->pdev;
|
|
|
|
int data_desc_offset = MAX_BUFF_SIZE - sizeof(struct pxa_dma_desc);
|
|
|
|
|
|
|
|
if (use_dma == 0) {
|
|
|
|
info->data_buff = kmalloc(MAX_BUFF_SIZE, GFP_KERNEL);
|
|
|
|
if (info->data_buff == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
info->data_buff = dma_alloc_coherent(&pdev->dev, MAX_BUFF_SIZE,
|
|
|
|
&info->data_buff_phys, GFP_KERNEL);
|
|
|
|
if (info->data_buff == NULL) {
|
|
|
|
dev_err(&pdev->dev, "failed to allocate dma buffer\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
info->data_buff_size = MAX_BUFF_SIZE;
|
|
|
|
info->data_desc = (void *)info->data_buff + data_desc_offset;
|
|
|
|
info->data_desc_addr = info->data_buff_phys + data_desc_offset;
|
|
|
|
|
|
|
|
info->data_dma_ch = pxa_request_dma("nand-data", DMA_PRIO_LOW,
|
|
|
|
pxa3xx_nand_data_dma_irq, info);
|
|
|
|
if (info->data_dma_ch < 0) {
|
|
|
|
dev_err(&pdev->dev, "failed to request data dma\n");
|
|
|
|
dma_free_coherent(&pdev->dev, info->data_buff_size,
|
|
|
|
info->data_buff, info->data_buff_phys);
|
|
|
|
return info->data_dma_ch;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nand_ecclayout hw_smallpage_ecclayout = {
|
|
|
|
.eccbytes = 6,
|
|
|
|
.eccpos = {8, 9, 10, 11, 12, 13 },
|
|
|
|
.oobfree = { {2, 6} }
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct nand_ecclayout hw_largepage_ecclayout = {
|
|
|
|
.eccbytes = 24,
|
|
|
|
.eccpos = {
|
|
|
|
40, 41, 42, 43, 44, 45, 46, 47,
|
|
|
|
48, 49, 50, 51, 52, 53, 54, 55,
|
|
|
|
56, 57, 58, 59, 60, 61, 62, 63},
|
|
|
|
.oobfree = { {2, 38} }
|
|
|
|
};
|
|
|
|
|
|
|
|
static void pxa3xx_nand_init_mtd(struct mtd_info *mtd,
|
|
|
|
struct pxa3xx_nand_info *info)
|
|
|
|
{
|
|
|
|
struct nand_chip *this = &info->nand_chip;
|
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
this->options = (info->reg_ndcr & NDCR_DWIDTH_C) ? NAND_BUSWIDTH_16: 0;
|
2011-02-28 02:32:13 +00:00
|
|
|
this->options |= NAND_NO_AUTOINCR;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
this->waitfunc = pxa3xx_nand_waitfunc;
|
|
|
|
this->select_chip = pxa3xx_nand_select_chip;
|
|
|
|
this->dev_ready = pxa3xx_nand_dev_ready;
|
|
|
|
this->cmdfunc = pxa3xx_nand_cmdfunc;
|
2011-02-28 02:32:11 +00:00
|
|
|
this->ecc.read_page = pxa3xx_nand_read_page_hwecc;
|
|
|
|
this->ecc.write_page = pxa3xx_nand_write_page_hwecc;
|
2008-02-14 07:48:23 +00:00
|
|
|
this->read_word = pxa3xx_nand_read_word;
|
|
|
|
this->read_byte = pxa3xx_nand_read_byte;
|
|
|
|
this->read_buf = pxa3xx_nand_read_buf;
|
|
|
|
this->write_buf = pxa3xx_nand_write_buf;
|
|
|
|
this->verify_buf = pxa3xx_nand_verify_buf;
|
|
|
|
|
|
|
|
this->ecc.mode = NAND_ECC_HW;
|
2010-08-17 09:25:57 +00:00
|
|
|
this->ecc.size = info->page_size;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
if (info->page_size == 2048)
|
2008-02-14 07:48:23 +00:00
|
|
|
this->ecc.layout = &hw_largepage_ecclayout;
|
|
|
|
else
|
|
|
|
this->ecc.layout = &hw_smallpage_ecclayout;
|
|
|
|
|
2008-04-22 19:39:43 +00:00
|
|
|
this->chip_delay = 25;
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
|
|
|
|
2011-03-03 03:08:30 +00:00
|
|
|
static
|
|
|
|
struct pxa3xx_nand_info *alloc_nand_resource(struct platform_device *pdev)
|
2008-02-14 07:48:23 +00:00
|
|
|
{
|
2011-03-03 03:08:30 +00:00
|
|
|
struct pxa3xx_nand_platform_data *pdata = pdev->dev.platform_data;
|
2008-02-14 07:48:23 +00:00
|
|
|
struct pxa3xx_nand_info *info;
|
|
|
|
struct mtd_info *mtd;
|
|
|
|
struct resource *r;
|
2011-03-03 03:08:30 +00:00
|
|
|
int ret, irq;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
mtd = kzalloc(sizeof(struct mtd_info) + sizeof(struct pxa3xx_nand_info),
|
|
|
|
GFP_KERNEL);
|
2008-04-22 19:39:43 +00:00
|
|
|
if (!mtd) {
|
2008-02-14 07:48:23 +00:00
|
|
|
dev_err(&pdev->dev, "failed to allocate memory\n");
|
2011-03-03 03:08:30 +00:00
|
|
|
return NULL;
|
2008-04-22 19:39:43 +00:00
|
|
|
}
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
info = (struct pxa3xx_nand_info *)(&mtd[1]);
|
|
|
|
info->pdev = pdev;
|
|
|
|
|
|
|
|
mtd->priv = info;
|
2011-03-03 03:08:30 +00:00
|
|
|
info->mtd = mtd;
|
2009-02-17 11:54:46 +00:00
|
|
|
mtd->owner = THIS_MODULE;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
2008-11-11 17:52:32 +00:00
|
|
|
info->clk = clk_get(&pdev->dev, NULL);
|
2008-02-14 07:48:23 +00:00
|
|
|
if (IS_ERR(info->clk)) {
|
|
|
|
dev_err(&pdev->dev, "failed to get nand clock\n");
|
|
|
|
ret = PTR_ERR(info->clk);
|
|
|
|
goto fail_free_mtd;
|
|
|
|
}
|
|
|
|
clk_enable(info->clk);
|
|
|
|
|
|
|
|
r = platform_get_resource(pdev, IORESOURCE_DMA, 0);
|
|
|
|
if (r == NULL) {
|
|
|
|
dev_err(&pdev->dev, "no resource defined for data DMA\n");
|
|
|
|
ret = -ENXIO;
|
|
|
|
goto fail_put_clk;
|
|
|
|
}
|
|
|
|
info->drcmr_dat = r->start;
|
|
|
|
|
|
|
|
r = platform_get_resource(pdev, IORESOURCE_DMA, 1);
|
|
|
|
if (r == NULL) {
|
|
|
|
dev_err(&pdev->dev, "no resource defined for command DMA\n");
|
|
|
|
ret = -ENXIO;
|
|
|
|
goto fail_put_clk;
|
|
|
|
}
|
|
|
|
info->drcmr_cmd = r->start;
|
|
|
|
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
|
|
if (irq < 0) {
|
|
|
|
dev_err(&pdev->dev, "no IRQ resource defined\n");
|
|
|
|
ret = -ENXIO;
|
|
|
|
goto fail_put_clk;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
if (r == NULL) {
|
|
|
|
dev_err(&pdev->dev, "no IO memory resource defined\n");
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto fail_put_clk;
|
|
|
|
}
|
|
|
|
|
2009-02-17 11:54:45 +00:00
|
|
|
r = request_mem_region(r->start, resource_size(r), pdev->name);
|
2008-02-14 07:48:23 +00:00
|
|
|
if (r == NULL) {
|
|
|
|
dev_err(&pdev->dev, "failed to request memory resource\n");
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto fail_put_clk;
|
|
|
|
}
|
|
|
|
|
2009-02-17 11:54:45 +00:00
|
|
|
info->mmio_base = ioremap(r->start, resource_size(r));
|
2008-02-14 07:48:23 +00:00
|
|
|
if (info->mmio_base == NULL) {
|
|
|
|
dev_err(&pdev->dev, "ioremap() failed\n");
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto fail_free_res;
|
|
|
|
}
|
2009-09-10 06:11:44 +00:00
|
|
|
info->mmio_phys = r->start;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
ret = pxa3xx_nand_init_buff(info);
|
|
|
|
if (ret)
|
|
|
|
goto fail_free_io;
|
|
|
|
|
2009-09-10 06:27:23 +00:00
|
|
|
/* initialize all interrupts to be disabled */
|
|
|
|
disable_int(info, NDSR_MASK);
|
|
|
|
|
2009-09-10 06:22:55 +00:00
|
|
|
ret = request_irq(irq, pxa3xx_nand_irq, IRQF_DISABLED,
|
|
|
|
pdev->name, info);
|
2008-02-14 07:48:23 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(&pdev->dev, "failed to request IRQ\n");
|
|
|
|
goto fail_free_buf;
|
|
|
|
}
|
|
|
|
|
2008-08-29 10:59:48 +00:00
|
|
|
ret = pxa3xx_nand_detect_flash(info, pdata);
|
2008-02-14 07:48:23 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_err(&pdev->dev, "failed to detect flash\n");
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto fail_free_irq;
|
|
|
|
}
|
|
|
|
|
|
|
|
pxa3xx_nand_init_mtd(mtd, info);
|
2011-03-03 03:08:30 +00:00
|
|
|
platform_set_drvdata(pdev, info);
|
2008-02-14 07:48:23 +00:00
|
|
|
|
2011-03-03 03:08:30 +00:00
|
|
|
return info;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
fail_free_irq:
|
2009-09-10 06:22:55 +00:00
|
|
|
free_irq(irq, info);
|
2008-02-14 07:48:23 +00:00
|
|
|
fail_free_buf:
|
|
|
|
if (use_dma) {
|
|
|
|
pxa_free_dma(info->data_dma_ch);
|
|
|
|
dma_free_coherent(&pdev->dev, info->data_buff_size,
|
|
|
|
info->data_buff, info->data_buff_phys);
|
|
|
|
} else
|
|
|
|
kfree(info->data_buff);
|
|
|
|
fail_free_io:
|
|
|
|
iounmap(info->mmio_base);
|
|
|
|
fail_free_res:
|
2009-02-17 11:54:45 +00:00
|
|
|
release_mem_region(r->start, resource_size(r));
|
2008-02-14 07:48:23 +00:00
|
|
|
fail_put_clk:
|
|
|
|
clk_disable(info->clk);
|
|
|
|
clk_put(info->clk);
|
|
|
|
fail_free_mtd:
|
|
|
|
kfree(mtd);
|
2011-03-03 03:08:30 +00:00
|
|
|
return NULL;
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int pxa3xx_nand_remove(struct platform_device *pdev)
|
|
|
|
{
|
2011-03-03 03:08:30 +00:00
|
|
|
struct pxa3xx_nand_info *info = platform_get_drvdata(pdev);
|
|
|
|
struct mtd_info *mtd = info->mtd;
|
2009-02-17 11:54:46 +00:00
|
|
|
struct resource *r;
|
2009-09-10 06:22:55 +00:00
|
|
|
int irq;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
|
|
|
platform_set_drvdata(pdev, NULL);
|
|
|
|
|
2009-09-10 06:22:55 +00:00
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
|
|
if (irq >= 0)
|
|
|
|
free_irq(irq, info);
|
2008-02-14 07:48:23 +00:00
|
|
|
if (use_dma) {
|
|
|
|
pxa_free_dma(info->data_dma_ch);
|
|
|
|
dma_free_writecombine(&pdev->dev, info->data_buff_size,
|
|
|
|
info->data_buff, info->data_buff_phys);
|
|
|
|
} else
|
|
|
|
kfree(info->data_buff);
|
2009-02-17 11:54:46 +00:00
|
|
|
|
|
|
|
iounmap(info->mmio_base);
|
|
|
|
r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
release_mem_region(r->start, resource_size(r));
|
|
|
|
|
|
|
|
clk_disable(info->clk);
|
|
|
|
clk_put(info->clk);
|
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
if (mtd) {
|
|
|
|
del_mtd_device(mtd);
|
|
|
|
#ifdef CONFIG_MTD_PARTITIONS
|
|
|
|
del_mtd_partitions(mtd);
|
|
|
|
#endif
|
|
|
|
kfree(mtd);
|
|
|
|
}
|
2008-02-14 07:48:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-03-03 03:08:30 +00:00
|
|
|
static int pxa3xx_nand_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct pxa3xx_nand_platform_data *pdata;
|
|
|
|
struct pxa3xx_nand_info *info;
|
|
|
|
|
|
|
|
pdata = pdev->dev.platform_data;
|
|
|
|
if (!pdata) {
|
|
|
|
dev_err(&pdev->dev, "no platform data defined\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
info = alloc_nand_resource(pdev);
|
|
|
|
if (info == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (nand_scan(info->mtd, 1)) {
|
|
|
|
dev_err(&pdev->dev, "failed to scan nand\n");
|
|
|
|
pxa3xx_nand_remove(pdev);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_MTD_PARTITIONS
|
|
|
|
if (mtd_has_cmdlinepart()) {
|
|
|
|
const char *probes[] = { "cmdlinepart", NULL };
|
|
|
|
struct mtd_partition *parts;
|
|
|
|
int nr_parts;
|
|
|
|
|
|
|
|
nr_parts = parse_mtd_partitions(info->mtd, probes, &parts, 0);
|
|
|
|
|
|
|
|
if (nr_parts)
|
2011-02-28 02:32:11 +00:00
|
|
|
return add_mtd_partitions(info->mtd, parts, nr_parts);
|
2011-03-03 03:08:30 +00:00
|
|
|
}
|
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
return add_mtd_partitions(info->mtd, pdata->parts, pdata->nr_parts);
|
2011-03-03 03:08:30 +00:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-02-14 07:48:23 +00:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
static int pxa3xx_nand_suspend(struct platform_device *pdev, pm_message_t state)
|
|
|
|
{
|
2011-03-03 03:08:30 +00:00
|
|
|
struct pxa3xx_nand_info *info = platform_get_drvdata(pdev);
|
|
|
|
struct mtd_info *mtd = info->mtd;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
2011-02-28 02:32:11 +00:00
|
|
|
if (info->state) {
|
2008-02-14 07:48:23 +00:00
|
|
|
dev_err(&pdev->dev, "driver busy, state = %d\n", info->state);
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pxa3xx_nand_resume(struct platform_device *pdev)
|
|
|
|
{
|
2011-03-03 03:08:30 +00:00
|
|
|
struct pxa3xx_nand_info *info = platform_get_drvdata(pdev);
|
|
|
|
struct mtd_info *mtd = info->mtd;
|
2008-02-14 07:48:23 +00:00
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
nand_writel(info, NDTR0CS0, info->ndtr0cs0);
|
|
|
|
nand_writel(info, NDTR1CS0, info->ndtr1cs0);
|
2008-02-14 07:48:23 +00:00
|
|
|
clk_enable(info->clk);
|
|
|
|
|
2010-08-17 09:25:57 +00:00
|
|
|
return 0;
|
2008-02-14 07:48:23 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define pxa3xx_nand_suspend NULL
|
|
|
|
#define pxa3xx_nand_resume NULL
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static struct platform_driver pxa3xx_nand_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "pxa3xx-nand",
|
|
|
|
},
|
|
|
|
.probe = pxa3xx_nand_probe,
|
|
|
|
.remove = pxa3xx_nand_remove,
|
|
|
|
.suspend = pxa3xx_nand_suspend,
|
|
|
|
.resume = pxa3xx_nand_resume,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init pxa3xx_nand_init(void)
|
|
|
|
{
|
|
|
|
return platform_driver_register(&pxa3xx_nand_driver);
|
|
|
|
}
|
|
|
|
module_init(pxa3xx_nand_init);
|
|
|
|
|
|
|
|
static void __exit pxa3xx_nand_exit(void)
|
|
|
|
{
|
|
|
|
platform_driver_unregister(&pxa3xx_nand_driver);
|
|
|
|
}
|
|
|
|
module_exit(pxa3xx_nand_exit);
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DESCRIPTION("PXA3xx NAND controller driver");
|