mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-12-05 02:51:00 +00:00
6c0e59fcd9
The most of drivers are using '_' instead of '-' in driver name. That's why sync up these names to be aligned. It looks quite bad to see both in use. It is visible via dm tree command. Signed-off-by: Michal Simek <michal.simek@xilinx.com> Reviewed-by: Simon Glass <sjg@chromium.org>
1325 lines
35 KiB
C
1325 lines
35 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Arasan NAND Flash Controller Driver
|
|
*
|
|
* Copyright (C) 2014 - 2015 Xilinx, Inc.
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <malloc.h>
|
|
#include <asm/io.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/mtd/mtd.h>
|
|
#include <linux/mtd/rawnand.h>
|
|
#include <linux/mtd/partitions.h>
|
|
#include <linux/mtd/nand_ecc.h>
|
|
#include <asm/arch/hardware.h>
|
|
#include <asm/arch/sys_proto.h>
|
|
#include <dm.h>
|
|
#include <nand.h>
|
|
|
|
struct nand_config {
|
|
u32 page;
|
|
bool on_die_ecc_enabled;
|
|
};
|
|
|
|
struct nand_drv {
|
|
struct nand_regs *reg;
|
|
struct nand_config config;
|
|
};
|
|
|
|
struct arasan_nand_info {
|
|
struct udevice *dev;
|
|
struct nand_drv nand_ctrl;
|
|
struct nand_chip nand_chip;
|
|
};
|
|
|
|
struct nand_regs {
|
|
u32 pkt_reg;
|
|
u32 memadr_reg1;
|
|
u32 memadr_reg2;
|
|
u32 cmd_reg;
|
|
u32 pgm_reg;
|
|
u32 intsts_enr;
|
|
u32 intsig_enr;
|
|
u32 intsts_reg;
|
|
u32 rdy_busy;
|
|
u32 cms_sysadr_reg;
|
|
u32 flash_sts_reg;
|
|
u32 tmg_reg;
|
|
u32 buf_dataport;
|
|
u32 ecc_reg;
|
|
u32 ecc_errcnt_reg;
|
|
u32 ecc_sprcmd_reg;
|
|
u32 errcnt_1bitreg;
|
|
u32 errcnt_2bitreg;
|
|
u32 errcnt_3bitreg;
|
|
u32 errcnt_4bitreg;
|
|
u32 dma_sysadr0_reg;
|
|
u32 dma_bufbdry_reg;
|
|
u32 cpu_rls_reg;
|
|
u32 errcnt_5bitreg;
|
|
u32 errcnt_6bitreg;
|
|
u32 errcnt_7bitreg;
|
|
u32 errcnt_8bitreg;
|
|
u32 data_if_reg;
|
|
};
|
|
|
|
struct arasan_nand_command_format {
|
|
u8 cmd1;
|
|
u8 cmd2;
|
|
u8 addr_cycles;
|
|
u32 pgm;
|
|
};
|
|
|
|
#define ONDIE_ECC_FEATURE_ADDR 0x90
|
|
#define ENABLE_ONDIE_ECC 0x08
|
|
|
|
#define ARASAN_PROG_RD_MASK 0x00000001
|
|
#define ARASAN_PROG_BLK_ERS_MASK 0x00000004
|
|
#define ARASAN_PROG_RD_ID_MASK 0x00000040
|
|
#define ARASAN_PROG_RD_STS_MASK 0x00000008
|
|
#define ARASAN_PROG_PG_PROG_MASK 0x00000010
|
|
#define ARASAN_PROG_RD_PARAM_PG_MASK 0x00000080
|
|
#define ARASAN_PROG_RST_MASK 0x00000100
|
|
#define ARASAN_PROG_GET_FTRS_MASK 0x00000200
|
|
#define ARASAN_PROG_SET_FTRS_MASK 0x00000400
|
|
#define ARASAN_PROG_CHNG_ROWADR_END_MASK 0x00400000
|
|
|
|
#define ARASAN_NAND_CMD_ECC_ON_MASK 0x80000000
|
|
#define ARASAN_NAND_CMD_CMD12_MASK 0xFFFF
|
|
#define ARASAN_NAND_CMD_PG_SIZE_MASK 0x3800000
|
|
#define ARASAN_NAND_CMD_PG_SIZE_SHIFT 23
|
|
#define ARASAN_NAND_CMD_CMD2_SHIFT 8
|
|
#define ARASAN_NAND_CMD_ADDR_CYCL_MASK 0x70000000
|
|
#define ARASAN_NAND_CMD_ADDR_CYCL_SHIFT 28
|
|
|
|
#define ARASAN_NAND_MEM_ADDR1_PAGE_MASK 0xFFFF0000
|
|
#define ARASAN_NAND_MEM_ADDR1_COL_MASK 0xFFFF
|
|
#define ARASAN_NAND_MEM_ADDR1_PAGE_SHIFT 16
|
|
#define ARASAN_NAND_MEM_ADDR2_PAGE_MASK 0xFF
|
|
#define ARASAN_NAND_MEM_ADDR2_CS_MASK 0xC0000000
|
|
#define ARASAN_NAND_MEM_ADDR2_CS0_MASK (0x3 << 30)
|
|
#define ARASAN_NAND_MEM_ADDR2_CS1_MASK (0x1 << 30)
|
|
#define ARASAN_NAND_MEM_ADDR2_BCH_MASK 0xE000000
|
|
#define ARASAN_NAND_MEM_ADDR2_BCH_SHIFT 25
|
|
|
|
#define ARASAN_NAND_INT_STS_ERR_EN_MASK 0x10
|
|
#define ARASAN_NAND_INT_STS_MUL_BIT_ERR_MASK 0x08
|
|
#define ARASAN_NAND_INT_STS_BUF_RD_RDY_MASK 0x02
|
|
#define ARASAN_NAND_INT_STS_BUF_WR_RDY_MASK 0x01
|
|
#define ARASAN_NAND_INT_STS_XFR_CMPLT_MASK 0x04
|
|
|
|
#define ARASAN_NAND_PKT_REG_PKT_CNT_MASK 0xFFF000
|
|
#define ARASAN_NAND_PKT_REG_PKT_SIZE_MASK 0x7FF
|
|
#define ARASAN_NAND_PKT_REG_PKT_CNT_SHFT 12
|
|
|
|
#define ARASAN_NAND_ROW_ADDR_CYCL_MASK 0x0F
|
|
#define ARASAN_NAND_COL_ADDR_CYCL_MASK 0xF0
|
|
#define ARASAN_NAND_COL_ADDR_CYCL_SHIFT 4
|
|
|
|
#define ARASAN_NAND_ECC_SIZE_SHIFT 16
|
|
#define ARASAN_NAND_ECC_BCH_SHIFT 27
|
|
|
|
#define ARASAN_NAND_PKTSIZE_1K 1024
|
|
#define ARASAN_NAND_PKTSIZE_512 512
|
|
|
|
#define ARASAN_NAND_POLL_TIMEOUT 1000000
|
|
#define ARASAN_NAND_INVALID_ADDR_CYCL 0xFF
|
|
|
|
#define ERR_ADDR_CYCLE -1
|
|
#define READ_BUFF_SIZE 0x4000
|
|
|
|
static struct arasan_nand_command_format *curr_cmd;
|
|
|
|
enum addr_cycles {
|
|
NAND_ADDR_CYCL_NONE,
|
|
NAND_ADDR_CYCL_ONE,
|
|
NAND_ADDR_CYCL_ROW,
|
|
NAND_ADDR_CYCL_COL,
|
|
NAND_ADDR_CYCL_BOTH,
|
|
};
|
|
|
|
static struct arasan_nand_command_format arasan_nand_commands[] = {
|
|
{NAND_CMD_READ0, NAND_CMD_READSTART, NAND_ADDR_CYCL_BOTH,
|
|
ARASAN_PROG_RD_MASK},
|
|
{NAND_CMD_RNDOUT, NAND_CMD_RNDOUTSTART, NAND_ADDR_CYCL_COL,
|
|
ARASAN_PROG_RD_MASK},
|
|
{NAND_CMD_READID, NAND_CMD_NONE, NAND_ADDR_CYCL_ONE,
|
|
ARASAN_PROG_RD_ID_MASK},
|
|
{NAND_CMD_STATUS, NAND_CMD_NONE, NAND_ADDR_CYCL_NONE,
|
|
ARASAN_PROG_RD_STS_MASK},
|
|
{NAND_CMD_SEQIN, NAND_CMD_PAGEPROG, NAND_ADDR_CYCL_BOTH,
|
|
ARASAN_PROG_PG_PROG_MASK},
|
|
{NAND_CMD_RNDIN, NAND_CMD_NONE, NAND_ADDR_CYCL_COL,
|
|
ARASAN_PROG_CHNG_ROWADR_END_MASK},
|
|
{NAND_CMD_ERASE1, NAND_CMD_ERASE2, NAND_ADDR_CYCL_ROW,
|
|
ARASAN_PROG_BLK_ERS_MASK},
|
|
{NAND_CMD_RESET, NAND_CMD_NONE, NAND_ADDR_CYCL_NONE,
|
|
ARASAN_PROG_RST_MASK},
|
|
{NAND_CMD_PARAM, NAND_CMD_NONE, NAND_ADDR_CYCL_ONE,
|
|
ARASAN_PROG_RD_PARAM_PG_MASK},
|
|
{NAND_CMD_GET_FEATURES, NAND_CMD_NONE, NAND_ADDR_CYCL_ONE,
|
|
ARASAN_PROG_GET_FTRS_MASK},
|
|
{NAND_CMD_SET_FEATURES, NAND_CMD_NONE, NAND_ADDR_CYCL_ONE,
|
|
ARASAN_PROG_SET_FTRS_MASK},
|
|
{NAND_CMD_NONE, NAND_CMD_NONE, NAND_ADDR_CYCL_NONE, 0},
|
|
};
|
|
|
|
struct arasan_ecc_matrix {
|
|
u32 pagesize;
|
|
u32 ecc_codeword_size;
|
|
u8 eccbits;
|
|
u8 bch;
|
|
u8 bchval;
|
|
u16 eccaddr;
|
|
u16 eccsize;
|
|
};
|
|
|
|
static const struct arasan_ecc_matrix ecc_matrix[] = {
|
|
{512, 512, 1, 0, 0, 0x20D, 0x3},
|
|
{512, 512, 4, 1, 3, 0x209, 0x7},
|
|
{512, 512, 8, 1, 2, 0x203, 0xD},
|
|
/*
|
|
* 2K byte page
|
|
*/
|
|
{2048, 512, 1, 0, 0, 0x834, 0xC},
|
|
{2048, 512, 4, 1, 3, 0x826, 0x1A},
|
|
{2048, 512, 8, 1, 2, 0x80c, 0x34},
|
|
{2048, 512, 12, 1, 1, 0x822, 0x4E},
|
|
{2048, 512, 16, 1, 0, 0x808, 0x68},
|
|
{2048, 1024, 24, 1, 4, 0x81c, 0x54},
|
|
/*
|
|
* 4K byte page
|
|
*/
|
|
{4096, 512, 1, 0, 0, 0x1068, 0x18},
|
|
{4096, 512, 4, 1, 3, 0x104c, 0x34},
|
|
{4096, 512, 8, 1, 2, 0x1018, 0x68},
|
|
{4096, 512, 12, 1, 1, 0x1044, 0x9C},
|
|
{4096, 512, 16, 1, 0, 0x1010, 0xD0},
|
|
{4096, 1024, 24, 1, 4, 0x1038, 0xA8},
|
|
/*
|
|
* 8K byte page
|
|
*/
|
|
{8192, 512, 1, 0, 0, 0x20d0, 0x30},
|
|
{8192, 512, 4, 1, 3, 0x2098, 0x68},
|
|
{8192, 512, 8, 1, 2, 0x2030, 0xD0},
|
|
{8192, 512, 12, 1, 1, 0x2088, 0x138},
|
|
{8192, 512, 16, 1, 0, 0x2020, 0x1A0},
|
|
{8192, 1024, 24, 1, 4, 0x2070, 0x150},
|
|
/*
|
|
* 16K byte page
|
|
*/
|
|
{16384, 512, 1, 0, 0, 0x4460, 0x60},
|
|
{16384, 512, 4, 1, 3, 0x43f0, 0xD0},
|
|
{16384, 512, 8, 1, 2, 0x4320, 0x1A0},
|
|
{16384, 512, 12, 1, 1, 0x4250, 0x270},
|
|
{16384, 512, 16, 1, 0, 0x4180, 0x340},
|
|
{16384, 1024, 24, 1, 4, 0x4220, 0x2A0}
|
|
};
|
|
|
|
static struct nand_ecclayout ondie_nand_oob_64 = {
|
|
.eccbytes = 32,
|
|
|
|
.eccpos = {
|
|
8, 9, 10, 11, 12, 13, 14, 15,
|
|
24, 25, 26, 27, 28, 29, 30, 31,
|
|
40, 41, 42, 43, 44, 45, 46, 47,
|
|
56, 57, 58, 59, 60, 61, 62, 63
|
|
},
|
|
|
|
.oobfree = {
|
|
{ .offset = 4, .length = 4 },
|
|
{ .offset = 20, .length = 4 },
|
|
{ .offset = 36, .length = 4 },
|
|
{ .offset = 52, .length = 4 }
|
|
}
|
|
};
|
|
|
|
/*
|
|
* bbt decriptors for chips with on-die ECC and
|
|
* chips with 64-byte OOB
|
|
*/
|
|
static u8 bbt_pattern[] = {'B', 'b', 't', '0' };
|
|
static u8 mirror_pattern[] = {'1', 't', 'b', 'B' };
|
|
|
|
static struct nand_bbt_descr bbt_main_descr = {
|
|
.options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE |
|
|
NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
|
|
.offs = 4,
|
|
.len = 4,
|
|
.veroffs = 20,
|
|
.maxblocks = 4,
|
|
.pattern = bbt_pattern
|
|
};
|
|
|
|
static struct nand_bbt_descr bbt_mirror_descr = {
|
|
.options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE |
|
|
NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
|
|
.offs = 4,
|
|
.len = 4,
|
|
.veroffs = 20,
|
|
.maxblocks = 4,
|
|
.pattern = mirror_pattern
|
|
};
|
|
|
|
static u8 buf_data[READ_BUFF_SIZE];
|
|
static u32 buf_index;
|
|
|
|
static struct nand_ecclayout nand_oob;
|
|
|
|
static void arasan_nand_select_chip(struct mtd_info *mtd, int chip)
|
|
{
|
|
struct nand_chip *nand_chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(nand_chip);
|
|
u32 reg_val;
|
|
|
|
reg_val = readl(&info->reg->memadr_reg2);
|
|
if (chip == 0) {
|
|
reg_val &= ~ARASAN_NAND_MEM_ADDR2_CS0_MASK;
|
|
writel(reg_val, &info->reg->memadr_reg2);
|
|
} else if (chip == 1) {
|
|
reg_val |= ARASAN_NAND_MEM_ADDR2_CS1_MASK;
|
|
writel(reg_val, &info->reg->memadr_reg2);
|
|
}
|
|
}
|
|
|
|
static void arasan_nand_enable_ecc(struct mtd_info *mtd)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
u32 reg_val;
|
|
|
|
reg_val = readl(&info->reg->cmd_reg);
|
|
reg_val |= ARASAN_NAND_CMD_ECC_ON_MASK;
|
|
|
|
writel(reg_val, &info->reg->cmd_reg);
|
|
}
|
|
|
|
static u8 arasan_nand_get_addrcycle(struct mtd_info *mtd)
|
|
{
|
|
u8 addrcycles;
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
|
|
switch (curr_cmd->addr_cycles) {
|
|
case NAND_ADDR_CYCL_NONE:
|
|
addrcycles = 0;
|
|
break;
|
|
case NAND_ADDR_CYCL_ONE:
|
|
addrcycles = 1;
|
|
break;
|
|
case NAND_ADDR_CYCL_ROW:
|
|
addrcycles = chip->onfi_params.addr_cycles &
|
|
ARASAN_NAND_ROW_ADDR_CYCL_MASK;
|
|
break;
|
|
case NAND_ADDR_CYCL_COL:
|
|
addrcycles = (chip->onfi_params.addr_cycles &
|
|
ARASAN_NAND_COL_ADDR_CYCL_MASK) >>
|
|
ARASAN_NAND_COL_ADDR_CYCL_SHIFT;
|
|
break;
|
|
case NAND_ADDR_CYCL_BOTH:
|
|
addrcycles = chip->onfi_params.addr_cycles &
|
|
ARASAN_NAND_ROW_ADDR_CYCL_MASK;
|
|
addrcycles += (chip->onfi_params.addr_cycles &
|
|
ARASAN_NAND_COL_ADDR_CYCL_MASK) >>
|
|
ARASAN_NAND_COL_ADDR_CYCL_SHIFT;
|
|
break;
|
|
default:
|
|
addrcycles = ARASAN_NAND_INVALID_ADDR_CYCL;
|
|
break;
|
|
}
|
|
return addrcycles;
|
|
}
|
|
|
|
static int arasan_nand_read_page(struct mtd_info *mtd, u8 *buf, u32 size)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
struct nand_config *nand = &info->config;
|
|
u32 reg_val, i, pktsize, pktnum;
|
|
u32 *bufptr = (u32 *)buf;
|
|
u32 timeout;
|
|
u32 rdcount = 0;
|
|
u8 addr_cycles;
|
|
|
|
if (chip->ecc_step_ds >= ARASAN_NAND_PKTSIZE_1K)
|
|
pktsize = ARASAN_NAND_PKTSIZE_1K;
|
|
else
|
|
pktsize = ARASAN_NAND_PKTSIZE_512;
|
|
|
|
if (size % pktsize)
|
|
pktnum = size/pktsize + 1;
|
|
else
|
|
pktnum = size/pktsize;
|
|
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
reg_val |= ARASAN_NAND_INT_STS_ERR_EN_MASK |
|
|
ARASAN_NAND_INT_STS_MUL_BIT_ERR_MASK;
|
|
writel(reg_val, &info->reg->intsts_enr);
|
|
|
|
reg_val = readl(&info->reg->pkt_reg);
|
|
reg_val &= ~(ARASAN_NAND_PKT_REG_PKT_CNT_MASK |
|
|
ARASAN_NAND_PKT_REG_PKT_SIZE_MASK);
|
|
reg_val |= (pktnum << ARASAN_NAND_PKT_REG_PKT_CNT_SHFT) |
|
|
pktsize;
|
|
writel(reg_val, &info->reg->pkt_reg);
|
|
|
|
if (!nand->on_die_ecc_enabled) {
|
|
arasan_nand_enable_ecc(mtd);
|
|
addr_cycles = arasan_nand_get_addrcycle(mtd);
|
|
if (addr_cycles == ARASAN_NAND_INVALID_ADDR_CYCL)
|
|
return ERR_ADDR_CYCLE;
|
|
|
|
writel((NAND_CMD_RNDOUTSTART << ARASAN_NAND_CMD_CMD2_SHIFT) |
|
|
NAND_CMD_RNDOUT | (addr_cycles <<
|
|
ARASAN_NAND_CMD_ADDR_CYCL_SHIFT),
|
|
&info->reg->ecc_sprcmd_reg);
|
|
}
|
|
writel(curr_cmd->pgm, &info->reg->pgm_reg);
|
|
|
|
while (rdcount < pktnum) {
|
|
timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
while (!(readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_BUF_RD_RDY_MASK) && timeout) {
|
|
udelay(1);
|
|
timeout--;
|
|
}
|
|
if (!timeout) {
|
|
puts("arasan_read_page: timedout:Buff RDY\n");
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
rdcount++;
|
|
|
|
if (pktnum == rdcount) {
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
reg_val |= ARASAN_NAND_INT_STS_XFR_CMPLT_MASK;
|
|
writel(reg_val, &info->reg->intsts_enr);
|
|
} else {
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_BUF_RD_RDY_MASK,
|
|
&info->reg->intsts_enr);
|
|
}
|
|
reg_val = readl(&info->reg->intsts_reg);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_BUF_RD_RDY_MASK,
|
|
&info->reg->intsts_reg);
|
|
|
|
for (i = 0; i < pktsize/4; i++)
|
|
bufptr[i] = readl(&info->reg->buf_dataport);
|
|
|
|
|
|
bufptr += pktsize/4;
|
|
|
|
if (rdcount >= pktnum)
|
|
break;
|
|
|
|
writel(ARASAN_NAND_INT_STS_BUF_RD_RDY_MASK,
|
|
&info->reg->intsts_enr);
|
|
}
|
|
|
|
timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
|
|
while (!(readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_XFR_CMPLT_MASK) && timeout) {
|
|
udelay(1);
|
|
timeout--;
|
|
}
|
|
if (!timeout) {
|
|
puts("arasan rd_page timedout:Xfer CMPLT\n");
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_enr);
|
|
reg_val = readl(&info->reg->intsts_reg);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_reg);
|
|
|
|
if (!nand->on_die_ecc_enabled) {
|
|
if (readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_MUL_BIT_ERR_MASK) {
|
|
printf("arasan rd_page:sbiterror\n");
|
|
return -1;
|
|
}
|
|
|
|
if (readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_ERR_EN_MASK) {
|
|
mtd->ecc_stats.failed++;
|
|
printf("arasan rd_page:multibiterror\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int arasan_nand_read_page_hwecc(struct mtd_info *mtd,
|
|
struct nand_chip *chip, u8 *buf, int oob_required, int page)
|
|
{
|
|
int status;
|
|
|
|
status = arasan_nand_read_page(mtd, buf, (mtd->writesize));
|
|
|
|
if (oob_required)
|
|
chip->ecc.read_oob(mtd, chip, page);
|
|
|
|
return status;
|
|
}
|
|
|
|
static void arasan_nand_fill_tx(struct mtd_info *mtd, const u8 *buf, int len)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
u32 __iomem *nand = &info->reg->buf_dataport;
|
|
|
|
if (((unsigned long)buf & 0x3) != 0) {
|
|
if (((unsigned long)buf & 0x1) != 0) {
|
|
if (len) {
|
|
writeb(*buf, nand);
|
|
buf += 1;
|
|
len--;
|
|
}
|
|
}
|
|
|
|
if (((unsigned long)buf & 0x3) != 0) {
|
|
if (len >= 2) {
|
|
writew(*(u16 *)buf, nand);
|
|
buf += 2;
|
|
len -= 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
while (len >= 4) {
|
|
writel(*(u32 *)buf, nand);
|
|
buf += 4;
|
|
len -= 4;
|
|
}
|
|
|
|
if (len) {
|
|
if (len >= 2) {
|
|
writew(*(u16 *)buf, nand);
|
|
buf += 2;
|
|
len -= 2;
|
|
}
|
|
|
|
if (len)
|
|
writeb(*buf, nand);
|
|
}
|
|
}
|
|
|
|
static int arasan_nand_write_page_hwecc(struct mtd_info *mtd,
|
|
struct nand_chip *chip, const u8 *buf, int oob_required,
|
|
int page)
|
|
{
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
struct nand_config *nand = &info->config;
|
|
u32 reg_val, i, pktsize, pktnum;
|
|
const u32 *bufptr = (const u32 *)buf;
|
|
u32 timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
u32 size = mtd->writesize;
|
|
u32 rdcount = 0;
|
|
u8 column_addr_cycles;
|
|
|
|
if (chip->ecc_step_ds >= ARASAN_NAND_PKTSIZE_1K)
|
|
pktsize = ARASAN_NAND_PKTSIZE_1K;
|
|
else
|
|
pktsize = ARASAN_NAND_PKTSIZE_512;
|
|
|
|
if (size % pktsize)
|
|
pktnum = size/pktsize + 1;
|
|
else
|
|
pktnum = size/pktsize;
|
|
|
|
reg_val = readl(&info->reg->pkt_reg);
|
|
reg_val &= ~(ARASAN_NAND_PKT_REG_PKT_CNT_MASK |
|
|
ARASAN_NAND_PKT_REG_PKT_SIZE_MASK);
|
|
reg_val |= (pktnum << ARASAN_NAND_PKT_REG_PKT_CNT_SHFT) | pktsize;
|
|
writel(reg_val, &info->reg->pkt_reg);
|
|
|
|
if (!nand->on_die_ecc_enabled) {
|
|
arasan_nand_enable_ecc(mtd);
|
|
column_addr_cycles = (chip->onfi_params.addr_cycles &
|
|
ARASAN_NAND_COL_ADDR_CYCL_MASK) >>
|
|
ARASAN_NAND_COL_ADDR_CYCL_SHIFT;
|
|
writel((NAND_CMD_RNDIN | (column_addr_cycles << 28)),
|
|
&info->reg->ecc_sprcmd_reg);
|
|
}
|
|
writel(curr_cmd->pgm, &info->reg->pgm_reg);
|
|
|
|
while (rdcount < pktnum) {
|
|
timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
while (!(readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_BUF_WR_RDY_MASK) && timeout) {
|
|
udelay(1);
|
|
timeout--;
|
|
}
|
|
|
|
if (!timeout) {
|
|
puts("arasan_write_page: timedout:Buff RDY\n");
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
rdcount++;
|
|
|
|
if (pktnum == rdcount) {
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
reg_val |= ARASAN_NAND_INT_STS_XFR_CMPLT_MASK;
|
|
writel(reg_val, &info->reg->intsts_enr);
|
|
} else {
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_BUF_WR_RDY_MASK,
|
|
&info->reg->intsts_enr);
|
|
}
|
|
|
|
reg_val = readl(&info->reg->intsts_reg);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_BUF_WR_RDY_MASK,
|
|
&info->reg->intsts_reg);
|
|
|
|
for (i = 0; i < pktsize/4; i++)
|
|
writel(bufptr[i], &info->reg->buf_dataport);
|
|
|
|
bufptr += pktsize/4;
|
|
|
|
if (rdcount >= pktnum)
|
|
break;
|
|
|
|
writel(ARASAN_NAND_INT_STS_BUF_WR_RDY_MASK,
|
|
&info->reg->intsts_enr);
|
|
}
|
|
|
|
timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
|
|
while (!(readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_XFR_CMPLT_MASK) && timeout) {
|
|
udelay(1);
|
|
timeout--;
|
|
}
|
|
if (!timeout) {
|
|
puts("arasan write_page timedout:Xfer CMPLT\n");
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_enr);
|
|
reg_val = readl(&info->reg->intsts_reg);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_reg);
|
|
|
|
if (oob_required)
|
|
chip->ecc.write_oob(mtd, chip, nand->page);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int arasan_nand_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
|
|
int page)
|
|
{
|
|
chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
|
|
chip->read_buf(mtd, chip->oob_poi, (mtd->oobsize));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int arasan_nand_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
|
|
int page)
|
|
{
|
|
int status = 0;
|
|
const u8 *buf = chip->oob_poi;
|
|
|
|
chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page);
|
|
chip->write_buf(mtd, buf, mtd->oobsize);
|
|
|
|
return status;
|
|
}
|
|
|
|
static int arasan_nand_reset(struct mtd_info *mtd,
|
|
struct arasan_nand_command_format *curr_cmd)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
u32 timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
u32 cmd_reg = 0;
|
|
|
|
writel(ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_enr);
|
|
cmd_reg = readl(&info->reg->cmd_reg);
|
|
cmd_reg &= ~ARASAN_NAND_CMD_CMD12_MASK;
|
|
|
|
cmd_reg |= curr_cmd->cmd1 |
|
|
(curr_cmd->cmd2 << ARASAN_NAND_CMD_CMD2_SHIFT);
|
|
writel(cmd_reg, &info->reg->cmd_reg);
|
|
writel(curr_cmd->pgm, &info->reg->pgm_reg);
|
|
|
|
while (!(readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_XFR_CMPLT_MASK) && timeout) {
|
|
udelay(1);
|
|
timeout--;
|
|
}
|
|
if (!timeout) {
|
|
printf("ERROR:%s timedout\n", __func__);
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
writel(ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_enr);
|
|
|
|
writel(ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_reg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static u8 arasan_nand_page(struct mtd_info *mtd)
|
|
{
|
|
u8 page_val = 0;
|
|
|
|
switch (mtd->writesize) {
|
|
case 512:
|
|
page_val = 0;
|
|
break;
|
|
case 2048:
|
|
page_val = 1;
|
|
break;
|
|
case 4096:
|
|
page_val = 2;
|
|
break;
|
|
case 8192:
|
|
page_val = 3;
|
|
break;
|
|
case 16384:
|
|
page_val = 4;
|
|
break;
|
|
case 1024:
|
|
page_val = 5;
|
|
break;
|
|
default:
|
|
printf("%s:Pagesize>16K\n", __func__);
|
|
break;
|
|
}
|
|
|
|
return page_val;
|
|
}
|
|
|
|
static int arasan_nand_send_wrcmd(struct arasan_nand_command_format *curr_cmd,
|
|
int column, int page_addr, struct mtd_info *mtd)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
u32 reg_val, page;
|
|
u8 page_val, addr_cycles;
|
|
|
|
writel(ARASAN_NAND_INT_STS_BUF_WR_RDY_MASK,
|
|
&info->reg->intsts_enr);
|
|
reg_val = readl(&info->reg->cmd_reg);
|
|
reg_val &= ~ARASAN_NAND_CMD_CMD12_MASK;
|
|
reg_val |= curr_cmd->cmd1 |
|
|
(curr_cmd->cmd2 << ARASAN_NAND_CMD_CMD2_SHIFT);
|
|
if (curr_cmd->cmd1 == NAND_CMD_SEQIN) {
|
|
reg_val &= ~ARASAN_NAND_CMD_PG_SIZE_MASK;
|
|
page_val = arasan_nand_page(mtd);
|
|
reg_val |= (page_val << ARASAN_NAND_CMD_PG_SIZE_SHIFT);
|
|
}
|
|
|
|
reg_val &= ~ARASAN_NAND_CMD_ADDR_CYCL_MASK;
|
|
addr_cycles = arasan_nand_get_addrcycle(mtd);
|
|
|
|
if (addr_cycles == ARASAN_NAND_INVALID_ADDR_CYCL)
|
|
return ERR_ADDR_CYCLE;
|
|
|
|
reg_val |= (addr_cycles <<
|
|
ARASAN_NAND_CMD_ADDR_CYCL_SHIFT);
|
|
writel(reg_val, &info->reg->cmd_reg);
|
|
|
|
if (page_addr == -1)
|
|
page_addr = 0;
|
|
|
|
page = (page_addr << ARASAN_NAND_MEM_ADDR1_PAGE_SHIFT) &
|
|
ARASAN_NAND_MEM_ADDR1_PAGE_MASK;
|
|
column &= ARASAN_NAND_MEM_ADDR1_COL_MASK;
|
|
writel(page | column, &info->reg->memadr_reg1);
|
|
|
|
reg_val = readl(&info->reg->memadr_reg2);
|
|
reg_val &= ~ARASAN_NAND_MEM_ADDR2_PAGE_MASK;
|
|
reg_val |= (page_addr >> ARASAN_NAND_MEM_ADDR1_PAGE_SHIFT);
|
|
writel(reg_val, &info->reg->memadr_reg2);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void arasan_nand_write_buf(struct mtd_info *mtd, const u8 *buf, int len)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
u32 reg_val;
|
|
u32 timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
|
|
reg_val = readl(&info->reg->pkt_reg);
|
|
reg_val &= ~(ARASAN_NAND_PKT_REG_PKT_CNT_MASK |
|
|
ARASAN_NAND_PKT_REG_PKT_SIZE_MASK);
|
|
|
|
reg_val |= (1 << ARASAN_NAND_PKT_REG_PKT_CNT_SHFT) | len;
|
|
writel(reg_val, &info->reg->pkt_reg);
|
|
writel(curr_cmd->pgm, &info->reg->pgm_reg);
|
|
|
|
while (!(readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_BUF_WR_RDY_MASK) && timeout) {
|
|
udelay(1);
|
|
timeout--;
|
|
}
|
|
|
|
if (!timeout)
|
|
puts("ERROR:arasan_nand_write_buf timedout:Buff RDY\n");
|
|
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
reg_val |= ARASAN_NAND_INT_STS_XFR_CMPLT_MASK;
|
|
writel(reg_val, &info->reg->intsts_enr);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_BUF_WR_RDY_MASK,
|
|
&info->reg->intsts_enr);
|
|
reg_val = readl(&info->reg->intsts_reg);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_BUF_WR_RDY_MASK,
|
|
&info->reg->intsts_reg);
|
|
|
|
arasan_nand_fill_tx(mtd, buf, len);
|
|
|
|
timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
while (!(readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_XFR_CMPLT_MASK) && timeout) {
|
|
udelay(1);
|
|
timeout--;
|
|
}
|
|
if (!timeout)
|
|
puts("ERROR:arasan_nand_write_buf timedout:Xfer CMPLT\n");
|
|
|
|
writel(readl(&info->reg->intsts_enr) |
|
|
ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_enr);
|
|
writel(readl(&info->reg->intsts_reg) |
|
|
ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_reg);
|
|
}
|
|
|
|
static int arasan_nand_erase(struct arasan_nand_command_format *curr_cmd,
|
|
int column, int page_addr, struct mtd_info *mtd)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
u32 reg_val, page;
|
|
u32 timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
u8 row_addr_cycles;
|
|
|
|
writel(ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_enr);
|
|
reg_val = readl(&info->reg->cmd_reg);
|
|
reg_val &= ~ARASAN_NAND_CMD_CMD12_MASK;
|
|
reg_val |= curr_cmd->cmd1 |
|
|
(curr_cmd->cmd2 << ARASAN_NAND_CMD_CMD2_SHIFT);
|
|
row_addr_cycles = arasan_nand_get_addrcycle(mtd);
|
|
|
|
if (row_addr_cycles == ARASAN_NAND_INVALID_ADDR_CYCL)
|
|
return ERR_ADDR_CYCLE;
|
|
|
|
reg_val &= ~ARASAN_NAND_CMD_ADDR_CYCL_MASK;
|
|
reg_val |= (row_addr_cycles <<
|
|
ARASAN_NAND_CMD_ADDR_CYCL_SHIFT);
|
|
|
|
writel(reg_val, &info->reg->cmd_reg);
|
|
|
|
page = (page_addr >> ARASAN_NAND_MEM_ADDR1_PAGE_SHIFT) &
|
|
ARASAN_NAND_MEM_ADDR1_COL_MASK;
|
|
column = page_addr & ARASAN_NAND_MEM_ADDR1_COL_MASK;
|
|
writel(column | (page << ARASAN_NAND_MEM_ADDR1_PAGE_SHIFT),
|
|
&info->reg->memadr_reg1);
|
|
|
|
reg_val = readl(&info->reg->memadr_reg2);
|
|
reg_val &= ~ARASAN_NAND_MEM_ADDR2_PAGE_MASK;
|
|
reg_val |= (page_addr >> ARASAN_NAND_MEM_ADDR1_PAGE_SHIFT);
|
|
writel(reg_val, &info->reg->memadr_reg2);
|
|
writel(curr_cmd->pgm, &info->reg->pgm_reg);
|
|
|
|
while (!(readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_XFR_CMPLT_MASK) && timeout) {
|
|
udelay(1);
|
|
timeout--;
|
|
}
|
|
if (!timeout) {
|
|
printf("ERROR:%s timedout:Xfer CMPLT\n", __func__);
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_enr);
|
|
reg_val = readl(&info->reg->intsts_reg);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_reg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int arasan_nand_read_status(struct arasan_nand_command_format *curr_cmd,
|
|
int column, int page_addr, struct mtd_info *mtd)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
u32 reg_val;
|
|
u32 timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
u8 addr_cycles;
|
|
|
|
writel(ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_enr);
|
|
reg_val = readl(&info->reg->cmd_reg);
|
|
reg_val &= ~ARASAN_NAND_CMD_CMD12_MASK;
|
|
reg_val |= curr_cmd->cmd1 |
|
|
(curr_cmd->cmd2 << ARASAN_NAND_CMD_CMD2_SHIFT);
|
|
addr_cycles = arasan_nand_get_addrcycle(mtd);
|
|
|
|
if (addr_cycles == ARASAN_NAND_INVALID_ADDR_CYCL)
|
|
return ERR_ADDR_CYCLE;
|
|
|
|
reg_val &= ~ARASAN_NAND_CMD_ADDR_CYCL_MASK;
|
|
reg_val |= (addr_cycles <<
|
|
ARASAN_NAND_CMD_ADDR_CYCL_SHIFT);
|
|
|
|
writel(reg_val, &info->reg->cmd_reg);
|
|
|
|
reg_val = readl(&info->reg->pkt_reg);
|
|
reg_val &= ~(ARASAN_NAND_PKT_REG_PKT_CNT_MASK |
|
|
ARASAN_NAND_PKT_REG_PKT_SIZE_MASK);
|
|
reg_val |= (1 << ARASAN_NAND_PKT_REG_PKT_CNT_SHFT) | 1;
|
|
writel(reg_val, &info->reg->pkt_reg);
|
|
|
|
writel(curr_cmd->pgm, &info->reg->pgm_reg);
|
|
while (!(readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_XFR_CMPLT_MASK) && timeout) {
|
|
udelay(1);
|
|
timeout--;
|
|
}
|
|
|
|
if (!timeout) {
|
|
printf("ERROR:%s: timedout:Xfer CMPLT\n", __func__);
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_enr);
|
|
reg_val = readl(&info->reg->intsts_reg);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_reg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int arasan_nand_send_rdcmd(struct arasan_nand_command_format *curr_cmd,
|
|
int column, int page_addr, struct mtd_info *mtd)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
u32 reg_val, addr_cycles, page;
|
|
u8 page_val;
|
|
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_BUF_RD_RDY_MASK,
|
|
&info->reg->intsts_enr);
|
|
|
|
reg_val = readl(&info->reg->cmd_reg);
|
|
reg_val &= ~ARASAN_NAND_CMD_CMD12_MASK;
|
|
reg_val |= curr_cmd->cmd1 |
|
|
(curr_cmd->cmd2 << ARASAN_NAND_CMD_CMD2_SHIFT);
|
|
|
|
if (curr_cmd->cmd1 == NAND_CMD_RNDOUT ||
|
|
curr_cmd->cmd1 == NAND_CMD_READ0) {
|
|
reg_val &= ~ARASAN_NAND_CMD_PG_SIZE_MASK;
|
|
page_val = arasan_nand_page(mtd);
|
|
reg_val |= (page_val << ARASAN_NAND_CMD_PG_SIZE_SHIFT);
|
|
}
|
|
|
|
reg_val &= ~ARASAN_NAND_CMD_ECC_ON_MASK;
|
|
|
|
reg_val &= ~ARASAN_NAND_CMD_ADDR_CYCL_MASK;
|
|
|
|
addr_cycles = arasan_nand_get_addrcycle(mtd);
|
|
|
|
if (addr_cycles == ARASAN_NAND_INVALID_ADDR_CYCL)
|
|
return ERR_ADDR_CYCLE;
|
|
|
|
reg_val |= (addr_cycles << 28);
|
|
writel(reg_val, &info->reg->cmd_reg);
|
|
|
|
if (page_addr == -1)
|
|
page_addr = 0;
|
|
|
|
page = (page_addr << ARASAN_NAND_MEM_ADDR1_PAGE_SHIFT) &
|
|
ARASAN_NAND_MEM_ADDR1_PAGE_MASK;
|
|
column &= ARASAN_NAND_MEM_ADDR1_COL_MASK;
|
|
writel(page | column, &info->reg->memadr_reg1);
|
|
|
|
reg_val = readl(&info->reg->memadr_reg2);
|
|
reg_val &= ~ARASAN_NAND_MEM_ADDR2_PAGE_MASK;
|
|
reg_val |= (page_addr >> ARASAN_NAND_MEM_ADDR1_PAGE_SHIFT);
|
|
writel(reg_val, &info->reg->memadr_reg2);
|
|
|
|
buf_index = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void arasan_nand_read_buf(struct mtd_info *mtd, u8 *buf, int size)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
u32 reg_val, i;
|
|
u32 *bufptr = (u32 *)buf;
|
|
u32 timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
|
|
reg_val = readl(&info->reg->pkt_reg);
|
|
reg_val &= ~(ARASAN_NAND_PKT_REG_PKT_CNT_MASK |
|
|
ARASAN_NAND_PKT_REG_PKT_SIZE_MASK);
|
|
reg_val |= (1 << ARASAN_NAND_PKT_REG_PKT_CNT_SHFT) | size;
|
|
writel(reg_val, &info->reg->pkt_reg);
|
|
|
|
writel(curr_cmd->pgm, &info->reg->pgm_reg);
|
|
|
|
while (!(readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_BUF_RD_RDY_MASK) && timeout) {
|
|
udelay(1);
|
|
timeout--;
|
|
}
|
|
|
|
if (!timeout)
|
|
puts("ERROR:arasan_nand_read_buf timedout:Buff RDY\n");
|
|
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
reg_val |= ARASAN_NAND_INT_STS_XFR_CMPLT_MASK;
|
|
writel(reg_val, &info->reg->intsts_enr);
|
|
|
|
writel(reg_val | ARASAN_NAND_INT_STS_BUF_RD_RDY_MASK,
|
|
&info->reg->intsts_enr);
|
|
reg_val = readl(&info->reg->intsts_reg);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_BUF_RD_RDY_MASK,
|
|
&info->reg->intsts_reg);
|
|
|
|
buf_index = 0;
|
|
for (i = 0; i < size / 4; i++)
|
|
bufptr[i] = readl(&info->reg->buf_dataport);
|
|
|
|
if (size & 0x03)
|
|
bufptr[i] = readl(&info->reg->buf_dataport);
|
|
|
|
timeout = ARASAN_NAND_POLL_TIMEOUT;
|
|
|
|
while (!(readl(&info->reg->intsts_reg) &
|
|
ARASAN_NAND_INT_STS_XFR_CMPLT_MASK) && timeout) {
|
|
udelay(1);
|
|
timeout--;
|
|
}
|
|
|
|
if (!timeout)
|
|
puts("ERROR:arasan_nand_read_buf timedout:Xfer CMPLT\n");
|
|
|
|
reg_val = readl(&info->reg->intsts_enr);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_enr);
|
|
reg_val = readl(&info->reg->intsts_reg);
|
|
writel(reg_val | ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_reg);
|
|
}
|
|
|
|
static u8 arasan_nand_read_byte(struct mtd_info *mtd)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
u32 size;
|
|
u8 val;
|
|
struct nand_onfi_params *p;
|
|
|
|
if (buf_index == 0) {
|
|
p = &chip->onfi_params;
|
|
if (curr_cmd->cmd1 == NAND_CMD_READID)
|
|
size = 4;
|
|
else if (curr_cmd->cmd1 == NAND_CMD_PARAM)
|
|
size = sizeof(struct nand_onfi_params);
|
|
else if (curr_cmd->cmd1 == NAND_CMD_RNDOUT)
|
|
size = le16_to_cpu(p->ext_param_page_length) * 16;
|
|
else if (curr_cmd->cmd1 == NAND_CMD_GET_FEATURES)
|
|
size = 4;
|
|
else if (curr_cmd->cmd1 == NAND_CMD_STATUS)
|
|
return readb(&info->reg->flash_sts_reg);
|
|
else
|
|
size = 8;
|
|
chip->read_buf(mtd, &buf_data[0], size);
|
|
}
|
|
|
|
val = *(&buf_data[0] + buf_index);
|
|
buf_index++;
|
|
|
|
return val;
|
|
}
|
|
|
|
static void arasan_nand_cmd_function(struct mtd_info *mtd, unsigned int command,
|
|
int column, int page_addr)
|
|
{
|
|
struct nand_chip *chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(chip);
|
|
struct nand_config *nand = &info->config;
|
|
u32 i, ret = 0;
|
|
|
|
curr_cmd = NULL;
|
|
writel(ARASAN_NAND_INT_STS_XFR_CMPLT_MASK,
|
|
&info->reg->intsts_enr);
|
|
|
|
if ((command == NAND_CMD_READOOB) &&
|
|
(mtd->writesize > 512)) {
|
|
column += mtd->writesize;
|
|
command = NAND_CMD_READ0;
|
|
}
|
|
|
|
/* Get the command format */
|
|
for (i = 0; (arasan_nand_commands[i].cmd1 != NAND_CMD_NONE ||
|
|
arasan_nand_commands[i].cmd2 != NAND_CMD_NONE); i++) {
|
|
if (command == arasan_nand_commands[i].cmd1) {
|
|
curr_cmd = &arasan_nand_commands[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (curr_cmd == NULL) {
|
|
printf("Unsupported Command; 0x%x\n", command);
|
|
return;
|
|
}
|
|
|
|
if (curr_cmd->cmd1 == NAND_CMD_RESET)
|
|
ret = arasan_nand_reset(mtd, curr_cmd);
|
|
|
|
if ((curr_cmd->cmd1 == NAND_CMD_READID) ||
|
|
(curr_cmd->cmd1 == NAND_CMD_PARAM) ||
|
|
(curr_cmd->cmd1 == NAND_CMD_RNDOUT) ||
|
|
(curr_cmd->cmd1 == NAND_CMD_GET_FEATURES) ||
|
|
(curr_cmd->cmd1 == NAND_CMD_READ0))
|
|
ret = arasan_nand_send_rdcmd(curr_cmd, column, page_addr, mtd);
|
|
|
|
if ((curr_cmd->cmd1 == NAND_CMD_SET_FEATURES) ||
|
|
(curr_cmd->cmd1 == NAND_CMD_SEQIN)) {
|
|
nand->page = page_addr;
|
|
ret = arasan_nand_send_wrcmd(curr_cmd, column, page_addr, mtd);
|
|
}
|
|
|
|
if (curr_cmd->cmd1 == NAND_CMD_ERASE1)
|
|
ret = arasan_nand_erase(curr_cmd, column, page_addr, mtd);
|
|
|
|
if (curr_cmd->cmd1 == NAND_CMD_STATUS)
|
|
ret = arasan_nand_read_status(curr_cmd, column, page_addr, mtd);
|
|
|
|
if (ret != 0)
|
|
printf("ERROR:%s:command:0x%x\n", __func__, curr_cmd->cmd1);
|
|
}
|
|
|
|
static void arasan_check_ondie(struct mtd_info *mtd)
|
|
{
|
|
struct nand_chip *nand_chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(nand_chip);
|
|
struct nand_config *nand = &info->config;
|
|
u8 maf_id, dev_id;
|
|
u8 get_feature[4];
|
|
u8 set_feature[4] = {ENABLE_ONDIE_ECC, 0x00, 0x00, 0x00};
|
|
u32 i;
|
|
|
|
nand_chip->select_chip(mtd, 0);
|
|
|
|
/* Send the command for reading device ID */
|
|
nand_chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
|
|
nand_chip->cmdfunc(mtd, NAND_CMD_READID, 0, -1);
|
|
|
|
/* Read manufacturer and device IDs */
|
|
maf_id = nand_chip->read_byte(mtd);
|
|
dev_id = nand_chip->read_byte(mtd);
|
|
|
|
if ((maf_id == NAND_MFR_MICRON) &&
|
|
((dev_id == 0xf1) || (dev_id == 0xa1) || (dev_id == 0xb1) ||
|
|
(dev_id == 0xaa) || (dev_id == 0xba) || (dev_id == 0xda) ||
|
|
(dev_id == 0xca) || (dev_id == 0xac) || (dev_id == 0xbc) ||
|
|
(dev_id == 0xdc) || (dev_id == 0xcc) || (dev_id == 0xa3) ||
|
|
(dev_id == 0xb3) || (dev_id == 0xd3) || (dev_id == 0xc3))) {
|
|
nand_chip->cmdfunc(mtd, NAND_CMD_SET_FEATURES,
|
|
ONDIE_ECC_FEATURE_ADDR, -1);
|
|
|
|
nand_chip->write_buf(mtd, &set_feature[0], 4);
|
|
nand_chip->cmdfunc(mtd, NAND_CMD_GET_FEATURES,
|
|
ONDIE_ECC_FEATURE_ADDR, -1);
|
|
|
|
for (i = 0; i < 4; i++)
|
|
get_feature[i] = nand_chip->read_byte(mtd);
|
|
|
|
if (get_feature[0] & ENABLE_ONDIE_ECC) {
|
|
nand->on_die_ecc_enabled = true;
|
|
printf("On-DIE ECC Enabled\n");
|
|
} else {
|
|
printf("%s: Unable to enable OnDie ECC\n", __func__);
|
|
}
|
|
|
|
/* Use the BBT pattern descriptors */
|
|
nand_chip->bbt_td = &bbt_main_descr;
|
|
nand_chip->bbt_md = &bbt_mirror_descr;
|
|
}
|
|
}
|
|
|
|
static int arasan_nand_ecc_init(struct mtd_info *mtd)
|
|
{
|
|
struct nand_chip *nand_chip = mtd_to_nand(mtd);
|
|
struct nand_drv *info = nand_get_controller_data(nand_chip);
|
|
int found = -1;
|
|
u32 regval, eccpos_start, i, eccaddr;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ecc_matrix); i++) {
|
|
if ((ecc_matrix[i].pagesize == mtd->writesize) &&
|
|
(ecc_matrix[i].ecc_codeword_size >=
|
|
nand_chip->ecc_step_ds)) {
|
|
if (ecc_matrix[i].eccbits >=
|
|
nand_chip->ecc_strength_ds) {
|
|
found = i;
|
|
break;
|
|
}
|
|
found = i;
|
|
}
|
|
}
|
|
|
|
if (found < 0)
|
|
return 1;
|
|
|
|
eccaddr = mtd->writesize + mtd->oobsize -
|
|
ecc_matrix[found].eccsize;
|
|
|
|
regval = eccaddr |
|
|
(ecc_matrix[found].eccsize << ARASAN_NAND_ECC_SIZE_SHIFT) |
|
|
(ecc_matrix[found].bch << ARASAN_NAND_ECC_BCH_SHIFT);
|
|
writel(regval, &info->reg->ecc_reg);
|
|
|
|
if (ecc_matrix[found].bch) {
|
|
regval = readl(&info->reg->memadr_reg2);
|
|
regval &= ~ARASAN_NAND_MEM_ADDR2_BCH_MASK;
|
|
regval |= (ecc_matrix[found].bchval <<
|
|
ARASAN_NAND_MEM_ADDR2_BCH_SHIFT);
|
|
writel(regval, &info->reg->memadr_reg2);
|
|
}
|
|
|
|
nand_oob.eccbytes = ecc_matrix[found].eccsize;
|
|
eccpos_start = mtd->oobsize - nand_oob.eccbytes;
|
|
|
|
for (i = 0; i < nand_oob.eccbytes; i++)
|
|
nand_oob.eccpos[i] = eccpos_start + i;
|
|
|
|
nand_oob.oobfree[0].offset = 2;
|
|
nand_oob.oobfree[0].length = eccpos_start - 2;
|
|
|
|
nand_chip->ecc.size = ecc_matrix[found].ecc_codeword_size;
|
|
nand_chip->ecc.strength = ecc_matrix[found].eccbits;
|
|
nand_chip->ecc.bytes = ecc_matrix[found].eccsize;
|
|
nand_chip->ecc.layout = &nand_oob;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int arasan_probe(struct udevice *dev)
|
|
{
|
|
struct arasan_nand_info *arasan = dev_get_priv(dev);
|
|
struct nand_chip *nand_chip = &arasan->nand_chip;
|
|
struct nand_drv *info = &arasan->nand_ctrl;
|
|
struct nand_config *nand = &info->config;
|
|
struct mtd_info *mtd;
|
|
int err = -1;
|
|
|
|
info->reg = (struct nand_regs *)dev_read_addr(dev);
|
|
mtd = nand_to_mtd(nand_chip);
|
|
nand_set_controller_data(nand_chip, &arasan->nand_ctrl);
|
|
|
|
#ifdef CONFIG_SYS_NAND_NO_SUBPAGE_WRITE
|
|
nand_chip->options |= NAND_NO_SUBPAGE_WRITE;
|
|
#endif
|
|
|
|
/* Set the driver entry points for MTD */
|
|
nand_chip->cmdfunc = arasan_nand_cmd_function;
|
|
nand_chip->select_chip = arasan_nand_select_chip;
|
|
nand_chip->read_byte = arasan_nand_read_byte;
|
|
|
|
/* Buffer read/write routines */
|
|
nand_chip->read_buf = arasan_nand_read_buf;
|
|
nand_chip->write_buf = arasan_nand_write_buf;
|
|
nand_chip->bbt_options = NAND_BBT_USE_FLASH;
|
|
|
|
writel(0x0, &info->reg->cmd_reg);
|
|
writel(0x0, &info->reg->pgm_reg);
|
|
|
|
/* first scan to find the device and get the page size */
|
|
if (nand_scan_ident(mtd, CONFIG_SYS_NAND_MAX_CHIPS, NULL)) {
|
|
printf("%s: nand_scan_ident failed\n", __func__);
|
|
goto fail;
|
|
}
|
|
|
|
nand_chip->ecc.mode = NAND_ECC_HW;
|
|
nand_chip->ecc.hwctl = NULL;
|
|
nand_chip->ecc.read_page = arasan_nand_read_page_hwecc;
|
|
nand_chip->ecc.write_page = arasan_nand_write_page_hwecc;
|
|
nand_chip->ecc.read_oob = arasan_nand_read_oob;
|
|
nand_chip->ecc.write_oob = arasan_nand_write_oob;
|
|
|
|
arasan_check_ondie(mtd);
|
|
|
|
/*
|
|
* If on die supported, then give priority to on-die ecc and use
|
|
* it instead of controller ecc.
|
|
*/
|
|
if (nand->on_die_ecc_enabled) {
|
|
nand_chip->ecc.strength = 1;
|
|
nand_chip->ecc.size = mtd->writesize;
|
|
nand_chip->ecc.bytes = 0;
|
|
nand_chip->ecc.layout = &ondie_nand_oob_64;
|
|
} else {
|
|
if (arasan_nand_ecc_init(mtd)) {
|
|
printf("%s: nand_ecc_init failed\n", __func__);
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
if (nand_scan_tail(mtd)) {
|
|
printf("%s: nand_scan_tail failed\n", __func__);
|
|
goto fail;
|
|
}
|
|
|
|
if (nand_register(0, mtd)) {
|
|
printf("Nand Register Fail\n");
|
|
goto fail;
|
|
}
|
|
|
|
return 0;
|
|
fail:
|
|
free(nand);
|
|
return err;
|
|
}
|
|
|
|
static const struct udevice_id arasan_nand_dt_ids[] = {
|
|
{.compatible = "arasan,nfc-v3p10",},
|
|
{ /* sentinel */ }
|
|
};
|
|
|
|
U_BOOT_DRIVER(arasan_nand) = {
|
|
.name = "arasan_nand",
|
|
.id = UCLASS_MTD,
|
|
.of_match = arasan_nand_dt_ids,
|
|
.probe = arasan_probe,
|
|
.priv_auto_alloc_size = sizeof(struct arasan_nand_info),
|
|
};
|
|
|
|
void board_nand_init(void)
|
|
{
|
|
struct udevice *dev;
|
|
int ret;
|
|
|
|
ret = uclass_get_device_by_driver(UCLASS_MTD,
|
|
DM_GET_DRIVER(arasan_nand), &dev);
|
|
if (ret && ret != -ENODEV)
|
|
pr_err("Failed to initialize %s. (error %d)\n", dev->name, ret);
|
|
}
|