* [U-Boot] [PATCH 0/6] sunxi: Add NAND controller driver
@ 2016-06-06 15:21 Boris Brezillon
2016-06-06 15:21 ` [U-Boot] [PATCH 1/6] sunxi: Add missing macros to configure the NAND controller clk Boris Brezillon
` (6 more replies)
0 siblings, 7 replies; 15+ messages in thread
From: Boris Brezillon @ 2016-06-06 15:21 UTC (permalink / raw)
To: u-boot
Hello,
This patch series is adding the normal sunxi NAND controller driver to
u-boot.
It's based on the Linux driver, with a few adaptions to make it work
in Linux.
It's based on Scott's series syncing the MTD/NAND frameworks with
Linux 4.6 [1].
Best Regards,
Boris
[1]https://patchwork.ozlabs.org/patch/627928/
Boris Brezillon (4):
sunxi: Add missing macros to configure the NAND controller clk
mtd: nand: Add the sunxi NAND controller driver
mtd: nand: Add a full-id entry for the H27QCG8T2E5R?BCF NAND
sunxi: Enable NAND controller on the CHIP
Brian Norris (1):
mtd: nand: add common DT init code
Maxime Ripard (1):
sun5i: Add NAND controller to the sun5i DTSI
arch/arm/dts/sun5i-a10s.dtsi | 14 +
arch/arm/dts/sun5i-a13-olinuxino.dts | 15 +
arch/arm/dts/sun5i-r8-chip.dts | 15 +
arch/arm/dts/sun5i.dtsi | 49 +
arch/arm/include/asm/arch-sunxi/clock_sun4i.h | 5 +
board/sunxi/board.c | 9 +-
drivers/mtd/nand/Kconfig | 8 +-
drivers/mtd/nand/Makefile | 1 +
drivers/mtd/nand/nand_base.c | 70 +
drivers/mtd/nand/nand_ids.c | 4 +
drivers/mtd/nand/sunxi_nand.c | 1845 +++++++++++++++++++++++++
include/configs/sunxi-common.h | 2 +
include/fdtdec.h | 1 +
include/linux/mtd/nand.h | 3 +
lib/fdtdec.c | 1 +
15 files changed, 2038 insertions(+), 4 deletions(-)
create mode 100644 drivers/mtd/nand/sunxi_nand.c
--
2.7.4
^ permalink raw reply [flat|nested] 15+ messages in thread* [U-Boot] [PATCH 1/6] sunxi: Add missing macros to configure the NAND controller clk 2016-06-06 15:21 [U-Boot] [PATCH 0/6] sunxi: Add NAND controller driver Boris Brezillon @ 2016-06-06 15:21 ` Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 2/6] mtd: nand: add common DT init code Boris Brezillon ` (5 subsequent siblings) 6 siblings, 0 replies; 15+ messages in thread From: Boris Brezillon @ 2016-06-06 15:21 UTC (permalink / raw) To: u-boot We some macro to manipulate the NAND controller clock. Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com> --- arch/arm/include/asm/arch-sunxi/clock_sun4i.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/arch/arm/include/asm/arch-sunxi/clock_sun4i.h b/arch/arm/include/asm/arch-sunxi/clock_sun4i.h index 0088bb9..d1c5ad0 100644 --- a/arch/arm/include/asm/arch-sunxi/clock_sun4i.h +++ b/arch/arm/include/asm/arch-sunxi/clock_sun4i.h @@ -269,6 +269,11 @@ struct sunxi_ccm_reg { #define CCM_MBUS_CTRL_CLK_SRC_PLL5 0x2 #define CCM_MBUS_CTRL_GATE (0x1 << 31) +#define CCM_NAND_CTRL_M(x) ((x) - 1) +#define CCM_NAND_CTRL_N(x) ((x) << 16) +#define CCM_NAND_CTRL_OSCM24 (0x0 << 24) +#define CCM_NAND_CTRL_PLL6 (0x1 << 24) +#define CCM_NAND_CTRL_PLL5 (0x2 << 24) #define CCM_NAND_CTRL_ENABLE (0x1 << 31) #define CCM_MMC_CTRL_M(x) ((x) - 1) -- 2.7.4 ^ permalink raw reply related [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 2/6] mtd: nand: add common DT init code 2016-06-06 15:21 [U-Boot] [PATCH 0/6] sunxi: Add NAND controller driver Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 1/6] sunxi: Add missing macros to configure the NAND controller clk Boris Brezillon @ 2016-06-06 15:21 ` Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver Boris Brezillon ` (4 subsequent siblings) 6 siblings, 0 replies; 15+ messages in thread From: Boris Brezillon @ 2016-06-06 15:21 UTC (permalink / raw) To: u-boot From: Brian Norris <computersforpeace@gmail.com> These are already-documented common bindings for NAND chips. Let's handle them in nand_base. If NAND controller drivers need to act on this data before bringing up the NAND chip (e.g., fill out ECC callback functions, change HW modes, etc.), then they can do so between calling nand_scan_ident() and nand_scan_tail(). The original commit has been slightly reworked to use the fdtdec_xxx() helpers (instead of the of_xxxx() ones). Signed-off-by: Brian Norris <computersforpeace@gmail.com> Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com> --- drivers/mtd/nand/nand_base.c | 70 ++++++++++++++++++++++++++++++++++++++++++++ include/linux/mtd/nand.h | 3 ++ 2 files changed, 73 insertions(+) diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c index 74c563c..c72ff86 100644 --- a/drivers/mtd/nand/nand_base.c +++ b/drivers/mtd/nand/nand_base.c @@ -29,6 +29,9 @@ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <common.h> +#if CONFIG_IS_ENABLED(OF_CONTROL) +#include <fdtdec.h> +#endif #include <malloc.h> #include <watchdog.h> #include <linux/err.h> @@ -3764,6 +3767,66 @@ ident_done: return type; } +#if CONFIG_IS_ENABLED(OF_CONTROL) +DECLARE_GLOBAL_DATA_PTR; + +static int nand_dt_init(struct mtd_info *mtd, struct nand_chip *chip, int node) +{ + int ret, ecc_mode = -1, ecc_strength, ecc_step; + const void *blob = gd->fdt_blob; + const char *str; + + ret = fdtdec_get_int(blob, node, "nand-bus-width", -1); + if (ret == 16) + chip->options |= NAND_BUSWIDTH_16; + + if (fdtdec_get_bool(blob, node, "nand-on-flash-bbt")) + chip->bbt_options |= NAND_BBT_USE_FLASH; + + str = fdt_getprop(blob, node, "nand-ecc-mode", NULL); + if (str) { + if (!strcmp(str, "none")) + ecc_mode = NAND_ECC_NONE; + else if (!strcmp(str, "soft")) + ecc_mode = NAND_ECC_SOFT; + else if (!strcmp(str, "hw")) + ecc_mode = NAND_ECC_HW; + else if (!strcmp(str, "hw_syndrome")) + ecc_mode = NAND_ECC_HW_SYNDROME; + else if (!strcmp(str, "hw_oob_first")) + ecc_mode = NAND_ECC_HW_OOB_FIRST; + else if (!strcmp(str, "soft_bch")) + ecc_mode = NAND_ECC_SOFT_BCH; + } + + + ecc_strength = fdtdec_get_int(blob, node, "nand-ecc-strength", -1); + ecc_step = fdtdec_get_int(blob, node, "nand-ecc-step-size", -1); + + if ((ecc_step >= 0 && !(ecc_strength >= 0)) || + (!(ecc_step >= 0) && ecc_strength >= 0)) { + pr_err("must set both strength and step size in DT\n"); + return -EINVAL; + } + + if (ecc_mode >= 0) + chip->ecc.mode = ecc_mode; + + if (ecc_strength >= 0) + chip->ecc.strength = ecc_strength; + + if (ecc_step > 0) + chip->ecc.size = ecc_step; + + return 0; +} +#else +static int nand_dt_init(struct mtd_info *mtd, struct nand_chip *chip, int node) +{ + return 0; +} +#endif /* CONFIG_IS_ENABLED(OF_CONTROL) */ + /** * nand_scan_ident - [NAND Interface] Scan for the NAND device * @mtd: MTD device structure @@ -3780,6 +3843,13 @@ int nand_scan_ident(struct mtd_info *mtd, int maxchips, int i, nand_maf_id, nand_dev_id; struct nand_chip *chip = mtd_to_nand(mtd); struct nand_flash_dev *type; + int ret; + + if (chip->flash_node) { + ret = nand_dt_init(mtd, chip, chip->flash_node); + if (ret) + return ret; + } /* Set the default functions */ nand_set_defaults(chip, chip->options & NAND_BUSWIDTH_16); diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h index b5a02c3..29aae43 100644 --- a/include/linux/mtd/nand.h +++ b/include/linux/mtd/nand.h @@ -590,6 +590,7 @@ struct nand_buffers { * flash device * @IO_ADDR_W: [BOARDSPECIFIC] address to write the 8 I/O lines of the * flash device. + * @flash_node: [BOARDSPECIFIC] device node describing this instance * @read_byte: [REPLACEABLE] read one byte from the chip * @read_word: [REPLACEABLE] read one word from the chip * @write_byte: [REPLACEABLE] write a single byte to the chip on the @@ -689,6 +690,8 @@ struct nand_chip { void __iomem *IO_ADDR_R; void __iomem *IO_ADDR_W; + int flash_node; + uint8_t (*read_byte)(struct mtd_info *mtd); u16 (*read_word)(struct mtd_info *mtd); void (*write_byte)(struct mtd_info *mtd, uint8_t byte); -- 2.7.4 ^ permalink raw reply related [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver 2016-06-06 15:21 [U-Boot] [PATCH 0/6] sunxi: Add NAND controller driver Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 1/6] sunxi: Add missing macros to configure the NAND controller clk Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 2/6] mtd: nand: add common DT init code Boris Brezillon @ 2016-06-06 15:21 ` Boris Brezillon 2016-06-06 15:36 ` Hans de Goede 2016-06-06 15:21 ` [U-Boot] [PATCH 4/6] sun5i: Add NAND controller to the sun5i DTSI Boris Brezillon ` (3 subsequent siblings) 6 siblings, 1 reply; 15+ messages in thread From: Boris Brezillon @ 2016-06-06 15:21 UTC (permalink / raw) To: u-boot We already have an SPL driver for the sunxi NAND controller, now add the normal/standard one. The source has been copied from Linux 4.6 with a few changes to make it work in u-boot. Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com> --- board/sunxi/board.c | 9 +- drivers/mtd/nand/Kconfig | 8 +- drivers/mtd/nand/Makefile | 1 + drivers/mtd/nand/sunxi_nand.c | 1845 ++++++++++++++++++++++++++++++++++++++++ include/configs/sunxi-common.h | 2 + include/fdtdec.h | 1 + lib/fdtdec.c | 1 + 7 files changed, 1863 insertions(+), 4 deletions(-) create mode 100644 drivers/mtd/nand/sunxi_nand.c diff --git a/board/sunxi/board.c b/board/sunxi/board.c index 3cf3614..e0b3fb0 100644 --- a/board/sunxi/board.c +++ b/board/sunxi/board.c @@ -142,7 +142,7 @@ void dram_init_banksize(void) } #endif -#if defined(CONFIG_NAND_SUNXI) && defined(CONFIG_SPL_BUILD) +#if defined(CONFIG_NAND_SUNXI) static void nand_pinmux_setup(void) { unsigned int pin; @@ -175,10 +175,17 @@ static void nand_clock_setup(void) setbits_le32(&ccm->nand0_clk_cfg, CCM_NAND_CTRL_ENABLE | AHB_DIV_1); } +#ifndef CONFIG_SPL_BUILD +void sunxi_nand_init(void); +#endif + void board_nand_init(void) { nand_pinmux_setup(); nand_clock_setup(); +#ifndef CONFIG_SPL_BUILD + sunxi_nand_init(); +#endif } #endif diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig index 8c46a2f..5ce7d6d 100644 --- a/drivers/mtd/nand/Kconfig +++ b/drivers/mtd/nand/Kconfig @@ -64,12 +64,14 @@ config NAND_PXA3XX PXA3xx processors (NFCv1) and also on Armada 370/XP (NFCv2). config NAND_SUNXI - bool "Support for NAND on Allwinner SoCs in SPL" + bool "Support for NAND on Allwinner SoCs" depends on MACH_SUN4I || MACH_SUN5I || MACH_SUN7I select SYS_NAND_SELF_INIT ---help--- - Enable support for NAND. This option allows SPL to read from - sunxi NAND using DMA transfers. + Enable support for NAND. This option enables the standard and + SPL drivers. + The SPL driver only supports reading from the NAND using DMA + transfers. config NAND_ARASAN bool "Configure Arasan Nand" diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile index 837d397..1df9273 100644 --- a/drivers/mtd/nand/Makefile +++ b/drivers/mtd/nand/Makefile @@ -66,6 +66,7 @@ obj-$(CONFIG_TEGRA_NAND) += tegra_nand.o obj-$(CONFIG_NAND_OMAP_GPMC) += omap_gpmc.o obj-$(CONFIG_NAND_OMAP_ELM) += omap_elm.o obj-$(CONFIG_NAND_PLAT) += nand_plat.o +obj-$(CONFIG_NAND_SUNXI) += sunxi_nand.o else # minimal SPL drivers diff --git a/drivers/mtd/nand/sunxi_nand.c b/drivers/mtd/nand/sunxi_nand.c new file mode 100644 index 0000000..c4e2cd7 --- /dev/null +++ b/drivers/mtd/nand/sunxi_nand.c @@ -0,0 +1,1845 @@ +/* + * Copyright (C) 2013 Boris BREZILLON <b.brezillon.dev@gmail.com> + * Copyright (C) 2015 Roy Spliet <r.spliet@ultimaker.com> + * + * Derived from: + * https://github.com/yuq/sunxi-nfc-mtd + * Copyright (C) 2013 Qiang Yu <yuq825@gmail.com> + * + * https://github.com/hno/Allwinner-Info + * Copyright (C) 2013 Henrik Nordstr?m <Henrik Nordstr?m> + * + * Copyright (C) 2013 Dmitriy B. <rzk333@gmail.com> + * Copyright (C) 2013 Sergey Lapin <slapin@ossfans.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include <common.h> +#include <fdtdec.h> +#include <memalign.h> +#include <nand.h> + +#include <linux/kernel.h> +#include <linux/mtd/mtd.h> +#include <linux/mtd/nand.h> +#include <linux/mtd/partitions.h> +#include <linux/io.h> + +#include <asm/gpio.h> +#include <asm/arch/clock.h> + +DECLARE_GLOBAL_DATA_PTR; + +#define NFC_REG_CTL 0x0000 +#define NFC_REG_ST 0x0004 +#define NFC_REG_INT 0x0008 +#define NFC_REG_TIMING_CTL 0x000C +#define NFC_REG_TIMING_CFG 0x0010 +#define NFC_REG_ADDR_LOW 0x0014 +#define NFC_REG_ADDR_HIGH 0x0018 +#define NFC_REG_SECTOR_NUM 0x001C +#define NFC_REG_CNT 0x0020 +#define NFC_REG_CMD 0x0024 +#define NFC_REG_RCMD_SET 0x0028 +#define NFC_REG_WCMD_SET 0x002C +#define NFC_REG_IO_DATA 0x0030 +#define NFC_REG_ECC_CTL 0x0034 +#define NFC_REG_ECC_ST 0x0038 +#define NFC_REG_DEBUG 0x003C +#define NFC_REG_ECC_ERR_CNT(x) ((0x0040 + (x)) & ~0x3) +#define NFC_REG_USER_DATA(x) (0x0050 + ((x) * 4)) +#define NFC_REG_SPARE_AREA 0x00A0 +#define NFC_REG_PAT_ID 0x00A4 +#define NFC_RAM0_BASE 0x0400 +#define NFC_RAM1_BASE 0x0800 + +/* define bit use in NFC_CTL */ +#define NFC_EN BIT(0) +#define NFC_RESET BIT(1) +#define NFC_BUS_WIDTH_MSK BIT(2) +#define NFC_BUS_WIDTH_8 (0 << 2) +#define NFC_BUS_WIDTH_16 (1 << 2) +#define NFC_RB_SEL_MSK BIT(3) +#define NFC_RB_SEL(x) ((x) << 3) +#define NFC_CE_SEL_MSK (0x7 << 24) +#define NFC_CE_SEL(x) ((x) << 24) +#define NFC_CE_CTL BIT(6) +#define NFC_PAGE_SHIFT_MSK (0xf << 8) +#define NFC_PAGE_SHIFT(x) (((x) < 10 ? 0 : (x) - 10) << 8) +#define NFC_SAM BIT(12) +#define NFC_RAM_METHOD BIT(14) +#define NFC_DEBUG_CTL BIT(31) + +/* define bit use in NFC_ST */ +#define NFC_RB_B2R BIT(0) +#define NFC_CMD_INT_FLAG BIT(1) +#define NFC_DMA_INT_FLAG BIT(2) +#define NFC_CMD_FIFO_STATUS BIT(3) +#define NFC_STA BIT(4) +#define NFC_NATCH_INT_FLAG BIT(5) +#define NFC_RB_STATE(x) BIT(x + 8) + +/* define bit use in NFC_INT */ +#define NFC_B2R_INT_ENABLE BIT(0) +#define NFC_CMD_INT_ENABLE BIT(1) +#define NFC_DMA_INT_ENABLE BIT(2) +#define NFC_INT_MASK (NFC_B2R_INT_ENABLE | \ + NFC_CMD_INT_ENABLE | \ + NFC_DMA_INT_ENABLE) + +/* define bit use in NFC_TIMING_CTL */ +#define NFC_TIMING_CTL_EDO BIT(8) + +/* define NFC_TIMING_CFG register layout */ +#define NFC_TIMING_CFG(tWB, tADL, tWHR, tRHW, tCAD) \ + (((tWB) & 0x3) | (((tADL) & 0x3) << 2) | \ + (((tWHR) & 0x3) << 4) | (((tRHW) & 0x3) << 6) | \ + (((tCAD) & 0x7) << 8)) + +/* define bit use in NFC_CMD */ +#define NFC_CMD_LOW_BYTE_MSK 0xff +#define NFC_CMD_HIGH_BYTE_MSK (0xff << 8) +#define NFC_CMD(x) (x) +#define NFC_ADR_NUM_MSK (0x7 << 16) +#define NFC_ADR_NUM(x) (((x) - 1) << 16) +#define NFC_SEND_ADR BIT(19) +#define NFC_ACCESS_DIR BIT(20) +#define NFC_DATA_TRANS BIT(21) +#define NFC_SEND_CMD1 BIT(22) +#define NFC_WAIT_FLAG BIT(23) +#define NFC_SEND_CMD2 BIT(24) +#define NFC_SEQ BIT(25) +#define NFC_DATA_SWAP_METHOD BIT(26) +#define NFC_ROW_AUTO_INC BIT(27) +#define NFC_SEND_CMD3 BIT(28) +#define NFC_SEND_CMD4 BIT(29) +#define NFC_CMD_TYPE_MSK (0x3 << 30) +#define NFC_NORMAL_OP (0 << 30) +#define NFC_ECC_OP (1 << 30) +#define NFC_PAGE_OP (2 << 30) + +/* define bit use in NFC_RCMD_SET */ +#define NFC_READ_CMD_MSK 0xff +#define NFC_RND_READ_CMD0_MSK (0xff << 8) +#define NFC_RND_READ_CMD1_MSK (0xff << 16) + +/* define bit use in NFC_WCMD_SET */ +#define NFC_PROGRAM_CMD_MSK 0xff +#define NFC_RND_WRITE_CMD_MSK (0xff << 8) +#define NFC_READ_CMD0_MSK (0xff << 16) +#define NFC_READ_CMD1_MSK (0xff << 24) + +/* define bit use in NFC_ECC_CTL */ +#define NFC_ECC_EN BIT(0) +#define NFC_ECC_PIPELINE BIT(3) +#define NFC_ECC_EXCEPTION BIT(4) +#define NFC_ECC_BLOCK_SIZE_MSK BIT(5) +#define NFC_ECC_BLOCK_512 (1 << 5) +#define NFC_RANDOM_EN BIT(9) +#define NFC_RANDOM_DIRECTION BIT(10) +#define NFC_ECC_MODE_MSK (0xf << 12) +#define NFC_ECC_MODE(x) ((x) << 12) +#define NFC_RANDOM_SEED_MSK (0x7fff << 16) +#define NFC_RANDOM_SEED(x) ((x) << 16) + +/* define bit use in NFC_ECC_ST */ +#define NFC_ECC_ERR(x) BIT(x) +#define NFC_ECC_PAT_FOUND(x) BIT(x + 16) +#define NFC_ECC_ERR_CNT(b, x) (((x) >> ((b) * 8)) & 0xff) + +#define NFC_DEFAULT_TIMEOUT_MS 1000 + +#define NFC_SRAM_SIZE 1024 + +#define NFC_MAX_CS 7 + +/* + * Ready/Busy detection type: describes the Ready/Busy detection modes + * + * @RB_NONE: no external detection available, rely on STATUS command + * and software timeouts + * @RB_NATIVE: use sunxi NAND controller Ready/Busy support. The Ready/Busy + * pin of the NAND flash chip must be connected to one of the + * native NAND R/B pins (those which can be muxed to the NAND + * Controller) + * @RB_GPIO: use a simple GPIO to handle Ready/Busy status. The Ready/Busy + * pin of the NAND flash chip must be connected to a GPIO capable + * pin. + */ +enum sunxi_nand_rb_type { + RB_NONE, + RB_NATIVE, + RB_GPIO, +}; + +/* + * Ready/Busy structure: stores information related to Ready/Busy detection + * + * @type: the Ready/Busy detection mode + * @info: information related to the R/B detection mode. Either a gpio + * id or a native R/B id (those supported by the NAND controller). + */ +struct sunxi_nand_rb { + enum sunxi_nand_rb_type type; + union { + struct gpio_desc gpio; + int nativeid; + } info; +}; + +/* + * Chip Select structure: stores information related to NAND Chip Select + * + * @cs: the NAND CS id used to communicate with a NAND Chip + * @rb: the Ready/Busy description + */ +struct sunxi_nand_chip_sel { + u8 cs; + struct sunxi_nand_rb rb; +}; + +/* + * sunxi HW ECC infos: stores information related to HW ECC support + * + * @mode: the sunxi ECC mode field deduced from ECC requirements + * @layout: the OOB layout depending on the ECC requirements and the + * selected ECC mode + */ +struct sunxi_nand_hw_ecc { + int mode; + struct nand_ecclayout layout; +}; + +/* + * NAND chip structure: stores NAND chip device related information + * + * @node: used to store NAND chips into a list + * @nand: base NAND chip structure + * @mtd: base MTD structure + * @clk_rate: clk_rate required for this NAND chip + * @timing_cfg TIMING_CFG register value for this NAND chip + * @selected: current active CS + * @nsels: number of CS lines required by the NAND chip + * @sels: array of CS lines descriptions + */ +struct sunxi_nand_chip { + struct list_head node; + struct nand_chip nand; + unsigned long clk_rate; + u32 timing_cfg; + u32 timing_ctl; + int selected; + int addr_cycles; + u32 addr[2]; + int cmd_cycles; + u8 cmd[2]; + int nsels; + struct sunxi_nand_chip_sel sels[0]; +}; + +static inline struct sunxi_nand_chip *to_sunxi_nand(struct nand_chip *nand) +{ + return container_of(nand, struct sunxi_nand_chip, nand); +} + +/* + * NAND Controller structure: stores sunxi NAND controller information + * + * @controller: base controller structure + * @dev: parent device (used to print error messages) + * @regs: NAND controller registers + * @ahb_clk: NAND Controller AHB clock + * @mod_clk: NAND Controller mod clock + * @assigned_cs: bitmask describing already assigned CS lines + * @clk_rate: NAND controller current clock rate + * @chips: a list containing all the NAND chips attached to + * this NAND controller + * @complete: a completion object used to wait for NAND + * controller events + */ +struct sunxi_nfc { + struct nand_hw_control controller; + struct device *dev; + void __iomem *regs; + struct clk *ahb_clk; + struct clk *mod_clk; + unsigned long assigned_cs; + unsigned long clk_rate; + struct list_head chips; +}; + +static inline struct sunxi_nfc *to_sunxi_nfc(struct nand_hw_control *ctrl) +{ + return container_of(ctrl, struct sunxi_nfc, controller); +} + +static void sunxi_nfc_set_clk_rate(unsigned long hz) +{ + struct sunxi_ccm_reg *const ccm = + (struct sunxi_ccm_reg *)SUNXI_CCM_BASE; + int div_m, div_n; + + div_m = (clock_get_pll6() + hz - 1) / hz; + for (div_n = 0; div_n < 3 && div_m > 16; div_n++) { + if (div_m % 2) + div_m++; + div_m >>= 1; + } + if (div_m > 16) + div_m = 16; + + /* config mod clock */ + writel(CCM_NAND_CTRL_ENABLE | CCM_NAND_CTRL_PLL6 | + CCM_NAND_CTRL_N(div_n) | CCM_NAND_CTRL_M(div_m), + &ccm->nand0_clk_cfg); + + /* gate on nand clock */ + setbits_le32(&ccm->ahb_gate0, (1 << AHB_GATE_OFFSET_NAND0)); +#ifdef CONFIG_MACH_SUN9I + setbits_le32(&ccm->ahb_gate1, (1 << AHB_GATE_OFFSET_DMA)); +#else + setbits_le32(&ccm->ahb_gate0, (1 << AHB_GATE_OFFSET_DMA)); +#endif +} + +static int sunxi_nfc_wait_int(struct sunxi_nfc *nfc, u32 flags, + unsigned int timeout_ms) +{ + unsigned int timeout_ticks; + u32 time_start, status; + int ret = -ETIMEDOUT; + + if (!timeout_ms) + timeout_ms = NFC_DEFAULT_TIMEOUT_MS; + + timeout_ticks = (timeout_ms * CONFIG_SYS_HZ) / 1000; + + time_start = get_timer(0); + + do { + status = readl(nfc->regs + NFC_REG_ST); + if ((status & flags) == flags) { + ret = 0; + break; + } + + udelay(1); + } while (get_timer(time_start) < timeout_ticks); + + writel(status & flags, nfc->regs + NFC_REG_ST); + + return ret; +} + +static int sunxi_nfc_wait_cmd_fifo_empty(struct sunxi_nfc *nfc) +{ + unsigned long timeout = (CONFIG_SYS_HZ * + NFC_DEFAULT_TIMEOUT_MS) / 1000; + u32 time_start; + + time_start = get_timer(0); + do { + if (!(readl(nfc->regs + NFC_REG_ST) & NFC_CMD_FIFO_STATUS)) + return 0; + } while (get_timer(time_start) < timeout); + + dev_err(nfc->dev, "wait for empty cmd FIFO timedout\n"); + return -ETIMEDOUT; +} + +static int sunxi_nfc_rst(struct sunxi_nfc *nfc) +{ + unsigned long timeout = (CONFIG_SYS_HZ * + NFC_DEFAULT_TIMEOUT_MS) / 1000; + u32 time_start; + + writel(0, nfc->regs + NFC_REG_ECC_CTL); + writel(NFC_RESET, nfc->regs + NFC_REG_CTL); + + time_start = get_timer(0); + do { + if (!(readl(nfc->regs + NFC_REG_CTL) & NFC_RESET)) + return 0; + } while (get_timer(time_start) < timeout); + + dev_err(nfc->dev, "wait for NAND controller reset timedout\n"); + return -ETIMEDOUT; +} + +static int sunxi_nfc_dev_ready(struct mtd_info *mtd) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand); + struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller); + struct sunxi_nand_rb *rb; + unsigned long timeo = (sunxi_nand->nand.state == FL_ERASING ? 400 : 20); + int ret; + + if (sunxi_nand->selected < 0) + return 0; + + rb = &sunxi_nand->sels[sunxi_nand->selected].rb; + + switch (rb->type) { + case RB_NATIVE: + ret = !!(readl(nfc->regs + NFC_REG_ST) & + NFC_RB_STATE(rb->info.nativeid)); + if (ret) + break; + + sunxi_nfc_wait_int(nfc, NFC_RB_B2R, timeo); + ret = !!(readl(nfc->regs + NFC_REG_ST) & + NFC_RB_STATE(rb->info.nativeid)); + break; + case RB_GPIO: + ret = dm_gpio_get_value(&rb->info.gpio); + break; + case RB_NONE: + default: + ret = 0; + dev_err(nfc->dev, "cannot check R/B NAND status!\n"); + break; + } + + return ret; +} + +static void sunxi_nfc_select_chip(struct mtd_info *mtd, int chip) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand); + struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller); + struct sunxi_nand_chip_sel *sel; + u32 ctl; + + if (chip > 0 && chip >= sunxi_nand->nsels) + return; + + if (chip == sunxi_nand->selected) + return; + + ctl = readl(nfc->regs + NFC_REG_CTL) & + ~(NFC_PAGE_SHIFT_MSK | NFC_CE_SEL_MSK | NFC_RB_SEL_MSK | NFC_EN); + + if (chip >= 0) { + sel = &sunxi_nand->sels[chip]; + + ctl |= NFC_CE_SEL(sel->cs) | NFC_EN | + NFC_PAGE_SHIFT(nand->page_shift - 10); + if (sel->rb.type == RB_NONE) { + nand->dev_ready = NULL; + } else { + nand->dev_ready = sunxi_nfc_dev_ready; + if (sel->rb.type == RB_NATIVE) + ctl |= NFC_RB_SEL(sel->rb.info.nativeid); + } + + writel(mtd->writesize, nfc->regs + NFC_REG_SPARE_AREA); + + if (nfc->clk_rate != sunxi_nand->clk_rate) { + sunxi_nfc_set_clk_rate(sunxi_nand->clk_rate); + nfc->clk_rate = sunxi_nand->clk_rate; + } + } + + writel(sunxi_nand->timing_ctl, nfc->regs + NFC_REG_TIMING_CTL); + writel(sunxi_nand->timing_cfg, nfc->regs + NFC_REG_TIMING_CFG); + writel(ctl, nfc->regs + NFC_REG_CTL); + + sunxi_nand->selected = chip; +} + +static void sunxi_nfc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand); + struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller); + int ret; + int cnt; + int offs = 0; + u32 tmp; + + while (len > offs) { + cnt = min(len - offs, NFC_SRAM_SIZE); + + ret = sunxi_nfc_wait_cmd_fifo_empty(nfc); + if (ret) + break; + + writel(cnt, nfc->regs + NFC_REG_CNT); + tmp = NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD; + writel(tmp, nfc->regs + NFC_REG_CMD); + + ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0); + if (ret) + break; + + if (buf) + memcpy_fromio(buf + offs, nfc->regs + NFC_RAM0_BASE, + cnt); + offs += cnt; + } +} + +static void sunxi_nfc_write_buf(struct mtd_info *mtd, const uint8_t *buf, + int len) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand); + struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller); + int ret; + int cnt; + int offs = 0; + u32 tmp; + + while (len > offs) { + cnt = min(len - offs, NFC_SRAM_SIZE); + + ret = sunxi_nfc_wait_cmd_fifo_empty(nfc); + if (ret) + break; + + writel(cnt, nfc->regs + NFC_REG_CNT); + memcpy_toio(nfc->regs + NFC_RAM0_BASE, buf + offs, cnt); + tmp = NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD | + NFC_ACCESS_DIR; + writel(tmp, nfc->regs + NFC_REG_CMD); + + ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0); + if (ret) + break; + + offs += cnt; + } +} + +static uint8_t sunxi_nfc_read_byte(struct mtd_info *mtd) +{ + uint8_t ret; + + sunxi_nfc_read_buf(mtd, &ret, 1); + + return ret; +} + +static void sunxi_nfc_cmd_ctrl(struct mtd_info *mtd, int dat, + unsigned int ctrl) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand); + struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller); + int ret; + u32 tmp; + + ret = sunxi_nfc_wait_cmd_fifo_empty(nfc); + if (ret) + return; + + if (ctrl & NAND_CTRL_CHANGE) { + tmp = readl(nfc->regs + NFC_REG_CTL); + if (ctrl & NAND_NCE) + tmp |= NFC_CE_CTL; + else + tmp &= ~NFC_CE_CTL; + writel(tmp, nfc->regs + NFC_REG_CTL); + } + + if (dat == NAND_CMD_NONE && (ctrl & NAND_NCE) && + !(ctrl & (NAND_CLE | NAND_ALE))) { + u32 cmd = 0; + + if (!sunxi_nand->addr_cycles && !sunxi_nand->cmd_cycles) + return; + + if (sunxi_nand->cmd_cycles--) + cmd |= NFC_SEND_CMD1 | sunxi_nand->cmd[0]; + + if (sunxi_nand->cmd_cycles--) { + cmd |= NFC_SEND_CMD2; + writel(sunxi_nand->cmd[1], + nfc->regs + NFC_REG_RCMD_SET); + } + + sunxi_nand->cmd_cycles = 0; + + if (sunxi_nand->addr_cycles) { + cmd |= NFC_SEND_ADR | + NFC_ADR_NUM(sunxi_nand->addr_cycles); + writel(sunxi_nand->addr[0], + nfc->regs + NFC_REG_ADDR_LOW); + } + + if (sunxi_nand->addr_cycles > 4) + writel(sunxi_nand->addr[1], + nfc->regs + NFC_REG_ADDR_HIGH); + + writel(cmd, nfc->regs + NFC_REG_CMD); + sunxi_nand->addr[0] = 0; + sunxi_nand->addr[1] = 0; + sunxi_nand->addr_cycles = 0; + sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0); + } + + if (ctrl & NAND_CLE) { + sunxi_nand->cmd[sunxi_nand->cmd_cycles++] = dat; + } else if (ctrl & NAND_ALE) { + sunxi_nand->addr[sunxi_nand->addr_cycles / 4] |= + dat << ((sunxi_nand->addr_cycles % 4) * 8); + sunxi_nand->addr_cycles++; + } +} + +/* These seed values have been extracted from Allwinner's BSP */ +static const u16 sunxi_nfc_randomizer_page_seeds[] = { + 0x2b75, 0x0bd0, 0x5ca3, 0x62d1, 0x1c93, 0x07e9, 0x2162, 0x3a72, + 0x0d67, 0x67f9, 0x1be7, 0x077d, 0x032f, 0x0dac, 0x2716, 0x2436, + 0x7922, 0x1510, 0x3860, 0x5287, 0x480f, 0x4252, 0x1789, 0x5a2d, + 0x2a49, 0x5e10, 0x437f, 0x4b4e, 0x2f45, 0x216e, 0x5cb7, 0x7130, + 0x2a3f, 0x60e4, 0x4dc9, 0x0ef0, 0x0f52, 0x1bb9, 0x6211, 0x7a56, + 0x226d, 0x4ea7, 0x6f36, 0x3692, 0x38bf, 0x0c62, 0x05eb, 0x4c55, + 0x60f4, 0x728c, 0x3b6f, 0x2037, 0x7f69, 0x0936, 0x651a, 0x4ceb, + 0x6218, 0x79f3, 0x383f, 0x18d9, 0x4f05, 0x5c82, 0x2912, 0x6f17, + 0x6856, 0x5938, 0x1007, 0x61ab, 0x3e7f, 0x57c2, 0x542f, 0x4f62, + 0x7454, 0x2eac, 0x7739, 0x42d4, 0x2f90, 0x435a, 0x2e52, 0x2064, + 0x637c, 0x66ad, 0x2c90, 0x0bad, 0x759c, 0x0029, 0x0986, 0x7126, + 0x1ca7, 0x1605, 0x386a, 0x27f5, 0x1380, 0x6d75, 0x24c3, 0x0f8e, + 0x2b7a, 0x1418, 0x1fd1, 0x7dc1, 0x2d8e, 0x43af, 0x2267, 0x7da3, + 0x4e3d, 0x1338, 0x50db, 0x454d, 0x764d, 0x40a3, 0x42e6, 0x262b, + 0x2d2e, 0x1aea, 0x2e17, 0x173d, 0x3a6e, 0x71bf, 0x25f9, 0x0a5d, + 0x7c57, 0x0fbe, 0x46ce, 0x4939, 0x6b17, 0x37bb, 0x3e91, 0x76db, +}; + +/* + * sunxi_nfc_randomizer_ecc512_seeds and sunxi_nfc_randomizer_ecc1024_seeds + * have been generated using + * sunxi_nfc_randomizer_step(seed, (step_size * 8) + 15), which is what + * the randomizer engine does internally before de/scrambling OOB data. + * + * Those tables are statically defined to avoid calculating randomizer state + * at runtime. + */ +static const u16 sunxi_nfc_randomizer_ecc512_seeds[] = { + 0x3346, 0x367f, 0x1f18, 0x769a, 0x4f64, 0x068c, 0x2ef1, 0x6b64, + 0x28a9, 0x15d7, 0x30f8, 0x3659, 0x53db, 0x7c5f, 0x71d4, 0x4409, + 0x26eb, 0x03cc, 0x655d, 0x47d4, 0x4daa, 0x0877, 0x712d, 0x3617, + 0x3264, 0x49aa, 0x7f9e, 0x588e, 0x4fbc, 0x7176, 0x7f91, 0x6c6d, + 0x4b95, 0x5fb7, 0x3844, 0x4037, 0x0184, 0x081b, 0x0ee8, 0x5b91, + 0x293d, 0x1f71, 0x0e6f, 0x402b, 0x5122, 0x1e52, 0x22be, 0x3d2d, + 0x75bc, 0x7c60, 0x6291, 0x1a2f, 0x61d4, 0x74aa, 0x4140, 0x29ab, + 0x472d, 0x2852, 0x017e, 0x15e8, 0x5ec2, 0x17cf, 0x7d0f, 0x06b8, + 0x117a, 0x6b94, 0x789b, 0x3126, 0x6ac5, 0x5be7, 0x150f, 0x51f8, + 0x7889, 0x0aa5, 0x663d, 0x77e8, 0x0b87, 0x3dcb, 0x360d, 0x218b, + 0x512f, 0x7dc9, 0x6a4d, 0x630a, 0x3547, 0x1dd2, 0x5aea, 0x69a5, + 0x7bfa, 0x5e4f, 0x1519, 0x6430, 0x3a0e, 0x5eb3, 0x5425, 0x0c7a, + 0x5540, 0x3670, 0x63c1, 0x31e9, 0x5a39, 0x2de7, 0x5979, 0x2891, + 0x1562, 0x014b, 0x5b05, 0x2756, 0x5a34, 0x13aa, 0x6cb5, 0x2c36, + 0x5e72, 0x1306, 0x0861, 0x15ef, 0x1ee8, 0x5a37, 0x7ac4, 0x45dd, + 0x44c4, 0x7266, 0x2f41, 0x3ccc, 0x045e, 0x7d40, 0x7c66, 0x0fa0, +}; + +static const u16 sunxi_nfc_randomizer_ecc1024_seeds[] = { + 0x2cf5, 0x35f1, 0x63a4, 0x5274, 0x2bd2, 0x778b, 0x7285, 0x32b6, + 0x6a5c, 0x70d6, 0x757d, 0x6769, 0x5375, 0x1e81, 0x0cf3, 0x3982, + 0x6787, 0x042a, 0x6c49, 0x1925, 0x56a8, 0x40a9, 0x063e, 0x7bd9, + 0x4dbf, 0x55ec, 0x672e, 0x7334, 0x5185, 0x4d00, 0x232a, 0x7e07, + 0x445d, 0x6b92, 0x528f, 0x4255, 0x53ba, 0x7d82, 0x2a2e, 0x3a4e, + 0x75eb, 0x450c, 0x6844, 0x1b5d, 0x581a, 0x4cc6, 0x0379, 0x37b2, + 0x419f, 0x0e92, 0x6b27, 0x5624, 0x01e3, 0x07c1, 0x44a5, 0x130c, + 0x13e8, 0x5910, 0x0876, 0x60c5, 0x54e3, 0x5b7f, 0x2269, 0x509f, + 0x7665, 0x36fd, 0x3e9a, 0x0579, 0x6295, 0x14ef, 0x0a81, 0x1bcc, + 0x4b16, 0x64db, 0x0514, 0x4f07, 0x0591, 0x3576, 0x6853, 0x0d9e, + 0x259f, 0x38b7, 0x64fb, 0x3094, 0x4693, 0x6ddd, 0x29bb, 0x0bc8, + 0x3f47, 0x490e, 0x0c0e, 0x7933, 0x3c9e, 0x5840, 0x398d, 0x3e68, + 0x4af1, 0x71f5, 0x57cf, 0x1121, 0x64eb, 0x3579, 0x15ac, 0x584d, + 0x5f2a, 0x47e2, 0x6528, 0x6eac, 0x196e, 0x6b96, 0x0450, 0x0179, + 0x609c, 0x06e1, 0x4626, 0x42c7, 0x273e, 0x486f, 0x0705, 0x1601, + 0x145b, 0x407e, 0x062b, 0x57a5, 0x53f9, 0x5659, 0x4410, 0x3ccd, +}; + +static u16 sunxi_nfc_randomizer_step(u16 state, int count) +{ + state &= 0x7fff; + + /* + * This loop is just a simple implementation of a Fibonacci LFSR using + * the x16 + x15 + 1 polynomial. + */ + while (count--) + state = ((state >> 1) | + (((state ^ (state >> 1)) & 1) << 14)) & 0x7fff; + + return state; +} + +static u16 sunxi_nfc_randomizer_state(struct mtd_info *mtd, int page, bool ecc) +{ + const u16 *seeds = sunxi_nfc_randomizer_page_seeds; + int mod = mtd->erasesize / mtd->writesize; + + if (mod > ARRAY_SIZE(sunxi_nfc_randomizer_page_seeds)) + mod = ARRAY_SIZE(sunxi_nfc_randomizer_page_seeds); + + if (ecc) { + if (mtd->ecc_step_size == 512) + seeds = sunxi_nfc_randomizer_ecc512_seeds; + else + seeds = sunxi_nfc_randomizer_ecc1024_seeds; + } + + return seeds[page % mod]; +} + +static void sunxi_nfc_randomizer_config(struct mtd_info *mtd, + int page, bool ecc) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); + u32 ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL); + u16 state; + + if (!(nand->options & NAND_NEED_SCRAMBLING)) + return; + + ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL); + state = sunxi_nfc_randomizer_state(mtd, page, ecc); + ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_RANDOM_SEED_MSK; + writel(ecc_ctl | NFC_RANDOM_SEED(state), nfc->regs + NFC_REG_ECC_CTL); +} + +static void sunxi_nfc_randomizer_enable(struct mtd_info *mtd) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); + + if (!(nand->options & NAND_NEED_SCRAMBLING)) + return; + + writel(readl(nfc->regs + NFC_REG_ECC_CTL) | NFC_RANDOM_EN, + nfc->regs + NFC_REG_ECC_CTL); +} + +static void sunxi_nfc_randomizer_disable(struct mtd_info *mtd) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); + + if (!(nand->options & NAND_NEED_SCRAMBLING)) + return; + + writel(readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_RANDOM_EN, + nfc->regs + NFC_REG_ECC_CTL); +} + +static void sunxi_nfc_randomize_bbm(struct mtd_info *mtd, int page, u8 *bbm) +{ + u16 state = sunxi_nfc_randomizer_state(mtd, page, true); + + bbm[0] ^= state; + bbm[1] ^= sunxi_nfc_randomizer_step(state, 8); +} + +static void sunxi_nfc_randomizer_write_buf(struct mtd_info *mtd, + const uint8_t *buf, int len, + bool ecc, int page) +{ + sunxi_nfc_randomizer_config(mtd, page, ecc); + sunxi_nfc_randomizer_enable(mtd); + sunxi_nfc_write_buf(mtd, buf, len); + sunxi_nfc_randomizer_disable(mtd); +} + +static void sunxi_nfc_randomizer_read_buf(struct mtd_info *mtd, uint8_t *buf, + int len, bool ecc, int page) +{ + sunxi_nfc_randomizer_config(mtd, page, ecc); + sunxi_nfc_randomizer_enable(mtd); + sunxi_nfc_read_buf(mtd, buf, len); + sunxi_nfc_randomizer_disable(mtd); +} + +static void sunxi_nfc_hw_ecc_enable(struct mtd_info *mtd) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); + struct sunxi_nand_hw_ecc *data = nand->ecc.priv; + u32 ecc_ctl; + + ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL); + ecc_ctl &= ~(NFC_ECC_MODE_MSK | NFC_ECC_PIPELINE | + NFC_ECC_BLOCK_SIZE_MSK); + ecc_ctl |= NFC_ECC_EN | NFC_ECC_MODE(data->mode) | NFC_ECC_EXCEPTION; + + if (nand->ecc.size == 512) + ecc_ctl |= NFC_ECC_BLOCK_512; + + writel(ecc_ctl, nfc->regs + NFC_REG_ECC_CTL); +} + +static void sunxi_nfc_hw_ecc_disable(struct mtd_info *mtd) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); + + writel(readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_ECC_EN, + nfc->regs + NFC_REG_ECC_CTL); +} + +static inline void sunxi_nfc_user_data_to_buf(u32 user_data, u8 *buf) +{ + buf[0] = user_data; + buf[1] = user_data >> 8; + buf[2] = user_data >> 16; + buf[3] = user_data >> 24; +} + +static int sunxi_nfc_hw_ecc_read_chunk(struct mtd_info *mtd, + u8 *data, int data_off, + u8 *oob, int oob_off, + int *cur_off, + unsigned int *max_bitflips, + bool bbm, int page) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); + struct nand_ecc_ctrl *ecc = &nand->ecc; + int raw_mode = 0; + u32 status; + int ret; + + if (*cur_off != data_off) + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, data_off, -1); + + sunxi_nfc_randomizer_read_buf(mtd, NULL, ecc->size, false, page); + + if (data_off + ecc->size != oob_off) + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1); + + ret = sunxi_nfc_wait_cmd_fifo_empty(nfc); + if (ret) + return ret; + + sunxi_nfc_randomizer_enable(mtd); + writel(NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD | NFC_ECC_OP, + nfc->regs + NFC_REG_CMD); + + ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0); + sunxi_nfc_randomizer_disable(mtd); + if (ret) + return ret; + + *cur_off = oob_off + ecc->bytes + 4; + + status = readl(nfc->regs + NFC_REG_ECC_ST); + if (status & NFC_ECC_PAT_FOUND(0)) { + u8 pattern = 0xff; + + if (unlikely(!(readl(nfc->regs + NFC_REG_PAT_ID) & 0x1))) + pattern = 0x0; + + memset(data, pattern, ecc->size); + memset(oob, pattern, ecc->bytes + 4); + + return 1; + } + + ret = NFC_ECC_ERR_CNT(0, readl(nfc->regs + NFC_REG_ECC_ERR_CNT(0))); + + memcpy_fromio(data, nfc->regs + NFC_RAM0_BASE, ecc->size); + + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1); + sunxi_nfc_randomizer_read_buf(mtd, oob, ecc->bytes + 4, true, page); + + if (status & NFC_ECC_ERR(0)) { + /* + * Re-read the data with the randomizer disabled to identify + * bitflips in erased pages. + */ + if (nand->options & NAND_NEED_SCRAMBLING) { + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, data_off, -1); + nand->read_buf(mtd, data, ecc->size); + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1); + nand->read_buf(mtd, oob, ecc->bytes + 4); + } + + ret = nand_check_erased_ecc_chunk(data, ecc->size, + oob, ecc->bytes + 4, + NULL, 0, ecc->strength); + if (ret >= 0) + raw_mode = 1; + } else { + /* + * The engine protects 4 bytes of OOB data per chunk. + * Retrieve the corrected OOB bytes. + */ + sunxi_nfc_user_data_to_buf(readl(nfc->regs + + NFC_REG_USER_DATA(0)), + oob); + + /* De-randomize the Bad Block Marker. */ + if (bbm && nand->options & NAND_NEED_SCRAMBLING) + sunxi_nfc_randomize_bbm(mtd, page, oob); + } + + if (ret < 0) { + mtd->ecc_stats.failed++; + } else { + mtd->ecc_stats.corrected += ret; + *max_bitflips = max_t(unsigned int, *max_bitflips, ret); + } + + return raw_mode; +} + +static void sunxi_nfc_hw_ecc_read_extra_oob(struct mtd_info *mtd, + u8 *oob, int *cur_off, + bool randomize, int page) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct nand_ecc_ctrl *ecc = &nand->ecc; + int offset = ((ecc->bytes + 4) * ecc->steps); + int len = mtd->oobsize - offset; + + if (len <= 0) + return; + + if (*cur_off != offset) + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, + offset + mtd->writesize, -1); + + if (!randomize) + sunxi_nfc_read_buf(mtd, oob + offset, len); + else + sunxi_nfc_randomizer_read_buf(mtd, oob + offset, len, + false, page); + + *cur_off = mtd->oobsize + mtd->writesize; +} + +static inline u32 sunxi_nfc_buf_to_user_data(const u8 *buf) +{ + return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); +} + +static int sunxi_nfc_hw_ecc_write_chunk(struct mtd_info *mtd, + const u8 *data, int data_off, + const u8 *oob, int oob_off, + int *cur_off, bool bbm, + int page) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); + struct nand_ecc_ctrl *ecc = &nand->ecc; + int ret; + + if (data_off != *cur_off) + nand->cmdfunc(mtd, NAND_CMD_RNDIN, data_off, -1); + + sunxi_nfc_randomizer_write_buf(mtd, data, ecc->size, false, page); + + /* Fill OOB data in */ + if ((nand->options & NAND_NEED_SCRAMBLING) && bbm) { + u8 user_data[4]; + + memcpy(user_data, oob, 4); + sunxi_nfc_randomize_bbm(mtd, page, user_data); + writel(sunxi_nfc_buf_to_user_data(user_data), + nfc->regs + NFC_REG_USER_DATA(0)); + } else { + writel(sunxi_nfc_buf_to_user_data(oob), + nfc->regs + NFC_REG_USER_DATA(0)); + } + + if (data_off + ecc->size != oob_off) + nand->cmdfunc(mtd, NAND_CMD_RNDIN, oob_off, -1); + + ret = sunxi_nfc_wait_cmd_fifo_empty(nfc); + if (ret) + return ret; + + sunxi_nfc_randomizer_enable(mtd); + writel(NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD | + NFC_ACCESS_DIR | NFC_ECC_OP, + nfc->regs + NFC_REG_CMD); + + ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0); + sunxi_nfc_randomizer_disable(mtd); + if (ret) + return ret; + + *cur_off = oob_off + ecc->bytes + 4; + + return 0; +} + +static void sunxi_nfc_hw_ecc_write_extra_oob(struct mtd_info *mtd, + u8 *oob, int *cur_off, + int page) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + struct nand_ecc_ctrl *ecc = &nand->ecc; + int offset = ((ecc->bytes + 4) * ecc->steps); + int len = mtd->oobsize - offset; + + if (len <= 0) + return; + + if (*cur_off != offset) + nand->cmdfunc(mtd, NAND_CMD_RNDIN, + offset + mtd->writesize, -1); + + sunxi_nfc_randomizer_write_buf(mtd, oob + offset, len, false, page); + + *cur_off = mtd->oobsize + mtd->writesize; +} + +static int sunxi_nfc_hw_ecc_read_page(struct mtd_info *mtd, + struct nand_chip *chip, uint8_t *buf, + int oob_required, int page) +{ + struct nand_ecc_ctrl *ecc = &chip->ecc; + unsigned int max_bitflips = 0; + int ret, i, cur_off = 0; + bool raw_mode = false; + + sunxi_nfc_hw_ecc_enable(mtd); + + for (i = 0; i < ecc->steps; i++) { + int data_off = i * ecc->size; + int oob_off = i * (ecc->bytes + 4); + u8 *data = buf + data_off; + u8 *oob = chip->oob_poi + oob_off; + + ret = sunxi_nfc_hw_ecc_read_chunk(mtd, data, data_off, oob, + oob_off + mtd->writesize, + &cur_off, &max_bitflips, + !i, page); + if (ret < 0) + return ret; + else if (ret) + raw_mode = true; + } + + if (oob_required) + sunxi_nfc_hw_ecc_read_extra_oob(mtd, chip->oob_poi, &cur_off, + !raw_mode, page); + + sunxi_nfc_hw_ecc_disable(mtd); + + return max_bitflips; +} + +static int sunxi_nfc_hw_ecc_read_subpage(struct mtd_info *mtd, + struct nand_chip *chip, + uint32_t data_offs, uint32_t readlen, + uint8_t *bufpoi, int page) +{ + struct nand_ecc_ctrl *ecc = &chip->ecc; + int ret, i, cur_off = 0; + unsigned int max_bitflips = 0; + + sunxi_nfc_hw_ecc_enable(mtd); + + chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page); + for (i = data_offs / ecc->size; + i < DIV_ROUND_UP(data_offs + readlen, ecc->size); i++) { + int data_off = i * ecc->size; + int oob_off = i * (ecc->bytes + 4); + u8 *data = bufpoi + data_off; + u8 *oob = chip->oob_poi + oob_off; + + ret = sunxi_nfc_hw_ecc_read_chunk(mtd, data, data_off, + oob, oob_off + mtd->writesize, + &cur_off, &max_bitflips, !i, page); + if (ret < 0) + return ret; + } + + sunxi_nfc_hw_ecc_disable(mtd); + + return max_bitflips; +} + +static int sunxi_nfc_hw_ecc_write_page(struct mtd_info *mtd, + struct nand_chip *chip, + const uint8_t *buf, int oob_required, + int page) +{ + struct nand_ecc_ctrl *ecc = &chip->ecc; + int ret, i, cur_off = 0; + + sunxi_nfc_hw_ecc_enable(mtd); + + for (i = 0; i < ecc->steps; i++) { + int data_off = i * ecc->size; + int oob_off = i * (ecc->bytes + 4); + const u8 *data = buf + data_off; + const u8 *oob = chip->oob_poi + oob_off; + + ret = sunxi_nfc_hw_ecc_write_chunk(mtd, data, data_off, oob, + oob_off + mtd->writesize, + &cur_off, !i, page); + if (ret) + return ret; + } + + if (oob_required || (chip->options & NAND_NEED_SCRAMBLING)) + sunxi_nfc_hw_ecc_write_extra_oob(mtd, chip->oob_poi, + &cur_off, page); + + sunxi_nfc_hw_ecc_disable(mtd); + + return 0; +} + +static int sunxi_nfc_hw_ecc_write_subpage(struct mtd_info *mtd, + struct nand_chip *chip, + u32 data_offs, u32 data_len, + const u8 *buf, int oob_required, + int page) +{ + struct nand_ecc_ctrl *ecc = &chip->ecc; + int ret, i, cur_off = 0; + + sunxi_nfc_hw_ecc_enable(mtd); + + for (i = data_offs / ecc->size; + i < DIV_ROUND_UP(data_offs + data_len, ecc->size); i++) { + int data_off = i * ecc->size; + int oob_off = i * (ecc->bytes + 4); + const u8 *data = buf + data_off; + const u8 *oob = chip->oob_poi + oob_off; + + ret = sunxi_nfc_hw_ecc_write_chunk(mtd, data, data_off, oob, + oob_off + mtd->writesize, + &cur_off, !i, page); + if (ret) + return ret; + } + + sunxi_nfc_hw_ecc_disable(mtd); + + return 0; +} + +static int sunxi_nfc_hw_syndrome_ecc_read_page(struct mtd_info *mtd, + struct nand_chip *chip, + uint8_t *buf, int oob_required, + int page) +{ + struct nand_ecc_ctrl *ecc = &chip->ecc; + unsigned int max_bitflips = 0; + int ret, i, cur_off = 0; + bool raw_mode = false; + + sunxi_nfc_hw_ecc_enable(mtd); + + for (i = 0; i < ecc->steps; i++) { + int data_off = i * (ecc->size + ecc->bytes + 4); + int oob_off = data_off + ecc->size; + u8 *data = buf + (i * ecc->size); + u8 *oob = chip->oob_poi + (i * (ecc->bytes + 4)); + + ret = sunxi_nfc_hw_ecc_read_chunk(mtd, data, data_off, oob, + oob_off, &cur_off, + &max_bitflips, !i, page); + if (ret < 0) + return ret; + else if (ret) + raw_mode = true; + } + + if (oob_required) + sunxi_nfc_hw_ecc_read_extra_oob(mtd, chip->oob_poi, &cur_off, + !raw_mode, page); + + sunxi_nfc_hw_ecc_disable(mtd); + + return max_bitflips; +} + +static int sunxi_nfc_hw_syndrome_ecc_write_page(struct mtd_info *mtd, + struct nand_chip *chip, + const uint8_t *buf, + int oob_required, int page) +{ + struct nand_ecc_ctrl *ecc = &chip->ecc; + int ret, i, cur_off = 0; + + sunxi_nfc_hw_ecc_enable(mtd); + + for (i = 0; i < ecc->steps; i++) { + int data_off = i * (ecc->size + ecc->bytes + 4); + int oob_off = data_off + ecc->size; + const u8 *data = buf + (i * ecc->size); + const u8 *oob = chip->oob_poi + (i * (ecc->bytes + 4)); + + ret = sunxi_nfc_hw_ecc_write_chunk(mtd, data, data_off, + oob, oob_off, &cur_off, + false, page); + if (ret) + return ret; + } + + if (oob_required || (chip->options & NAND_NEED_SCRAMBLING)) + sunxi_nfc_hw_ecc_write_extra_oob(mtd, chip->oob_poi, + &cur_off, page); + + sunxi_nfc_hw_ecc_disable(mtd); + + return 0; +} + +static const s32 tWB_lut[] = {6, 12, 16, 20}; +static const s32 tRHW_lut[] = {4, 8, 12, 20}; + +static int _sunxi_nand_lookup_timing(const s32 *lut, int lut_size, u32 duration, + u32 clk_period) +{ + u32 clk_cycles = DIV_ROUND_UP(duration, clk_period); + int i; + + for (i = 0; i < lut_size; i++) { + if (clk_cycles <= lut[i]) + return i; + } + + /* Doesn't fit */ + return -EINVAL; +} + +#define sunxi_nand_lookup_timing(l, p, c) \ + _sunxi_nand_lookup_timing(l, ARRAY_SIZE(l), p, c) + +static int sunxi_nand_chip_set_timings(struct sunxi_nand_chip *chip, + const struct nand_sdr_timings *timings) +{ + u32 min_clk_period = 0; + s32 tWB, tADL, tWHR, tRHW, tCAD; + + /* T1 <=> tCLS */ + if (timings->tCLS_min > min_clk_period) + min_clk_period = timings->tCLS_min; + + /* T2 <=> tCLH */ + if (timings->tCLH_min > min_clk_period) + min_clk_period = timings->tCLH_min; + + /* T3 <=> tCS */ + if (timings->tCS_min > min_clk_period) + min_clk_period = timings->tCS_min; + + /* T4 <=> tCH */ + if (timings->tCH_min > min_clk_period) + min_clk_period = timings->tCH_min; + + /* T5 <=> tWP */ + if (timings->tWP_min > min_clk_period) + min_clk_period = timings->tWP_min; + + /* T6 <=> tWH */ + if (timings->tWH_min > min_clk_period) + min_clk_period = timings->tWH_min; + + /* T7 <=> tALS */ + if (timings->tALS_min > min_clk_period) + min_clk_period = timings->tALS_min; + + /* T8 <=> tDS */ + if (timings->tDS_min > min_clk_period) + min_clk_period = timings->tDS_min; + + /* T9 <=> tDH */ + if (timings->tDH_min > min_clk_period) + min_clk_period = timings->tDH_min; + + /* T10 <=> tRR */ + if (timings->tRR_min > (min_clk_period * 3)) + min_clk_period = DIV_ROUND_UP(timings->tRR_min, 3); + + /* T11 <=> tALH */ + if (timings->tALH_min > min_clk_period) + min_clk_period = timings->tALH_min; + + /* T12 <=> tRP */ + if (timings->tRP_min > min_clk_period) + min_clk_period = timings->tRP_min; + + /* T13 <=> tREH */ + if (timings->tREH_min > min_clk_period) + min_clk_period = timings->tREH_min; + + /* T14 <=> tRC */ + if (timings->tRC_min > (min_clk_period * 2)) + min_clk_period = DIV_ROUND_UP(timings->tRC_min, 2); + + /* T15 <=> tWC */ + if (timings->tWC_min > (min_clk_period * 2)) + min_clk_period = DIV_ROUND_UP(timings->tWC_min, 2); + + /* T16 - T19 + tCAD */ + tWB = sunxi_nand_lookup_timing(tWB_lut, timings->tWB_max, + min_clk_period); + if (tWB < 0) { + dev_err(nfc->dev, "unsupported tWB\n"); + return tWB; + } + + tADL = DIV_ROUND_UP(timings->tADL_min, min_clk_period) >> 3; + if (tADL > 3) { + dev_err(nfc->dev, "unsupported tADL\n"); + return -EINVAL; + } + + tWHR = DIV_ROUND_UP(timings->tWHR_min, min_clk_period) >> 3; + if (tWHR > 3) { + dev_err(nfc->dev, "unsupported tWHR\n"); + return -EINVAL; + } + + tRHW = sunxi_nand_lookup_timing(tRHW_lut, timings->tRHW_min, + min_clk_period); + if (tRHW < 0) { + dev_err(nfc->dev, "unsupported tRHW\n"); + return tRHW; + } + + /* + * TODO: according to ONFI specs this value only applies for DDR NAND, + * but Allwinner seems to set this to 0x7. Mimic them for now. + */ + tCAD = 0x7; + + /* TODO: A83 has some more bits for CDQSS, CS, CLHZ, CCS, WC */ + chip->timing_cfg = NFC_TIMING_CFG(tWB, tADL, tWHR, tRHW, tCAD); + + /* + * ONFI specification 3.1, paragraph 4.15.2 dictates that EDO data + * output cycle timings shall be used if the host drives tRC less than + * 30 ns. + */ + chip->timing_ctl = (timings->tRC_min < 30000) ? NFC_TIMING_CTL_EDO : 0; + + /* Convert min_clk_period from picoseconds to nanoseconds */ + min_clk_period = DIV_ROUND_UP(min_clk_period, 1000); + + /* + * Convert min_clk_period into a clk frequency, then get the + * appropriate rate for the NAND controller IP given this formula + * (specified in the datasheet): + * nand clk_rate = min_clk_rate + */ + chip->clk_rate = 1000000000L / min_clk_period; + + return 0; +} + +static int sunxi_nand_chip_init_timings(struct sunxi_nand_chip *chip) +{ + struct mtd_info *mtd = nand_to_mtd(&chip->nand); + const struct nand_sdr_timings *timings; + int ret; + int mode; + + mode = onfi_get_async_timing_mode(&chip->nand); + if (mode == ONFI_TIMING_MODE_UNKNOWN) { + mode = chip->nand.onfi_timing_mode_default; + } else { + uint8_t feature[ONFI_SUBFEATURE_PARAM_LEN] = {}; + int i; + + mode = fls(mode) - 1; + if (mode < 0) + mode = 0; + + feature[0] = mode; + for (i = 0; i < chip->nsels; i++) { + chip->nand.select_chip(mtd, i); + ret = chip->nand.onfi_set_features(mtd, + &chip->nand, + ONFI_FEATURE_ADDR_TIMING_MODE, + feature); + chip->nand.select_chip(mtd, -1); + if (ret) + return ret; + } + } + + timings = onfi_async_timing_mode_to_sdr_timings(mode); + if (IS_ERR(timings)) + return PTR_ERR(timings); + + return sunxi_nand_chip_set_timings(chip, timings); +} + +static int sunxi_nand_hw_common_ecc_ctrl_init(struct mtd_info *mtd, + struct nand_ecc_ctrl *ecc) +{ + static const u8 strengths[] = { 16, 24, 28, 32, 40, 48, 56, 60, 64 }; + struct sunxi_nand_hw_ecc *data; + struct nand_ecclayout *layout; + int nsectors; + int ret; + int i; + + data = kzalloc(sizeof(*data), GFP_KERNEL); + if (!data) + return -ENOMEM; + + if (ecc->size != 512 && ecc->size != 1024) + return -EINVAL; + + /* Prefer 1k ECC chunk over 512 ones */ + if (ecc->size == 512 && mtd->writesize > 512) { + ecc->size = 1024; + ecc->strength *= 2; + } + + /* Add ECC info retrieval from DT */ + for (i = 0; i < ARRAY_SIZE(strengths); i++) { + if (ecc->strength <= strengths[i]) + break; + } + + if (i >= ARRAY_SIZE(strengths)) { + dev_err(nfc->dev, "unsupported strength\n"); + ret = -ENOTSUPP; + goto err; + } + + data->mode = i; + + /* HW ECC always request ECC bytes for 1024 bytes blocks */ + ecc->bytes = DIV_ROUND_UP(ecc->strength * fls(8 * 1024), 8); + + /* HW ECC always work with even numbers of ECC bytes */ + ecc->bytes = ALIGN(ecc->bytes, 2); + + layout = &data->layout; + nsectors = mtd->writesize / ecc->size; + + if (mtd->oobsize < ((ecc->bytes + 4) * nsectors)) { + ret = -EINVAL; + goto err; + } + + layout->eccbytes = (ecc->bytes * nsectors); + + ecc->layout = layout; + ecc->priv = data; + + return 0; + +err: + kfree(data); + + return ret; +} + +#ifndef __UBOOT__ +static void sunxi_nand_hw_common_ecc_ctrl_cleanup(struct nand_ecc_ctrl *ecc) +{ + kfree(ecc->priv); +} +#endif /* __UBOOT__ */ + +static int sunxi_nand_hw_ecc_ctrl_init(struct mtd_info *mtd, + struct nand_ecc_ctrl *ecc) +{ + struct nand_ecclayout *layout; + int nsectors; + int i, j; + int ret; + + ret = sunxi_nand_hw_common_ecc_ctrl_init(mtd, ecc); + if (ret) + return ret; + + ecc->read_page = sunxi_nfc_hw_ecc_read_page; + ecc->write_page = sunxi_nfc_hw_ecc_write_page; + ecc->read_subpage = sunxi_nfc_hw_ecc_read_subpage; + ecc->write_subpage = sunxi_nfc_hw_ecc_write_subpage; + layout = ecc->layout; + nsectors = mtd->writesize / ecc->size; + + for (i = 0; i < nsectors; i++) { + if (i) { + layout->oobfree[i].offset = + layout->oobfree[i - 1].offset + + layout->oobfree[i - 1].length + + ecc->bytes; + layout->oobfree[i].length = 4; + } else { + /* + * The first 2 bytes are used for BB markers, hence we + * only have 2 bytes available in the first user data + * section. + */ + layout->oobfree[i].length = 2; + layout->oobfree[i].offset = 2; + } + + for (j = 0; j < ecc->bytes; j++) + layout->eccpos[(ecc->bytes * i) + j] = + layout->oobfree[i].offset + + layout->oobfree[i].length + j; + } + + if (mtd->oobsize > (ecc->bytes + 4) * nsectors) { + layout->oobfree[nsectors].offset = + layout->oobfree[nsectors - 1].offset + + layout->oobfree[nsectors - 1].length + + ecc->bytes; + layout->oobfree[nsectors].length = mtd->oobsize - + ((ecc->bytes + 4) * nsectors); + } + + return 0; +} + +static int sunxi_nand_hw_syndrome_ecc_ctrl_init(struct mtd_info *mtd, + struct nand_ecc_ctrl *ecc) +{ + struct nand_ecclayout *layout; + int nsectors; + int i; + int ret; + + ret = sunxi_nand_hw_common_ecc_ctrl_init(mtd, ecc); + if (ret) + return ret; + + ecc->prepad = 4; + ecc->read_page = sunxi_nfc_hw_syndrome_ecc_read_page; + ecc->write_page = sunxi_nfc_hw_syndrome_ecc_write_page; + + layout = ecc->layout; + nsectors = mtd->writesize / ecc->size; + + for (i = 0; i < (ecc->bytes * nsectors); i++) + layout->eccpos[i] = i; + + layout->oobfree[0].length = mtd->oobsize - i; + layout->oobfree[0].offset = i; + + return 0; +} + +#ifndef __UBOOT__ +static void sunxi_nand_ecc_cleanup(struct nand_ecc_ctrl *ecc) +{ + switch (ecc->mode) { + case NAND_ECC_HW: + case NAND_ECC_HW_SYNDROME: + sunxi_nand_hw_common_ecc_ctrl_cleanup(ecc); + break; + case NAND_ECC_NONE: + kfree(ecc->layout); + default: + break; + } +} +#endif /* __UBOOT__ */ + +static int sunxi_nand_ecc_init(struct mtd_info *mtd, struct nand_ecc_ctrl *ecc) +{ + struct nand_chip *nand = mtd_to_nand(mtd); + int ret; + + if (!ecc->size) { + ecc->size = nand->ecc_step_ds; + ecc->strength = nand->ecc_strength_ds; + } + + if (!ecc->size || !ecc->strength) + return -EINVAL; + + switch (ecc->mode) { + case NAND_ECC_SOFT_BCH: + break; + case NAND_ECC_HW: + ret = sunxi_nand_hw_ecc_ctrl_init(mtd, ecc); + if (ret) + return ret; + break; + case NAND_ECC_HW_SYNDROME: + ret = sunxi_nand_hw_syndrome_ecc_ctrl_init(mtd, ecc); + if (ret) + return ret; + break; + case NAND_ECC_NONE: + ecc->layout = kzalloc(sizeof(*ecc->layout), GFP_KERNEL); + if (!ecc->layout) + return -ENOMEM; + ecc->layout->oobfree[0].length = mtd->oobsize; + case NAND_ECC_SOFT: + break; + default: + return -EINVAL; + } + + return 0; +} + +static int sunxi_nand_chip_init(int node, struct sunxi_nfc *nfc, int devnum) +{ + const struct nand_sdr_timings *timings; + const void *blob = gd->fdt_blob; + struct sunxi_nand_chip *chip; + struct mtd_info *mtd; + struct nand_chip *nand; + int nsels; + int ret; + int i; + u32 cs[8], rb[8]; + + if (!fdt_getprop(blob, node, "reg", &nsels)) + return -EINVAL; + + nsels /= sizeof(u32); + if (!nsels || nsels > 8) { + dev_err(dev, "invalid reg property size\n"); + return -EINVAL; + } + + chip = kzalloc(sizeof(*chip) + + (nsels * sizeof(struct sunxi_nand_chip_sel)), + GFP_KERNEL); + if (!chip) { + dev_err(dev, "could not allocate chip\n"); + return -ENOMEM; + } + + chip->nsels = nsels; + chip->selected = -1; + + for (i = 0; i < nsels; i++) { + cs[i] = -1; + rb[i] = -1; + } + + ret = fdtdec_get_int_array(gd->fdt_blob, node, "reg", cs, nsels); + if (ret) { + dev_err(dev, "could not retrieve reg property: %d\n", ret); + return ret; + } + + ret = fdtdec_get_int_array(gd->fdt_blob, node, "allwinner,rb", rb, + nsels); + if (ret) { + dev_err(dev, "could not retrieve reg property: %d\n", ret); + return ret; + } + + for (i = 0; i < nsels; i++) { + int tmp = cs[i]; + + if (tmp > NFC_MAX_CS) { + dev_err(dev, + "invalid reg value: %u (max CS = 7)\n", + tmp); + return -EINVAL; + } + + if (test_and_set_bit(tmp, &nfc->assigned_cs)) { + dev_err(dev, "CS %d already assigned\n", tmp); + return -EINVAL; + } + + chip->sels[i].cs = tmp; + + tmp = rb[i]; + if (tmp >= 0 && tmp < 2) { + chip->sels[i].rb.type = RB_NATIVE; + chip->sels[i].rb.info.nativeid = tmp; + } else { + ret = gpio_request_by_name_nodev(blob, node, + "rb-gpios", i, + &chip->sels[i].rb.info.gpio, + GPIOD_IS_IN); + if (ret) + chip->sels[i].rb.type = RB_GPIO; + else + chip->sels[i].rb.type = RB_NONE; + } + } + + timings = onfi_async_timing_mode_to_sdr_timings(0); + if (IS_ERR(timings)) { + ret = PTR_ERR(timings); + dev_err(dev, + "could not retrieve timings for ONFI mode 0: %d\n", + ret); + return ret; + } + + ret = sunxi_nand_chip_set_timings(chip, timings); + if (ret) { + dev_err(dev, "could not configure chip timings: %d\n", ret); + return ret; + } + + nand = &chip->nand; + /* Default tR value specified in the ONFI spec (chapter 4.15.1) */ + nand->chip_delay = 200; + nand->controller = &nfc->controller; + /* + * Set the ECC mode to the default value in case nothing is specified + * in the DT. + */ + nand->ecc.mode = NAND_ECC_HW; + nand->flash_node = node; + nand->select_chip = sunxi_nfc_select_chip; + nand->cmd_ctrl = sunxi_nfc_cmd_ctrl; + nand->read_buf = sunxi_nfc_read_buf; + nand->write_buf = sunxi_nfc_write_buf; + nand->read_byte = sunxi_nfc_read_byte; + + mtd = nand_to_mtd(nand); + ret = nand_scan_ident(mtd, nsels, NULL); + if (ret) + return ret; + + if (nand->bbt_options & NAND_BBT_USE_FLASH) + nand->bbt_options |= NAND_BBT_NO_OOB; + + if (nand->options & NAND_NEED_SCRAMBLING) + nand->options |= NAND_NO_SUBPAGE_WRITE; + + nand->options |= NAND_SUBPAGE_READ; + + ret = sunxi_nand_chip_init_timings(chip); + if (ret) { + dev_err(dev, "could not configure chip timings: %d\n", ret); + return ret; + } + + ret = sunxi_nand_ecc_init(mtd, &nand->ecc); + if (ret) { + dev_err(dev, "ECC init failed: %d\n", ret); + return ret; + } + + ret = nand_scan_tail(mtd); + if (ret) { + dev_err(dev, "nand_scan_tail failed: %d\n", ret); + return ret; + } + + ret = nand_register(devnum, mtd); + if (ret) { + dev_err(dev, "failed to register mtd device: %d\n", ret); + return ret; + } + + list_add_tail(&chip->node, &nfc->chips); + + return 0; +} + +static int sunxi_nand_chips_init(int node, struct sunxi_nfc *nfc) +{ + const void *blob = gd->fdt_blob; + int nand_node; + int ret, i = 0; + + for (nand_node = fdt_first_subnode(blob, node); nand_node >= 0; + nand_node = fdt_next_subnode(blob, nand_node)) + i++; + + if (i > 8) { + dev_err(dev, "too many NAND chips: %d (max = 8)\n", i); + return -EINVAL; + } + + i = 0; + for (nand_node = fdt_first_subnode(blob, node); nand_node >= 0; + nand_node = fdt_next_subnode(blob, nand_node)) { + ret = sunxi_nand_chip_init(nand_node, nfc, i++); + if (ret) + return ret; + } + + return 0; +} + +#ifndef __UBOOT__ +static void sunxi_nand_chips_cleanup(struct sunxi_nfc *nfc) +{ + struct sunxi_nand_chip *chip; + + while (!list_empty(&nfc->chips)) { + chip = list_first_entry(&nfc->chips, struct sunxi_nand_chip, + node); + nand_release(&chip->mtd); + sunxi_nand_ecc_cleanup(&chip->nand.ecc); + list_del(&chip->node); + kfree(chip); + } +} +#endif /* __UBOOT__ */ + +void sunxi_nand_init(void) +{ + const void *blob = gd->fdt_blob; + struct sunxi_nfc *nfc; + fdt_addr_t regs; + int node; + int ret; + + nfc = kzalloc(sizeof(*nfc), GFP_KERNEL); + if (!nfc) + return; + + spin_lock_init(&nfc->controller.lock); + init_waitqueue_head(&nfc->controller.wq); + INIT_LIST_HEAD(&nfc->chips); + + node = fdtdec_next_compatible(blob, 0, COMPAT_SUNXI_NAND); + if (node < 0) { + pr_err("unable to find nfc node in device tree\n"); + goto err; + } + + if (!fdtdec_get_is_enabled(blob, node)) { + pr_err("nfc disabled in device tree\n"); + goto err; + } + + regs = fdtdec_get_addr(blob, node, "reg"); + if (regs == FDT_ADDR_T_NONE) { + pr_err("unable to find nfc address in device tree\n"); + goto err; + } + + nfc->regs = (void *)regs; + + ret = sunxi_nfc_rst(nfc); + if (ret) + goto err; + + ret = sunxi_nand_chips_init(node, nfc); + if (ret) { + dev_err(dev, "failed to init nand chips\n"); + goto err; + } + + return; + +err: + kfree(nfc); +} + +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR("Boris BREZILLON"); +MODULE_DESCRIPTION("Allwinner NAND Flash Controller driver"); diff --git a/include/configs/sunxi-common.h b/include/configs/sunxi-common.h index ac2d931..70aaa76 100644 --- a/include/configs/sunxi-common.h +++ b/include/configs/sunxi-common.h @@ -135,6 +135,8 @@ #ifdef CONFIG_NAND_SUNXI #define CONFIG_SPL_NAND_SUPPORT 1 +#define CONFIG_SYS_NAND_ONFI_DETECTION +#define CONFIG_SYS_MAX_NAND_DEVICE 8 #endif /* mmc config */ diff --git a/include/fdtdec.h b/include/fdtdec.h index 37d482a..940ab8b 100644 --- a/include/fdtdec.h +++ b/include/fdtdec.h @@ -166,6 +166,7 @@ enum fdt_compat_id { COMPAT_INTEL_BAYTRAIL_FSP, /* Intel Bay Trail FSP */ COMPAT_INTEL_BAYTRAIL_FSP_MDP, /* Intel FSP memory-down params */ COMPAT_INTEL_IVYBRIDGE_FSP, /* Intel Ivy Bridge FSP */ + COMPAT_SUNXI_NAND, /* SUNXI NAND controller */ COMPAT_COUNT, }; diff --git a/lib/fdtdec.c b/lib/fdtdec.c index 70acc29..ed8e294 100644 --- a/lib/fdtdec.c +++ b/lib/fdtdec.c @@ -71,6 +71,7 @@ static const char * const compat_names[COMPAT_COUNT] = { COMPAT(COMPAT_INTEL_BAYTRAIL_FSP, "intel,baytrail-fsp"), COMPAT(COMPAT_INTEL_BAYTRAIL_FSP_MDP, "intel,baytrail-fsp-mdp"), COMPAT(COMPAT_INTEL_IVYBRIDGE_FSP, "intel,ivybridge-fsp"), + COMPAT(COMPAT_SUNXI_NAND, "allwinner,sun4i-a10-nand"), }; const char *fdtdec_get_compatible(enum fdt_compat_id id) -- 2.7.4 ^ permalink raw reply related [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver 2016-06-06 15:21 ` [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver Boris Brezillon @ 2016-06-06 15:36 ` Hans de Goede 2016-06-06 16:22 ` Boris Brezillon 0 siblings, 1 reply; 15+ messages in thread From: Hans de Goede @ 2016-06-06 15:36 UTC (permalink / raw) To: u-boot Hi, One small remark inline. On 06-06-16 17:21, Boris Brezillon wrote: > We already have an SPL driver for the sunxi NAND controller, now add > the normal/standard one. > > The source has been copied from Linux 4.6 with a few changes to make > it work in u-boot. > > Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com> > --- > board/sunxi/board.c | 9 +- > drivers/mtd/nand/Kconfig | 8 +- > drivers/mtd/nand/Makefile | 1 + > drivers/mtd/nand/sunxi_nand.c | 1845 ++++++++++++++++++++++++++++++++++++++++ > include/configs/sunxi-common.h | 2 + > include/fdtdec.h | 1 + > lib/fdtdec.c | 1 + > 7 files changed, 1863 insertions(+), 4 deletions(-) > create mode 100644 drivers/mtd/nand/sunxi_nand.c > > diff --git a/board/sunxi/board.c b/board/sunxi/board.c > index 3cf3614..e0b3fb0 100644 > --- a/board/sunxi/board.c > +++ b/board/sunxi/board.c > @@ -142,7 +142,7 @@ void dram_init_banksize(void) > } > #endif > > -#if defined(CONFIG_NAND_SUNXI) && defined(CONFIG_SPL_BUILD) > +#if defined(CONFIG_NAND_SUNXI) > static void nand_pinmux_setup(void) > { > unsigned int pin; > @@ -175,10 +175,17 @@ static void nand_clock_setup(void) > setbits_le32(&ccm->nand0_clk_cfg, CCM_NAND_CTRL_ENABLE | AHB_DIV_1); > } > > +#ifndef CONFIG_SPL_BUILD > +void sunxi_nand_init(void); > +#endif > + Can we have this in a header somewhere please, and without the #ifdef around it, that is not necessary for prototypes. Otherwise the entire series looks good to me. Regards, Hans > void board_nand_init(void) > { > nand_pinmux_setup(); > nand_clock_setup(); > +#ifndef CONFIG_SPL_BUILD > + sunxi_nand_init(); > +#endif > } > #endif > > diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig > index 8c46a2f..5ce7d6d 100644 > --- a/drivers/mtd/nand/Kconfig > +++ b/drivers/mtd/nand/Kconfig > @@ -64,12 +64,14 @@ config NAND_PXA3XX > PXA3xx processors (NFCv1) and also on Armada 370/XP (NFCv2). > > config NAND_SUNXI > - bool "Support for NAND on Allwinner SoCs in SPL" > + bool "Support for NAND on Allwinner SoCs" > depends on MACH_SUN4I || MACH_SUN5I || MACH_SUN7I > select SYS_NAND_SELF_INIT > ---help--- > - Enable support for NAND. This option allows SPL to read from > - sunxi NAND using DMA transfers. > + Enable support for NAND. This option enables the standard and > + SPL drivers. > + The SPL driver only supports reading from the NAND using DMA > + transfers. > > config NAND_ARASAN > bool "Configure Arasan Nand" > diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile > index 837d397..1df9273 100644 > --- a/drivers/mtd/nand/Makefile > +++ b/drivers/mtd/nand/Makefile > @@ -66,6 +66,7 @@ obj-$(CONFIG_TEGRA_NAND) += tegra_nand.o > obj-$(CONFIG_NAND_OMAP_GPMC) += omap_gpmc.o > obj-$(CONFIG_NAND_OMAP_ELM) += omap_elm.o > obj-$(CONFIG_NAND_PLAT) += nand_plat.o > +obj-$(CONFIG_NAND_SUNXI) += sunxi_nand.o > > else # minimal SPL drivers > > diff --git a/drivers/mtd/nand/sunxi_nand.c b/drivers/mtd/nand/sunxi_nand.c > new file mode 100644 > index 0000000..c4e2cd7 > --- /dev/null > +++ b/drivers/mtd/nand/sunxi_nand.c > @@ -0,0 +1,1845 @@ > +/* > + * Copyright (C) 2013 Boris BREZILLON <b.brezillon.dev@gmail.com> > + * Copyright (C) 2015 Roy Spliet <r.spliet@ultimaker.com> > + * > + * Derived from: > + * https://github.com/yuq/sunxi-nfc-mtd > + * Copyright (C) 2013 Qiang Yu <yuq825@gmail.com> > + * > + * https://github.com/hno/Allwinner-Info > + * Copyright (C) 2013 Henrik Nordstr?m <Henrik Nordstr?m> > + * > + * Copyright (C) 2013 Dmitriy B. <rzk333@gmail.com> > + * Copyright (C) 2013 Sergey Lapin <slapin@ossfans.org> > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * SPDX-License-Identifier: GPL-2.0+ > + */ > + > +#include <common.h> > +#include <fdtdec.h> > +#include <memalign.h> > +#include <nand.h> > + > +#include <linux/kernel.h> > +#include <linux/mtd/mtd.h> > +#include <linux/mtd/nand.h> > +#include <linux/mtd/partitions.h> > +#include <linux/io.h> > + > +#include <asm/gpio.h> > +#include <asm/arch/clock.h> > + > +DECLARE_GLOBAL_DATA_PTR; > + > +#define NFC_REG_CTL 0x0000 > +#define NFC_REG_ST 0x0004 > +#define NFC_REG_INT 0x0008 > +#define NFC_REG_TIMING_CTL 0x000C > +#define NFC_REG_TIMING_CFG 0x0010 > +#define NFC_REG_ADDR_LOW 0x0014 > +#define NFC_REG_ADDR_HIGH 0x0018 > +#define NFC_REG_SECTOR_NUM 0x001C > +#define NFC_REG_CNT 0x0020 > +#define NFC_REG_CMD 0x0024 > +#define NFC_REG_RCMD_SET 0x0028 > +#define NFC_REG_WCMD_SET 0x002C > +#define NFC_REG_IO_DATA 0x0030 > +#define NFC_REG_ECC_CTL 0x0034 > +#define NFC_REG_ECC_ST 0x0038 > +#define NFC_REG_DEBUG 0x003C > +#define NFC_REG_ECC_ERR_CNT(x) ((0x0040 + (x)) & ~0x3) > +#define NFC_REG_USER_DATA(x) (0x0050 + ((x) * 4)) > +#define NFC_REG_SPARE_AREA 0x00A0 > +#define NFC_REG_PAT_ID 0x00A4 > +#define NFC_RAM0_BASE 0x0400 > +#define NFC_RAM1_BASE 0x0800 > + > +/* define bit use in NFC_CTL */ > +#define NFC_EN BIT(0) > +#define NFC_RESET BIT(1) > +#define NFC_BUS_WIDTH_MSK BIT(2) > +#define NFC_BUS_WIDTH_8 (0 << 2) > +#define NFC_BUS_WIDTH_16 (1 << 2) > +#define NFC_RB_SEL_MSK BIT(3) > +#define NFC_RB_SEL(x) ((x) << 3) > +#define NFC_CE_SEL_MSK (0x7 << 24) > +#define NFC_CE_SEL(x) ((x) << 24) > +#define NFC_CE_CTL BIT(6) > +#define NFC_PAGE_SHIFT_MSK (0xf << 8) > +#define NFC_PAGE_SHIFT(x) (((x) < 10 ? 0 : (x) - 10) << 8) > +#define NFC_SAM BIT(12) > +#define NFC_RAM_METHOD BIT(14) > +#define NFC_DEBUG_CTL BIT(31) > + > +/* define bit use in NFC_ST */ > +#define NFC_RB_B2R BIT(0) > +#define NFC_CMD_INT_FLAG BIT(1) > +#define NFC_DMA_INT_FLAG BIT(2) > +#define NFC_CMD_FIFO_STATUS BIT(3) > +#define NFC_STA BIT(4) > +#define NFC_NATCH_INT_FLAG BIT(5) > +#define NFC_RB_STATE(x) BIT(x + 8) > + > +/* define bit use in NFC_INT */ > +#define NFC_B2R_INT_ENABLE BIT(0) > +#define NFC_CMD_INT_ENABLE BIT(1) > +#define NFC_DMA_INT_ENABLE BIT(2) > +#define NFC_INT_MASK (NFC_B2R_INT_ENABLE | \ > + NFC_CMD_INT_ENABLE | \ > + NFC_DMA_INT_ENABLE) > + > +/* define bit use in NFC_TIMING_CTL */ > +#define NFC_TIMING_CTL_EDO BIT(8) > + > +/* define NFC_TIMING_CFG register layout */ > +#define NFC_TIMING_CFG(tWB, tADL, tWHR, tRHW, tCAD) \ > + (((tWB) & 0x3) | (((tADL) & 0x3) << 2) | \ > + (((tWHR) & 0x3) << 4) | (((tRHW) & 0x3) << 6) | \ > + (((tCAD) & 0x7) << 8)) > + > +/* define bit use in NFC_CMD */ > +#define NFC_CMD_LOW_BYTE_MSK 0xff > +#define NFC_CMD_HIGH_BYTE_MSK (0xff << 8) > +#define NFC_CMD(x) (x) > +#define NFC_ADR_NUM_MSK (0x7 << 16) > +#define NFC_ADR_NUM(x) (((x) - 1) << 16) > +#define NFC_SEND_ADR BIT(19) > +#define NFC_ACCESS_DIR BIT(20) > +#define NFC_DATA_TRANS BIT(21) > +#define NFC_SEND_CMD1 BIT(22) > +#define NFC_WAIT_FLAG BIT(23) > +#define NFC_SEND_CMD2 BIT(24) > +#define NFC_SEQ BIT(25) > +#define NFC_DATA_SWAP_METHOD BIT(26) > +#define NFC_ROW_AUTO_INC BIT(27) > +#define NFC_SEND_CMD3 BIT(28) > +#define NFC_SEND_CMD4 BIT(29) > +#define NFC_CMD_TYPE_MSK (0x3 << 30) > +#define NFC_NORMAL_OP (0 << 30) > +#define NFC_ECC_OP (1 << 30) > +#define NFC_PAGE_OP (2 << 30) > + > +/* define bit use in NFC_RCMD_SET */ > +#define NFC_READ_CMD_MSK 0xff > +#define NFC_RND_READ_CMD0_MSK (0xff << 8) > +#define NFC_RND_READ_CMD1_MSK (0xff << 16) > + > +/* define bit use in NFC_WCMD_SET */ > +#define NFC_PROGRAM_CMD_MSK 0xff > +#define NFC_RND_WRITE_CMD_MSK (0xff << 8) > +#define NFC_READ_CMD0_MSK (0xff << 16) > +#define NFC_READ_CMD1_MSK (0xff << 24) > + > +/* define bit use in NFC_ECC_CTL */ > +#define NFC_ECC_EN BIT(0) > +#define NFC_ECC_PIPELINE BIT(3) > +#define NFC_ECC_EXCEPTION BIT(4) > +#define NFC_ECC_BLOCK_SIZE_MSK BIT(5) > +#define NFC_ECC_BLOCK_512 (1 << 5) > +#define NFC_RANDOM_EN BIT(9) > +#define NFC_RANDOM_DIRECTION BIT(10) > +#define NFC_ECC_MODE_MSK (0xf << 12) > +#define NFC_ECC_MODE(x) ((x) << 12) > +#define NFC_RANDOM_SEED_MSK (0x7fff << 16) > +#define NFC_RANDOM_SEED(x) ((x) << 16) > + > +/* define bit use in NFC_ECC_ST */ > +#define NFC_ECC_ERR(x) BIT(x) > +#define NFC_ECC_PAT_FOUND(x) BIT(x + 16) > +#define NFC_ECC_ERR_CNT(b, x) (((x) >> ((b) * 8)) & 0xff) > + > +#define NFC_DEFAULT_TIMEOUT_MS 1000 > + > +#define NFC_SRAM_SIZE 1024 > + > +#define NFC_MAX_CS 7 > + > +/* > + * Ready/Busy detection type: describes the Ready/Busy detection modes > + * > + * @RB_NONE: no external detection available, rely on STATUS command > + * and software timeouts > + * @RB_NATIVE: use sunxi NAND controller Ready/Busy support. The Ready/Busy > + * pin of the NAND flash chip must be connected to one of the > + * native NAND R/B pins (those which can be muxed to the NAND > + * Controller) > + * @RB_GPIO: use a simple GPIO to handle Ready/Busy status. The Ready/Busy > + * pin of the NAND flash chip must be connected to a GPIO capable > + * pin. > + */ > +enum sunxi_nand_rb_type { > + RB_NONE, > + RB_NATIVE, > + RB_GPIO, > +}; > + > +/* > + * Ready/Busy structure: stores information related to Ready/Busy detection > + * > + * @type: the Ready/Busy detection mode > + * @info: information related to the R/B detection mode. Either a gpio > + * id or a native R/B id (those supported by the NAND controller). > + */ > +struct sunxi_nand_rb { > + enum sunxi_nand_rb_type type; > + union { > + struct gpio_desc gpio; > + int nativeid; > + } info; > +}; > + > +/* > + * Chip Select structure: stores information related to NAND Chip Select > + * > + * @cs: the NAND CS id used to communicate with a NAND Chip > + * @rb: the Ready/Busy description > + */ > +struct sunxi_nand_chip_sel { > + u8 cs; > + struct sunxi_nand_rb rb; > +}; > + > +/* > + * sunxi HW ECC infos: stores information related to HW ECC support > + * > + * @mode: the sunxi ECC mode field deduced from ECC requirements > + * @layout: the OOB layout depending on the ECC requirements and the > + * selected ECC mode > + */ > +struct sunxi_nand_hw_ecc { > + int mode; > + struct nand_ecclayout layout; > +}; > + > +/* > + * NAND chip structure: stores NAND chip device related information > + * > + * @node: used to store NAND chips into a list > + * @nand: base NAND chip structure > + * @mtd: base MTD structure > + * @clk_rate: clk_rate required for this NAND chip > + * @timing_cfg TIMING_CFG register value for this NAND chip > + * @selected: current active CS > + * @nsels: number of CS lines required by the NAND chip > + * @sels: array of CS lines descriptions > + */ > +struct sunxi_nand_chip { > + struct list_head node; > + struct nand_chip nand; > + unsigned long clk_rate; > + u32 timing_cfg; > + u32 timing_ctl; > + int selected; > + int addr_cycles; > + u32 addr[2]; > + int cmd_cycles; > + u8 cmd[2]; > + int nsels; > + struct sunxi_nand_chip_sel sels[0]; > +}; > + > +static inline struct sunxi_nand_chip *to_sunxi_nand(struct nand_chip *nand) > +{ > + return container_of(nand, struct sunxi_nand_chip, nand); > +} > + > +/* > + * NAND Controller structure: stores sunxi NAND controller information > + * > + * @controller: base controller structure > + * @dev: parent device (used to print error messages) > + * @regs: NAND controller registers > + * @ahb_clk: NAND Controller AHB clock > + * @mod_clk: NAND Controller mod clock > + * @assigned_cs: bitmask describing already assigned CS lines > + * @clk_rate: NAND controller current clock rate > + * @chips: a list containing all the NAND chips attached to > + * this NAND controller > + * @complete: a completion object used to wait for NAND > + * controller events > + */ > +struct sunxi_nfc { > + struct nand_hw_control controller; > + struct device *dev; > + void __iomem *regs; > + struct clk *ahb_clk; > + struct clk *mod_clk; > + unsigned long assigned_cs; > + unsigned long clk_rate; > + struct list_head chips; > +}; > + > +static inline struct sunxi_nfc *to_sunxi_nfc(struct nand_hw_control *ctrl) > +{ > + return container_of(ctrl, struct sunxi_nfc, controller); > +} > + > +static void sunxi_nfc_set_clk_rate(unsigned long hz) > +{ > + struct sunxi_ccm_reg *const ccm = > + (struct sunxi_ccm_reg *)SUNXI_CCM_BASE; > + int div_m, div_n; > + > + div_m = (clock_get_pll6() + hz - 1) / hz; > + for (div_n = 0; div_n < 3 && div_m > 16; div_n++) { > + if (div_m % 2) > + div_m++; > + div_m >>= 1; > + } > + if (div_m > 16) > + div_m = 16; > + > + /* config mod clock */ > + writel(CCM_NAND_CTRL_ENABLE | CCM_NAND_CTRL_PLL6 | > + CCM_NAND_CTRL_N(div_n) | CCM_NAND_CTRL_M(div_m), > + &ccm->nand0_clk_cfg); > + > + /* gate on nand clock */ > + setbits_le32(&ccm->ahb_gate0, (1 << AHB_GATE_OFFSET_NAND0)); > +#ifdef CONFIG_MACH_SUN9I > + setbits_le32(&ccm->ahb_gate1, (1 << AHB_GATE_OFFSET_DMA)); > +#else > + setbits_le32(&ccm->ahb_gate0, (1 << AHB_GATE_OFFSET_DMA)); > +#endif > +} > + > +static int sunxi_nfc_wait_int(struct sunxi_nfc *nfc, u32 flags, > + unsigned int timeout_ms) > +{ > + unsigned int timeout_ticks; > + u32 time_start, status; > + int ret = -ETIMEDOUT; > + > + if (!timeout_ms) > + timeout_ms = NFC_DEFAULT_TIMEOUT_MS; > + > + timeout_ticks = (timeout_ms * CONFIG_SYS_HZ) / 1000; > + > + time_start = get_timer(0); > + > + do { > + status = readl(nfc->regs + NFC_REG_ST); > + if ((status & flags) == flags) { > + ret = 0; > + break; > + } > + > + udelay(1); > + } while (get_timer(time_start) < timeout_ticks); > + > + writel(status & flags, nfc->regs + NFC_REG_ST); > + > + return ret; > +} > + > +static int sunxi_nfc_wait_cmd_fifo_empty(struct sunxi_nfc *nfc) > +{ > + unsigned long timeout = (CONFIG_SYS_HZ * > + NFC_DEFAULT_TIMEOUT_MS) / 1000; > + u32 time_start; > + > + time_start = get_timer(0); > + do { > + if (!(readl(nfc->regs + NFC_REG_ST) & NFC_CMD_FIFO_STATUS)) > + return 0; > + } while (get_timer(time_start) < timeout); > + > + dev_err(nfc->dev, "wait for empty cmd FIFO timedout\n"); > + return -ETIMEDOUT; > +} > + > +static int sunxi_nfc_rst(struct sunxi_nfc *nfc) > +{ > + unsigned long timeout = (CONFIG_SYS_HZ * > + NFC_DEFAULT_TIMEOUT_MS) / 1000; > + u32 time_start; > + > + writel(0, nfc->regs + NFC_REG_ECC_CTL); > + writel(NFC_RESET, nfc->regs + NFC_REG_CTL); > + > + time_start = get_timer(0); > + do { > + if (!(readl(nfc->regs + NFC_REG_CTL) & NFC_RESET)) > + return 0; > + } while (get_timer(time_start) < timeout); > + > + dev_err(nfc->dev, "wait for NAND controller reset timedout\n"); > + return -ETIMEDOUT; > +} > + > +static int sunxi_nfc_dev_ready(struct mtd_info *mtd) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand); > + struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller); > + struct sunxi_nand_rb *rb; > + unsigned long timeo = (sunxi_nand->nand.state == FL_ERASING ? 400 : 20); > + int ret; > + > + if (sunxi_nand->selected < 0) > + return 0; > + > + rb = &sunxi_nand->sels[sunxi_nand->selected].rb; > + > + switch (rb->type) { > + case RB_NATIVE: > + ret = !!(readl(nfc->regs + NFC_REG_ST) & > + NFC_RB_STATE(rb->info.nativeid)); > + if (ret) > + break; > + > + sunxi_nfc_wait_int(nfc, NFC_RB_B2R, timeo); > + ret = !!(readl(nfc->regs + NFC_REG_ST) & > + NFC_RB_STATE(rb->info.nativeid)); > + break; > + case RB_GPIO: > + ret = dm_gpio_get_value(&rb->info.gpio); > + break; > + case RB_NONE: > + default: > + ret = 0; > + dev_err(nfc->dev, "cannot check R/B NAND status!\n"); > + break; > + } > + > + return ret; > +} > + > +static void sunxi_nfc_select_chip(struct mtd_info *mtd, int chip) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand); > + struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller); > + struct sunxi_nand_chip_sel *sel; > + u32 ctl; > + > + if (chip > 0 && chip >= sunxi_nand->nsels) > + return; > + > + if (chip == sunxi_nand->selected) > + return; > + > + ctl = readl(nfc->regs + NFC_REG_CTL) & > + ~(NFC_PAGE_SHIFT_MSK | NFC_CE_SEL_MSK | NFC_RB_SEL_MSK | NFC_EN); > + > + if (chip >= 0) { > + sel = &sunxi_nand->sels[chip]; > + > + ctl |= NFC_CE_SEL(sel->cs) | NFC_EN | > + NFC_PAGE_SHIFT(nand->page_shift - 10); > + if (sel->rb.type == RB_NONE) { > + nand->dev_ready = NULL; > + } else { > + nand->dev_ready = sunxi_nfc_dev_ready; > + if (sel->rb.type == RB_NATIVE) > + ctl |= NFC_RB_SEL(sel->rb.info.nativeid); > + } > + > + writel(mtd->writesize, nfc->regs + NFC_REG_SPARE_AREA); > + > + if (nfc->clk_rate != sunxi_nand->clk_rate) { > + sunxi_nfc_set_clk_rate(sunxi_nand->clk_rate); > + nfc->clk_rate = sunxi_nand->clk_rate; > + } > + } > + > + writel(sunxi_nand->timing_ctl, nfc->regs + NFC_REG_TIMING_CTL); > + writel(sunxi_nand->timing_cfg, nfc->regs + NFC_REG_TIMING_CFG); > + writel(ctl, nfc->regs + NFC_REG_CTL); > + > + sunxi_nand->selected = chip; > +} > + > +static void sunxi_nfc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand); > + struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller); > + int ret; > + int cnt; > + int offs = 0; > + u32 tmp; > + > + while (len > offs) { > + cnt = min(len - offs, NFC_SRAM_SIZE); > + > + ret = sunxi_nfc_wait_cmd_fifo_empty(nfc); > + if (ret) > + break; > + > + writel(cnt, nfc->regs + NFC_REG_CNT); > + tmp = NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD; > + writel(tmp, nfc->regs + NFC_REG_CMD); > + > + ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0); > + if (ret) > + break; > + > + if (buf) > + memcpy_fromio(buf + offs, nfc->regs + NFC_RAM0_BASE, > + cnt); > + offs += cnt; > + } > +} > + > +static void sunxi_nfc_write_buf(struct mtd_info *mtd, const uint8_t *buf, > + int len) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand); > + struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller); > + int ret; > + int cnt; > + int offs = 0; > + u32 tmp; > + > + while (len > offs) { > + cnt = min(len - offs, NFC_SRAM_SIZE); > + > + ret = sunxi_nfc_wait_cmd_fifo_empty(nfc); > + if (ret) > + break; > + > + writel(cnt, nfc->regs + NFC_REG_CNT); > + memcpy_toio(nfc->regs + NFC_RAM0_BASE, buf + offs, cnt); > + tmp = NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD | > + NFC_ACCESS_DIR; > + writel(tmp, nfc->regs + NFC_REG_CMD); > + > + ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0); > + if (ret) > + break; > + > + offs += cnt; > + } > +} > + > +static uint8_t sunxi_nfc_read_byte(struct mtd_info *mtd) > +{ > + uint8_t ret; > + > + sunxi_nfc_read_buf(mtd, &ret, 1); > + > + return ret; > +} > + > +static void sunxi_nfc_cmd_ctrl(struct mtd_info *mtd, int dat, > + unsigned int ctrl) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand); > + struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller); > + int ret; > + u32 tmp; > + > + ret = sunxi_nfc_wait_cmd_fifo_empty(nfc); > + if (ret) > + return; > + > + if (ctrl & NAND_CTRL_CHANGE) { > + tmp = readl(nfc->regs + NFC_REG_CTL); > + if (ctrl & NAND_NCE) > + tmp |= NFC_CE_CTL; > + else > + tmp &= ~NFC_CE_CTL; > + writel(tmp, nfc->regs + NFC_REG_CTL); > + } > + > + if (dat == NAND_CMD_NONE && (ctrl & NAND_NCE) && > + !(ctrl & (NAND_CLE | NAND_ALE))) { > + u32 cmd = 0; > + > + if (!sunxi_nand->addr_cycles && !sunxi_nand->cmd_cycles) > + return; > + > + if (sunxi_nand->cmd_cycles--) > + cmd |= NFC_SEND_CMD1 | sunxi_nand->cmd[0]; > + > + if (sunxi_nand->cmd_cycles--) { > + cmd |= NFC_SEND_CMD2; > + writel(sunxi_nand->cmd[1], > + nfc->regs + NFC_REG_RCMD_SET); > + } > + > + sunxi_nand->cmd_cycles = 0; > + > + if (sunxi_nand->addr_cycles) { > + cmd |= NFC_SEND_ADR | > + NFC_ADR_NUM(sunxi_nand->addr_cycles); > + writel(sunxi_nand->addr[0], > + nfc->regs + NFC_REG_ADDR_LOW); > + } > + > + if (sunxi_nand->addr_cycles > 4) > + writel(sunxi_nand->addr[1], > + nfc->regs + NFC_REG_ADDR_HIGH); > + > + writel(cmd, nfc->regs + NFC_REG_CMD); > + sunxi_nand->addr[0] = 0; > + sunxi_nand->addr[1] = 0; > + sunxi_nand->addr_cycles = 0; > + sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0); > + } > + > + if (ctrl & NAND_CLE) { > + sunxi_nand->cmd[sunxi_nand->cmd_cycles++] = dat; > + } else if (ctrl & NAND_ALE) { > + sunxi_nand->addr[sunxi_nand->addr_cycles / 4] |= > + dat << ((sunxi_nand->addr_cycles % 4) * 8); > + sunxi_nand->addr_cycles++; > + } > +} > + > +/* These seed values have been extracted from Allwinner's BSP */ > +static const u16 sunxi_nfc_randomizer_page_seeds[] = { > + 0x2b75, 0x0bd0, 0x5ca3, 0x62d1, 0x1c93, 0x07e9, 0x2162, 0x3a72, > + 0x0d67, 0x67f9, 0x1be7, 0x077d, 0x032f, 0x0dac, 0x2716, 0x2436, > + 0x7922, 0x1510, 0x3860, 0x5287, 0x480f, 0x4252, 0x1789, 0x5a2d, > + 0x2a49, 0x5e10, 0x437f, 0x4b4e, 0x2f45, 0x216e, 0x5cb7, 0x7130, > + 0x2a3f, 0x60e4, 0x4dc9, 0x0ef0, 0x0f52, 0x1bb9, 0x6211, 0x7a56, > + 0x226d, 0x4ea7, 0x6f36, 0x3692, 0x38bf, 0x0c62, 0x05eb, 0x4c55, > + 0x60f4, 0x728c, 0x3b6f, 0x2037, 0x7f69, 0x0936, 0x651a, 0x4ceb, > + 0x6218, 0x79f3, 0x383f, 0x18d9, 0x4f05, 0x5c82, 0x2912, 0x6f17, > + 0x6856, 0x5938, 0x1007, 0x61ab, 0x3e7f, 0x57c2, 0x542f, 0x4f62, > + 0x7454, 0x2eac, 0x7739, 0x42d4, 0x2f90, 0x435a, 0x2e52, 0x2064, > + 0x637c, 0x66ad, 0x2c90, 0x0bad, 0x759c, 0x0029, 0x0986, 0x7126, > + 0x1ca7, 0x1605, 0x386a, 0x27f5, 0x1380, 0x6d75, 0x24c3, 0x0f8e, > + 0x2b7a, 0x1418, 0x1fd1, 0x7dc1, 0x2d8e, 0x43af, 0x2267, 0x7da3, > + 0x4e3d, 0x1338, 0x50db, 0x454d, 0x764d, 0x40a3, 0x42e6, 0x262b, > + 0x2d2e, 0x1aea, 0x2e17, 0x173d, 0x3a6e, 0x71bf, 0x25f9, 0x0a5d, > + 0x7c57, 0x0fbe, 0x46ce, 0x4939, 0x6b17, 0x37bb, 0x3e91, 0x76db, > +}; > + > +/* > + * sunxi_nfc_randomizer_ecc512_seeds and sunxi_nfc_randomizer_ecc1024_seeds > + * have been generated using > + * sunxi_nfc_randomizer_step(seed, (step_size * 8) + 15), which is what > + * the randomizer engine does internally before de/scrambling OOB data. > + * > + * Those tables are statically defined to avoid calculating randomizer state > + * at runtime. > + */ > +static const u16 sunxi_nfc_randomizer_ecc512_seeds[] = { > + 0x3346, 0x367f, 0x1f18, 0x769a, 0x4f64, 0x068c, 0x2ef1, 0x6b64, > + 0x28a9, 0x15d7, 0x30f8, 0x3659, 0x53db, 0x7c5f, 0x71d4, 0x4409, > + 0x26eb, 0x03cc, 0x655d, 0x47d4, 0x4daa, 0x0877, 0x712d, 0x3617, > + 0x3264, 0x49aa, 0x7f9e, 0x588e, 0x4fbc, 0x7176, 0x7f91, 0x6c6d, > + 0x4b95, 0x5fb7, 0x3844, 0x4037, 0x0184, 0x081b, 0x0ee8, 0x5b91, > + 0x293d, 0x1f71, 0x0e6f, 0x402b, 0x5122, 0x1e52, 0x22be, 0x3d2d, > + 0x75bc, 0x7c60, 0x6291, 0x1a2f, 0x61d4, 0x74aa, 0x4140, 0x29ab, > + 0x472d, 0x2852, 0x017e, 0x15e8, 0x5ec2, 0x17cf, 0x7d0f, 0x06b8, > + 0x117a, 0x6b94, 0x789b, 0x3126, 0x6ac5, 0x5be7, 0x150f, 0x51f8, > + 0x7889, 0x0aa5, 0x663d, 0x77e8, 0x0b87, 0x3dcb, 0x360d, 0x218b, > + 0x512f, 0x7dc9, 0x6a4d, 0x630a, 0x3547, 0x1dd2, 0x5aea, 0x69a5, > + 0x7bfa, 0x5e4f, 0x1519, 0x6430, 0x3a0e, 0x5eb3, 0x5425, 0x0c7a, > + 0x5540, 0x3670, 0x63c1, 0x31e9, 0x5a39, 0x2de7, 0x5979, 0x2891, > + 0x1562, 0x014b, 0x5b05, 0x2756, 0x5a34, 0x13aa, 0x6cb5, 0x2c36, > + 0x5e72, 0x1306, 0x0861, 0x15ef, 0x1ee8, 0x5a37, 0x7ac4, 0x45dd, > + 0x44c4, 0x7266, 0x2f41, 0x3ccc, 0x045e, 0x7d40, 0x7c66, 0x0fa0, > +}; > + > +static const u16 sunxi_nfc_randomizer_ecc1024_seeds[] = { > + 0x2cf5, 0x35f1, 0x63a4, 0x5274, 0x2bd2, 0x778b, 0x7285, 0x32b6, > + 0x6a5c, 0x70d6, 0x757d, 0x6769, 0x5375, 0x1e81, 0x0cf3, 0x3982, > + 0x6787, 0x042a, 0x6c49, 0x1925, 0x56a8, 0x40a9, 0x063e, 0x7bd9, > + 0x4dbf, 0x55ec, 0x672e, 0x7334, 0x5185, 0x4d00, 0x232a, 0x7e07, > + 0x445d, 0x6b92, 0x528f, 0x4255, 0x53ba, 0x7d82, 0x2a2e, 0x3a4e, > + 0x75eb, 0x450c, 0x6844, 0x1b5d, 0x581a, 0x4cc6, 0x0379, 0x37b2, > + 0x419f, 0x0e92, 0x6b27, 0x5624, 0x01e3, 0x07c1, 0x44a5, 0x130c, > + 0x13e8, 0x5910, 0x0876, 0x60c5, 0x54e3, 0x5b7f, 0x2269, 0x509f, > + 0x7665, 0x36fd, 0x3e9a, 0x0579, 0x6295, 0x14ef, 0x0a81, 0x1bcc, > + 0x4b16, 0x64db, 0x0514, 0x4f07, 0x0591, 0x3576, 0x6853, 0x0d9e, > + 0x259f, 0x38b7, 0x64fb, 0x3094, 0x4693, 0x6ddd, 0x29bb, 0x0bc8, > + 0x3f47, 0x490e, 0x0c0e, 0x7933, 0x3c9e, 0x5840, 0x398d, 0x3e68, > + 0x4af1, 0x71f5, 0x57cf, 0x1121, 0x64eb, 0x3579, 0x15ac, 0x584d, > + 0x5f2a, 0x47e2, 0x6528, 0x6eac, 0x196e, 0x6b96, 0x0450, 0x0179, > + 0x609c, 0x06e1, 0x4626, 0x42c7, 0x273e, 0x486f, 0x0705, 0x1601, > + 0x145b, 0x407e, 0x062b, 0x57a5, 0x53f9, 0x5659, 0x4410, 0x3ccd, > +}; > + > +static u16 sunxi_nfc_randomizer_step(u16 state, int count) > +{ > + state &= 0x7fff; > + > + /* > + * This loop is just a simple implementation of a Fibonacci LFSR using > + * the x16 + x15 + 1 polynomial. > + */ > + while (count--) > + state = ((state >> 1) | > + (((state ^ (state >> 1)) & 1) << 14)) & 0x7fff; > + > + return state; > +} > + > +static u16 sunxi_nfc_randomizer_state(struct mtd_info *mtd, int page, bool ecc) > +{ > + const u16 *seeds = sunxi_nfc_randomizer_page_seeds; > + int mod = mtd->erasesize / mtd->writesize; > + > + if (mod > ARRAY_SIZE(sunxi_nfc_randomizer_page_seeds)) > + mod = ARRAY_SIZE(sunxi_nfc_randomizer_page_seeds); > + > + if (ecc) { > + if (mtd->ecc_step_size == 512) > + seeds = sunxi_nfc_randomizer_ecc512_seeds; > + else > + seeds = sunxi_nfc_randomizer_ecc1024_seeds; > + } > + > + return seeds[page % mod]; > +} > + > +static void sunxi_nfc_randomizer_config(struct mtd_info *mtd, > + int page, bool ecc) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); > + u32 ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL); > + u16 state; > + > + if (!(nand->options & NAND_NEED_SCRAMBLING)) > + return; > + > + ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL); > + state = sunxi_nfc_randomizer_state(mtd, page, ecc); > + ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_RANDOM_SEED_MSK; > + writel(ecc_ctl | NFC_RANDOM_SEED(state), nfc->regs + NFC_REG_ECC_CTL); > +} > + > +static void sunxi_nfc_randomizer_enable(struct mtd_info *mtd) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); > + > + if (!(nand->options & NAND_NEED_SCRAMBLING)) > + return; > + > + writel(readl(nfc->regs + NFC_REG_ECC_CTL) | NFC_RANDOM_EN, > + nfc->regs + NFC_REG_ECC_CTL); > +} > + > +static void sunxi_nfc_randomizer_disable(struct mtd_info *mtd) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); > + > + if (!(nand->options & NAND_NEED_SCRAMBLING)) > + return; > + > + writel(readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_RANDOM_EN, > + nfc->regs + NFC_REG_ECC_CTL); > +} > + > +static void sunxi_nfc_randomize_bbm(struct mtd_info *mtd, int page, u8 *bbm) > +{ > + u16 state = sunxi_nfc_randomizer_state(mtd, page, true); > + > + bbm[0] ^= state; > + bbm[1] ^= sunxi_nfc_randomizer_step(state, 8); > +} > + > +static void sunxi_nfc_randomizer_write_buf(struct mtd_info *mtd, > + const uint8_t *buf, int len, > + bool ecc, int page) > +{ > + sunxi_nfc_randomizer_config(mtd, page, ecc); > + sunxi_nfc_randomizer_enable(mtd); > + sunxi_nfc_write_buf(mtd, buf, len); > + sunxi_nfc_randomizer_disable(mtd); > +} > + > +static void sunxi_nfc_randomizer_read_buf(struct mtd_info *mtd, uint8_t *buf, > + int len, bool ecc, int page) > +{ > + sunxi_nfc_randomizer_config(mtd, page, ecc); > + sunxi_nfc_randomizer_enable(mtd); > + sunxi_nfc_read_buf(mtd, buf, len); > + sunxi_nfc_randomizer_disable(mtd); > +} > + > +static void sunxi_nfc_hw_ecc_enable(struct mtd_info *mtd) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); > + struct sunxi_nand_hw_ecc *data = nand->ecc.priv; > + u32 ecc_ctl; > + > + ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL); > + ecc_ctl &= ~(NFC_ECC_MODE_MSK | NFC_ECC_PIPELINE | > + NFC_ECC_BLOCK_SIZE_MSK); > + ecc_ctl |= NFC_ECC_EN | NFC_ECC_MODE(data->mode) | NFC_ECC_EXCEPTION; > + > + if (nand->ecc.size == 512) > + ecc_ctl |= NFC_ECC_BLOCK_512; > + > + writel(ecc_ctl, nfc->regs + NFC_REG_ECC_CTL); > +} > + > +static void sunxi_nfc_hw_ecc_disable(struct mtd_info *mtd) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); > + > + writel(readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_ECC_EN, > + nfc->regs + NFC_REG_ECC_CTL); > +} > + > +static inline void sunxi_nfc_user_data_to_buf(u32 user_data, u8 *buf) > +{ > + buf[0] = user_data; > + buf[1] = user_data >> 8; > + buf[2] = user_data >> 16; > + buf[3] = user_data >> 24; > +} > + > +static int sunxi_nfc_hw_ecc_read_chunk(struct mtd_info *mtd, > + u8 *data, int data_off, > + u8 *oob, int oob_off, > + int *cur_off, > + unsigned int *max_bitflips, > + bool bbm, int page) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); > + struct nand_ecc_ctrl *ecc = &nand->ecc; > + int raw_mode = 0; > + u32 status; > + int ret; > + > + if (*cur_off != data_off) > + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, data_off, -1); > + > + sunxi_nfc_randomizer_read_buf(mtd, NULL, ecc->size, false, page); > + > + if (data_off + ecc->size != oob_off) > + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1); > + > + ret = sunxi_nfc_wait_cmd_fifo_empty(nfc); > + if (ret) > + return ret; > + > + sunxi_nfc_randomizer_enable(mtd); > + writel(NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD | NFC_ECC_OP, > + nfc->regs + NFC_REG_CMD); > + > + ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0); > + sunxi_nfc_randomizer_disable(mtd); > + if (ret) > + return ret; > + > + *cur_off = oob_off + ecc->bytes + 4; > + > + status = readl(nfc->regs + NFC_REG_ECC_ST); > + if (status & NFC_ECC_PAT_FOUND(0)) { > + u8 pattern = 0xff; > + > + if (unlikely(!(readl(nfc->regs + NFC_REG_PAT_ID) & 0x1))) > + pattern = 0x0; > + > + memset(data, pattern, ecc->size); > + memset(oob, pattern, ecc->bytes + 4); > + > + return 1; > + } > + > + ret = NFC_ECC_ERR_CNT(0, readl(nfc->regs + NFC_REG_ECC_ERR_CNT(0))); > + > + memcpy_fromio(data, nfc->regs + NFC_RAM0_BASE, ecc->size); > + > + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1); > + sunxi_nfc_randomizer_read_buf(mtd, oob, ecc->bytes + 4, true, page); > + > + if (status & NFC_ECC_ERR(0)) { > + /* > + * Re-read the data with the randomizer disabled to identify > + * bitflips in erased pages. > + */ > + if (nand->options & NAND_NEED_SCRAMBLING) { > + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, data_off, -1); > + nand->read_buf(mtd, data, ecc->size); > + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1); > + nand->read_buf(mtd, oob, ecc->bytes + 4); > + } > + > + ret = nand_check_erased_ecc_chunk(data, ecc->size, > + oob, ecc->bytes + 4, > + NULL, 0, ecc->strength); > + if (ret >= 0) > + raw_mode = 1; > + } else { > + /* > + * The engine protects 4 bytes of OOB data per chunk. > + * Retrieve the corrected OOB bytes. > + */ > + sunxi_nfc_user_data_to_buf(readl(nfc->regs + > + NFC_REG_USER_DATA(0)), > + oob); > + > + /* De-randomize the Bad Block Marker. */ > + if (bbm && nand->options & NAND_NEED_SCRAMBLING) > + sunxi_nfc_randomize_bbm(mtd, page, oob); > + } > + > + if (ret < 0) { > + mtd->ecc_stats.failed++; > + } else { > + mtd->ecc_stats.corrected += ret; > + *max_bitflips = max_t(unsigned int, *max_bitflips, ret); > + } > + > + return raw_mode; > +} > + > +static void sunxi_nfc_hw_ecc_read_extra_oob(struct mtd_info *mtd, > + u8 *oob, int *cur_off, > + bool randomize, int page) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct nand_ecc_ctrl *ecc = &nand->ecc; > + int offset = ((ecc->bytes + 4) * ecc->steps); > + int len = mtd->oobsize - offset; > + > + if (len <= 0) > + return; > + > + if (*cur_off != offset) > + nand->cmdfunc(mtd, NAND_CMD_RNDOUT, > + offset + mtd->writesize, -1); > + > + if (!randomize) > + sunxi_nfc_read_buf(mtd, oob + offset, len); > + else > + sunxi_nfc_randomizer_read_buf(mtd, oob + offset, len, > + false, page); > + > + *cur_off = mtd->oobsize + mtd->writesize; > +} > + > +static inline u32 sunxi_nfc_buf_to_user_data(const u8 *buf) > +{ > + return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); > +} > + > +static int sunxi_nfc_hw_ecc_write_chunk(struct mtd_info *mtd, > + const u8 *data, int data_off, > + const u8 *oob, int oob_off, > + int *cur_off, bool bbm, > + int page) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller); > + struct nand_ecc_ctrl *ecc = &nand->ecc; > + int ret; > + > + if (data_off != *cur_off) > + nand->cmdfunc(mtd, NAND_CMD_RNDIN, data_off, -1); > + > + sunxi_nfc_randomizer_write_buf(mtd, data, ecc->size, false, page); > + > + /* Fill OOB data in */ > + if ((nand->options & NAND_NEED_SCRAMBLING) && bbm) { > + u8 user_data[4]; > + > + memcpy(user_data, oob, 4); > + sunxi_nfc_randomize_bbm(mtd, page, user_data); > + writel(sunxi_nfc_buf_to_user_data(user_data), > + nfc->regs + NFC_REG_USER_DATA(0)); > + } else { > + writel(sunxi_nfc_buf_to_user_data(oob), > + nfc->regs + NFC_REG_USER_DATA(0)); > + } > + > + if (data_off + ecc->size != oob_off) > + nand->cmdfunc(mtd, NAND_CMD_RNDIN, oob_off, -1); > + > + ret = sunxi_nfc_wait_cmd_fifo_empty(nfc); > + if (ret) > + return ret; > + > + sunxi_nfc_randomizer_enable(mtd); > + writel(NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD | > + NFC_ACCESS_DIR | NFC_ECC_OP, > + nfc->regs + NFC_REG_CMD); > + > + ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0); > + sunxi_nfc_randomizer_disable(mtd); > + if (ret) > + return ret; > + > + *cur_off = oob_off + ecc->bytes + 4; > + > + return 0; > +} > + > +static void sunxi_nfc_hw_ecc_write_extra_oob(struct mtd_info *mtd, > + u8 *oob, int *cur_off, > + int page) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + struct nand_ecc_ctrl *ecc = &nand->ecc; > + int offset = ((ecc->bytes + 4) * ecc->steps); > + int len = mtd->oobsize - offset; > + > + if (len <= 0) > + return; > + > + if (*cur_off != offset) > + nand->cmdfunc(mtd, NAND_CMD_RNDIN, > + offset + mtd->writesize, -1); > + > + sunxi_nfc_randomizer_write_buf(mtd, oob + offset, len, false, page); > + > + *cur_off = mtd->oobsize + mtd->writesize; > +} > + > +static int sunxi_nfc_hw_ecc_read_page(struct mtd_info *mtd, > + struct nand_chip *chip, uint8_t *buf, > + int oob_required, int page) > +{ > + struct nand_ecc_ctrl *ecc = &chip->ecc; > + unsigned int max_bitflips = 0; > + int ret, i, cur_off = 0; > + bool raw_mode = false; > + > + sunxi_nfc_hw_ecc_enable(mtd); > + > + for (i = 0; i < ecc->steps; i++) { > + int data_off = i * ecc->size; > + int oob_off = i * (ecc->bytes + 4); > + u8 *data = buf + data_off; > + u8 *oob = chip->oob_poi + oob_off; > + > + ret = sunxi_nfc_hw_ecc_read_chunk(mtd, data, data_off, oob, > + oob_off + mtd->writesize, > + &cur_off, &max_bitflips, > + !i, page); > + if (ret < 0) > + return ret; > + else if (ret) > + raw_mode = true; > + } > + > + if (oob_required) > + sunxi_nfc_hw_ecc_read_extra_oob(mtd, chip->oob_poi, &cur_off, > + !raw_mode, page); > + > + sunxi_nfc_hw_ecc_disable(mtd); > + > + return max_bitflips; > +} > + > +static int sunxi_nfc_hw_ecc_read_subpage(struct mtd_info *mtd, > + struct nand_chip *chip, > + uint32_t data_offs, uint32_t readlen, > + uint8_t *bufpoi, int page) > +{ > + struct nand_ecc_ctrl *ecc = &chip->ecc; > + int ret, i, cur_off = 0; > + unsigned int max_bitflips = 0; > + > + sunxi_nfc_hw_ecc_enable(mtd); > + > + chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page); > + for (i = data_offs / ecc->size; > + i < DIV_ROUND_UP(data_offs + readlen, ecc->size); i++) { > + int data_off = i * ecc->size; > + int oob_off = i * (ecc->bytes + 4); > + u8 *data = bufpoi + data_off; > + u8 *oob = chip->oob_poi + oob_off; > + > + ret = sunxi_nfc_hw_ecc_read_chunk(mtd, data, data_off, > + oob, oob_off + mtd->writesize, > + &cur_off, &max_bitflips, !i, page); > + if (ret < 0) > + return ret; > + } > + > + sunxi_nfc_hw_ecc_disable(mtd); > + > + return max_bitflips; > +} > + > +static int sunxi_nfc_hw_ecc_write_page(struct mtd_info *mtd, > + struct nand_chip *chip, > + const uint8_t *buf, int oob_required, > + int page) > +{ > + struct nand_ecc_ctrl *ecc = &chip->ecc; > + int ret, i, cur_off = 0; > + > + sunxi_nfc_hw_ecc_enable(mtd); > + > + for (i = 0; i < ecc->steps; i++) { > + int data_off = i * ecc->size; > + int oob_off = i * (ecc->bytes + 4); > + const u8 *data = buf + data_off; > + const u8 *oob = chip->oob_poi + oob_off; > + > + ret = sunxi_nfc_hw_ecc_write_chunk(mtd, data, data_off, oob, > + oob_off + mtd->writesize, > + &cur_off, !i, page); > + if (ret) > + return ret; > + } > + > + if (oob_required || (chip->options & NAND_NEED_SCRAMBLING)) > + sunxi_nfc_hw_ecc_write_extra_oob(mtd, chip->oob_poi, > + &cur_off, page); > + > + sunxi_nfc_hw_ecc_disable(mtd); > + > + return 0; > +} > + > +static int sunxi_nfc_hw_ecc_write_subpage(struct mtd_info *mtd, > + struct nand_chip *chip, > + u32 data_offs, u32 data_len, > + const u8 *buf, int oob_required, > + int page) > +{ > + struct nand_ecc_ctrl *ecc = &chip->ecc; > + int ret, i, cur_off = 0; > + > + sunxi_nfc_hw_ecc_enable(mtd); > + > + for (i = data_offs / ecc->size; > + i < DIV_ROUND_UP(data_offs + data_len, ecc->size); i++) { > + int data_off = i * ecc->size; > + int oob_off = i * (ecc->bytes + 4); > + const u8 *data = buf + data_off; > + const u8 *oob = chip->oob_poi + oob_off; > + > + ret = sunxi_nfc_hw_ecc_write_chunk(mtd, data, data_off, oob, > + oob_off + mtd->writesize, > + &cur_off, !i, page); > + if (ret) > + return ret; > + } > + > + sunxi_nfc_hw_ecc_disable(mtd); > + > + return 0; > +} > + > +static int sunxi_nfc_hw_syndrome_ecc_read_page(struct mtd_info *mtd, > + struct nand_chip *chip, > + uint8_t *buf, int oob_required, > + int page) > +{ > + struct nand_ecc_ctrl *ecc = &chip->ecc; > + unsigned int max_bitflips = 0; > + int ret, i, cur_off = 0; > + bool raw_mode = false; > + > + sunxi_nfc_hw_ecc_enable(mtd); > + > + for (i = 0; i < ecc->steps; i++) { > + int data_off = i * (ecc->size + ecc->bytes + 4); > + int oob_off = data_off + ecc->size; > + u8 *data = buf + (i * ecc->size); > + u8 *oob = chip->oob_poi + (i * (ecc->bytes + 4)); > + > + ret = sunxi_nfc_hw_ecc_read_chunk(mtd, data, data_off, oob, > + oob_off, &cur_off, > + &max_bitflips, !i, page); > + if (ret < 0) > + return ret; > + else if (ret) > + raw_mode = true; > + } > + > + if (oob_required) > + sunxi_nfc_hw_ecc_read_extra_oob(mtd, chip->oob_poi, &cur_off, > + !raw_mode, page); > + > + sunxi_nfc_hw_ecc_disable(mtd); > + > + return max_bitflips; > +} > + > +static int sunxi_nfc_hw_syndrome_ecc_write_page(struct mtd_info *mtd, > + struct nand_chip *chip, > + const uint8_t *buf, > + int oob_required, int page) > +{ > + struct nand_ecc_ctrl *ecc = &chip->ecc; > + int ret, i, cur_off = 0; > + > + sunxi_nfc_hw_ecc_enable(mtd); > + > + for (i = 0; i < ecc->steps; i++) { > + int data_off = i * (ecc->size + ecc->bytes + 4); > + int oob_off = data_off + ecc->size; > + const u8 *data = buf + (i * ecc->size); > + const u8 *oob = chip->oob_poi + (i * (ecc->bytes + 4)); > + > + ret = sunxi_nfc_hw_ecc_write_chunk(mtd, data, data_off, > + oob, oob_off, &cur_off, > + false, page); > + if (ret) > + return ret; > + } > + > + if (oob_required || (chip->options & NAND_NEED_SCRAMBLING)) > + sunxi_nfc_hw_ecc_write_extra_oob(mtd, chip->oob_poi, > + &cur_off, page); > + > + sunxi_nfc_hw_ecc_disable(mtd); > + > + return 0; > +} > + > +static const s32 tWB_lut[] = {6, 12, 16, 20}; > +static const s32 tRHW_lut[] = {4, 8, 12, 20}; > + > +static int _sunxi_nand_lookup_timing(const s32 *lut, int lut_size, u32 duration, > + u32 clk_period) > +{ > + u32 clk_cycles = DIV_ROUND_UP(duration, clk_period); > + int i; > + > + for (i = 0; i < lut_size; i++) { > + if (clk_cycles <= lut[i]) > + return i; > + } > + > + /* Doesn't fit */ > + return -EINVAL; > +} > + > +#define sunxi_nand_lookup_timing(l, p, c) \ > + _sunxi_nand_lookup_timing(l, ARRAY_SIZE(l), p, c) > + > +static int sunxi_nand_chip_set_timings(struct sunxi_nand_chip *chip, > + const struct nand_sdr_timings *timings) > +{ > + u32 min_clk_period = 0; > + s32 tWB, tADL, tWHR, tRHW, tCAD; > + > + /* T1 <=> tCLS */ > + if (timings->tCLS_min > min_clk_period) > + min_clk_period = timings->tCLS_min; > + > + /* T2 <=> tCLH */ > + if (timings->tCLH_min > min_clk_period) > + min_clk_period = timings->tCLH_min; > + > + /* T3 <=> tCS */ > + if (timings->tCS_min > min_clk_period) > + min_clk_period = timings->tCS_min; > + > + /* T4 <=> tCH */ > + if (timings->tCH_min > min_clk_period) > + min_clk_period = timings->tCH_min; > + > + /* T5 <=> tWP */ > + if (timings->tWP_min > min_clk_period) > + min_clk_period = timings->tWP_min; > + > + /* T6 <=> tWH */ > + if (timings->tWH_min > min_clk_period) > + min_clk_period = timings->tWH_min; > + > + /* T7 <=> tALS */ > + if (timings->tALS_min > min_clk_period) > + min_clk_period = timings->tALS_min; > + > + /* T8 <=> tDS */ > + if (timings->tDS_min > min_clk_period) > + min_clk_period = timings->tDS_min; > + > + /* T9 <=> tDH */ > + if (timings->tDH_min > min_clk_period) > + min_clk_period = timings->tDH_min; > + > + /* T10 <=> tRR */ > + if (timings->tRR_min > (min_clk_period * 3)) > + min_clk_period = DIV_ROUND_UP(timings->tRR_min, 3); > + > + /* T11 <=> tALH */ > + if (timings->tALH_min > min_clk_period) > + min_clk_period = timings->tALH_min; > + > + /* T12 <=> tRP */ > + if (timings->tRP_min > min_clk_period) > + min_clk_period = timings->tRP_min; > + > + /* T13 <=> tREH */ > + if (timings->tREH_min > min_clk_period) > + min_clk_period = timings->tREH_min; > + > + /* T14 <=> tRC */ > + if (timings->tRC_min > (min_clk_period * 2)) > + min_clk_period = DIV_ROUND_UP(timings->tRC_min, 2); > + > + /* T15 <=> tWC */ > + if (timings->tWC_min > (min_clk_period * 2)) > + min_clk_period = DIV_ROUND_UP(timings->tWC_min, 2); > + > + /* T16 - T19 + tCAD */ > + tWB = sunxi_nand_lookup_timing(tWB_lut, timings->tWB_max, > + min_clk_period); > + if (tWB < 0) { > + dev_err(nfc->dev, "unsupported tWB\n"); > + return tWB; > + } > + > + tADL = DIV_ROUND_UP(timings->tADL_min, min_clk_period) >> 3; > + if (tADL > 3) { > + dev_err(nfc->dev, "unsupported tADL\n"); > + return -EINVAL; > + } > + > + tWHR = DIV_ROUND_UP(timings->tWHR_min, min_clk_period) >> 3; > + if (tWHR > 3) { > + dev_err(nfc->dev, "unsupported tWHR\n"); > + return -EINVAL; > + } > + > + tRHW = sunxi_nand_lookup_timing(tRHW_lut, timings->tRHW_min, > + min_clk_period); > + if (tRHW < 0) { > + dev_err(nfc->dev, "unsupported tRHW\n"); > + return tRHW; > + } > + > + /* > + * TODO: according to ONFI specs this value only applies for DDR NAND, > + * but Allwinner seems to set this to 0x7. Mimic them for now. > + */ > + tCAD = 0x7; > + > + /* TODO: A83 has some more bits for CDQSS, CS, CLHZ, CCS, WC */ > + chip->timing_cfg = NFC_TIMING_CFG(tWB, tADL, tWHR, tRHW, tCAD); > + > + /* > + * ONFI specification 3.1, paragraph 4.15.2 dictates that EDO data > + * output cycle timings shall be used if the host drives tRC less than > + * 30 ns. > + */ > + chip->timing_ctl = (timings->tRC_min < 30000) ? NFC_TIMING_CTL_EDO : 0; > + > + /* Convert min_clk_period from picoseconds to nanoseconds */ > + min_clk_period = DIV_ROUND_UP(min_clk_period, 1000); > + > + /* > + * Convert min_clk_period into a clk frequency, then get the > + * appropriate rate for the NAND controller IP given this formula > + * (specified in the datasheet): > + * nand clk_rate = min_clk_rate > + */ > + chip->clk_rate = 1000000000L / min_clk_period; > + > + return 0; > +} > + > +static int sunxi_nand_chip_init_timings(struct sunxi_nand_chip *chip) > +{ > + struct mtd_info *mtd = nand_to_mtd(&chip->nand); > + const struct nand_sdr_timings *timings; > + int ret; > + int mode; > + > + mode = onfi_get_async_timing_mode(&chip->nand); > + if (mode == ONFI_TIMING_MODE_UNKNOWN) { > + mode = chip->nand.onfi_timing_mode_default; > + } else { > + uint8_t feature[ONFI_SUBFEATURE_PARAM_LEN] = {}; > + int i; > + > + mode = fls(mode) - 1; > + if (mode < 0) > + mode = 0; > + > + feature[0] = mode; > + for (i = 0; i < chip->nsels; i++) { > + chip->nand.select_chip(mtd, i); > + ret = chip->nand.onfi_set_features(mtd, > + &chip->nand, > + ONFI_FEATURE_ADDR_TIMING_MODE, > + feature); > + chip->nand.select_chip(mtd, -1); > + if (ret) > + return ret; > + } > + } > + > + timings = onfi_async_timing_mode_to_sdr_timings(mode); > + if (IS_ERR(timings)) > + return PTR_ERR(timings); > + > + return sunxi_nand_chip_set_timings(chip, timings); > +} > + > +static int sunxi_nand_hw_common_ecc_ctrl_init(struct mtd_info *mtd, > + struct nand_ecc_ctrl *ecc) > +{ > + static const u8 strengths[] = { 16, 24, 28, 32, 40, 48, 56, 60, 64 }; > + struct sunxi_nand_hw_ecc *data; > + struct nand_ecclayout *layout; > + int nsectors; > + int ret; > + int i; > + > + data = kzalloc(sizeof(*data), GFP_KERNEL); > + if (!data) > + return -ENOMEM; > + > + if (ecc->size != 512 && ecc->size != 1024) > + return -EINVAL; > + > + /* Prefer 1k ECC chunk over 512 ones */ > + if (ecc->size == 512 && mtd->writesize > 512) { > + ecc->size = 1024; > + ecc->strength *= 2; > + } > + > + /* Add ECC info retrieval from DT */ > + for (i = 0; i < ARRAY_SIZE(strengths); i++) { > + if (ecc->strength <= strengths[i]) > + break; > + } > + > + if (i >= ARRAY_SIZE(strengths)) { > + dev_err(nfc->dev, "unsupported strength\n"); > + ret = -ENOTSUPP; > + goto err; > + } > + > + data->mode = i; > + > + /* HW ECC always request ECC bytes for 1024 bytes blocks */ > + ecc->bytes = DIV_ROUND_UP(ecc->strength * fls(8 * 1024), 8); > + > + /* HW ECC always work with even numbers of ECC bytes */ > + ecc->bytes = ALIGN(ecc->bytes, 2); > + > + layout = &data->layout; > + nsectors = mtd->writesize / ecc->size; > + > + if (mtd->oobsize < ((ecc->bytes + 4) * nsectors)) { > + ret = -EINVAL; > + goto err; > + } > + > + layout->eccbytes = (ecc->bytes * nsectors); > + > + ecc->layout = layout; > + ecc->priv = data; > + > + return 0; > + > +err: > + kfree(data); > + > + return ret; > +} > + > +#ifndef __UBOOT__ > +static void sunxi_nand_hw_common_ecc_ctrl_cleanup(struct nand_ecc_ctrl *ecc) > +{ > + kfree(ecc->priv); > +} > +#endif /* __UBOOT__ */ > + > +static int sunxi_nand_hw_ecc_ctrl_init(struct mtd_info *mtd, > + struct nand_ecc_ctrl *ecc) > +{ > + struct nand_ecclayout *layout; > + int nsectors; > + int i, j; > + int ret; > + > + ret = sunxi_nand_hw_common_ecc_ctrl_init(mtd, ecc); > + if (ret) > + return ret; > + > + ecc->read_page = sunxi_nfc_hw_ecc_read_page; > + ecc->write_page = sunxi_nfc_hw_ecc_write_page; > + ecc->read_subpage = sunxi_nfc_hw_ecc_read_subpage; > + ecc->write_subpage = sunxi_nfc_hw_ecc_write_subpage; > + layout = ecc->layout; > + nsectors = mtd->writesize / ecc->size; > + > + for (i = 0; i < nsectors; i++) { > + if (i) { > + layout->oobfree[i].offset = > + layout->oobfree[i - 1].offset + > + layout->oobfree[i - 1].length + > + ecc->bytes; > + layout->oobfree[i].length = 4; > + } else { > + /* > + * The first 2 bytes are used for BB markers, hence we > + * only have 2 bytes available in the first user data > + * section. > + */ > + layout->oobfree[i].length = 2; > + layout->oobfree[i].offset = 2; > + } > + > + for (j = 0; j < ecc->bytes; j++) > + layout->eccpos[(ecc->bytes * i) + j] = > + layout->oobfree[i].offset + > + layout->oobfree[i].length + j; > + } > + > + if (mtd->oobsize > (ecc->bytes + 4) * nsectors) { > + layout->oobfree[nsectors].offset = > + layout->oobfree[nsectors - 1].offset + > + layout->oobfree[nsectors - 1].length + > + ecc->bytes; > + layout->oobfree[nsectors].length = mtd->oobsize - > + ((ecc->bytes + 4) * nsectors); > + } > + > + return 0; > +} > + > +static int sunxi_nand_hw_syndrome_ecc_ctrl_init(struct mtd_info *mtd, > + struct nand_ecc_ctrl *ecc) > +{ > + struct nand_ecclayout *layout; > + int nsectors; > + int i; > + int ret; > + > + ret = sunxi_nand_hw_common_ecc_ctrl_init(mtd, ecc); > + if (ret) > + return ret; > + > + ecc->prepad = 4; > + ecc->read_page = sunxi_nfc_hw_syndrome_ecc_read_page; > + ecc->write_page = sunxi_nfc_hw_syndrome_ecc_write_page; > + > + layout = ecc->layout; > + nsectors = mtd->writesize / ecc->size; > + > + for (i = 0; i < (ecc->bytes * nsectors); i++) > + layout->eccpos[i] = i; > + > + layout->oobfree[0].length = mtd->oobsize - i; > + layout->oobfree[0].offset = i; > + > + return 0; > +} > + > +#ifndef __UBOOT__ > +static void sunxi_nand_ecc_cleanup(struct nand_ecc_ctrl *ecc) > +{ > + switch (ecc->mode) { > + case NAND_ECC_HW: > + case NAND_ECC_HW_SYNDROME: > + sunxi_nand_hw_common_ecc_ctrl_cleanup(ecc); > + break; > + case NAND_ECC_NONE: > + kfree(ecc->layout); > + default: > + break; > + } > +} > +#endif /* __UBOOT__ */ > + > +static int sunxi_nand_ecc_init(struct mtd_info *mtd, struct nand_ecc_ctrl *ecc) > +{ > + struct nand_chip *nand = mtd_to_nand(mtd); > + int ret; > + > + if (!ecc->size) { > + ecc->size = nand->ecc_step_ds; > + ecc->strength = nand->ecc_strength_ds; > + } > + > + if (!ecc->size || !ecc->strength) > + return -EINVAL; > + > + switch (ecc->mode) { > + case NAND_ECC_SOFT_BCH: > + break; > + case NAND_ECC_HW: > + ret = sunxi_nand_hw_ecc_ctrl_init(mtd, ecc); > + if (ret) > + return ret; > + break; > + case NAND_ECC_HW_SYNDROME: > + ret = sunxi_nand_hw_syndrome_ecc_ctrl_init(mtd, ecc); > + if (ret) > + return ret; > + break; > + case NAND_ECC_NONE: > + ecc->layout = kzalloc(sizeof(*ecc->layout), GFP_KERNEL); > + if (!ecc->layout) > + return -ENOMEM; > + ecc->layout->oobfree[0].length = mtd->oobsize; > + case NAND_ECC_SOFT: > + break; > + default: > + return -EINVAL; > + } > + > + return 0; > +} > + > +static int sunxi_nand_chip_init(int node, struct sunxi_nfc *nfc, int devnum) > +{ > + const struct nand_sdr_timings *timings; > + const void *blob = gd->fdt_blob; > + struct sunxi_nand_chip *chip; > + struct mtd_info *mtd; > + struct nand_chip *nand; > + int nsels; > + int ret; > + int i; > + u32 cs[8], rb[8]; > + > + if (!fdt_getprop(blob, node, "reg", &nsels)) > + return -EINVAL; > + > + nsels /= sizeof(u32); > + if (!nsels || nsels > 8) { > + dev_err(dev, "invalid reg property size\n"); > + return -EINVAL; > + } > + > + chip = kzalloc(sizeof(*chip) + > + (nsels * sizeof(struct sunxi_nand_chip_sel)), > + GFP_KERNEL); > + if (!chip) { > + dev_err(dev, "could not allocate chip\n"); > + return -ENOMEM; > + } > + > + chip->nsels = nsels; > + chip->selected = -1; > + > + for (i = 0; i < nsels; i++) { > + cs[i] = -1; > + rb[i] = -1; > + } > + > + ret = fdtdec_get_int_array(gd->fdt_blob, node, "reg", cs, nsels); > + if (ret) { > + dev_err(dev, "could not retrieve reg property: %d\n", ret); > + return ret; > + } > + > + ret = fdtdec_get_int_array(gd->fdt_blob, node, "allwinner,rb", rb, > + nsels); > + if (ret) { > + dev_err(dev, "could not retrieve reg property: %d\n", ret); > + return ret; > + } > + > + for (i = 0; i < nsels; i++) { > + int tmp = cs[i]; > + > + if (tmp > NFC_MAX_CS) { > + dev_err(dev, > + "invalid reg value: %u (max CS = 7)\n", > + tmp); > + return -EINVAL; > + } > + > + if (test_and_set_bit(tmp, &nfc->assigned_cs)) { > + dev_err(dev, "CS %d already assigned\n", tmp); > + return -EINVAL; > + } > + > + chip->sels[i].cs = tmp; > + > + tmp = rb[i]; > + if (tmp >= 0 && tmp < 2) { > + chip->sels[i].rb.type = RB_NATIVE; > + chip->sels[i].rb.info.nativeid = tmp; > + } else { > + ret = gpio_request_by_name_nodev(blob, node, > + "rb-gpios", i, > + &chip->sels[i].rb.info.gpio, > + GPIOD_IS_IN); > + if (ret) > + chip->sels[i].rb.type = RB_GPIO; > + else > + chip->sels[i].rb.type = RB_NONE; > + } > + } > + > + timings = onfi_async_timing_mode_to_sdr_timings(0); > + if (IS_ERR(timings)) { > + ret = PTR_ERR(timings); > + dev_err(dev, > + "could not retrieve timings for ONFI mode 0: %d\n", > + ret); > + return ret; > + } > + > + ret = sunxi_nand_chip_set_timings(chip, timings); > + if (ret) { > + dev_err(dev, "could not configure chip timings: %d\n", ret); > + return ret; > + } > + > + nand = &chip->nand; > + /* Default tR value specified in the ONFI spec (chapter 4.15.1) */ > + nand->chip_delay = 200; > + nand->controller = &nfc->controller; > + /* > + * Set the ECC mode to the default value in case nothing is specified > + * in the DT. > + */ > + nand->ecc.mode = NAND_ECC_HW; > + nand->flash_node = node; > + nand->select_chip = sunxi_nfc_select_chip; > + nand->cmd_ctrl = sunxi_nfc_cmd_ctrl; > + nand->read_buf = sunxi_nfc_read_buf; > + nand->write_buf = sunxi_nfc_write_buf; > + nand->read_byte = sunxi_nfc_read_byte; > + > + mtd = nand_to_mtd(nand); > + ret = nand_scan_ident(mtd, nsels, NULL); > + if (ret) > + return ret; > + > + if (nand->bbt_options & NAND_BBT_USE_FLASH) > + nand->bbt_options |= NAND_BBT_NO_OOB; > + > + if (nand->options & NAND_NEED_SCRAMBLING) > + nand->options |= NAND_NO_SUBPAGE_WRITE; > + > + nand->options |= NAND_SUBPAGE_READ; > + > + ret = sunxi_nand_chip_init_timings(chip); > + if (ret) { > + dev_err(dev, "could not configure chip timings: %d\n", ret); > + return ret; > + } > + > + ret = sunxi_nand_ecc_init(mtd, &nand->ecc); > + if (ret) { > + dev_err(dev, "ECC init failed: %d\n", ret); > + return ret; > + } > + > + ret = nand_scan_tail(mtd); > + if (ret) { > + dev_err(dev, "nand_scan_tail failed: %d\n", ret); > + return ret; > + } > + > + ret = nand_register(devnum, mtd); > + if (ret) { > + dev_err(dev, "failed to register mtd device: %d\n", ret); > + return ret; > + } > + > + list_add_tail(&chip->node, &nfc->chips); > + > + return 0; > +} > + > +static int sunxi_nand_chips_init(int node, struct sunxi_nfc *nfc) > +{ > + const void *blob = gd->fdt_blob; > + int nand_node; > + int ret, i = 0; > + > + for (nand_node = fdt_first_subnode(blob, node); nand_node >= 0; > + nand_node = fdt_next_subnode(blob, nand_node)) > + i++; > + > + if (i > 8) { > + dev_err(dev, "too many NAND chips: %d (max = 8)\n", i); > + return -EINVAL; > + } > + > + i = 0; > + for (nand_node = fdt_first_subnode(blob, node); nand_node >= 0; > + nand_node = fdt_next_subnode(blob, nand_node)) { > + ret = sunxi_nand_chip_init(nand_node, nfc, i++); > + if (ret) > + return ret; > + } > + > + return 0; > +} > + > +#ifndef __UBOOT__ > +static void sunxi_nand_chips_cleanup(struct sunxi_nfc *nfc) > +{ > + struct sunxi_nand_chip *chip; > + > + while (!list_empty(&nfc->chips)) { > + chip = list_first_entry(&nfc->chips, struct sunxi_nand_chip, > + node); > + nand_release(&chip->mtd); > + sunxi_nand_ecc_cleanup(&chip->nand.ecc); > + list_del(&chip->node); > + kfree(chip); > + } > +} > +#endif /* __UBOOT__ */ > + > +void sunxi_nand_init(void) > +{ > + const void *blob = gd->fdt_blob; > + struct sunxi_nfc *nfc; > + fdt_addr_t regs; > + int node; > + int ret; > + > + nfc = kzalloc(sizeof(*nfc), GFP_KERNEL); > + if (!nfc) > + return; > + > + spin_lock_init(&nfc->controller.lock); > + init_waitqueue_head(&nfc->controller.wq); > + INIT_LIST_HEAD(&nfc->chips); > + > + node = fdtdec_next_compatible(blob, 0, COMPAT_SUNXI_NAND); > + if (node < 0) { > + pr_err("unable to find nfc node in device tree\n"); > + goto err; > + } > + > + if (!fdtdec_get_is_enabled(blob, node)) { > + pr_err("nfc disabled in device tree\n"); > + goto err; > + } > + > + regs = fdtdec_get_addr(blob, node, "reg"); > + if (regs == FDT_ADDR_T_NONE) { > + pr_err("unable to find nfc address in device tree\n"); > + goto err; > + } > + > + nfc->regs = (void *)regs; > + > + ret = sunxi_nfc_rst(nfc); > + if (ret) > + goto err; > + > + ret = sunxi_nand_chips_init(node, nfc); > + if (ret) { > + dev_err(dev, "failed to init nand chips\n"); > + goto err; > + } > + > + return; > + > +err: > + kfree(nfc); > +} > + > +MODULE_LICENSE("GPL v2"); > +MODULE_AUTHOR("Boris BREZILLON"); > +MODULE_DESCRIPTION("Allwinner NAND Flash Controller driver"); > diff --git a/include/configs/sunxi-common.h b/include/configs/sunxi-common.h > index ac2d931..70aaa76 100644 > --- a/include/configs/sunxi-common.h > +++ b/include/configs/sunxi-common.h > @@ -135,6 +135,8 @@ > > #ifdef CONFIG_NAND_SUNXI > #define CONFIG_SPL_NAND_SUPPORT 1 > +#define CONFIG_SYS_NAND_ONFI_DETECTION > +#define CONFIG_SYS_MAX_NAND_DEVICE 8 > #endif > > /* mmc config */ > diff --git a/include/fdtdec.h b/include/fdtdec.h > index 37d482a..940ab8b 100644 > --- a/include/fdtdec.h > +++ b/include/fdtdec.h > @@ -166,6 +166,7 @@ enum fdt_compat_id { > COMPAT_INTEL_BAYTRAIL_FSP, /* Intel Bay Trail FSP */ > COMPAT_INTEL_BAYTRAIL_FSP_MDP, /* Intel FSP memory-down params */ > COMPAT_INTEL_IVYBRIDGE_FSP, /* Intel Ivy Bridge FSP */ > + COMPAT_SUNXI_NAND, /* SUNXI NAND controller */ > > COMPAT_COUNT, > }; > diff --git a/lib/fdtdec.c b/lib/fdtdec.c > index 70acc29..ed8e294 100644 > --- a/lib/fdtdec.c > +++ b/lib/fdtdec.c > @@ -71,6 +71,7 @@ static const char * const compat_names[COMPAT_COUNT] = { > COMPAT(COMPAT_INTEL_BAYTRAIL_FSP, "intel,baytrail-fsp"), > COMPAT(COMPAT_INTEL_BAYTRAIL_FSP_MDP, "intel,baytrail-fsp-mdp"), > COMPAT(COMPAT_INTEL_IVYBRIDGE_FSP, "intel,ivybridge-fsp"), > + COMPAT(COMPAT_SUNXI_NAND, "allwinner,sun4i-a10-nand"), > }; > > const char *fdtdec_get_compatible(enum fdt_compat_id id) > ^ permalink raw reply [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver 2016-06-06 15:36 ` Hans de Goede @ 2016-06-06 16:22 ` Boris Brezillon 2016-06-06 17:56 ` Scott Wood 0 siblings, 1 reply; 15+ messages in thread From: Boris Brezillon @ 2016-06-06 16:22 UTC (permalink / raw) To: u-boot On Mon, 6 Jun 2016 17:36:10 +0200 Hans de Goede <hdegoede@redhat.com> wrote: > > +#ifndef CONFIG_SPL_BUILD > > +void sunxi_nand_init(void); > > +#endif > > + > > Can we have this in a header somewhere please, and without > the #ifdef around it, that is not necessary for prototypes. Hehe, I was expecting this one :-). Do you know where I should put this prototype definition? A board.h file in board/sunxi/? -- Boris Brezillon, Free Electrons Embedded Linux and Kernel engineering http://free-electrons.com ^ permalink raw reply [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver 2016-06-06 16:22 ` Boris Brezillon @ 2016-06-06 17:56 ` Scott Wood 2016-06-06 18:31 ` Boris Brezillon 0 siblings, 1 reply; 15+ messages in thread From: Scott Wood @ 2016-06-06 17:56 UTC (permalink / raw) To: u-boot On Mon, 2016-06-06 at 18:22 +0200, Boris Brezillon wrote: > On Mon, 6 Jun 2016 17:36:10 +0200 > Hans de Goede <hdegoede@redhat.com> wrote: > > > > +#ifndef CONFIG_SPL_BUILD > > > +void sunxi_nand_init(void); > > > +#endif > > > + > > > > Can we have this in a header somewhere please, and without > > the #ifdef around it, that is not necessary for prototypes. > > Hehe, I was expecting this one :-). Do you know where I should put this > prototype definition? A board.h file in board/sunxi/? It's defined in drivers/mtd/nand and called from board/sunxi so the prototype needs to go somewhere under include/. It can go in include/configs/sunxi -common.h with #ifndef __ASSEMBLY__ around it -- or as long as it's limited to one init func per driver, maybe we could just put it in include/nand.h. -Scott ^ permalink raw reply [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver 2016-06-06 17:56 ` Scott Wood @ 2016-06-06 18:31 ` Boris Brezillon 2016-06-06 23:54 ` Scott Wood 0 siblings, 1 reply; 15+ messages in thread From: Boris Brezillon @ 2016-06-06 18:31 UTC (permalink / raw) To: u-boot On Mon, 06 Jun 2016 12:56:48 -0500 Scott Wood <oss@buserror.net> wrote: > On Mon, 2016-06-06 at 18:22 +0200, Boris Brezillon wrote: > > On Mon, 6 Jun 2016 17:36:10 +0200 > > Hans de Goede <hdegoede@redhat.com> wrote: > > > > > > +#ifndef CONFIG_SPL_BUILD > > > > +void sunxi_nand_init(void); > > > > +#endif > > > > + > > > > > > Can we have this in a header somewhere please, and without > > > the #ifdef around it, that is not necessary for prototypes. > > > > Hehe, I was expecting this one :-). Do you know where I should put this > > prototype definition? A board.h file in board/sunxi/? > > It's defined in drivers/mtd/nand and called from board/sunxi so the prototype > needs to go somewhere under include/. It can go in include/configs/sunxi > -common.h with #ifndef __ASSEMBLY__ around it -- or as long as it's limited to > one init func per driver, maybe we could just put it in include/nand.h. Hm, none of these solutions seem ideal. Maybe we could define a generic void nand_controller_init(void) prototype so that we don't need to add new xxx_nand_init() functions for platforms needing this 2 steps initialization (platform specific pinmux + clocks config before NAND controller initialization). Otherwise, I think I'll go for the 2nd solution (defining sunxi_nand_init() in include/nand.h). Let me know what you prefer. Thanks, Boris -- Boris Brezillon, Free Electrons Embedded Linux and Kernel engineering http://free-electrons.com ^ permalink raw reply [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver 2016-06-06 18:31 ` Boris Brezillon @ 2016-06-06 23:54 ` Scott Wood 2016-06-07 5:41 ` Boris Brezillon 0 siblings, 1 reply; 15+ messages in thread From: Scott Wood @ 2016-06-06 23:54 UTC (permalink / raw) To: u-boot On Mon, 2016-06-06 at 20:31 +0200, Boris Brezillon wrote: > On Mon, 06 Jun 2016 12:56:48 -0500 > Scott Wood <oss@buserror.net> wrote: > > > On Mon, 2016-06-06 at 18:22 +0200, Boris Brezillon wrote: > > > On Mon, 6 Jun 2016 17:36:10 +0200 > > > Hans de Goede <hdegoede@redhat.com> wrote: > > > > > > > > +#ifndef CONFIG_SPL_BUILD > > > > > +void sunxi_nand_init(void); > > > > > +#endif > > > > > + > > > > > > > > Can we have this in a header somewhere please, and without > > > > the #ifdef around it, that is not necessary for prototypes. > > > > > > Hehe, I was expecting this one :-). Do you know where I should put this > > > prototype definition? A board.h file in board/sunxi/? > > > > It's defined in drivers/mtd/nand and called from board/sunxi so the > > prototype > > needs to go somewhere under include/. It can go in include/configs/sunxi > > -common.h with #ifndef __ASSEMBLY__ around it -- or as long as it's > > limited to > > one init func per driver, maybe we could just put it in include/nand.h. > > Hm, none of these solutions seem ideal. > > Maybe we could define a generic void nand_controller_init(void) > prototype so that we don't need to add new xxx_nand_init() functions for > platforms needing this 2 steps initialization (platform specific pinmux > + clocks config before NAND controller initialization). > > Otherwise, I think I'll go for the 2nd solution (defining > sunxi_nand_init() in include/nand.h). I'd prefer not having a generic nand_controller_init() because some platforms may want to pass arguments, plus I don't want to rule out the possibility of two different NAND controller types being supported at once. include/nand.h is fine with me, as long as any driver than wants more than an initfunc moves its stuff into a dedicated header. Of course the driver model is probably the long-term solution. -Scott ^ permalink raw reply [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver 2016-06-06 23:54 ` Scott Wood @ 2016-06-07 5:41 ` Boris Brezillon 2016-06-09 0:44 ` Scott Wood 0 siblings, 1 reply; 15+ messages in thread From: Boris Brezillon @ 2016-06-07 5:41 UTC (permalink / raw) To: u-boot On Mon, 06 Jun 2016 18:54:03 -0500 Scott Wood <oss@buserror.net> wrote: > On Mon, 2016-06-06 at 20:31 +0200, Boris Brezillon wrote: > > On Mon, 06 Jun 2016 12:56:48 -0500 > > Scott Wood <oss@buserror.net> wrote: > > > > > On Mon, 2016-06-06 at 18:22 +0200, Boris Brezillon wrote: > > > > On Mon, 6 Jun 2016 17:36:10 +0200 > > > > Hans de Goede <hdegoede@redhat.com> wrote: > > > > > > > > > > +#ifndef CONFIG_SPL_BUILD > > > > > > +void sunxi_nand_init(void); > > > > > > +#endif > > > > > > + > > > > > > > > > > Can we have this in a header somewhere please, and without > > > > > the #ifdef around it, that is not necessary for prototypes. > > > > > > > > Hehe, I was expecting this one :-). Do you know where I should put this > > > > prototype definition? A board.h file in board/sunxi/? > > > > > > It's defined in drivers/mtd/nand and called from board/sunxi so the > > > prototype > > > needs to go somewhere under include/. It can go in include/configs/sunxi > > > -common.h with #ifndef __ASSEMBLY__ around it -- or as long as it's > > > limited to > > > one init func per driver, maybe we could just put it in include/nand.h. > > > > Hm, none of these solutions seem ideal. > > > > Maybe we could define a generic void nand_controller_init(void) > > prototype so that we don't need to add new xxx_nand_init() functions for > > platforms needing this 2 steps initialization (platform specific pinmux > > + clocks config before NAND controller initialization). > > > > Otherwise, I think I'll go for the 2nd solution (defining > > sunxi_nand_init() in include/nand.h). > > I'd prefer not having a generic nand_controller_init() because some platforms > may want to pass arguments, plus I don't want to rule out the possibility of > two different NAND controller types being supported at once. > > include/nand.h is fine with me, as long as any driver than wants more than an > initfunc moves its stuff into a dedicated header. Sure. > Of course the driver model > is probably the long-term solution. Definitely, and talking about things that need to be reworked, do you know why u-boot is using its own MTD partition infrastructure instead of relying on mtdpart.c? That's really a pain when one wants to add a new feature (like definitions of partitions in the DT, or SLC mode on MLC NANDs) because he has to do it twice. And that's not the only inconsistent part in the MTD/NAND layer IMO. MTD is providing a generic abstraction for all flashes, but nand_util is still directly accessing the NAND layer instead of going through the MTD abstraction. By using the MTD abstraction everywhere (I mean for all flash devices), we could provide generic utils (flash erase, flash write), even if specific tools might be needed in a few cases. Anyway, good to hear that you plan to switch to the driver model. Regards, Boris -- Boris Brezillon, Free Electrons Embedded Linux and Kernel engineering http://free-electrons.com ^ permalink raw reply [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver 2016-06-07 5:41 ` Boris Brezillon @ 2016-06-09 0:44 ` Scott Wood 0 siblings, 0 replies; 15+ messages in thread From: Scott Wood @ 2016-06-09 0:44 UTC (permalink / raw) To: u-boot On Tue, 2016-06-07 at 07:41 +0200, Boris Brezillon wrote: > On Mon, 06 Jun 2016 18:54:03 -0500 > Scott Wood <oss@buserror.net> wrote: > > > Of course the driver model > > is probably the long-term solution. > > Definitely, and talking about things that need to be reworked, do you > know why u-boot is using its own MTD partition infrastructure instead > of relying on mtdpart.c? U-Boot's partition code predates the importation of the MTD code. > That's really a pain when one wants to add a new feature (like > definitions of partitions in the DT, or SLC mode on MLC NANDs) because > he has to do it twice. Defining partitions in the DT isn't such a great idea, at least on reference boards, as it's configuration that users are likely to want to change. > And that's not the only inconsistent part in the MTD/NAND layer IMO. > MTD is providing a generic abstraction for all flashes, but nand_util > is still directly accessing the NAND layer instead of going through the > MTD abstraction. As with partitions, that code predates the existence of the MTD abstraction in U-Boot. > By using the MTD abstraction everywhere (I mean for all flash devices), > we could provide generic utils (flash erase, flash write), even if > specific tools might be needed in a few cases. There are a lot of special NANDisms being handled in that code (bad block skipping, JFFS2 OOB cleanmarkers, etc), so I wonder what a generic version would look like. > Anyway, good to hear that you plan to switch to the driver model. I don't plan to do much of anything with the NAND code -- I'm still acting as custodian because nobody stepped up when I asked for volunteers to take it over a couple years back, but it's pretty low on my priority list regarding active development[1]. But if someone else wants to DM-ize a NAND driver I have no problem with that. :-) -Scott [1] Linux syncs are an exception, as they're easier to do than to review, especially since a patch only shows the end result rather than the process to produce it. ^ permalink raw reply [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 4/6] sun5i: Add NAND controller to the sun5i DTSI 2016-06-06 15:21 [U-Boot] [PATCH 0/6] sunxi: Add NAND controller driver Boris Brezillon ` (2 preceding siblings ...) 2016-06-06 15:21 ` [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver Boris Brezillon @ 2016-06-06 15:21 ` Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 5/6] mtd: nand: Add a full-id entry for the H27QCG8T2E5R‐BCF NAND Boris Brezillon ` (2 subsequent siblings) 6 siblings, 0 replies; 15+ messages in thread From: Boris Brezillon @ 2016-06-06 15:21 UTC (permalink / raw) To: u-boot From: Maxime Ripard <maxime.ripard@free-electrons.com> Add the NAND controller definition to sun5i.dtsi. Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com> Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com> --- arch/arm/dts/sun5i.dtsi | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/arch/arm/dts/sun5i.dtsi b/arch/arm/dts/sun5i.dtsi index 59a9426..87e5353 100644 --- a/arch/arm/dts/sun5i.dtsi +++ b/arch/arm/dts/sun5i.dtsi @@ -356,6 +356,17 @@ #dma-cells = <2>; }; + nfc: nand at 01c03000 { + compatible = "allwinner,sun4i-a10-nand"; + reg = <0x01c03000 0x1000>; + interrupts = <37>; + clocks = <&ahb_gates 13>, <&nand_clk>; + clock-names = "ahb", "mod"; + #address-cells = <1>; + #size-cells = <0>; + status = "disabled"; + }; + spi0: spi at 01c05000 { compatible = "allwinner,sun4i-a10-spi"; reg = <0x01c05000 0x1000>; @@ -548,6 +559,44 @@ allwinner,pull = <SUN4I_PINCTRL_PULL_UP>; }; + nand_pins_a: nand_base0 at 0 { + allwinner,pins = "PC0", "PC1", "PC2", + "PC5", "PC8", "PC9", "PC10", + "PC11", "PC12", "PC13", "PC14", + "PC15"; + allwinner,function = "nand0"; + allwinner,drive = <0>; + allwinner,pull = <0>; + }; + + nand_cs0_pins_a: nand_cs at 0 { + allwinner,pins = "PC4"; + allwinner,function = "nand0"; + allwinner,drive = <0>; + allwinner,pull = <0>; + }; + + nand_cs1_pins_a: nand_cs at 1 { + allwinner,pins = "PC3"; + allwinner,function = "nand0"; + allwinner,drive = <0>; + allwinner,pull = <0>; + }; + + nand_rb0_pins_a: nand_rb at 0 { + allwinner,pins = "PC6"; + allwinner,function = "nand0"; + allwinner,drive = <0>; + allwinner,pull = <0>; + }; + + nand_rb1_pins_a: nand_rb at 1 { + allwinner,pins = "PC7"; + allwinner,function = "nand0"; + allwinner,drive = <0>; + allwinner,pull = <0>; + }; + uart3_pins_a: uart3 at 0 { allwinner,pins = "PG9", "PG10"; allwinner,function = "uart3"; -- 2.7.4 ^ permalink raw reply related [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 5/6] mtd: nand: Add a full-id entry for the H27QCG8T2E5R‐BCF NAND 2016-06-06 15:21 [U-Boot] [PATCH 0/6] sunxi: Add NAND controller driver Boris Brezillon ` (3 preceding siblings ...) 2016-06-06 15:21 ` [U-Boot] [PATCH 4/6] sun5i: Add NAND controller to the sun5i DTSI Boris Brezillon @ 2016-06-06 15:21 ` Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 6/6] sunxi: Enable NAND controller on the CHIP Boris Brezillon 2016-06-06 15:37 ` [U-Boot] [linux-sunxi] [PATCH 0/6] sunxi: Add NAND controller driver Hans de Goede 6 siblings, 0 replies; 15+ messages in thread From: Boris Brezillon @ 2016-06-06 15:21 UTC (permalink / raw) To: u-boot Add a full-id entry for the H27QCG8T2E5R?BCF NAND. Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com> --- drivers/mtd/nand/nand_ids.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/drivers/mtd/nand/nand_ids.c b/drivers/mtd/nand/nand_ids.c index 561d2cd..ce0a14e 100644 --- a/drivers/mtd/nand/nand_ids.c +++ b/drivers/mtd/nand/nand_ids.c @@ -62,6 +62,10 @@ struct nand_flash_dev nand_flash_ids[] = { { .id = {0xad, 0xde, 0x94, 0xda, 0x74, 0xc4} }, SZ_8K, SZ_8K, SZ_2M, NAND_NEED_SCRAMBLING, 6, 640, NAND_ECC_INFO(40, SZ_1K), 4 }, + {"H27QCG8T2E5R?BCF 64G 3.3V 8-bit", + { .id = {0xad, 0xde, 0x14, 0xa7, 0x42, 0x4a} }, + SZ_16K, SZ_8K, SZ_4M, NAND_NEED_SCRAMBLING, 6, 1664, + NAND_ECC_INFO(56, SZ_1K), 1 }, LEGACY_ID_NAND("NAND 4MiB 5V 8-bit", 0x6B, 4, SZ_8K, SP_OPTIONS), LEGACY_ID_NAND("NAND 4MiB 3,3V 8-bit", 0xE3, 4, SZ_8K, SP_OPTIONS), -- 2.7.4 ^ permalink raw reply related [flat|nested] 15+ messages in thread
* [U-Boot] [PATCH 6/6] sunxi: Enable NAND controller on the CHIP 2016-06-06 15:21 [U-Boot] [PATCH 0/6] sunxi: Add NAND controller driver Boris Brezillon ` (4 preceding siblings ...) 2016-06-06 15:21 ` [U-Boot] [PATCH 5/6] mtd: nand: Add a full-id entry for the H27QCG8T2E5R‐BCF NAND Boris Brezillon @ 2016-06-06 15:21 ` Boris Brezillon 2016-06-06 15:37 ` [U-Boot] [linux-sunxi] [PATCH 0/6] sunxi: Add NAND controller driver Hans de Goede 6 siblings, 0 replies; 15+ messages in thread From: Boris Brezillon @ 2016-06-06 15:21 UTC (permalink / raw) To: u-boot Enable the NAND controller in the sun5i-r8-chip.dts. Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com> --- arch/arm/dts/sun5i-a10s.dtsi | 14 ++++++++++++++ arch/arm/dts/sun5i-a13-olinuxino.dts | 15 +++++++++++++++ arch/arm/dts/sun5i-r8-chip.dts | 15 +++++++++++++++ 3 files changed, 44 insertions(+) diff --git a/arch/arm/dts/sun5i-a10s.dtsi b/arch/arm/dts/sun5i-a10s.dtsi index bddd0de..a5f8855 100644 --- a/arch/arm/dts/sun5i-a10s.dtsi +++ b/arch/arm/dts/sun5i-a10s.dtsi @@ -241,6 +241,20 @@ allwinner,drive = <SUN4I_PINCTRL_30_MA>; allwinner,pull = <SUN4I_PINCTRL_NO_PULL>; }; + + nand_cs2_pins_a: nand_cs at 2 { + allwinner,pins = "PC17"; + allwinner,function = "nand0"; + allwinner,drive = <0>; + allwinner,pull = <0>; + }; + + nand_cs3_pins_a: nand_cs at 3 { + allwinner,pins = "PC18"; + allwinner,function = "nand0"; + allwinner,drive = <0>; + allwinner,pull = <0>; + }; }; &sram_a { diff --git a/arch/arm/dts/sun5i-a13-olinuxino.dts b/arch/arm/dts/sun5i-a13-olinuxino.dts index b3c234c..30e069a 100644 --- a/arch/arm/dts/sun5i-a13-olinuxino.dts +++ b/arch/arm/dts/sun5i-a13-olinuxino.dts @@ -155,6 +155,21 @@ status = "okay"; }; +&nfc { + pinctrl-names = "default"; + pinctrl-0 = <&nand_pins_a &nand_cs0_pins_a &nand_rb0_pins_a>; + status = "okay"; + + nand at 0 { + #address-cells = <2>; + #size-cells = <2>; + reg = <0>; + allwinner,rb = <0>; + nand-ecc-mode = "hw"; + allwinner,randomize; + }; +}; + &ohci0 { status = "okay"; }; diff --git a/arch/arm/dts/sun5i-r8-chip.dts b/arch/arm/dts/sun5i-r8-chip.dts index 6ad19e2..b1b62d5 100644 --- a/arch/arm/dts/sun5i-r8-chip.dts +++ b/arch/arm/dts/sun5i-r8-chip.dts @@ -142,6 +142,21 @@ status = "okay"; }; +&nfc { + pinctrl-names = "default"; + pinctrl-0 = <&nand_pins_a &nand_cs0_pins_a &nand_rb0_pins_a>; + status = "okay"; + + nand at 0 { + #address-cells = <2>; + #size-cells = <2>; + reg = <0>; + allwinner,rb = <0>; + nand-ecc-mode = "hw"; + nand-on-flash-bbt; + }; +}; + &ohci0 { status = "okay"; }; -- 2.7.4 ^ permalink raw reply related [flat|nested] 15+ messages in thread
* [U-Boot] [linux-sunxi] [PATCH 0/6] sunxi: Add NAND controller driver 2016-06-06 15:21 [U-Boot] [PATCH 0/6] sunxi: Add NAND controller driver Boris Brezillon ` (5 preceding siblings ...) 2016-06-06 15:21 ` [U-Boot] [PATCH 6/6] sunxi: Enable NAND controller on the CHIP Boris Brezillon @ 2016-06-06 15:37 ` Hans de Goede 6 siblings, 0 replies; 15+ messages in thread From: Hans de Goede @ 2016-06-06 15:37 UTC (permalink / raw) To: u-boot Hi, On 06-06-16 17:21, Boris Brezillon wrote: > Hello, > > This patch series is adding the normal sunxi NAND controller driver to > u-boot. > > It's based on the Linux driver, with a few adaptions to make it work > in Linux. > > It's based on Scott's series syncing the MTD/NAND frameworks with > Linux 4.6 [1]. The entire series looks good to me, execept for one small remark to 3/6 see me reply to that patch, with that fixed this series is: Acked-by: Hans de Goede <hdegoede@redhat.com> Scott, I believe it is best for this series to be merged through your tree, can you pick it up once any remarks you may have are dealt with ? Regards, Hans > > Best Regards, > > Boris > > [1]https://patchwork.ozlabs.org/patch/627928/ > > Boris Brezillon (4): > sunxi: Add missing macros to configure the NAND controller clk > mtd: nand: Add the sunxi NAND controller driver > mtd: nand: Add a full-id entry for the H27QCG8T2E5R?BCF NAND > sunxi: Enable NAND controller on the CHIP > > Brian Norris (1): > mtd: nand: add common DT init code > > Maxime Ripard (1): > sun5i: Add NAND controller to the sun5i DTSI > > arch/arm/dts/sun5i-a10s.dtsi | 14 + > arch/arm/dts/sun5i-a13-olinuxino.dts | 15 + > arch/arm/dts/sun5i-r8-chip.dts | 15 + > arch/arm/dts/sun5i.dtsi | 49 + > arch/arm/include/asm/arch-sunxi/clock_sun4i.h | 5 + > board/sunxi/board.c | 9 +- > drivers/mtd/nand/Kconfig | 8 +- > drivers/mtd/nand/Makefile | 1 + > drivers/mtd/nand/nand_base.c | 70 + > drivers/mtd/nand/nand_ids.c | 4 + > drivers/mtd/nand/sunxi_nand.c | 1845 +++++++++++++++++++++++++ > include/configs/sunxi-common.h | 2 + > include/fdtdec.h | 1 + > include/linux/mtd/nand.h | 3 + > lib/fdtdec.c | 1 + > 15 files changed, 2038 insertions(+), 4 deletions(-) > create mode 100644 drivers/mtd/nand/sunxi_nand.c > ^ permalink raw reply [flat|nested] 15+ messages in thread
end of thread, other threads:[~2016-06-09 0:44 UTC | newest] Thread overview: 15+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2016-06-06 15:21 [U-Boot] [PATCH 0/6] sunxi: Add NAND controller driver Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 1/6] sunxi: Add missing macros to configure the NAND controller clk Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 2/6] mtd: nand: add common DT init code Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 3/6] mtd: nand: Add the sunxi NAND controller driver Boris Brezillon 2016-06-06 15:36 ` Hans de Goede 2016-06-06 16:22 ` Boris Brezillon 2016-06-06 17:56 ` Scott Wood 2016-06-06 18:31 ` Boris Brezillon 2016-06-06 23:54 ` Scott Wood 2016-06-07 5:41 ` Boris Brezillon 2016-06-09 0:44 ` Scott Wood 2016-06-06 15:21 ` [U-Boot] [PATCH 4/6] sun5i: Add NAND controller to the sun5i DTSI Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 5/6] mtd: nand: Add a full-id entry for the H27QCG8T2E5R‐BCF NAND Boris Brezillon 2016-06-06 15:21 ` [U-Boot] [PATCH 6/6] sunxi: Enable NAND controller on the CHIP Boris Brezillon 2016-06-06 15:37 ` [U-Boot] [linux-sunxi] [PATCH 0/6] sunxi: Add NAND controller driver Hans de Goede
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.