[linux-2.6-block.git] / include / linux / mtd / map.h


/* Overhauled routines for dealing with different mmap regions of flash */
/* $Id: map.h,v 1.54 2005/11/07 11:14:54 gleixner Exp $ */

#ifndef __LINUX_MTD_MAP_H__
#define __LINUX_MTD_MAP_H__

#include <linux/types.h>
#include <linux/list.h>
#include <linux/string.h>

#include <linux/mtd/compatmac.h>

#include <asm/unaligned.h>
#include <asm/system.h>
#include <asm/io.h>

#ifdef CONFIG_MTD_MAP_BANK_WIDTH_1
#define map_bankwidth(map) 1
#define map_bankwidth_is_1(map) (map_bankwidth(map) == 1)
#define map_bankwidth_is_large(map) (0)
#define map_words(map) (1)
#define MAX_MAP_BANKWIDTH 1
#else
#define map_bankwidth_is_1(map) (0)
#endif

#ifdef CONFIG_MTD_MAP_BANK_WIDTH_2
# ifdef map_bankwidth
#  undef map_bankwidth
#  define map_bankwidth(map) ((map)->bankwidth)
# else
#  define map_bankwidth(map) 2
#  define map_bankwidth_is_large(map) (0)
#  define map_words(map) (1)
# endif
#define map_bankwidth_is_2(map) (map_bankwidth(map) == 2)
#undef MAX_MAP_BANKWIDTH
#define MAX_MAP_BANKWIDTH 2
#else
#define map_bankwidth_is_2(map) (0)
#endif

#ifdef CONFIG_MTD_MAP_BANK_WIDTH_4
# ifdef map_bankwidth
#  undef map_bankwidth
#  define map_bankwidth(map) ((map)->bankwidth)
# else
#  define map_bankwidth(map) 4
#  define map_bankwidth_is_large(map) (0)
#  define map_words(map) (1)
# endif
#define map_bankwidth_is_4(map) (map_bankwidth(map) == 4)
#undef MAX_MAP_BANKWIDTH
#define MAX_MAP_BANKWIDTH 4
#else
#define map_bankwidth_is_4(map) (0)
#endif

/* ensure we never evaluate anything shorted than an unsigned long
 * to zero, and ensure we'll never miss the end of an comparison (bjd) */

#define map_calc_words(map) ((map_bankwidth(map) + (sizeof(unsigned long)-1))/ sizeof(unsigned long))

#ifdef CONFIG_MTD_MAP_BANK_WIDTH_8
# ifdef map_bankwidth
#  undef map_bankwidth
#  define map_bankwidth(map) ((map)->bankwidth)
#  if BITS_PER_LONG < 64
#   undef map_bankwidth_is_large
#   define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
#   undef map_words
#   define map_words(map) map_calc_words(map)
#  endif
# else
#  define map_bankwidth(map) 8
#  define map_bankwidth_is_large(map) (BITS_PER_LONG < 64)
#  define map_words(map) map_calc_words(map)
# endif
#define map_bankwidth_is_8(map) (map_bankwidth(map) == 8)
#undef MAX_MAP_BANKWIDTH
#define MAX_MAP_BANKWIDTH 8
#else
#define map_bankwidth_is_8(map) (0)
#endif

#ifdef CONFIG_MTD_MAP_BANK_WIDTH_16
# ifdef map_bankwidth
#  undef map_bankwidth
#  define map_bankwidth(map) ((map)->bankwidth)
#  undef map_bankwidth_is_large
#  define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
#  undef map_words
#  define map_words(map) map_calc_words(map)
# else
#  define map_bankwidth(map) 16
#  define map_bankwidth_is_large(map) (1)
#  define map_words(map) map_calc_words(map)
# endif
#define map_bankwidth_is_16(map) (map_bankwidth(map) == 16)
#undef MAX_MAP_BANKWIDTH
#define MAX_MAP_BANKWIDTH 16
#else
#define map_bankwidth_is_16(map) (0)
#endif

#ifdef CONFIG_MTD_MAP_BANK_WIDTH_32
# ifdef map_bankwidth
#  undef map_bankwidth
#  define map_bankwidth(map) ((map)->bankwidth)
#  undef map_bankwidth_is_large
#  define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
#  undef map_words
#  define map_words(map) map_calc_words(map)
# else
#  define map_bankwidth(map) 32
#  define map_bankwidth_is_large(map) (1)
#  define map_words(map) map_calc_words(map)
# endif
#define map_bankwidth_is_32(map) (map_bankwidth(map) == 32)
#undef MAX_MAP_BANKWIDTH
#define MAX_MAP_BANKWIDTH 32
#else
#define map_bankwidth_is_32(map) (0)
#endif

#ifndef map_bankwidth
#warning "No CONFIG_MTD_MAP_BANK_WIDTH_xx selected. No NOR chip support can work"
static inline int map_bankwidth(void *map)
{
	BUG();
	return 0;
}
#define map_bankwidth_is_large(map) (0)
#define map_words(map) (0)
#define MAX_MAP_BANKWIDTH 1
#endif

static inline int map_bankwidth_supported(int w)
{
	switch (w) {
#ifdef CONFIG_MTD_MAP_BANK_WIDTH_1
	case 1:
#endif
#ifdef CONFIG_MTD_MAP_BANK_WIDTH_2
	case 2:
#endif
#ifdef CONFIG_MTD_MAP_BANK_WIDTH_4
	case 4:
#endif
#ifdef CONFIG_MTD_MAP_BANK_WIDTH_8
	case 8:
#endif
#ifdef CONFIG_MTD_MAP_BANK_WIDTH_16
	case 16:
#endif
#ifdef CONFIG_MTD_MAP_BANK_WIDTH_32
	case 32:
#endif
		return 1;

	default:
		return 0;
	}
}

#define MAX_MAP_LONGS ( ((MAX_MAP_BANKWIDTH*8) + BITS_PER_LONG - 1) / BITS_PER_LONG )

typedef union {
	unsigned long x[MAX_MAP_LONGS];
} map_word;

/* The map stuff is very simple. You fill in your struct map_info with
   a handful of routines for accessing the device, making sure they handle
   paging etc. correctly if your device needs it. Then you pass it off
   to a chip probe routine -- either JEDEC or CFI probe or both -- via
   do_map_probe(). If a chip is recognised, the probe code will invoke the
   appropriate chip driver (if present) and return a struct mtd_info.
   At which point, you fill in the mtd->module with your own module
   address, and register it with the MTD core code. Or you could partition
   it and register the partitions instead, or keep it for your own private
   use; whatever.

   The mtd->priv field will point to the struct map_info, and any further
   private data required by the chip driver is linked from the
   mtd->priv->fldrv_priv field. This allows the map driver to get at
   the destructor function map->fldrv_destroy() when it's tired
   of living.
*/

struct map_info {
	char *name;
	unsigned long size;
	resource_size_t phys;
#define NO_XIP (-1UL)

	void __iomem *virt;
	void *cached;

	int bankwidth; /* in octets. This isn't necessarily the width
		       of actual bus cycles -- it's the repeat interval
		      in bytes, before you are talking to the first chip again.
		      */

#ifdef CONFIG_MTD_COMPLEX_MAPPINGS
	map_word (*read)(struct map_info *, unsigned long);
	void (*copy_from)(struct map_info *, void *, unsigned long, ssize_t);

	void (*write)(struct map_info *, const map_word, unsigned long);
	void (*copy_to)(struct map_info *, unsigned long, const void *, ssize_t);

	/* We can perhaps put in 'point' and 'unpoint' methods, if we really
	   want to enable XIP for non-linear mappings. Not yet though. */
#endif
	/* It's possible for the map driver to use cached memory in its
	   copy_from implementation (and _only_ with copy_from).  However,
	   when the chip driver knows some flash area has changed contents,
	   it will signal it to the map driver through this routine to let
	   the map driver invalidate the corresponding cache as needed.
	   If there is no cache to care about this can be set to NULL. */
	void (*inval_cache)(struct map_info *, unsigned long, ssize_t);

	/* set_vpp() must handle being reentered -- enable, enable, disable
	   must leave it enabled. */
	void (*set_vpp)(struct map_info *, int);

	unsigned long map_priv_1;
	unsigned long map_priv_2;
	void *fldrv_priv;
	struct mtd_chip_driver *fldrv;
};

struct mtd_chip_driver {
	struct mtd_info *(*probe)(struct map_info *map);
	void (*destroy)(struct mtd_info *);
	struct module *module;
	char *name;
	struct list_head list;
};

void register_mtd_chip_driver(struct mtd_chip_driver *);
void unregister_mtd_chip_driver(struct mtd_chip_driver *);

struct mtd_info *do_map_probe(const char *name, struct map_info *map);
void map_destroy(struct mtd_info *mtd);

#define ENABLE_VPP(map) do { if(map->set_vpp) map->set_vpp(map, 1); } while(0)
#define DISABLE_VPP(map) do { if(map->set_vpp) map->set_vpp(map, 0); } while(0)

#define INVALIDATE_CACHED_RANGE(map, from, size) \
	do { if(map->inval_cache) map->inval_cache(map, from, size); } while(0)


static inline int map_word_equal(struct map_info *map, map_word val1, map_word val2)
{
	int i;
	for (i=0; i<map_words(map); i++) {
		if (val1.x[i] != val2.x[i])
			return 0;
	}
	return 1;
}

static inline map_word map_word_and(struct map_info *map, map_word val1, map_word val2)
{
	map_word r;
	int i;

	for (i=0; i<map_words(map); i++) {
		r.x[i] = val1.x[i] & val2.x[i];
	}
	return r;
}

static inline map_word map_word_clr(struct map_info *map, map_word val1, map_word val2)
{
	map_word r;
	int i;

	for (i=0; i<map_words(map); i++) {
		r.x[i] = val1.x[i] & ~val2.x[i];
	}
	return r;
}

static inline map_word map_word_or(struct map_info *map, map_word val1, map_word val2)
{
	map_word r;
	int i;

	for (i=0; i<map_words(map); i++) {
		r.x[i] = val1.x[i] | val2.x[i];
	}
	return r;
}

#define map_word_andequal(m, a, b, z) map_word_equal(m, z, map_word_and(m, a, b))

static inline int map_word_bitsset(struct map_info *map, map_word val1, map_word val2)
{
	int i;

	for (i=0; i<map_words(map); i++) {
		if (val1.x[i] & val2.x[i])
			return 1;
	}
	return 0;
}

static inline map_word map_word_load(struct map_info *map, const void *ptr)
{
	map_word r;

	if (map_bankwidth_is_1(map))
		r.x[0] = *(unsigned char *)ptr;
	else if (map_bankwidth_is_2(map))
		r.x[0] = get_unaligned((uint16_t *)ptr);
	else if (map_bankwidth_is_4(map))
		r.x[0] = get_unaligned((uint32_t *)ptr);
#if BITS_PER_LONG >= 64
	else if (map_bankwidth_is_8(map))
		r.x[0] = get_unaligned((uint64_t *)ptr);
#endif
	else if (map_bankwidth_is_large(map))
		memcpy(r.x, ptr, map->bankwidth);

	return r;
}

static inline map_word map_word_load_partial(struct map_info *map, map_word orig, const unsigned char *buf, int start, int len)
{
	int i;

	if (map_bankwidth_is_large(map)) {
		char *dest = (char *)&orig;
		memcpy(dest+start, buf, len);
	} else {
		for (i=start; i < start+len; i++) {
			int bitpos;
#ifdef __LITTLE_ENDIAN
			bitpos = i*8;
#else /* __BIG_ENDIAN */
			bitpos = (map_bankwidth(map)-1-i)*8;
#endif
			orig.x[0] &= ~(0xff << bitpos);
			orig.x[0] |= buf[i-start] << bitpos;
		}
	}
	return orig;
}

#if BITS_PER_LONG < 64
#define MAP_FF_LIMIT 4
#else
#define MAP_FF_LIMIT 8
#endif

static inline map_word map_word_ff(struct map_info *map)
{
	map_word r;
	int i;

	if (map_bankwidth(map) < MAP_FF_LIMIT) {
		int bw = 8 * map_bankwidth(map);
		r.x[0] = (1 << bw) - 1;
	} else {
		for (i=0; i<map_words(map); i++)
			r.x[i] = ~0UL;
	}
	return r;
}

static inline map_word inline_map_read(struct map_info *map, unsigned long ofs)
{
	map_word r;

	if (map_bankwidth_is_1(map))
		r.x[0] = __raw_readb(map->virt + ofs);
	else if (map_bankwidth_is_2(map))
		r.x[0] = __raw_readw(map->virt + ofs);
	else if (map_bankwidth_is_4(map))
		r.x[0] = __raw_readl(map->virt + ofs);
#if BITS_PER_LONG >= 64
	else if (map_bankwidth_is_8(map))
		r.x[0] = __raw_readq(map->virt + ofs);
#endif
	else if (map_bankwidth_is_large(map))
		memcpy_fromio(r.x, map->virt+ofs, map->bankwidth);

	return r;
}

static inline void inline_map_write(struct map_info *map, const map_word datum, unsigned long ofs)
{
	if (map_bankwidth_is_1(map))
		__raw_writeb(datum.x[0], map->virt + ofs);
	else if (map_bankwidth_is_2(map))
		__raw_writew(datum.x[0], map->virt + ofs);
	else if (map_bankwidth_is_4(map))
		__raw_writel(datum.x[0], map->virt + ofs);
#if BITS_PER_LONG >= 64
	else if (map_bankwidth_is_8(map))
		__raw_writeq(datum.x[0], map->virt + ofs);
#endif
	else if (map_bankwidth_is_large(map))
		memcpy_toio(map->virt+ofs, datum.x, map->bankwidth);
	mb();
}

static inline void inline_map_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len)
{
	if (map->cached)
		memcpy(to, (char *)map->cached + from, len);
	else
		memcpy_fromio(to, map->virt + from, len);
}

static inline void inline_map_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
{
	memcpy_toio(map->virt + to, from, len);
}

#ifdef CONFIG_MTD_COMPLEX_MAPPINGS
#define map_read(map, ofs) (map)->read(map, ofs)
#define map_copy_from(map, to, from, len) (map)->copy_from(map, to, from, len)
#define map_write(map, datum, ofs) (map)->write(map, datum, ofs)
#define map_copy_to(map, to, from, len) (map)->copy_to(map, to, from, len)

extern void simple_map_init(struct map_info *);
#define map_is_linear(map) (map->phys != NO_XIP)

#else
#define map_read(map, ofs) inline_map_read(map, ofs)
#define map_copy_from(map, to, from, len) inline_map_copy_from(map, to, from, len)
#define map_write(map, datum, ofs) inline_map_write(map, datum, ofs)
#define map_copy_to(map, to, from, len) inline_map_copy_to(map, to, from, len)


#define simple_map_init(map) BUG_ON(!map_bankwidth_supported((map)->bankwidth))
#define map_is_linear(map) ({ (void)(map); 1; })

#endif /* !CONFIG_MTD_COMPLEX_MAPPINGS */

#endif /* __LINUX_MTD_MAP_H__ */
Commit	Line	Data
1da177e4 LT	1
1da177e4 LT	2	/* Overhauled routines for dealing with different mmap regions of flash */
61ecfa87	3	/* $Id: map.h,v 1.54 2005/11/07 11:14:54 gleixner Exp $ */
1da177e4 LT	4
	5	#ifndef __LINUX_MTD_MAP_H__
	6	#define __LINUX_MTD_MAP_H__
	7
1da177e4 LT	8	#include <linux/types.h>
1da177e4 LT	9	#include <linux/list.h>
4e57b681 TS	10	#include <linux/string.h>
4e57b681 TS	11
1da177e4	12	#include <linux/mtd/compatmac.h>
4e57b681	13
1da177e4 LT	14	#include <asm/unaligned.h>
	15	#include <asm/system.h>
	16	#include <asm/io.h>
1da177e4 LT	17
	18	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_1
	19	#define map_bankwidth(map) 1
	20	#define map_bankwidth_is_1(map) (map_bankwidth(map) == 1)
	21	#define map_bankwidth_is_large(map) (0)
	22	#define map_words(map) (1)
	23	#define MAX_MAP_BANKWIDTH 1
	24	#else
	25	#define map_bankwidth_is_1(map) (0)
	26	#endif
	27
	28	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_2
	29	# ifdef map_bankwidth
	30	# undef map_bankwidth
	31	# define map_bankwidth(map) ((map)->bankwidth)
	32	# else
	33	# define map_bankwidth(map) 2
	34	# define map_bankwidth_is_large(map) (0)
	35	# define map_words(map) (1)
	36	# endif
	37	#define map_bankwidth_is_2(map) (map_bankwidth(map) == 2)
	38	#undef MAX_MAP_BANKWIDTH
	39	#define MAX_MAP_BANKWIDTH 2
	40	#else
	41	#define map_bankwidth_is_2(map) (0)
	42	#endif
	43
	44	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_4
	45	# ifdef map_bankwidth
	46	# undef map_bankwidth
	47	# define map_bankwidth(map) ((map)->bankwidth)
	48	# else
	49	# define map_bankwidth(map) 4
	50	# define map_bankwidth_is_large(map) (0)
	51	# define map_words(map) (1)
	52	# endif
	53	#define map_bankwidth_is_4(map) (map_bankwidth(map) == 4)
	54	#undef MAX_MAP_BANKWIDTH
	55	#define MAX_MAP_BANKWIDTH 4
	56	#else
	57	#define map_bankwidth_is_4(map) (0)
	58	#endif
	59
	60	/* ensure we never evaluate anything shorted than an unsigned long
	61	* to zero, and ensure we'll never miss the end of an comparison (bjd) */
	62
	63	#define map_calc_words(map) ((map_bankwidth(map) + (sizeof(unsigned long)-1))/ sizeof(unsigned long))
	64
	65	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_8
	66	# ifdef map_bankwidth
	67	# undef map_bankwidth
	68	# define map_bankwidth(map) ((map)->bankwidth)
	69	# if BITS_PER_LONG < 64
	70	# undef map_bankwidth_is_large
	71	# define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
	72	# undef map_words
	73	# define map_words(map) map_calc_words(map)
	74	# endif
	75	# else
	76	# define map_bankwidth(map) 8
	77	# define map_bankwidth_is_large(map) (BITS_PER_LONG < 64)
	78	# define map_words(map) map_calc_words(map)
	79	# endif
	80	#define map_bankwidth_is_8(map) (map_bankwidth(map) == 8)
81	#undef MAX_MAP_BANKWIDTH
82	#define MAX_MAP_BANKWIDTH 8
83	#else
84	#define map_bankwidth_is_8(map) (0)
85	#endif
86
87	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_16
88	# ifdef map_bankwidth
89	# undef map_bankwidth
90	# define map_bankwidth(map) ((map)->bankwidth)
91	# undef map_bankwidth_is_large
92	# define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
93	# undef map_words
94	# define map_words(map) map_calc_words(map)
95	# else
96	# define map_bankwidth(map) 16
97	# define map_bankwidth_is_large(map) (1)
98	# define map_words(map) map_calc_words(map)
99	# endif
100	#define map_bankwidth_is_16(map) (map_bankwidth(map) == 16)
101	#undef MAX_MAP_BANKWIDTH
102	#define MAX_MAP_BANKWIDTH 16
103	#else
104	#define map_bankwidth_is_16(map) (0)
105	#endif
106
107	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_32
108	# ifdef map_bankwidth
109	# undef map_bankwidth
110	# define map_bankwidth(map) ((map)->bankwidth)
111	# undef map_bankwidth_is_large
112	# define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
113	# undef map_words
114	# define map_words(map) map_calc_words(map)
115	# else
116	# define map_bankwidth(map) 32
117	# define map_bankwidth_is_large(map) (1)
118	# define map_words(map) map_calc_words(map)
119	# endif
120	#define map_bankwidth_is_32(map) (map_bankwidth(map) == 32)
121	#undef MAX_MAP_BANKWIDTH
122	#define MAX_MAP_BANKWIDTH 32
123	#else
124	#define map_bankwidth_is_32(map) (0)
125	#endif
126
127	#ifndef map_bankwidth
241651d0 DW	128	#warning "No CONFIG_MTD_MAP_BANK_WIDTH_xx selected. No NOR chip support can work"
	129	static inline int map_bankwidth(void *map)
	130	{
	131	BUG();
	132	return 0;
	133	}
	134	#define map_bankwidth_is_large(map) (0)
	135	#define map_words(map) (0)
	136	#define MAX_MAP_BANKWIDTH 1
1da177e4 LT	137	#endif
	138
	139	static inline int map_bankwidth_supported(int w)
	140	{
	141	switch (w) {
	142	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_1
	143	case 1:
	144	#endif
	145	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_2
	146	case 2:
	147	#endif
	148	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_4
	149	case 4:
	150	#endif
	151	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_8
	152	case 8:
	153	#endif
	154	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_16
	155	case 16:
	156	#endif
	157	#ifdef CONFIG_MTD_MAP_BANK_WIDTH_32
	158	case 32:
	159	#endif
	160	return 1;
	161
	162	default:
	163	return 0;
	164	}
	165	}
	166
	167	#define MAX_MAP_LONGS ( ((MAX_MAP_BANKWIDTH*8) + BITS_PER_LONG - 1) / BITS_PER_LONG )
	168
	169	typedef union {
	170	unsigned long x[MAX_MAP_LONGS];
	171	} map_word;
	172
	173	/* The map stuff is very simple. You fill in your struct map_info with
	174	a handful of routines for accessing the device, making sure they handle
	175	paging etc. correctly if your device needs it. Then you pass it off
	176	to a chip probe routine -- either JEDEC or CFI probe or both -- via
	177	do_map_probe(). If a chip is recognised, the probe code will invoke the
	178	appropriate chip driver (if present) and return a struct mtd_info.
61ecfa87	179	At which point, you fill in the mtd->module with your own module
1da177e4 LT	180	address, and register it with the MTD core code. Or you could partition
	181	it and register the partitions instead, or keep it for your own private
	182	use; whatever.
61ecfa87	183
1da177e4	184	The mtd->priv field will point to the struct map_info, and any further
61ecfa87 TG	185	private data required by the chip driver is linked from the
61ecfa87 TG	186	mtd->priv->fldrv_priv field. This allows the map driver to get at
1da177e4 LT	187	the destructor function map->fldrv_destroy() when it's tired
	188	of living.
	189	*/
	190
	191	struct map_info {
	192	char *name;
	193	unsigned long size;
0d36da3b	194	resource_size_t phys;
1da177e4 LT	195	#define NO_XIP (-1UL)
	196
	197	void __iomem *virt;
	198	void *cached;
	199
	200	int bankwidth; /* in octets. This isn't necessarily the width
	201	of actual bus cycles -- it's the repeat interval
	202	in bytes, before you are talking to the first chip again.
	203	*/
	204
	205	#ifdef CONFIG_MTD_COMPLEX_MAPPINGS
	206	map_word (read)(struct map_info , unsigned long);
	207	void (copy_from)(struct map_info , void *, unsigned long, ssize_t);
	208
	209	void (write)(struct map_info , const map_word, unsigned long);
	210	void (copy_to)(struct map_info , unsigned long, const void *, ssize_t);
	211
	212	/* We can perhaps put in 'point' and 'unpoint' methods, if we really
	213	want to enable XIP for non-linear mappings. Not yet though. */
	214	#endif
	215	/* It's possible for the map driver to use cached memory in its
	216	copy_from implementation (and _only_ with copy_from). However,
	217	when the chip driver knows some flash area has changed contents,
	218	it will signal it to the map driver through this routine to let
	219	the map driver invalidate the corresponding cache as needed.
	220	If there is no cache to care about this can be set to NULL. */
	221	void (inval_cache)(struct map_info , unsigned long, ssize_t);
	222
61ecfa87	223	/* set_vpp() must handle being reentered -- enable, enable, disable
1da177e4 LT	224	must leave it enabled. */
	225	void (set_vpp)(struct map_info , int);
	226
	227	unsigned long map_priv_1;
	228	unsigned long map_priv_2;
	229	void *fldrv_priv;
	230	struct mtd_chip_driver *fldrv;
	231	};
	232
	233	struct mtd_chip_driver {
	234	struct mtd_info (probe)(struct map_info *map);
	235	void (destroy)(struct mtd_info );
	236	struct module *module;
	237	char *name;
	238	struct list_head list;
	239	};
	240
	241	void register_mtd_chip_driver(struct mtd_chip_driver *);
	242	void unregister_mtd_chip_driver(struct mtd_chip_driver *);
	243
	244	struct mtd_info do_map_probe(const char name, struct map_info *map);
	245	void map_destroy(struct mtd_info *mtd);
	246
	247	#define ENABLE_VPP(map) do { if(map->set_vpp) map->set_vpp(map, 1); } while(0)
	248	#define DISABLE_VPP(map) do { if(map->set_vpp) map->set_vpp(map, 0); } while(0)
	249
	250	#define INVALIDATE_CACHED_RANGE(map, from, size) \
	251	do { if(map->inval_cache) map->inval_cache(map, from, size); } while(0)
	252
	253
	254	static inline int map_word_equal(struct map_info *map, map_word val1, map_word val2)
	255	{
	256	int i;
	257	for (i=0; i<map_words(map); i++) {
	258	if (val1.x[i] != val2.x[i])
	259	return 0;
	260	}
	261	return 1;
	262	}
	263
	264	static inline map_word map_word_and(struct map_info *map, map_word val1, map_word val2)
	265	{
	266	map_word r;
	267	int i;
	268
	269	for (i=0; i<map_words(map); i++) {
	270	r.x[i] = val1.x[i] & val2.x[i];
	271	}
	272	return r;
	273	}
	274
f77814dd NP	275	static inline map_word map_word_clr(struct map_info *map, map_word val1, map_word val2)
	276	{
	277	map_word r;
	278	int i;
	279
	280	for (i=0; i<map_words(map); i++) {
	281	r.x[i] = val1.x[i] & ~val2.x[i];
	282	}
	283	return r;
	284	}
	285
1da177e4 LT	286	static inline map_word map_word_or(struct map_info *map, map_word val1, map_word val2)
	287	{
	288	map_word r;
	289	int i;
	290
	291	for (i=0; i<map_words(map); i++) {
	292	r.x[i] = val1.x[i] \| val2.x[i];
	293	}
	294	return r;
	295	}
f77814dd	296
1da177e4 LT	297	#define map_word_andequal(m, a, b, z) map_word_equal(m, z, map_word_and(m, a, b))
	298
	299	static inline int map_word_bitsset(struct map_info *map, map_word val1, map_word val2)
	300	{
	301	int i;
	302
	303	for (i=0; i<map_words(map); i++) {
	304	if (val1.x[i] & val2.x[i])
	305	return 1;
	306	}
	307	return 0;
	308	}
	309
	310	static inline map_word map_word_load(struct map_info map, const void ptr)
	311	{
	312	map_word r;
	313
	314	if (map_bankwidth_is_1(map))
	315	r.x[0] = (unsigned char )ptr;
	316	else if (map_bankwidth_is_2(map))
	317	r.x[0] = get_unaligned((uint16_t *)ptr);
	318	else if (map_bankwidth_is_4(map))
	319	r.x[0] = get_unaligned((uint32_t *)ptr);
	320	#if BITS_PER_LONG >= 64
	321	else if (map_bankwidth_is_8(map))
	322	r.x[0] = get_unaligned((uint64_t *)ptr);
	323	#endif
	324	else if (map_bankwidth_is_large(map))
	325	memcpy(r.x, ptr, map->bankwidth);
	326
	327	return r;
	328	}
	329
	330	static inline map_word map_word_load_partial(struct map_info map, map_word orig, const unsigned char buf, int start, int len)
	331	{
	332	int i;
	333
	334	if (map_bankwidth_is_large(map)) {
	335	char dest = (char )&orig;
	336	memcpy(dest+start, buf, len);
	337	} else {
	338	for (i=start; i < start+len; i++) {
	339	int bitpos;
	340	#ifdef __LITTLE_ENDIAN
	341	bitpos = i*8;
	342	#else /* __BIG_ENDIAN */
	343	bitpos = (map_bankwidth(map)-1-i)*8;
	344	#endif
	345	orig.x[0] &= ~(0xff << bitpos);
	346	orig.x[0] \|= buf[i-start] << bitpos;
	347	}
	348	}
	349	return orig;
	350	}
	351
3a3ab48c TG	352	#if BITS_PER_LONG < 64
	353	#define MAP_FF_LIMIT 4
	354	#else
	355	#define MAP_FF_LIMIT 8
	356	#endif
	357
1da177e4 LT	358	static inline map_word map_word_ff(struct map_info *map)
	359	{
	360	map_word r;
	361	int i;
61ecfa87	362
b0435695	363	if (map_bankwidth(map) < MAP_FF_LIMIT) {
a8aff8ab	364	int bw = 8 * map_bankwidth(map);
b0435695	365	r.x[0] = (1 << bw) - 1;
3a3ab48c TG	366	} else {
	367	for (i=0; i<map_words(map); i++)
	368	r.x[i] = ~0UL;
1da177e4 LT	369	}
	370	return r;
	371	}
f77814dd	372
1da177e4 LT	373	static inline map_word inline_map_read(struct map_info *map, unsigned long ofs)
	374	{
	375	map_word r;
	376
	377	if (map_bankwidth_is_1(map))
	378	r.x[0] = __raw_readb(map->virt + ofs);
	379	else if (map_bankwidth_is_2(map))
	380	r.x[0] = __raw_readw(map->virt + ofs);
	381	else if (map_bankwidth_is_4(map))
	382	r.x[0] = __raw_readl(map->virt + ofs);
	383	#if BITS_PER_LONG >= 64
	384	else if (map_bankwidth_is_8(map))
	385	r.x[0] = __raw_readq(map->virt + ofs);
	386	#endif
	387	else if (map_bankwidth_is_large(map))
	388	memcpy_fromio(r.x, map->virt+ofs, map->bankwidth);
	389
	390	return r;
	391	}
	392
	393	static inline void inline_map_write(struct map_info *map, const map_word datum, unsigned long ofs)
	394	{
	395	if (map_bankwidth_is_1(map))
	396	__raw_writeb(datum.x[0], map->virt + ofs);
	397	else if (map_bankwidth_is_2(map))
	398	__raw_writew(datum.x[0], map->virt + ofs);
	399	else if (map_bankwidth_is_4(map))
	400	__raw_writel(datum.x[0], map->virt + ofs);
	401	#if BITS_PER_LONG >= 64
	402	else if (map_bankwidth_is_8(map))
	403	__raw_writeq(datum.x[0], map->virt + ofs);
	404	#endif
	405	else if (map_bankwidth_is_large(map))
	406	memcpy_toio(map->virt+ofs, datum.x, map->bankwidth);
	407	mb();
	408	}
	409
	410	static inline void inline_map_copy_from(struct map_info map, void to, unsigned long from, ssize_t len)
	411	{
	412	if (map->cached)
	413	memcpy(to, (char *)map->cached + from, len);
	414	else
	415	memcpy_fromio(to, map->virt + from, len);
	416	}
	417
	418	static inline void inline_map_copy_to(struct map_info map, unsigned long to, const void from, ssize_t len)
	419	{
	420	memcpy_toio(map->virt + to, from, len);
	421	}
	422
	423	#ifdef CONFIG_MTD_COMPLEX_MAPPINGS
	424	#define map_read(map, ofs) (map)->read(map, ofs)
	425	#define map_copy_from(map, to, from, len) (map)->copy_from(map, to, from, len)
	426	#define map_write(map, datum, ofs) (map)->write(map, datum, ofs)
	427	#define map_copy_to(map, to, from, len) (map)->copy_to(map, to, from, len)
	428
	429	extern void simple_map_init(struct map_info *);
	430	#define map_is_linear(map) (map->phys != NO_XIP)
	431
	432	#else
	433	#define map_read(map, ofs) inline_map_read(map, ofs)
	434	#define map_copy_from(map, to, from, len) inline_map_copy_from(map, to, from, len)
	435	#define map_write(map, datum, ofs) inline_map_write(map, datum, ofs)
	436	#define map_copy_to(map, to, from, len) inline_map_copy_to(map, to, from, len)
437
438
439	#define simple_map_init(map) BUG_ON(!map_bankwidth_supported((map)->bankwidth))
f16407d7	440	#define map_is_linear(map) ({ (void)(map); 1; })
1da177e4 LT	441
	442	#endif /* !CONFIG_MTD_COMPLEX_MAPPINGS */
	443
	444	#endif /* __LINUX_MTD_MAP_H__ */