[people/ms/u-boot.git] / include / linux / mtd / mtd.h

/*
 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org> et al.
 *
 * SPDX-License-Identifier:	GPL-2.0+
 *
 */

#ifndef __MTD_MTD_H__
#define __MTD_MTD_H__

#ifndef __UBOOT__
#include <linux/types.h>
#include <linux/uio.h>
#include <linux/notifier.h>
#include <linux/device.h>

#include <mtd/mtd-abi.h>

#include <asm/div64.h>
#else
#include <linux/compat.h>
#include <mtd/mtd-abi.h>
#include <linux/errno.h>
#include <div64.h>

#define MAX_MTD_DEVICES 32
#endif

#define MTD_ERASE_PENDING	0x01
#define MTD_ERASING		0x02
#define MTD_ERASE_SUSPEND	0x04
#define MTD_ERASE_DONE		0x08
#define MTD_ERASE_FAILED	0x10

#define MTD_FAIL_ADDR_UNKNOWN -1LL

/*
 * If the erase fails, fail_addr might indicate exactly which block failed. If
 * fail_addr = MTD_FAIL_ADDR_UNKNOWN, the failure was not at the device level
 * or was not specific to any particular block.
 */
struct erase_info {
	struct mtd_info *mtd;
	uint64_t addr;
	uint64_t len;
	uint64_t fail_addr;
	u_long time;
	u_long retries;
	unsigned dev;
	unsigned cell;
	void (*callback) (struct erase_info *self);
	u_long priv;
	u_char state;
	struct erase_info *next;
	int scrub;
};

struct mtd_erase_region_info {
	uint64_t offset;		/* At which this region starts, from the beginning of the MTD */
	uint32_t erasesize;		/* For this region */
	uint32_t numblocks;		/* Number of blocks of erasesize in this region */
	unsigned long *lockmap;		/* If keeping bitmap of locks */
};

/**
 * struct mtd_oob_ops - oob operation operands
 * @mode:	operation mode
 *
 * @len:	number of data bytes to write/read
 *
 * @retlen:	number of data bytes written/read
 *
 * @ooblen:	number of oob bytes to write/read
 * @oobretlen:	number of oob bytes written/read
 * @ooboffs:	offset of oob data in the oob area (only relevant when
 *		mode = MTD_OPS_PLACE_OOB or MTD_OPS_RAW)
 * @datbuf:	data buffer - if NULL only oob data are read/written
 * @oobbuf:	oob data buffer
 *
 * Note, it is allowed to read more than one OOB area at one go, but not write.
 * The interface assumes that the OOB write requests program only one page's
 * OOB area.
 */
struct mtd_oob_ops {
	unsigned int	mode;
	size_t		len;
	size_t		retlen;
	size_t		ooblen;
	size_t		oobretlen;
	uint32_t	ooboffs;
	uint8_t		*datbuf;
	uint8_t		*oobbuf;
};

#ifdef CONFIG_SYS_NAND_MAX_OOBFREE
#define MTD_MAX_OOBFREE_ENTRIES_LARGE	CONFIG_SYS_NAND_MAX_OOBFREE
#else
#define MTD_MAX_OOBFREE_ENTRIES_LARGE	32
#endif

#ifdef CONFIG_SYS_NAND_MAX_ECCPOS
#define MTD_MAX_ECCPOS_ENTRIES_LARGE	CONFIG_SYS_NAND_MAX_ECCPOS
#else
#define MTD_MAX_ECCPOS_ENTRIES_LARGE	680
#endif

/*
 * Internal ECC layout control structure. For historical reasons, there is a
 * similar, smaller struct nand_ecclayout_user (in mtd-abi.h) that is retained
 * for export to user-space via the ECCGETLAYOUT ioctl.
 * nand_ecclayout should be expandable in the future simply by the above macros.
 */
struct nand_ecclayout {
	__u32 eccbytes;
	__u32 eccpos[MTD_MAX_ECCPOS_ENTRIES_LARGE];
	__u32 oobavail;
	struct nand_oobfree oobfree[MTD_MAX_OOBFREE_ENTRIES_LARGE];
};

struct module;	/* only needed for owner field in mtd_info */

struct mtd_info {
	u_char type;
	uint32_t flags;
	uint64_t size;	 // Total size of the MTD

	/* "Major" erase size for the device. Naïve users may take this
	 * to be the only erase size available, or may use the more detailed
	 * information below if they desire
	 */
	uint32_t erasesize;
	/* Minimal writable flash unit size. In case of NOR flash it is 1 (even
	 * though individual bits can be cleared), in case of NAND flash it is
	 * one NAND page (or half, or one-fourths of it), in case of ECC-ed NOR
	 * it is of ECC block size, etc. It is illegal to have writesize = 0.
	 * Any driver registering a struct mtd_info must ensure a writesize of
	 * 1 or larger.
	 */
	uint32_t writesize;

	/*
	 * Size of the write buffer used by the MTD. MTD devices having a write
	 * buffer can write multiple writesize chunks at a time. E.g. while
	 * writing 4 * writesize bytes to a device with 2 * writesize bytes
	 * buffer the MTD driver can (but doesn't have to) do 2 writesize
	 * operations, but not 4. Currently, all NANDs have writebufsize
	 * equivalent to writesize (NAND page size). Some NOR flashes do have
	 * writebufsize greater than writesize.
	 */
	uint32_t writebufsize;

	uint32_t oobsize;   // Amount of OOB data per block (e.g. 16)
	uint32_t oobavail;  // Available OOB bytes per block

	/*
	 * If erasesize is a power of 2 then the shift is stored in
	 * erasesize_shift otherwise erasesize_shift is zero. Ditto writesize.
	 */
	unsigned int erasesize_shift;
	unsigned int writesize_shift;
	/* Masks based on erasesize_shift and writesize_shift */
	unsigned int erasesize_mask;
	unsigned int writesize_mask;

	/*
	 * read ops return -EUCLEAN if max number of bitflips corrected on any
	 * one region comprising an ecc step equals or exceeds this value.
	 * Settable by driver, else defaults to ecc_strength.  User can override
	 * in sysfs.  N.B. The meaning of the -EUCLEAN return code has changed;
	 * see Documentation/ABI/testing/sysfs-class-mtd for more detail.
	 */
	unsigned int bitflip_threshold;

	// Kernel-only stuff starts here.
#ifndef __UBOOT__
	const char *name;
#else
	char *name;
#endif
	int index;

	/* ECC layout structure pointer - read only! */
	struct nand_ecclayout *ecclayout;

	/* the ecc step size. */
	unsigned int ecc_step_size;

	/* max number of correctible bit errors per ecc step */
	unsigned int ecc_strength;

	/* Data for variable erase regions. If numeraseregions is zero,
	 * it means that the whole device has erasesize as given above.
	 */
	int numeraseregions;
	struct mtd_erase_region_info *eraseregions;

	/*
	 * Do not call via these pointers, use corresponding mtd_*()
	 * wrappers instead.
	 */
	int (*_erase) (struct mtd_info *mtd, struct erase_info *instr);
#ifndef __UBOOT__
	int (*_point) (struct mtd_info *mtd, loff_t from, size_t len,
		       size_t *retlen, void **virt, resource_size_t *phys);
	int (*_unpoint) (struct mtd_info *mtd, loff_t from, size_t len);
#endif
	unsigned long (*_get_unmapped_area) (struct mtd_info *mtd,
					     unsigned long len,
					     unsigned long offset,
					     unsigned long flags);
	int (*_read) (struct mtd_info *mtd, loff_t from, size_t len,
		      size_t *retlen, u_char *buf);
	int (*_write) (struct mtd_info *mtd, loff_t to, size_t len,
		       size_t *retlen, const u_char *buf);
	int (*_panic_write) (struct mtd_info *mtd, loff_t to, size_t len,
			     size_t *retlen, const u_char *buf);
	int (*_read_oob) (struct mtd_info *mtd, loff_t from,
			  struct mtd_oob_ops *ops);
	int (*_write_oob) (struct mtd_info *mtd, loff_t to,
			   struct mtd_oob_ops *ops);
	int (*_get_fact_prot_info) (struct mtd_info *mtd, size_t len,
				    size_t *retlen, struct otp_info *buf);
	int (*_read_fact_prot_reg) (struct mtd_info *mtd, loff_t from,
				    size_t len, size_t *retlen, u_char *buf);
	int (*_get_user_prot_info) (struct mtd_info *mtd, size_t len,
				    size_t *retlen, struct otp_info *buf);
	int (*_read_user_prot_reg) (struct mtd_info *mtd, loff_t from,
				    size_t len, size_t *retlen, u_char *buf);
	int (*_write_user_prot_reg) (struct mtd_info *mtd, loff_t to,
				     size_t len, size_t *retlen, u_char *buf);
	int (*_lock_user_prot_reg) (struct mtd_info *mtd, loff_t from,
				    size_t len);
#ifndef __UBOOT__
	int (*_writev) (struct mtd_info *mtd, const struct kvec *vecs,
			unsigned long count, loff_t to, size_t *retlen);
#endif
	void (*_sync) (struct mtd_info *mtd);
	int (*_lock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
	int (*_unlock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
	int (*_is_locked) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
	int (*_block_isreserved) (struct mtd_info *mtd, loff_t ofs);
	int (*_block_isbad) (struct mtd_info *mtd, loff_t ofs);
	int (*_block_markbad) (struct mtd_info *mtd, loff_t ofs);
#ifndef __UBOOT__
	int (*_suspend) (struct mtd_info *mtd);
	void (*_resume) (struct mtd_info *mtd);
	void (*_reboot) (struct mtd_info *mtd);
#endif
	/*
	 * If the driver is something smart, like UBI, it may need to maintain
	 * its own reference counting. The below functions are only for driver.
	 */
	int (*_get_device) (struct mtd_info *mtd);
	void (*_put_device) (struct mtd_info *mtd);

#ifndef __UBOOT__
	/* Backing device capabilities for this device
	 * - provides mmap capabilities
	 */
	struct backing_dev_info *backing_dev_info;

	struct notifier_block reboot_notifier;  /* default mode before reboot */
#endif

	/* ECC status information */
	struct mtd_ecc_stats ecc_stats;
	/* Subpage shift (NAND) */
	int subpage_sft;

	void *priv;

	struct module *owner;
#ifndef __UBOOT__
	struct device dev;
#else
	struct udevice *dev;
#endif
	int usecount;
};

static inline int mtd_oobavail(struct mtd_info *mtd, struct mtd_oob_ops *ops)
{
	return ops->mode == MTD_OPS_AUTO_OOB ? mtd->oobavail : mtd->oobsize;
}

int mtd_erase(struct mtd_info *mtd, struct erase_info *instr);
#ifndef __UBOOT__
int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
	      void **virt, resource_size_t *phys);
int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len);
#endif
unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len,
				    unsigned long offset, unsigned long flags);
int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
	     u_char *buf);
int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
	      const u_char *buf);
int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
		    const u_char *buf);

int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops);

static inline int mtd_write_oob(struct mtd_info *mtd, loff_t to,
				struct mtd_oob_ops *ops)
{
	ops->retlen = ops->oobretlen = 0;
	if (!mtd->_write_oob)
		return -EOPNOTSUPP;
	if (!(mtd->flags & MTD_WRITEABLE))
		return -EROFS;
	return mtd->_write_oob(mtd, to, ops);
}

int mtd_get_fact_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
			   struct otp_info *buf);
int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
			   size_t *retlen, u_char *buf);
int mtd_get_user_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
			   struct otp_info *buf);
int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
			   size_t *retlen, u_char *buf);
int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len,
			    size_t *retlen, u_char *buf);
int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len);

#ifndef __UBOOT__
int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
	       unsigned long count, loff_t to, size_t *retlen);
#endif

static inline void mtd_sync(struct mtd_info *mtd)
{
	if (mtd->_sync)
		mtd->_sync(mtd);
}

int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len);
int mtd_block_isreserved(struct mtd_info *mtd, loff_t ofs);
int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs);
int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs);

#ifndef __UBOOT__
static inline int mtd_suspend(struct mtd_info *mtd)
{
	return mtd->_suspend ? mtd->_suspend(mtd) : 0;
}

static inline void mtd_resume(struct mtd_info *mtd)
{
	if (mtd->_resume)
		mtd->_resume(mtd);
}
#endif

static inline uint32_t mtd_div_by_eb(uint64_t sz, struct mtd_info *mtd)
{
	if (mtd->erasesize_shift)
		return sz >> mtd->erasesize_shift;
	do_div(sz, mtd->erasesize);
	return sz;
}

static inline uint32_t mtd_mod_by_eb(uint64_t sz, struct mtd_info *mtd)
{
	if (mtd->erasesize_shift)
		return sz & mtd->erasesize_mask;
	return do_div(sz, mtd->erasesize);
}

static inline uint32_t mtd_div_by_ws(uint64_t sz, struct mtd_info *mtd)
{
	if (mtd->writesize_shift)
		return sz >> mtd->writesize_shift;
	do_div(sz, mtd->writesize);
	return sz;
}

static inline uint32_t mtd_mod_by_ws(uint64_t sz, struct mtd_info *mtd)
{
	if (mtd->writesize_shift)
		return sz & mtd->writesize_mask;
	return do_div(sz, mtd->writesize);
}

static inline int mtd_has_oob(const struct mtd_info *mtd)
{
	return mtd->_read_oob && mtd->_write_oob;
}

static inline int mtd_type_is_nand(const struct mtd_info *mtd)
{
	return mtd->type == MTD_NANDFLASH || mtd->type == MTD_MLCNANDFLASH;
}

static inline int mtd_can_have_bb(const struct mtd_info *mtd)
{
	return !!mtd->_block_isbad;
}

	/* Kernel-side ioctl definitions */

struct mtd_partition;
struct mtd_part_parser_data;

extern int mtd_device_parse_register(struct mtd_info *mtd,
				     const char * const *part_probe_types,
				     struct mtd_part_parser_data *parser_data,
				     const struct mtd_partition *defparts,
				     int defnr_parts);
#define mtd_device_register(master, parts, nr_parts)	\
	mtd_device_parse_register(master, NULL, NULL, parts, nr_parts)
extern int mtd_device_unregister(struct mtd_info *master);
extern struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num);
extern int __get_mtd_device(struct mtd_info *mtd);
extern void __put_mtd_device(struct mtd_info *mtd);
extern struct mtd_info *get_mtd_device_nm(const char *name);
extern void put_mtd_device(struct mtd_info *mtd);


#ifndef __UBOOT__
struct mtd_notifier {
	void (*add)(struct mtd_info *mtd);
	void (*remove)(struct mtd_info *mtd);
	struct list_head list;
};


extern void register_mtd_user (struct mtd_notifier *new);
extern int unregister_mtd_user (struct mtd_notifier *old);
#endif
void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size);

#ifdef CONFIG_MTD_PARTITIONS
void mtd_erase_callback(struct erase_info *instr);
#else
static inline void mtd_erase_callback(struct erase_info *instr)
{
	if (instr->callback)
		instr->callback(instr);
}
#endif

#ifdef __UBOOT__
/*
 * Debugging macro and defines
 */
#define MTD_DEBUG_LEVEL0	(0)	/* Quiet   */
#define MTD_DEBUG_LEVEL1	(1)	/* Audible */
#define MTD_DEBUG_LEVEL2	(2)	/* Loud    */
#define MTD_DEBUG_LEVEL3	(3)	/* Noisy   */

#ifdef CONFIG_MTD_DEBUG
#define pr_debug(args...)	MTDDEBUG(MTD_DEBUG_LEVEL0, args)
#define MTDDEBUG(n, args...)				\
	do {						\
		if (n <= CONFIG_MTD_DEBUG_VERBOSE)	\
			printk(KERN_INFO args);		\
	} while(0)
#else /* CONFIG_MTD_DEBUG */
#define pr_debug(args...)
#define MTDDEBUG(n, args...)				\
	do {						\
		if (0)					\
			printk(KERN_INFO args);		\
	} while(0)
#endif /* CONFIG_MTD_DEBUG */
#define pr_info(args...)	MTDDEBUG(MTD_DEBUG_LEVEL0, args)
#define pr_warn(args...)	MTDDEBUG(MTD_DEBUG_LEVEL0, args)
#define pr_err(args...)		MTDDEBUG(MTD_DEBUG_LEVEL0, args)
#define pr_crit(args...)	MTDDEBUG(MTD_DEBUG_LEVEL0, args)
#define pr_cont(args...)	MTDDEBUG(MTD_DEBUG_LEVEL0, args)
#define pr_notice(args...)	MTDDEBUG(MTD_DEBUG_LEVEL0, args)
#endif
 
static inline int mtd_is_bitflip(int err) {
	return err == -EUCLEAN;
}

static inline int mtd_is_eccerr(int err) {
	return err == -EBADMSG;
}

static inline int mtd_is_bitflip_or_eccerr(int err) {
	return mtd_is_bitflip(err) || mtd_is_eccerr(err);
}

unsigned mtd_mmap_capabilities(struct mtd_info *mtd);

#ifdef __UBOOT__
/* drivers/mtd/mtdcore.h */
int add_mtd_device(struct mtd_info *mtd);
int del_mtd_device(struct mtd_info *mtd);
int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *, int);
int del_mtd_partitions(struct mtd_info *);

int mtd_arg_off(const char *arg, int *idx, loff_t *off, loff_t *size,
		loff_t *maxsize, int devtype, uint64_t chipsize);
int mtd_arg_off_size(int argc, char *const argv[], int *idx, loff_t *off,
		     loff_t *size, loff_t *maxsize, int devtype,
		     uint64_t chipsize);

/* drivers/mtd/mtdcore.c */
void mtd_get_len_incl_bad(struct mtd_info *mtd, uint64_t offset,
			  const uint64_t length, uint64_t *len_incl_bad,
			  int *truncated);
#endif
#endif /* __MTD_MTD_H__ */
Commit	Line	Data
ac7eb8a3	1	/*
ff94bc40	2	* Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org> et al.
932394ac	3	*
78e9e71c	4	* SPDX-License-Identifier: GPL-2.0+
ff94bc40	5	*
932394ac WD	6	*/
	7
	8	#ifndef __MTD_MTD_H__
	9	#define __MTD_MTD_H__
cfa460ad	10
ff94bc40	11	#ifndef __UBOOT__
932394ac	12	#include <linux/types.h>
ff94bc40 HS	13	#include <linux/uio.h>
	14	#include <linux/notifier.h>
	15	#include <linux/device.h>
	16
	17	#include <mtd/mtd-abi.h>
	18
	19	#include <asm/div64.h>
	20	#else
	21	#include <linux/compat.h>
dfe64e2c	22	#include <mtd/mtd-abi.h>
1221ce45	23	#include <linux/errno.h>
ff94bc40	24	#include <div64.h>
932394ac	25
cfa460ad	26	#define MAX_MTD_DEVICES 32
ff94bc40	27	#endif
932394ac	28
53677ef1	29	#define MTD_ERASE_PENDING 0x01
932394ac WD	30	#define MTD_ERASING 0x02
932394ac WD	31	#define MTD_ERASE_SUSPEND 0x04
ff94bc40 HS	32	#define MTD_ERASE_DONE 0x08
ff94bc40 HS	33	#define MTD_ERASE_FAILED 0x10
932394ac	34
ff94bc40	35	#define MTD_FAIL_ADDR_UNKNOWN -1LL
8d2effea	36
d438d508	37	/*
ff94bc40 HS	38	* If the erase fails, fail_addr might indicate exactly which block failed. If
	39	* fail_addr = MTD_FAIL_ADDR_UNKNOWN, the failure was not at the device level
	40	* or was not specific to any particular block.
d438d508	41	*/
932394ac WD	42	struct erase_info {
932394ac WD	43	struct mtd_info *mtd;
8d2effea SR	44	uint64_t addr;
	45	uint64_t len;
	46	uint64_t fail_addr;
932394ac WD	47	u_long time;
932394ac WD	48	u_long retries;
ff94bc40 HS	49	unsigned dev;
ff94bc40 HS	50	unsigned cell;
932394ac WD	51	void (callback) (struct erase_info self);
	52	u_long priv;
	53	u_char state;
	54	struct erase_info *next;
6d41419f	55	int scrub;
932394ac WD	56	};
	57
	58	struct mtd_erase_region_info {
ff94bc40 HS	59	uint64_t offset; /* At which this region starts, from the beginning of the MTD */
	60	uint32_t erasesize; /* For this region */
	61	uint32_t numblocks; /* Number of blocks of erasesize in this region */
cfa460ad WJ	62	unsigned long lockmap; / If keeping bitmap of locks */
	63	};
	64
cfa460ad WJ	65	/**
	66	* struct mtd_oob_ops - oob operation operands
	67	* @mode: operation mode
	68	*
	69	* @len: number of data bytes to write/read
	70	*
	71	* @retlen: number of data bytes written/read
	72	*
	73	* @ooblen: number of oob bytes to write/read
	74	* @oobretlen: number of oob bytes written/read
	75	* @ooboffs: offset of oob data in the oob area (only relevant when
dfe64e2c	76	* mode = MTD_OPS_PLACE_OOB or MTD_OPS_RAW)
cfa460ad WJ	77	* @datbuf: data buffer - if NULL only oob data are read/written
	78	* @oobbuf: oob data buffer
	79	*
ff94bc40	80	* Note, it is allowed to read more than one OOB area at one go, but not write.
cfa460ad WJ	81	* The interface assumes that the OOB write requests program only one page's
	82	* OOB area.
	83	*/
	84	struct mtd_oob_ops {
dfe64e2c	85	unsigned int mode;
cfa460ad WJ	86	size_t len;
	87	size_t retlen;
	88	size_t ooblen;
	89	size_t oobretlen;
	90	uint32_t ooboffs;
	91	uint8_t *datbuf;
	92	uint8_t *oobbuf;
932394ac WD	93	};
932394ac WD	94
68ec9c85 PK	95	#ifdef CONFIG_SYS_NAND_MAX_OOBFREE
	96	#define MTD_MAX_OOBFREE_ENTRIES_LARGE CONFIG_SYS_NAND_MAX_OOBFREE
	97	#else
	98	#define MTD_MAX_OOBFREE_ENTRIES_LARGE 32
	99	#endif
	100
	101	#ifdef CONFIG_SYS_NAND_MAX_ECCPOS
	102	#define MTD_MAX_ECCPOS_ENTRIES_LARGE CONFIG_SYS_NAND_MAX_ECCPOS
	103	#else
2580a2a7	104	#define MTD_MAX_ECCPOS_ENTRIES_LARGE 680
68ec9c85 PK	105	#endif
	106
	107	/*
ff94bc40 HS	108	* Internal ECC layout control structure. For historical reasons, there is a
	109	* similar, smaller struct nand_ecclayout_user (in mtd-abi.h) that is retained
	110	* for export to user-space via the ECCGETLAYOUT ioctl.
	111	* nand_ecclayout should be expandable in the future simply by the above macros.
68ec9c85 PK	112	*/
68ec9c85 PK	113	struct nand_ecclayout {
ff94bc40 HS	114	__u32 eccbytes;
	115	__u32 eccpos[MTD_MAX_ECCPOS_ENTRIES_LARGE];
	116	__u32 oobavail;
68ec9c85 PK	117	struct nand_oobfree oobfree[MTD_MAX_OOBFREE_ENTRIES_LARGE];
	118	};
	119
ff94bc40 HS	120	struct module; /* only needed for owner field in mtd_info */
ff94bc40 HS	121
932394ac WD	122	struct mtd_info {
932394ac WD	123	u_char type;
ff94bc40 HS	124	uint32_t flags;
ff94bc40 HS	125	uint64_t size; // Total size of the MTD
932394ac	126
fa82f871	127	/* "Major" erase size for the device. Naïve users may take this
932394ac WD	128	* to be the only erase size available, or may use the more detailed
	129	* information below if they desire
	130	*/
ff94bc40	131	uint32_t erasesize;
cfa460ad WJ	132	/* Minimal writable flash unit size. In case of NOR flash it is 1 (even
	133	* though individual bits can be cleared), in case of NAND flash it is
	134	* one NAND page (or half, or one-fourths of it), in case of ECC-ed NOR
	135	* it is of ECC block size, etc. It is illegal to have writesize = 0.
	136	* Any driver registering a struct mtd_info must ensure a writesize of
	137	* 1 or larger.
	138	*/
ff94bc40 HS	139	uint32_t writesize;
	140
	141	/*
	142	* Size of the write buffer used by the MTD. MTD devices having a write
	143	* buffer can write multiple writesize chunks at a time. E.g. while
	144	* writing 4 * writesize bytes to a device with 2 * writesize bytes
	145	* buffer the MTD driver can (but doesn't have to) do 2 writesize
	146	* operations, but not 4. Currently, all NANDs have writebufsize
	147	* equivalent to writesize (NAND page size). Some NOR flashes do have
	148	* writebufsize greater than writesize.
	149	*/
	150	uint32_t writebufsize;
932394ac	151
ff94bc40 HS	152	uint32_t oobsize; // Amount of OOB data per block (e.g. 16)
	153	uint32_t oobavail; // Available OOB bytes per block
	154
	155	/*
	156	* If erasesize is a power of 2 then the shift is stored in
	157	* erasesize_shift otherwise erasesize_shift is zero. Ditto writesize.
	158	*/
	159	unsigned int erasesize_shift;
	160	unsigned int writesize_shift;
	161	/* Masks based on erasesize_shift and writesize_shift */
	162	unsigned int erasesize_mask;
	163	unsigned int writesize_mask;
ac7eb8a3	164
dfe64e2c SL	165	/*
	166	* read ops return -EUCLEAN if max number of bitflips corrected on any
	167	* one region comprising an ecc step equals or exceeds this value.
	168	* Settable by driver, else defaults to ecc_strength. User can override
	169	* in sysfs. N.B. The meaning of the -EUCLEAN return code has changed;
	170	* see Documentation/ABI/testing/sysfs-class-mtd for more detail.
	171	*/
	172	unsigned int bitflip_threshold;
	173
ff94bc40 HS	174	// Kernel-only stuff starts here.
ff94bc40 HS	175	#ifndef __UBOOT__
c45912d8	176	const char *name;
ff94bc40 HS	177	#else
	178	char *name;
	179	#endif
932394ac WD	180	int index;
932394ac WD	181
dfe64e2c	182	/* ECC layout structure pointer - read only! */
cfa460ad	183	struct nand_ecclayout *ecclayout;
932394ac	184
ff94bc40 HS	185	/* the ecc step size. */
	186	unsigned int ecc_step_size;
	187
dfe64e2c SL	188	/* max number of correctible bit errors per ecc step */
	189	unsigned int ecc_strength;
	190
932394ac	191	/* Data for variable erase regions. If numeraseregions is zero,
ac7eb8a3	192	* it means that the whole device has erasesize as given above.
932394ac WD	193	*/
932394ac WD	194	int numeraseregions;
ac7eb8a3	195	struct mtd_erase_region_info *eraseregions;
932394ac	196
c45912d8	197	/*
dfe64e2c SL	198	* Do not call via these pointers, use corresponding mtd_*()
dfe64e2c SL	199	* wrappers instead.
c45912d8	200	*/
dfe64e2c	201	int (_erase) (struct mtd_info mtd, struct erase_info *instr);
ff94bc40	202	#ifndef __UBOOT__
dfe64e2c	203	int (_point) (struct mtd_info mtd, loff_t from, size_t len,
ff94bc40 HS	204	size_t retlen, void virt, resource_size_t phys);
	205	int (_unpoint) (struct mtd_info mtd, loff_t from, size_t len);
	206	#endif
	207	unsigned long (_get_unmapped_area) (struct mtd_info mtd,
	208	unsigned long len,
	209	unsigned long offset,
	210	unsigned long flags);
dfe64e2c	211	int (_read) (struct mtd_info mtd, loff_t from, size_t len,
ff94bc40	212	size_t retlen, u_char buf);
dfe64e2c	213	int (_write) (struct mtd_info mtd, loff_t to, size_t len,
ff94bc40 HS	214	size_t retlen, const u_char buf);
	215	int (_panic_write) (struct mtd_info mtd, loff_t to, size_t len,
	216	size_t retlen, const u_char buf);
dfe64e2c	217	int (_read_oob) (struct mtd_info mtd, loff_t from,
ff94bc40	218	struct mtd_oob_ops *ops);
dfe64e2c	219	int (_write_oob) (struct mtd_info mtd, loff_t to,
ff94bc40	220	struct mtd_oob_ops *ops);
4e67c571 HS	221	int (_get_fact_prot_info) (struct mtd_info mtd, size_t len,
4e67c571 HS	222	size_t retlen, struct otp_info buf);
dfe64e2c	223	int (_read_fact_prot_reg) (struct mtd_info mtd, loff_t from,
ff94bc40	224	size_t len, size_t retlen, u_char buf);
4e67c571 HS	225	int (_get_user_prot_info) (struct mtd_info mtd, size_t len,
4e67c571 HS	226	size_t retlen, struct otp_info buf);
dfe64e2c	227	int (_read_user_prot_reg) (struct mtd_info mtd, loff_t from,
ff94bc40 HS	228	size_t len, size_t retlen, u_char buf);
	229	int (_write_user_prot_reg) (struct mtd_info mtd, loff_t to,
	230	size_t len, size_t retlen, u_char buf);
dfe64e2c	231	int (_lock_user_prot_reg) (struct mtd_info mtd, loff_t from,
ff94bc40 HS	232	size_t len);
	233	#ifndef __UBOOT__
	234	int (_writev) (struct mtd_info mtd, const struct kvec *vecs,
	235	unsigned long count, loff_t to, size_t *retlen);
	236	#endif
dfe64e2c SL	237	void (_sync) (struct mtd_info mtd);
	238	int (_lock) (struct mtd_info mtd, loff_t ofs, uint64_t len);
	239	int (_unlock) (struct mtd_info mtd, loff_t ofs, uint64_t len);
ff94bc40	240	int (_is_locked) (struct mtd_info mtd, loff_t ofs, uint64_t len);
86a720aa	241	int (_block_isreserved) (struct mtd_info mtd, loff_t ofs);
dfe64e2c SL	242	int (_block_isbad) (struct mtd_info mtd, loff_t ofs);
dfe64e2c SL	243	int (_block_markbad) (struct mtd_info mtd, loff_t ofs);
ff94bc40 HS	244	#ifndef __UBOOT__
	245	int (_suspend) (struct mtd_info mtd);
	246	void (_resume) (struct mtd_info mtd);
0195a7bb	247	void (_reboot) (struct mtd_info mtd);
ff94bc40	248	#endif
ac7eb8a3	249	/*
dfe64e2c SL	250	* If the driver is something smart, like UBI, it may need to maintain
dfe64e2c SL	251	* its own reference counting. The below functions are only for driver.
932394ac	252	*/
dfe64e2c SL	253	int (_get_device) (struct mtd_info mtd);
dfe64e2c SL	254	void (_put_device) (struct mtd_info mtd);
cfa460ad	255
ff94bc40 HS	256	#ifndef __UBOOT__
	257	/* Backing device capabilities for this device
	258	* - provides mmap capabilities
	259	*/
	260	struct backing_dev_info *backing_dev_info;
	261
cfa460ad WJ	262	struct notifier_block reboot_notifier; /* default mode before reboot */
	263	#endif
	264
	265	/* ECC status information */
	266	struct mtd_ecc_stats ecc_stats;
	267	/* Subpage shift (NAND) */
	268	int subpage_sft;
	269
932394ac WD	270	void *priv;
	271
	272	struct module *owner;
ff94bc40 HS	273	#ifndef __UBOOT__
ff94bc40 HS	274	struct device dev;
d8587993 TC	275	#else
d8587993 TC	276	struct udevice *dev;
ff94bc40	277	#endif
932394ac WD	278	int usecount;
	279	};
	280
ceee07b6 SW	281	static inline int mtd_oobavail(struct mtd_info mtd, struct mtd_oob_ops ops)
	282	{
	283	return ops->mode == MTD_OPS_AUTO_OOB ? mtd->oobavail : mtd->oobsize;
	284	}
	285
dfe64e2c	286	int mtd_erase(struct mtd_info mtd, struct erase_info instr);
ff94bc40 HS	287	#ifndef __UBOOT__
	288	int mtd_point(struct mtd_info mtd, loff_t from, size_t len, size_t retlen,
	289	void *virt, resource_size_t phys);
	290	int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len);
	291	#endif
	292	unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len,
	293	unsigned long offset, unsigned long flags);
dfe64e2c SL	294	int mtd_read(struct mtd_info mtd, loff_t from, size_t len, size_t retlen,
	295	u_char *buf);
	296	int mtd_write(struct mtd_info mtd, loff_t to, size_t len, size_t retlen,
	297	const u_char *buf);
	298	int mtd_panic_write(struct mtd_info mtd, loff_t to, size_t len, size_t retlen,
	299	const u_char *buf);
	300
	301	int mtd_read_oob(struct mtd_info mtd, loff_t from, struct mtd_oob_ops ops);
	302
	303	static inline int mtd_write_oob(struct mtd_info *mtd, loff_t to,
	304	struct mtd_oob_ops *ops)
	305	{
	306	ops->retlen = ops->oobretlen = 0;
	307	if (!mtd->_write_oob)
	308	return -EOPNOTSUPP;
	309	if (!(mtd->flags & MTD_WRITEABLE))
	310	return -EROFS;
	311	return mtd->_write_oob(mtd, to, ops);
	312	}
	313
4e67c571 HS	314	int mtd_get_fact_prot_info(struct mtd_info mtd, size_t len, size_t retlen,
4e67c571 HS	315	struct otp_info *buf);
dfe64e2c SL	316	int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
dfe64e2c SL	317	size_t retlen, u_char buf);
4e67c571 HS	318	int mtd_get_user_prot_info(struct mtd_info mtd, size_t len, size_t retlen,
4e67c571 HS	319	struct otp_info *buf);
dfe64e2c SL	320	int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
	321	size_t retlen, u_char buf);
	322	int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len,
	323	size_t retlen, u_char buf);
	324	int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len);
	325
ff94bc40	326	#ifndef __UBOOT__
dfe64e2c SL	327	int mtd_writev(struct mtd_info mtd, const struct kvec vecs,
	328	unsigned long count, loff_t to, size_t *retlen);
	329	#endif
	330
	331	static inline void mtd_sync(struct mtd_info *mtd)
	332	{
	333	if (mtd->_sync)
	334	mtd->_sync(mtd);
	335	}
	336
	337	int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
	338	int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
	339	int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len);
86a720aa	340	int mtd_block_isreserved(struct mtd_info *mtd, loff_t ofs);
dfe64e2c SL	341	int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs);
	342	int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs);
	343
ff94bc40 HS	344	#ifndef __UBOOT__
	345	static inline int mtd_suspend(struct mtd_info *mtd)
	346	{
	347	return mtd->_suspend ? mtd->_suspend(mtd) : 0;
	348	}
	349
	350	static inline void mtd_resume(struct mtd_info *mtd)
	351	{
	352	if (mtd->_resume)
	353	mtd->_resume(mtd);
	354	}
	355	#endif
	356
8d2effea SR	357	static inline uint32_t mtd_div_by_eb(uint64_t sz, struct mtd_info *mtd)
8d2effea SR	358	{
ff94bc40 HS	359	if (mtd->erasesize_shift)
ff94bc40 HS	360	return sz >> mtd->erasesize_shift;
8d2effea SR	361	do_div(sz, mtd->erasesize);
	362	return sz;
	363	}
	364
	365	static inline uint32_t mtd_mod_by_eb(uint64_t sz, struct mtd_info *mtd)
	366	{
ff94bc40 HS	367	if (mtd->erasesize_shift)
ff94bc40 HS	368	return sz & mtd->erasesize_mask;
8d2effea SR	369	return do_div(sz, mtd->erasesize);
8d2effea SR	370	}
932394ac	371
ff94bc40 HS	372	static inline uint32_t mtd_div_by_ws(uint64_t sz, struct mtd_info *mtd)
	373	{
	374	if (mtd->writesize_shift)
	375	return sz >> mtd->writesize_shift;
	376	do_div(sz, mtd->writesize);
	377	return sz;
	378	}
	379
	380	static inline uint32_t mtd_mod_by_ws(uint64_t sz, struct mtd_info *mtd)
	381	{
	382	if (mtd->writesize_shift)
	383	return sz & mtd->writesize_mask;
	384	return do_div(sz, mtd->writesize);
	385	}
	386
dfe64e2c SL	387	static inline int mtd_has_oob(const struct mtd_info *mtd)
	388	{
	389	return mtd->_read_oob && mtd->_write_oob;
	390	}
	391
ff94bc40 HS	392	static inline int mtd_type_is_nand(const struct mtd_info *mtd)
	393	{
	394	return mtd->type == MTD_NANDFLASH \|\| mtd->type == MTD_MLCNANDFLASH;
	395	}
	396
dfe64e2c SL	397	static inline int mtd_can_have_bb(const struct mtd_info *mtd)
	398	{
	399	return !!mtd->_block_isbad;
	400	}
	401
932394ac WD	402	/* Kernel-side ioctl definitions */
932394ac WD	403
ff94bc40 HS	404	struct mtd_partition;
	405	struct mtd_part_parser_data;
	406
	407	extern int mtd_device_parse_register(struct mtd_info *mtd,
	408	const char * const *part_probe_types,
	409	struct mtd_part_parser_data *parser_data,
	410	const struct mtd_partition *defparts,
	411	int defnr_parts);
	412	#define mtd_device_register(master, parts, nr_parts) \
	413	mtd_device_parse_register(master, NULL, NULL, parts, nr_parts)
	414	extern int mtd_device_unregister(struct mtd_info *master);
932394ac	415	extern struct mtd_info get_mtd_device(struct mtd_info mtd, int num);
ff94bc40 HS	416	extern int __get_mtd_device(struct mtd_info *mtd);
ff94bc40 HS	417	extern void __put_mtd_device(struct mtd_info *mtd);
cfa460ad	418	extern struct mtd_info get_mtd_device_nm(const char name);
932394ac	419	extern void put_mtd_device(struct mtd_info *mtd);
ff94bc40 HS	420
	421
	422	#ifndef __UBOOT__
932394ac WD	423	struct mtd_notifier {
	424	void (add)(struct mtd_info mtd);
	425	void (remove)(struct mtd_info mtd);
	426	struct list_head list;
	427	};
	428
ff94bc40	429
932394ac WD	430	extern void register_mtd_user (struct mtd_notifier *new);
932394ac WD	431	extern int unregister_mtd_user (struct mtd_notifier *old);
932394ac	432	#endif
ff94bc40	433	void mtd_kmalloc_up_to(const struct mtd_info mtd, size_t *size);
932394ac	434
932394ac WD	435	#ifdef CONFIG_MTD_PARTITIONS
	436	void mtd_erase_callback(struct erase_info *instr);
	437	#else
	438	static inline void mtd_erase_callback(struct erase_info *instr)
	439	{
	440	if (instr->callback)
	441	instr->callback(instr);
	442	}
	443	#endif
	444
ff94bc40	445	#ifdef __UBOOT__
932394ac WD	446	/*
	447	* Debugging macro and defines
	448	*/
	449	#define MTD_DEBUG_LEVEL0 (0) /* Quiet */
	450	#define MTD_DEBUG_LEVEL1 (1) /* Audible */
	451	#define MTD_DEBUG_LEVEL2 (2) /* Loud */
	452	#define MTD_DEBUG_LEVEL3 (3) /* Noisy */
	453
	454	#ifdef CONFIG_MTD_DEBUG
dfe64e2c	455	#define pr_debug(args...) MTDDEBUG(MTD_DEBUG_LEVEL0, args)
3167c538	456	#define MTDDEBUG(n, args...) \
53677ef1	457	do { \
932394ac WD	458	if (n <= CONFIG_MTD_DEBUG_VERBOSE) \
	459	printk(KERN_INFO args); \
	460	} while(0)
	461	#else /* CONFIG_MTD_DEBUG */
dfe64e2c	462	#define pr_debug(args...)
c45912d8 SW	463	#define MTDDEBUG(n, args...) \
	464	do { \
	465	if (0) \
	466	printk(KERN_INFO args); \
	467	} while(0)
932394ac	468	#endif /* CONFIG_MTD_DEBUG */
dfe64e2c SL	469	#define pr_info(args...) MTDDEBUG(MTD_DEBUG_LEVEL0, args)
	470	#define pr_warn(args...) MTDDEBUG(MTD_DEBUG_LEVEL0, args)
	471	#define pr_err(args...) MTDDEBUG(MTD_DEBUG_LEVEL0, args)
ff94bc40 HS	472	#define pr_crit(args...) MTDDEBUG(MTD_DEBUG_LEVEL0, args)
	473	#define pr_cont(args...) MTDDEBUG(MTD_DEBUG_LEVEL0, args)
	474	#define pr_notice(args...) MTDDEBUG(MTD_DEBUG_LEVEL0, args)
	475	#endif
	476
dfe64e2c SL	477	static inline int mtd_is_bitflip(int err) {
	478	return err == -EUCLEAN;
	479	}
	480
	481	static inline int mtd_is_eccerr(int err) {
	482	return err == -EBADMSG;
	483	}
	484
	485	static inline int mtd_is_bitflip_or_eccerr(int err) {
	486	return mtd_is_bitflip(err) \|\| mtd_is_eccerr(err);
	487	}
932394ac	488
0195a7bb HS	489	unsigned mtd_mmap_capabilities(struct mtd_info *mtd);
0195a7bb HS	490
ff94bc40 HS	491	#ifdef __UBOOT__
	492	/* drivers/mtd/mtdcore.h */
	493	int add_mtd_device(struct mtd_info *mtd);
ddf7bcfa	494	int del_mtd_device(struct mtd_info *mtd);
ff94bc40 HS	495	int add_mtd_partitions(struct mtd_info , const struct mtd_partition , int);
ff94bc40 HS	496	int del_mtd_partitions(struct mtd_info *);
09c32807 HS	497
09c32807 HS	498	int mtd_arg_off(const char arg, int idx, loff_t off, loff_t size,
f18d1116	499	loff_t *maxsize, int devtype, uint64_t chipsize);
09c32807	500	int mtd_arg_off_size(int argc, char const argv[], int idx, loff_t *off,
f18d1116 MY	501	loff_t size, loff_t maxsize, int devtype,
f18d1116 MY	502	uint64_t chipsize);
59441ac3 SR	503
	504	/* drivers/mtd/mtdcore.c */
	505	void mtd_get_len_incl_bad(struct mtd_info *mtd, uint64_t offset,
	506	const uint64_t length, uint64_t *len_incl_bad,
	507	int *truncated);
ff94bc40	508	#endif
932394ac	509	#endif /* __MTD_MTD_H__ */