linux/drivers/mtd/nand/raw/denali.c

// SPDX-License-Identifier: GPL-2.0
/*
 * NAND Flash Controller Device Driver
 * Copyright © 2009-2010, Intel Corporation and its suppliers.
 *
 * Copyright (c) 2017-2019 Socionext Inc.
 *   Reworked by Masahiro Yamada <[email protected]>
 */

#include <linux/bitfield.h>
#include <linux/completion.h>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/rawnand.h>
#include <linux/slab.h>
#include <linux/spinlock.h>

#include "denali.h"

#define DENALI_NAND_NAME …

/* for Indexed Addressing */
#define DENALI_INDEXED_CTRL …
#define DENALI_INDEXED_DATA …

#define DENALI_MAP00 …
#define DENALI_MAP01 …
#define DENALI_MAP10 …
#define DENALI_MAP11 …

/* MAP11 access cycle type */
#define DENALI_MAP11_CMD …
#define DENALI_MAP11_ADDR …
#define DENALI_MAP11_DATA …

#define DENALI_BANK(denali) …

#define DENALI_INVALID_BANK …

static struct denali_chip *to_denali_chip(struct nand_chip *chip)
{ … }

static struct denali_controller *to_denali_controller(struct nand_chip *chip)
{ … }

/*
 * Direct Addressing - the slave address forms the control information (command
 * type, bank, block, and page address).  The slave data is the actual data to
 * be transferred.  This mode requires 28 bits of address region allocated.
 */
static u32 denali_direct_read(struct denali_controller *denali, u32 addr)
{ … }

static void denali_direct_write(struct denali_controller *denali, u32 addr,
				u32 data)
{ … }

/*
 * Indexed Addressing - address translation module intervenes in passing the
 * control information.  This mode reduces the required address range.  The
 * control information and transferred data are latched by the registers in
 * the translation module.
 */
static u32 denali_indexed_read(struct denali_controller *denali, u32 addr)
{ … }

static void denali_indexed_write(struct denali_controller *denali, u32 addr,
				 u32 data)
{ … }

static void denali_enable_irq(struct denali_controller *denali)
{ … }

static void denali_disable_irq(struct denali_controller *denali)
{ … }

static void denali_clear_irq(struct denali_controller *denali,
			     int bank, u32 irq_status)
{ … }

static void denali_clear_irq_all(struct denali_controller *denali)
{ … }

static irqreturn_t denali_isr(int irq, void *dev_id)
{ … }

static void denali_reset_irq(struct denali_controller *denali)
{ … }

static u32 denali_wait_for_irq(struct denali_controller *denali, u32 irq_mask)
{ … }

static void denali_select_target(struct nand_chip *chip, int cs)
{ … }

static int denali_change_column(struct nand_chip *chip, unsigned int offset,
				void *buf, unsigned int len, bool write)
{ … }

static int denali_payload_xfer(struct nand_chip *chip, void *buf, bool write)
{ … }

static int denali_oob_xfer(struct nand_chip *chip, void *buf, bool write)
{ … }

static int denali_read_raw(struct nand_chip *chip, void *buf, void *oob_buf,
			   int page)
{ … }

static int denali_write_raw(struct nand_chip *chip, const void *buf,
			    const void *oob_buf, int page)
{ … }

static int denali_read_page_raw(struct nand_chip *chip, u8 *buf,
				int oob_required, int page)
{ … }

static int denali_write_page_raw(struct nand_chip *chip, const u8 *buf,
				 int oob_required, int page)
{ … }

static int denali_read_oob(struct nand_chip *chip, int page)
{ … }

static int denali_write_oob(struct nand_chip *chip, int page)
{ … }

static int denali_check_erased_page(struct nand_chip *chip, u8 *buf,
				    unsigned long uncor_ecc_flags,
				    unsigned int max_bitflips)
{ … }

static int denali_hw_ecc_fixup(struct nand_chip *chip,
			       unsigned long *uncor_ecc_flags)
{ … }

static int denali_sw_ecc_fixup(struct nand_chip *chip,
			       unsigned long *uncor_ecc_flags, u8 *buf)
{ … }

static void denali_setup_dma64(struct denali_controller *denali,
			       dma_addr_t dma_addr, int page, bool write)
{ … }

static void denali_setup_dma32(struct denali_controller *denali,
			       dma_addr_t dma_addr, int page, bool write)
{ … }

static int denali_pio_read(struct denali_controller *denali, u32 *buf,
			   size_t size, int page)
{ … }

static int denali_pio_write(struct denali_controller *denali, const u32 *buf,
			    size_t size, int page)
{ … }

static int denali_pio_xfer(struct denali_controller *denali, void *buf,
			   size_t size, int page, bool write)
{ … }

static int denali_dma_xfer(struct denali_controller *denali, void *buf,
			   size_t size, int page, bool write)
{ … }

static int denali_page_xfer(struct nand_chip *chip, void *buf, size_t size,
			    int page, bool write)
{ … }

static int denali_read_page(struct nand_chip *chip, u8 *buf,
			    int oob_required, int page)
{ … }

static int denali_write_page(struct nand_chip *chip, const u8 *buf,
			     int oob_required, int page)
{ … }

static int denali_setup_interface(struct nand_chip *chip, int chipnr,
				  const struct nand_interface_config *conf)
{ … }

int denali_calc_ecc_bytes(int step_size, int strength)
{ … }
EXPORT_SYMBOL(…);

static int denali_ooblayout_ecc(struct mtd_info *mtd, int section,
				struct mtd_oob_region *oobregion)
{ … }

static int denali_ooblayout_free(struct mtd_info *mtd, int section,
				 struct mtd_oob_region *oobregion)
{ … }

static const struct mtd_ooblayout_ops denali_ooblayout_ops = …;

static int denali_multidev_fixup(struct nand_chip *chip)
{ … }

static int denali_attach_chip(struct nand_chip *chip)
{ … }

static void denali_exec_in8(struct denali_controller *denali, u32 type,
			    u8 *buf, unsigned int len)
{ … }

static void denali_exec_in16(struct denali_controller *denali, u32 type,
			     u8 *buf, unsigned int len)
{ … }

static void denali_exec_in(struct denali_controller *denali, u32 type,
			   u8 *buf, unsigned int len, bool width16)
{ … }

static void denali_exec_out8(struct denali_controller *denali, u32 type,
			     const u8 *buf, unsigned int len)
{ … }

static void denali_exec_out16(struct denali_controller *denali, u32 type,
			      const u8 *buf, unsigned int len)
{ … }

static void denali_exec_out(struct denali_controller *denali, u32 type,
			    const u8 *buf, unsigned int len, bool width16)
{ … }

static int denali_exec_waitrdy(struct denali_controller *denali)
{ … }

static int denali_exec_instr(struct nand_chip *chip,
			     const struct nand_op_instr *instr)
{ … }

static int denali_exec_op(struct nand_chip *chip,
			  const struct nand_operation *op, bool check_only)
{ … }

static const struct nand_controller_ops denali_controller_ops = …;

int denali_chip_init(struct denali_controller *denali,
		     struct denali_chip *dchip)
{ … }
EXPORT_SYMBOL_GPL(…);

int denali_init(struct denali_controller *denali)
{ … }
EXPORT_SYMBOL(…);

void denali_remove(struct denali_controller *denali)
{ … }
EXPORT_SYMBOL(…);

MODULE_DESCRIPTION(…) …;
MODULE_AUTHOR(…) …;
MODULE_LICENSE(…) …;