Messages in this thread | | | Subject | Re: [PATCH v4 2/3] mtd: nand: Add support for Arasan Nand Flash Controller | From | Andy Shevchenko <> | Date | Mon, 09 Nov 2015 15:50:23 +0200 |
| |
On Thu, 2015-11-05 at 08:19 +0530, Punnaiah Choudary Kalluri wrote: > Added the basic driver for Arasan Nand Flash Controller used in > Zynq UltraScale+ MPSoC. It supports only Hw Ecc and upto 24bit > correction. >
> +config MTD_NAND_ARASAN > + tristate "Support for Arasan Nand Flash controller" > + depends on MTD_NAND
This looks useless since you can't see the item without MTD_NAND is chosen.
> + help > + Enables the driver for the Arasan Nand Flash controller on > + Zynq UltraScale+ MPSoC. > + > endif # MTD_NAND >
+obj-$(CONFIG_MTD_NAND_ARASAN) += arasan_nfc.o
"nfc" part a bit ambiguous since NFC might be Near Field Communication.
Perhaps "nand_fc" or something like that?
> > nand-objs := nand_base.o nand_bbt.o nand_timings.o > diff --git a/drivers/mtd/nand/arasan_nfc.c > b/drivers/mtd/nand/arasan_nfc.c > new file mode 100644 > index 0000000..9d4665e > --- /dev/null > +++ b/drivers/mtd/nand/arasan_nfc.c > @@ -0,0 +1,1026 @@ > +/* > + * Arasan Nand Flash Controller Driver > + * > + * Copyright (C) 2014 - 2015 Xilinx, Inc. > + * > + * 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; either version 2 of the License, or (at > your > + * option) any later version. > + */ > +#include <linux/clk.h> > +#include <linux/delay.h> > +#include <linux/dma-mapping.h> > +#include <linux/interrupt.h> > +#include <linux/module.h> > +#include <linux/mtd/mtd.h> > +#include <linux/mtd/nand.h> > +#include <linux/mtd/partitions.h> > +#include <linux/of.h> > +#include <linux/of_mtd.h> > +#include <linux/platform_device.h> > + > +#define DRIVER_NAME "arasan_nfc"
Ditto.
> +#define EVNT_TIMEOUT 1000 > +#define STATUS_TIMEOUT 2000 > + > +#define PKT_OFST 0x00 > +#define MEM_ADDR1_OFST 0x04 > +#define MEM_ADDR2_OFST 0x08 > +#define CMD_OFST 0x0C > +#define PROG_OFST 0x10 > +#define INTR_STS_EN_OFST 0x14 > +#define INTR_SIG_EN_OFST 0x18 > +#define INTR_STS_OFST 0x1C > +#define READY_STS_OFST 0x20 > +#define DMA_ADDR1_OFST 0x24 > +#define FLASH_STS_OFST 0x28 > +#define DATA_PORT_OFST 0x30 > +#define ECC_OFST 0x34 > +#define ECC_ERR_CNT_OFST 0x38 > +#define ECC_SPR_CMD_OFST 0x3C > +#define ECC_ERR_CNT_1BIT_OFST 0x40 > +#define ECC_ERR_CNT_2BIT_OFST 0x44 > +#define DMA_ADDR0_OFST 0x50 > +#define DATA_INTERFACE_REG 0x6C > + > +#define PKT_CNT_SHIFT 12 > + > +#define ECC_ENABLE BIT(31) > +#define DMA_EN_MASK GENMASK(27, 26) > +#define DMA_ENABLE 0x2 > +#define DMA_EN_SHIFT 26 > +#define PAGE_SIZE_MASK GENMASK(25, 23)
PAGE_SIZE_ prefix is too broad, might conflict with global definitions on some architectures.
> +#define PAGE_SIZE_SHIFT 23 > +#define PAGE_SIZE_512 0 > +#define PAGE_SIZE_1K 5 > +#define PAGE_SIZE_2K 1 > +#define PAGE_SIZE_4K 2 > +#define PAGE_SIZE_8K 3 > +#define PAGE_SIZE_16K 4 > +#define CMD2_SHIFT 8 > +#define ADDR_CYCLES_SHIFT 28 > + > +#define XFER_COMPLETE BIT(2) > +#define READ_READY BIT(1) > +#define WRITE_READY BIT(0) > +#define MBIT_ERROR BIT(3) > +#define ERR_INTRPT BIT(4) > + > +#define PROG_PGRD BIT(0) > +#define PROG_ERASE BIT(2) > +#define PROG_STATUS BIT(3) > +#define PROG_PGPROG BIT(4) > +#define PROG_RDID BIT(6) > +#define PROG_RDPARAM BIT(7) > +#define PROG_RST BIT(8) > +#define PROG_GET_FEATURE BIT(9) > +#define PROG_SET_FEATURE BIT(10) > + > +#define ONFI_STATUS_FAIL BIT(0) > +#define ONFI_STATUS_READY BIT(6) > + > +#define PG_ADDR_SHIFT 16 > +#define BCH_MODE_SHIFT 25 > +#define BCH_EN_SHIFT 27 > +#define ECC_SIZE_SHIFT 16 > + > +#define MEM_ADDR_MASK GENMASK(7, 0) > +#define BCH_MODE_MASK GENMASK(27, 25) > + > +#define CS_MASK GENMASK(31, 30) > +#define CS_SHIFT 30 > + > +#define PAGE_ERR_CNT_MASK GENMASK(16, 8) > +#define PKT_ERR_CNT_MASK GENMASK(7, 0) > + > +#define NVDDR_MODE BIT(9) > +#define NVDDR_TIMING_MODE_SHIFT 3 > + > +#define ONFI_ID_LEN 8 > +#define TEMP_BUF_SIZE 512 > +#define NVDDR_MODE_PACKET_SIZE 8 > +#define SDR_MODE_PACKET_SIZE 4 > + > +/** > + * struct anfc_ecc_matrix - Defines ecc information storage format > + * @pagesize: Page size in bytes. > + * @codeword_size: Code word size information. > + * @eccbits: Number of ecc bits. > + * @bch: Bch / Hamming mode enable/disable. > + * @eccsize: Ecc size information. > + */ > +struct anfc_ecc_matrix { > + u32 pagesize; > + u32 codeword_size; > + u8 eccbits; > + u8 bch; > + u16 eccsize; > +}; > + > +static const struct anfc_ecc_matrix ecc_matrix[] = { > + {512, 512, 1, 0, 0x3}, > + {512, 512, 4, 1, 0x7}, > + {512, 512, 8, 1, 0xD}, > + /* 2K byte page */ > + {2048, 512, 1, 0, 0xC}, > + {2048, 512, 4, 1, 0x1A}, > + {2048, 512, 8, 1, 0x34}, > + {2048, 512, 12, 1, 0x4E}, > + {2048, 1024, 24, 1, 0x54}, > + /* 4K byte page */ > + {4096, 512, 1, 0, 0x18}, > + {4096, 512, 4, 1, 0x34}, > + {4096, 512, 8, 1, 0x68}, > + {4096, 512, 12, 1, 0x9C}, > + {4096, 1024, 4, 1, 0xA8}, > + /* 8K byte page */ > + {8192, 512, 1, 0, 0x30}, > + {8192, 512, 4, 1, 0x68}, > + {8192, 512, 8, 1, 0xD0}, > + {8192, 512, 12, 1, 0x138}, > + {8192, 1024, 24, 1, 0x150}, > + /* 16K byte page */ > + {16384, 512, 1, 0, 0x60}, > + {16384, 512, 4, 1, 0xD0}, > + {16384, 512, 8, 1, 0x1A0}, > + {16384, 512, 12, 1, 0x270}, > + {16384, 1024, 24, 1, 0x2A0} > +}; > + > +/** > + * struct anfc - Defines the Arasan NAND flash driver instance > + * @chip: NAND chip information structure. > + * @mtd: MTD information structure. > + * @dev: Pointer to the device structure. > + * @base: Virtual address of the NAND flash device. > + * @curr_cmd: Current command issued. > + * @clk_sys: Pointer to the system clock. > + * @clk_flash: Pointer to the flash clock. > + * @dma: Dma enable/disable. > + * @bch: Bch / Hamming mode enable/disable. > + * @err: Error identifier. > + * @iswriteoob: Identifies if oob write operation is > required. > + * @buf: Buffer used for read/write byte operations. > + * @raddr_cycles: Row address cycle information. > + * @caddr_cycles: Column address cycle information. > + * @irq: irq number > + * @page: Page address to be use for write oob > operations. > + * @pktsize: Packet size for read / write operation. > + * @bufshift: Variable used for indexing buffer > operation > + * @rdintrmask: Interrupt mask value for read > operation. > + * @num_cs: Number of chip selects in use. > + * @spktsize: Packet size in ddr mode for status > operation. > + * @bufrdy: Completion event for buffer ready. > + * @xfercomp: Completion event for transfer complete. > + * @ecclayout: Ecc layout object > + */ > +struct anfc { > + struct nand_chip chip; > + struct mtd_info mtd; > + struct device *dev; > + > + void __iomem *base; > + int curr_cmd; > + struct clk *clk_sys; > + struct clk *clk_flash; > + > + bool dma; > + bool bch; > + bool err; > + bool iswriteoob; > + > + u8 buf[TEMP_BUF_SIZE]; > + > + u16 raddr_cycles; > + u16 caddr_cycles; > + > + u32 irq; > + u32 page; > + u32 pktsize; > + u32 bufshift; > + u32 rdintrmask; > + u32 num_cs; > + u32 spktsize; > + > + struct completion bufrdy; > + struct completion xfercomp; > + struct nand_ecclayout ecclayout; > +}; > + > +static u8 anfc_page(u32 pagesize) > +{ > + switch (pagesize) { > + case 512: > + return PAGE_SIZE_512; > + case 2048: > + return PAGE_SIZE_2K; > + case 4096: > + return PAGE_SIZE_4K; > + case 8192: > + return PAGE_SIZE_8K; > + case 16384: > + return PAGE_SIZE_16K; > + case 1024:
Why not keep sorted here?
> + return PAGE_SIZE_1K; > + default: > + break; > + } > + > + return 0;
> +} > + > +static inline void anfc_enable_intrs(struct anfc *nfc, u32 val) > +{ > + writel(val, nfc->base + INTR_STS_EN_OFST); > + writel(val, nfc->base + INTR_SIG_EN_OFST); > +} > + > +static int anfc_wait_for_event(struct anfc *nfc, u32 event) > +{ > + struct completion *comp; > + int ret; > + > + if (event == XFER_COMPLETE) > + comp = &nfc->xfercomp; > + else > + comp = &nfc->bufrdy; > + > + ret = wait_for_completion_timeout(comp, > msecs_to_jiffies(EVNT_TIMEOUT)); > + > + return ret;
return func();
> +} > + > +static inline void anfc_setpktszcnt(struct anfc *nfc, u32 pktsize, > + u32 pktcount) > +{ > + writel(pktsize | (pktcount << PKT_CNT_SHIFT), nfc->base + > PKT_OFST); > +} > + > +static inline void anfc_set_eccsparecmd(struct anfc *nfc, u8 cmd1, > u8 cmd2) > +{ > + writel(cmd1 | (cmd2 << CMD2_SHIFT) | > + (nfc->caddr_cycles << ADDR_CYCLES_SHIFT), > + nfc->base + ECC_SPR_CMD_OFST); > +} > + > +static void anfc_setpagecoladdr(struct anfc *nfc, u32 page, u16 col) > +{ > + u32 val; > + > + writel(col | (page << PG_ADDR_SHIFT), nfc->base + > MEM_ADDR1_OFST); > + > + val = readl(nfc->base + MEM_ADDR2_OFST); > + val = (val & ~MEM_ADDR_MASK) | > + ((page >> PG_ADDR_SHIFT) & MEM_ADDR_MASK); > + writel(val, nfc->base + MEM_ADDR2_OFST); > +} > + > +static void anfc_prepare_cmd(struct anfc *nfc, u8 cmd1, u8 cmd2, > + u8 dmamode, u32 pagesize, u8 > addrcycles) > +{ > + u32 regval; > + > + regval = cmd1 | (cmd2 << CMD2_SHIFT); > + if (dmamode && nfc->dma) > + regval |= DMA_ENABLE << DMA_EN_SHIFT; > + if (addrcycles) > + regval |= addrcycles << ADDR_CYCLES_SHIFT; > + if (pagesize) > + regval |= anfc_page(pagesize) << PAGE_SIZE_SHIFT; > + writel(regval, nfc->base + CMD_OFST); > +} > + > +static int anfc_device_ready(struct mtd_info *mtd, > + struct nand_chip *chip) > +{ > + u8 status; > + unsigned long timeout = jiffies + STATUS_TIMEOUT; > + > + do { > + chip->cmdfunc(mtd, NAND_CMD_STATUS, 0, 0); > + status = chip->read_byte(mtd); > + if (status & ONFI_STATUS_READY) {
> + if (status & ONFI_STATUS_FAIL) > + return NAND_STATUS_FAIL;
This is invariant to the loop, perhaps move outside.
> + break; > + } > + cpu_relax(); > + } while (!time_after_eq(jiffies, timeout)); > + > + if (time_after_eq(jiffies, timeout)) { > + pr_err("%s timed out\n", __func__);
dev_err?
> + return -ETIMEDOUT; > + } > + > + return 0; > +} > + > +static int anfc_read_oob(struct mtd_info *mtd, struct nand_chip > *chip, > + int page) > +{ > + struct anfc *nfc = container_of(mtd, struct anfc, mtd);
Since you use it more than once might be a good idea to do something like
#define to_anfc() container_of()
> + > + chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page); > + if (nfc->dma) > + nfc->rdintrmask = XFER_COMPLETE; > + else > + nfc->rdintrmask = READ_READY; > + chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); > + > + return 0; > +} > + > +static int anfc_write_oob(struct mtd_info *mtd, struct nand_chip > *chip, > + int page) > +{ > + struct anfc *nfc = container_of(mtd, struct anfc, mtd); > + > + nfc->iswriteoob = true; > + chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page); > + chip->write_buf(mtd, chip->oob_poi, mtd->oobsize); > + nfc->iswriteoob = false; > + > + return 0; > +} > + > +static void anfc_read_buf(struct mtd_info *mtd, uint8_t *buf, int > len) > +{ > + u32 i, pktcount, buf_rd_cnt = 0, pktsize;
Type for i looks unsigned int, why u32? Same question for all variables that are not used to directly program HW.
> + u32 *bufptr = (u32 *)buf; > + struct anfc *nfc = container_of(mtd, struct anfc, mtd); > + dma_addr_t paddr = 0; > + > + if (nfc->curr_cmd == NAND_CMD_READ0) { > + pktsize = nfc->pktsize; >
> + if (mtd->writesize % pktsize) > + pktcount = mtd->writesize / pktsize + 1; > + else > + pktcount = mtd->writesize / pktsize;
DIV_ROUND_UP ?
> + } else { > + pktsize = len; > + pktcount = 1; > + } > + > + anfc_setpktszcnt(nfc, pktsize, pktcount); > + > + if (nfc->dma) { > + paddr = dma_map_single(nfc->dev, buf, len, > DMA_FROM_DEVICE); > + if (dma_mapping_error(nfc->dev, paddr)) { > + dev_err(nfc->dev, "Read buffer mapping > error"); > + return; > + } > + writel(lower_32_bits(paddr), nfc->base + > DMA_ADDR0_OFST); > + writel(upper_32_bits(paddr), nfc->base + > DMA_ADDR1_OFST); > + anfc_enable_intrs(nfc, nfc->rdintrmask); > + writel(PROG_PGRD, nfc->base + PROG_OFST); > + anfc_wait_for_event(nfc, XFER_COMPLETE); > + dma_unmap_single(nfc->dev, paddr, len, > DMA_FROM_DEVICE); > + return; > + } > + > + anfc_enable_intrs(nfc, nfc->rdintrmask); > + writel(PROG_PGRD, nfc->base + PROG_OFST); > + > + while (buf_rd_cnt < pktcount) { > + > + anfc_wait_for_event(nfc, READ_READY); > + buf_rd_cnt++; > + > + if (buf_rd_cnt == pktcount) > + anfc_enable_intrs(nfc, XFER_COMPLETE); > + > + for (i = 0; i < pktsize / 4; i++) > + bufptr[i] = readl(nfc->base + > DATA_PORT_OFST); > + > + bufptr += (pktsize / 4);
Useless parens.
> + > + if (buf_rd_cnt < pktcount) > + anfc_enable_intrs(nfc, nfc->rdintrmask); > + } > + > + anfc_wait_for_event(nfc, XFER_COMPLETE); > +} > + > +static void anfc_write_buf(struct mtd_info *mtd, const uint8_t *buf, > int len) > +{ > + u32 buf_wr_cnt = 0, pktcount = 1, i, pktsize;
Useless assignment of pktcount. Check all your definition blocks for similar thing.
> + u32 *bufptr = (u32 *)buf; > + struct anfc *nfc = container_of(mtd, struct anfc, mtd); > + dma_addr_t paddr = 0; > + > + if (nfc->iswriteoob) { > + pktsize = len; > + pktcount = 1; > + } else { > + pktsize = nfc->pktsize; > + pktcount = mtd->writesize / pktsize; > + } > + > + anfc_setpktszcnt(nfc, pktsize, pktcount); > + > + if (nfc->dma) { > + paddr = dma_map_single(nfc->dev, (void *)buf, len, > + DMA_TO_DEVICE); > + if (dma_mapping_error(nfc->dev, paddr)) { > + dev_err(nfc->dev, "Write buffer mapping > error"); > + return; > + } >
> + writel(lower_32_bits(paddr), nfc->base + > DMA_ADDR0_OFST); > + writel(upper_32_bits(paddr), nfc->base + > DMA_ADDR1_OFST);
lo_hi_writeq();
Or even writeq() if it's acceptable by HW.
> + anfc_enable_intrs(nfc, XFER_COMPLETE); > + writel(PROG_PGPROG, nfc->base + PROG_OFST); > + anfc_wait_for_event(nfc, XFER_COMPLETE); > + dma_unmap_single(nfc->dev, paddr, len, > DMA_TO_DEVICE); > + return; > + } > + > + anfc_enable_intrs(nfc, WRITE_READY); > + writel(PROG_PGPROG, nfc->base + PROG_OFST); > + > + while (buf_wr_cnt < pktcount) { > + anfc_wait_for_event(nfc, WRITE_READY); > + > + buf_wr_cnt++; > + if (buf_wr_cnt == pktcount) > + anfc_enable_intrs(nfc, XFER_COMPLETE); > + > + for (i = 0; i < (pktsize / 4); i++) > + writel(bufptr[i], nfc->base + > DATA_PORT_OFST);
memcpy_toio() ?
> + > + bufptr += (pktsize / 4); > + > + if (buf_wr_cnt < pktcount) > + anfc_enable_intrs(nfc, WRITE_READY); > + } > + > + anfc_wait_for_event(nfc, XFER_COMPLETE); > +} > + > +static int anfc_read_page_hwecc(struct mtd_info *mtd, > + struct nand_chip *chip, uint8_t > *buf, > + int oob_required, int page) > +{ > + u32 val; > + struct anfc *nfc = container_of(mtd, struct anfc, mtd); > + > + anfc_set_eccsparecmd(nfc, NAND_CMD_RNDOUT, > NAND_CMD_RNDOUTSTART); > + > + val = readl(nfc->base + CMD_OFST); > + val = val | ECC_ENABLE; > + writel(val, nfc->base + CMD_OFST); > + > + if (nfc->dma) > + nfc->rdintrmask = XFER_COMPLETE; > + else > + nfc->rdintrmask = READ_READY; > + > + if (!nfc->bch) > + nfc->rdintrmask = MBIT_ERROR; > + > + chip->read_buf(mtd, buf, mtd->writesize); > + > + val = readl(nfc->base + ECC_ERR_CNT_OFST); > + if (nfc->bch) { > + mtd->ecc_stats.corrected += val & PAGE_ERR_CNT_MASK; > + } else { > + val = readl(nfc->base + ECC_ERR_CNT_1BIT_OFST); > + mtd->ecc_stats.corrected += val; > + val = readl(nfc->base + ECC_ERR_CNT_2BIT_OFST); > + mtd->ecc_stats.failed += val; > + /* Clear ecc error count register 1Bit, 2Bit */ > + writel(0x0, nfc->base + ECC_ERR_CNT_1BIT_OFST); > + writel(0x0, nfc->base + ECC_ERR_CNT_2BIT_OFST); > + } > + nfc->err = false; > + > + if (oob_required) > + chip->ecc.read_oob(mtd, chip, page); > + > + return 0; > +} > + > +static int anfc_write_page_hwecc(struct mtd_info *mtd, > + struct nand_chip *chip, const > uint8_t *buf, > + int oob_required) > +{ > + u32 val, i; > + struct anfc *nfc = container_of(mtd, struct anfc, mtd); > + uint8_t *ecc_calc = chip->buffers->ecccalc; > + uint32_t *eccpos = chip->ecc.layout->eccpos; > + > + anfc_set_eccsparecmd(nfc, NAND_CMD_RNDIN, 0); > + > + val = readl(nfc->base + CMD_OFST); > + val = val | ECC_ENABLE; > + writel(val, nfc->base + CMD_OFST); > + > + chip->write_buf(mtd, buf, mtd->writesize); > + > + if (oob_required) { > + anfc_device_ready(mtd, chip); > + chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, nfc->page); > + if (nfc->dma) > + nfc->rdintrmask = XFER_COMPLETE; > + else > + nfc->rdintrmask = READ_READY; > + chip->read_buf(mtd, ecc_calc, mtd->oobsize); > + for (i = 0; i < chip->ecc.total; i++) > + chip->oob_poi[eccpos[i]] = > ecc_calc[eccpos[i]]; > + chip->ecc.write_oob(mtd, chip, nfc->page); > + } > + > + return 0; > +} > + > +static u8 anfc_read_byte(struct mtd_info *mtd) > +{ > + struct anfc *nfc = container_of(mtd, struct anfc, mtd); > + > + return nfc->buf[nfc->bufshift++]; > +} > + > +static void anfc_writefifo(struct anfc *nfc, u32 prog, u32 size, u8 > *buf) > +{ > + u32 i, *bufptr = (u32 *)buf; > + > + anfc_enable_intrs(nfc, WRITE_READY); > + > + writel(prog, nfc->base + PROG_OFST); > + anfc_wait_for_event(nfc, WRITE_READY); > + > + anfc_enable_intrs(nfc, XFER_COMPLETE); > + for (i = 0; i < size / 4; i++) > + writel(bufptr[i], nfc->base + DATA_PORT_OFST);
memcpy_toio() ?
> + > + anfc_wait_for_event(nfc, XFER_COMPLETE); > +} > + > +static void anfc_readfifo(struct anfc *nfc, u32 prog, u32 size) > +{ > + u32 i, *bufptr = (u32 *)&nfc->buf[0]; > + > + anfc_enable_intrs(nfc, READ_READY); > + > + writel(prog, nfc->base + PROG_OFST); > + anfc_wait_for_event(nfc, READ_READY); > + > + anfc_enable_intrs(nfc, XFER_COMPLETE); > + > + for (i = 0; i < size / 4; i++) > + bufptr[i] = readl(nfc->base + DATA_PORT_OFST);
memcpy_fromio() ?
> + > + anfc_wait_for_event(nfc, XFER_COMPLETE); > +} > + > +static int anfc_ecc_init(struct mtd_info *mtd, > + struct nand_ecc_ctrl *ecc) > +{ > + u32 oob_index, i, ecc_addr, regval, bchmode = 0; > + struct nand_chip *nand_chip = mtd->priv; > + struct anfc *nfc = container_of(mtd, struct anfc, mtd); > + int found = -1; > + > + nand_chip->ecc.mode = NAND_ECC_HW; > + nand_chip->ecc.read_page = anfc_read_page_hwecc; > + nand_chip->ecc.write_page = anfc_write_page_hwecc; > + nand_chip->ecc.write_oob = anfc_write_oob; > + nand_chip->ecc.read_oob = anfc_read_oob; > + > + for (i = 0; i < sizeof(ecc_matrix) / sizeof(struct > anfc_ecc_matrix);
ARRAY_SIZE() ?
> + i++) { > + if ((ecc_matrix[i].pagesize == mtd->writesize) && > + (ecc_matrix[i].codeword_size >= nand_chip- > >ecc_step_ds)) { > + if (ecc_matrix[i].eccbits >= > + nand_chip->ecc_strength_ds) { > + found = i;
here
> + break; > + } > + found = i;
and here
One of them looks redundant, or
found = i; if () break;
> + } > + } > + > + if (found < 0) { > + dev_err(nfc->dev, "ECC scheme not supported"); > + return 1; > + } > + if (ecc_matrix[found].bch) { > + switch (ecc_matrix[found].eccbits) { > + case 12: > + bchmode = 0x1; > + break; > + case 8: > + bchmode = 0x2; > + break; > + case 4: > + bchmode = 0x3; > + break; > + case 24: > + bchmode = 0x4; > + break; > + default: > + bchmode = 0x0; > + } > + } > + > + nand_chip->ecc.strength = ecc_matrix[found].eccbits; > + nand_chip->ecc.size = ecc_matrix[found].codeword_size; > + nand_chip->ecc.steps = ecc_matrix[found].pagesize / > + ecc_matrix[found].codeword_size; > + nand_chip->ecc.bytes = ecc_matrix[found].eccsize / > + nand_chip->ecc.steps; > + nfc->ecclayout.eccbytes = ecc_matrix[found].eccsize; > + nfc->bch = ecc_matrix[found].bch; > + oob_index = mtd->oobsize - nfc->ecclayout.eccbytes; > + ecc_addr = mtd->writesize + oob_index; > + > + for (i = 0; i < nand_chip->ecc.size; i++) > + nfc->ecclayout.eccpos[i] = oob_index + i; > + > + nfc->ecclayout.oobfree->offset = 2; > + nfc->ecclayout.oobfree->length = oob_index - > + nfc->ecclayout.oobfree- > >offset; > + > + nand_chip->ecc.layout = &nfc->ecclayout; > + regval = ecc_addr | (ecc_matrix[found].eccsize << > ECC_SIZE_SHIFT) | > + (ecc_matrix[found].bch << BCH_EN_SHIFT); > + writel(regval, nfc->base + ECC_OFST); > + > + regval = readl(nfc->base + MEM_ADDR2_OFST); > + regval = (regval & ~(BCH_MODE_MASK)) | (bchmode << > BCH_MODE_SHIFT); > + writel(regval, nfc->base + MEM_ADDR2_OFST); > + > + if (nand_chip->ecc_step_ds >= 1024) > + nfc->pktsize = 1024; > + else > + nfc->pktsize = 512; > + > + return 0; > +} > + > +static void anfc_cmd_function(struct mtd_info *mtd, > + unsigned int cmd, int column, int > page_addr) > +{ > + struct anfc *nfc = container_of(mtd, struct anfc, mtd); > + bool wait = false, read = false; > + u32 addrcycles, prog; > + u32 *bufptr = (u32 *)&nfc->buf[0];
(u32 *)nfc->buf;
> + > + nfc->bufshift = 0; > + nfc->curr_cmd = cmd; > + > + if (page_addr == -1) > + page_addr = 0; > + if (column == -1) > + column = 0; > + > + switch (cmd) { > + case NAND_CMD_RESET: > + anfc_prepare_cmd(nfc, cmd, 0, 0, 0, 0); > + prog = PROG_RST; > + wait = true; > + break; > + case NAND_CMD_SEQIN: > + addrcycles = nfc->raddr_cycles + nfc->caddr_cycles; > + nfc->page = page_addr; > + anfc_prepare_cmd(nfc, cmd, NAND_CMD_PAGEPROG, 1, > + mtd->writesize, addrcycles); > + anfc_setpagecoladdr(nfc, page_addr, column); > + break; > + case NAND_CMD_READOOB: > + column += mtd->writesize; > + case NAND_CMD_READ0: > + case NAND_CMD_READ1: > + addrcycles = nfc->raddr_cycles + nfc->caddr_cycles; > + anfc_prepare_cmd(nfc, NAND_CMD_READ0, > NAND_CMD_READSTART, 1, > + mtd->writesize, addrcycles); > + anfc_setpagecoladdr(nfc, page_addr, column); > + break; > + case NAND_CMD_RNDOUT: > + anfc_prepare_cmd(nfc, cmd, NAND_CMD_RNDOUTSTART, 1, > + mtd->writesize, 2); > + anfc_setpagecoladdr(nfc, page_addr, column); > + if (nfc->dma) > + nfc->rdintrmask = XFER_COMPLETE; > + else > + nfc->rdintrmask = READ_READY; > + break; > + case NAND_CMD_PARAM: > + anfc_prepare_cmd(nfc, cmd, 0, 0, 0, 1); > + anfc_setpagecoladdr(nfc, page_addr, column); > + anfc_setpktszcnt(nfc, sizeof(struct > nand_onfi_params), 1); > + anfc_readfifo(nfc, PROG_RDPARAM, > + sizeof(struct nand_onfi_params)); > + break; > + case NAND_CMD_READID: > + anfc_prepare_cmd(nfc, cmd, 0, 0, 0, 1); > + anfc_setpagecoladdr(nfc, page_addr, column); > + anfc_setpktszcnt(nfc, ONFI_ID_LEN, 1); > + anfc_readfifo(nfc, PROG_RDID, ONFI_ID_LEN); > + break; > + case NAND_CMD_ERASE1: > + addrcycles = nfc->raddr_cycles; > + prog = PROG_ERASE; > + anfc_prepare_cmd(nfc, cmd, NAND_CMD_ERASE2, 0, 0, > addrcycles); > + column = page_addr & 0xffff; > + page_addr = (page_addr >> PG_ADDR_SHIFT) & 0xffff; > + anfc_setpagecoladdr(nfc, page_addr, column); > + wait = true; > + break; > + case NAND_CMD_STATUS: > + anfc_prepare_cmd(nfc, cmd, 0, 0, 0, 0); > + anfc_setpktszcnt(nfc, nfc->spktsize/4, 1); > + anfc_setpagecoladdr(nfc, page_addr, column); > + prog = PROG_STATUS; > + wait = read = true; > + break; > + case NAND_CMD_GET_FEATURES: > + anfc_prepare_cmd(nfc, cmd, 0, 0, 0, 1); > + anfc_setpagecoladdr(nfc, page_addr, column); > + anfc_setpktszcnt(nfc, nfc->spktsize, 1); > + anfc_readfifo(nfc, PROG_GET_FEATURE, 4); > + break; > + case NAND_CMD_SET_FEATURES: > + anfc_prepare_cmd(nfc, cmd, 0, 0, 0, 1); > + anfc_setpagecoladdr(nfc, page_addr, column); > + anfc_setpktszcnt(nfc, nfc->spktsize, 1); > + break; > + default: > + return; > + } > + > + if (wait) { > + anfc_enable_intrs(nfc, XFER_COMPLETE); > + writel(prog, nfc->base + PROG_OFST); > + anfc_wait_for_event(nfc, XFER_COMPLETE); > + } > + > + if (read) > + bufptr[0] = readl(nfc->base + FLASH_STS_OFST); > +} > + > +static void anfc_select_chip(struct mtd_info *mtd, int num) > +{ > + u32 val; > + struct anfc *nfc = container_of(mtd, struct anfc, mtd); > + > + if (num == -1) > + return; > + > + val = readl(nfc->base + MEM_ADDR2_OFST); > + val = (val & ~(CS_MASK)) | (num << CS_SHIFT); > + writel(val, nfc->base + MEM_ADDR2_OFST); > +} > + > +static irqreturn_t anfc_irq_handler(int irq, void *ptr) > +{ > + struct anfc *nfc = ptr; > + u32 regval = 0, status; > + > + status = readl(nfc->base + INTR_STS_OFST); > + if (status & XFER_COMPLETE) { > + complete(&nfc->xfercomp); > + regval |= XFER_COMPLETE; > + } > + > + if (status & READ_READY) { > + complete(&nfc->bufrdy); > + regval |= READ_READY; > + } > + > + if (status & WRITE_READY) { > + complete(&nfc->bufrdy); > + regval |= WRITE_READY; > + } > + > + if (status & MBIT_ERROR) { > + nfc->err = true; > + complete(&nfc->bufrdy); > + regval |= MBIT_ERROR; > + } > + > + if (regval) { > + writel(regval, nfc->base + INTR_STS_OFST); > + writel(0, nfc->base + INTR_STS_EN_OFST); > + writel(0, nfc->base + INTR_SIG_EN_OFST); > + > + return IRQ_HANDLED; > + } > + > + return IRQ_NONE; > +} > + > +static int anfc_onfi_set_features(struct mtd_info *mtd, struct > nand_chip *chip, > + int addr, uint8_t *subfeature_param) > +{ > + int status; > + struct anfc *nfc = container_of(mtd, struct anfc, mtd);
Usually int ret; or similar goes last in the definition block.
> + > + if (!chip->onfi_version || !(le16_to_cpu(chip- > >onfi_params.opt_cmd) > + & ONFI_OPT_CMD_SET_GET_FEATURES)) > + return -EINVAL; > + > + chip->cmdfunc(mtd, NAND_CMD_SET_FEATURES, addr, -1); > + anfc_writefifo(nfc, PROG_SET_FEATURE, nfc->spktsize, > subfeature_param); > + > + status = chip->waitfunc(mtd, chip); > + if (status & NAND_STATUS_FAIL) > + return -EIO; > + > + return 0; > +} > + > +static int anfc_init_timing_mode(struct anfc *nfc) > +{ > + int mode, err;
+ unsigned int feature[2], regval, i; > + struct nand_chip *chip = &nfc->chip; > + struct mtd_info *mtd = &nfc->mtd; > + > + memset(&feature[0], 0, NVDDR_MODE_PACKET_SIZE);
&array[0] is equivalent to array.
> + mode = onfi_get_sync_timing_mode(chip); > + /* Get nvddr timing modes */
> + mode = mode & 0xFF;
0xff and would be one line with previous.
> + if (!mode) { > + mode = onfi_get_async_timing_mode(&nfc->chip); > + mode = fls(mode) - 1;
...fls(func())
> + regval = mode; > + } else { > + mode = fls(mode) - 1; > + regval = NVDDR_MODE | mode << > NVDDR_TIMING_MODE_SHIFT; > + mode |= ONFI_DATA_INTERFACE_NVDDR; > + } > + > + feature[0] = mode; > + for (i = 0; i < nfc->num_cs; i++) { > + chip->select_chip(mtd, i); > + err = chip->onfi_set_features(mtd, chip, > + ONFI_FEATURE_ADDR_TIMING_MOD > E, > + (uint8_t *)&feature[0]);
No need &…[0]
> + if (err) > + return err; > + } > + writel(regval, nfc->base + DATA_INTERFACE_REG); > + > + if (mode & ONFI_DATA_INTERFACE_NVDDR) > + nfc->spktsize = NVDDR_MODE_PACKET_SIZE; > + > + return 0; > +} > + > +static int anfc_probe(struct platform_device *pdev) > +{ > + struct anfc *nfc; > + struct mtd_info *mtd; > + struct nand_chip *nand_chip; > + struct resource *res; > + struct mtd_part_parser_data ppdata; > + int err; > + > + nfc = devm_kzalloc(&pdev->dev, sizeof(*nfc), GFP_KERNEL); > + if (!nfc) > + return -ENOMEM; > + > + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + nfc->base = devm_ioremap_resource(&pdev->dev, res); > + if (IS_ERR(nfc->base)) > + return PTR_ERR(nfc->base); > + > + mtd = &nfc->mtd; > + nand_chip = &nfc->chip; > + nand_chip->priv = nfc; > + mtd->priv = nand_chip; >
> + mtd->owner = THIS_MODULE;
Shouldn't be this set by core?
> + mtd->name = DRIVER_NAME; > + nfc->dev = &pdev->dev; > + mtd->dev.parent = &pdev->dev; > + > + nand_chip->cmdfunc = anfc_cmd_function; > + nand_chip->waitfunc = anfc_device_ready; > + nand_chip->chip_delay = 30; > + nand_chip->read_buf = anfc_read_buf; > + nand_chip->write_buf = anfc_write_buf; > + nand_chip->read_byte = anfc_read_byte; > + nand_chip->options = NAND_BUSWIDTH_AUTO | > NAND_NO_SUBPAGE_WRITE; > + nand_chip->bbt_options = NAND_BBT_USE_FLASH; > + nand_chip->select_chip = anfc_select_chip; > + nand_chip->onfi_set_features = anfc_onfi_set_features; > + nfc->dma = of_property_read_bool(pdev->dev.of_node, > + "arasan,has-mdma"); > + nfc->num_cs = 1; > + of_property_read_u32(pdev->dev.of_node, "num-cs", &nfc- > >num_cs); > + platform_set_drvdata(pdev, nfc); > + init_completion(&nfc->bufrdy); > + init_completion(&nfc->xfercomp); > + nfc->irq = platform_get_irq(pdev, 0); > + if (nfc->irq < 0) { > + dev_err(&pdev->dev, "request_irq failed\n");
Wrong message. Should be below.
> + return -ENXIO; > + } > + err = devm_request_irq(&pdev->dev, nfc->irq, > anfc_irq_handler, > + 0, "arasannfc", nfc); > + if (err) > + return err; > + nfc->clk_sys = devm_clk_get(&pdev->dev, "clk_sys"); > + if (IS_ERR(nfc->clk_sys)) { > + dev_err(&pdev->dev, "sys clock not found.\n"); > + return PTR_ERR(nfc->clk_sys); > + } > + > + nfc->clk_flash = devm_clk_get(&pdev->dev, "clk_flash"); > + if (IS_ERR(nfc->clk_flash)) { > + dev_err(&pdev->dev, "flash clock not found.\n"); > + return PTR_ERR(nfc->clk_flash); > + } > + > + err = clk_prepare_enable(nfc->clk_sys); > + if (err) { > + dev_err(&pdev->dev, "Unable to enable sys > clock.\n"); > + return err; > + } > + > + err = clk_prepare_enable(nfc->clk_flash); > + if (err) { > + dev_err(&pdev->dev, "Unable to enable flash > clock.\n"); > + goto clk_dis_sys; > + } > + > + nfc->spktsize = SDR_MODE_PACKET_SIZE; > + if (nand_scan_ident(mtd, nfc->num_cs, NULL)) { > + err = -ENXIO;
Propagate the actual error code.
> + dev_err(&pdev->dev, "nand_scan_ident for NAND > failed\n"); > + goto clk_dis_all; > + } > + if (nand_chip->onfi_version) { > + nfc->raddr_cycles = nand_chip- > >onfi_params.addr_cycles & 0xF; > + nfc->caddr_cycles = > + (nand_chip->onfi_params.addr_cycles > >> 4) & 0xF;
0xf or 0x0f.
> + } else { > + /*For non-ONFI devices, configuring the address > cyles as 5 */ > + nfc->raddr_cycles = nfc->caddr_cycles = 5; > + } > + > + if (anfc_init_timing_mode(nfc)) { > + err = -ENXIO;
Doesn't return error code? Propagate if it does.
> + dev_err(&pdev->dev, "timing mode init failed\n"); > + goto clk_dis_all; > + } > + > + if (anfc_ecc_init(mtd, &nand_chip->ecc)) { > + err = -ENXIO;
Ditto.
> + goto clk_dis_all; > + } > + > + if (nand_scan_tail(mtd)) { > + err = -ENXIO;
Ditto.
> + dev_err(&pdev->dev, "nand_scan_tail for NAND > failed\n"); > + goto clk_dis_all; > + } > + > + ppdata.of_node = pdev->dev.of_node; > + > + err = mtd_device_parse_register(&nfc->mtd, NULL, &ppdata, > NULL, 0); > + if (err) > + goto clk_dis_all; > + > + return err;
Apparently return 0;
> + > +clk_dis_all: > + clk_disable_unprepare(nfc->clk_flash); > +clk_dis_sys: > + clk_disable_unprepare(nfc->clk_sys); > + > + return err; > +} > + > +static int anfc_remove(struct platform_device *pdev) > +{ > + struct anfc *nfc = platform_get_drvdata(pdev); > + > + clk_disable_unprepare(nfc->clk_sys); > + clk_disable_unprepare(nfc->clk_flash); > + > + nand_release(&nfc->mtd); > + > + return 0; > +} > + > +static const struct of_device_id anfc_ids[] = { > + { .compatible = "arasan,nfc-v3p10" }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, anfc_ids); > + > +static struct platform_driver anfc_driver = { > + .driver = { > + .name = DRIVER_NAME, > + .of_match_table = anfc_ids, > + }, > + .probe = anfc_probe, > + .remove = anfc_remove, > +}; > +module_platform_driver(anfc_driver); > + > +MODULE_LICENSE("GPL"); > +MODULE_AUTHOR("Xilinx, Inc"); > +MODULE_DESCRIPTION("Arasan NAND Flash Controller Driver");
-- Andy Shevchenko <andriy.shevchenko@linux.intel.com> Intel Finland Oy
| |