blob: a9fae032ba8176db0a256aea1160f3c04e78720e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001
2/* Overhauled routines for dealing with different mmap regions of flash */
Thomas Gleixner61ecfa82005-11-07 11:15:31 +00003/* $Id: map.h,v 1.54 2005/11/07 11:14:54 gleixner Exp $ */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004
5#ifndef __LINUX_MTD_MAP_H__
6#define __LINUX_MTD_MAP_H__
7
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/types.h>
9#include <linux/list.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080010#include <linux/string.h>
11
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/mtd/compatmac.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080013
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <asm/unaligned.h>
15#include <asm/system.h>
16#include <asm/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
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
David Woodhouse241651d2007-09-06 09:40:21 +0100128#warning "No CONFIG_MTD_MAP_BANK_WIDTH_xx selected. No NOR chip support can work"
129static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137#endif
138
139static 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
169typedef 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.
Thomas Gleixner61ecfa82005-11-07 11:15:31 +0000179 At which point, you fill in the mtd->module with your own module
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 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.
Thomas Gleixner61ecfa82005-11-07 11:15:31 +0000183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 The mtd->priv field will point to the struct map_info, and any further
Thomas Gleixner61ecfa82005-11-07 11:15:31 +0000185 private data required by the chip driver is linked from the
186 mtd->priv->fldrv_priv field. This allows the map driver to get at
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 the destructor function map->fldrv_destroy() when it's tired
188 of living.
189*/
190
191struct map_info {
192 char *name;
193 unsigned long size;
Stefan Roese0d36da32007-01-19 08:40:04 +0100194 resource_size_t phys;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195#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
Thomas Gleixner61ecfa82005-11-07 11:15:31 +0000223 /* set_vpp() must handle being reentered -- enable, enable, disable
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 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
233struct 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
241void register_mtd_chip_driver(struct mtd_chip_driver *);
242void unregister_mtd_chip_driver(struct mtd_chip_driver *);
243
244struct mtd_info *do_map_probe(const char *name, struct map_info *map);
245void 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
254static 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
264static 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
Nicolas Pitref77814d2005-02-08 17:11:19 +0000275static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286static 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}
Nicolas Pitref77814d2005-02-08 17:11:19 +0000296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297#define map_word_andequal(m, a, b, z) map_word_equal(m, z, map_word_and(m, a, b))
298
299static 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
310static 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
330static 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
Thomas Gleixner3a3ab482005-05-24 20:50:18 +0200352#if BITS_PER_LONG < 64
353#define MAP_FF_LIMIT 4
354#else
355#define MAP_FF_LIMIT 8
356#endif
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358static inline map_word map_word_ff(struct map_info *map)
359{
360 map_word r;
361 int i;
Thomas Gleixner61ecfa82005-11-07 11:15:31 +0000362
Thomas Gleixnerb0435692005-05-25 12:20:29 +0200363 if (map_bankwidth(map) < MAP_FF_LIMIT) {
Thomas Gleixnera8aff8a2005-05-25 12:32:37 +0200364 int bw = 8 * map_bankwidth(map);
Thomas Gleixnerb0435692005-05-25 12:20:29 +0200365 r.x[0] = (1 << bw) - 1;
Thomas Gleixner3a3ab482005-05-24 20:50:18 +0200366 } else {
367 for (i=0; i<map_words(map); i++)
368 r.x[i] = ~0UL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 }
370 return r;
371}
Nicolas Pitref77814d2005-02-08 17:11:19 +0000372
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373static 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
393static 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
410static 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
418static 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
429extern 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))
Nicolas Pitref16407d2005-02-16 15:55:03 +0000440#define map_is_linear(map) ({ (void)(map); 1; })
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442#endif /* !CONFIG_MTD_COMPLEX_MAPPINGS */
443
444#endif /* __LINUX_MTD_MAP_H__ */