1
2 /* Overhauled routines for dealing with different mmap regions of flash */
3
4 #ifndef __LINUX_MTD_MAP_H__
5 #define __LINUX_MTD_MAP_H__
6
7 #include <linux/types.h>
8 #include <linux/list.h>
9 #include <linux/string.h>
10
11 #include <linux/mtd/compatmac.h>
12
13 #include <asm/unaligned.h>
14 #include <asm/system.h>
15 #include <asm/io.h>
16
17 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_1
18 #define map_bankwidth(map) 1
19 #define map_bankwidth_is_1(map) (map_bankwidth(map) == 1)
20 #define map_bankwidth_is_large(map) (0)
21 #define map_words(map) (1)
22 #define MAX_MAP_BANKWIDTH 1
23 #else
24 #define map_bankwidth_is_1(map) (0)
25 #endif
26
27 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_2
28 # ifdef map_bankwidth
29 # undef map_bankwidth
30 # define map_bankwidth(map) ((map)->bankwidth)
31 # else
32 # define map_bankwidth(map) 2
33 # define map_bankwidth_is_large(map) (0)
34 # define map_words(map) (1)
35 # endif
36 #define map_bankwidth_is_2(map) (map_bankwidth(map) == 2)
37 #undef MAX_MAP_BANKWIDTH
38 #define MAX_MAP_BANKWIDTH 2
39 #else
40 #define map_bankwidth_is_2(map) (0)
41 #endif
42
43 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_4
44 # ifdef map_bankwidth
45 # undef map_bankwidth
46 # define map_bankwidth(map) ((map)->bankwidth)
47 # else
48 # define map_bankwidth(map) 4
49 # define map_bankwidth_is_large(map) (0)
50 # define map_words(map) (1)
51 # endif
52 #define map_bankwidth_is_4(map) (map_bankwidth(map) == 4)
53 #undef MAX_MAP_BANKWIDTH
54 #define MAX_MAP_BANKWIDTH 4
55 #else
56 #define map_bankwidth_is_4(map) (0)
57 #endif
58
59 /* ensure we never evaluate anything shorted than an unsigned long
60 * to zero, and ensure we'll never miss the end of an comparison (bjd) */
61
62 #define map_calc_words(map) ((map_bankwidth(map) + (sizeof(unsigned long)-1))/ sizeof(unsigned long))
63
64 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_8
65 # ifdef map_bankwidth
66 # undef map_bankwidth
67 # define map_bankwidth(map) ((map)->bankwidth)
68 # if BITS_PER_LONG < 64
69 # undef map_bankwidth_is_large
70 # define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
71 # undef map_words
72 # define map_words(map) map_calc_words(map)
73 # endif
74 # else
75 # define map_bankwidth(map) 8
76 # define map_bankwidth_is_large(map) (BITS_PER_LONG < 64)
77 # define map_words(map) map_calc_words(map)
78 # endif
79 #define map_bankwidth_is_8(map) (map_bankwidth(map) == 8)
80 #undef MAX_MAP_BANKWIDTH
81 #define MAX_MAP_BANKWIDTH 8
82 #else
83 #define map_bankwidth_is_8(map) (0)
84 #endif
85
86 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_16
87 # ifdef map_bankwidth
88 # undef map_bankwidth
89 # define map_bankwidth(map) ((map)->bankwidth)
90 # undef map_bankwidth_is_large
91 # define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
92 # undef map_words
93 # define map_words(map) map_calc_words(map)
94 # else
95 # define map_bankwidth(map) 16
96 # define map_bankwidth_is_large(map) (1)
97 # define map_words(map) map_calc_words(map)
98 # endif
99 #define map_bankwidth_is_16(map) (map_bankwidth(map) == 16)
100 #undef MAX_MAP_BANKWIDTH
101 #define MAX_MAP_BANKWIDTH 16
102 #else
103 #define map_bankwidth_is_16(map) (0)
104 #endif
105
106 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_32
107 # ifdef map_bankwidth
108 # undef map_bankwidth
109 # define map_bankwidth(map) ((map)->bankwidth)
110 # undef map_bankwidth_is_large
111 # define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
112 # undef map_words
113 # define map_words(map) map_calc_words(map)
114 # else
115 # define map_bankwidth(map) 32
116 # define map_bankwidth_is_large(map) (1)
117 # define map_words(map) map_calc_words(map)
118 # endif
119 #define map_bankwidth_is_32(map) (map_bankwidth(map) == 32)
120 #undef MAX_MAP_BANKWIDTH
121 #define MAX_MAP_BANKWIDTH 32
122 #else
123 #define map_bankwidth_is_32(map) (0)
124 #endif
125
126 #ifndef map_bankwidth
127 #warning "No CONFIG_MTD_MAP_BANK_WIDTH_xx selected. No NOR chip support can work"
128 static inline int map_bankwidth(void *map)
129 {
130 BUG();
131 return 0;
132 }
133 #define map_bankwidth_is_large(map) (0)
134 #define map_words(map) (0)
135 #define MAX_MAP_BANKWIDTH 1
136 #endif
137
138 static inline int map_bankwidth_supported(int w)
139 {
140 switch (w) {
141 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_1
142 case 1:
143 #endif
144 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_2
145 case 2:
146 #endif
147 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_4
148 case 4:
149 #endif
150 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_8
151 case 8:
152 #endif
153 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_16
154 case 16:
155 #endif
156 #ifdef CONFIG_MTD_MAP_BANK_WIDTH_32
157 case 32:
158 #endif
159 return 1;
160
161 default:
162 return 0;
163 }
164 }
165
166 #define MAX_MAP_LONGS ( ((MAX_MAP_BANKWIDTH*8) + BITS_PER_LONG - 1) / BITS_PER_LONG )
167
168 typedef union {
169 unsigned long x[MAX_MAP_LONGS];
170 } map_word;
171
172 /* The map stuff is very simple. You fill in your struct map_info with
173 a handful of routines for accessing the device, making sure they handle
174 paging etc. correctly if your device needs it. Then you pass it off
175 to a chip probe routine -- either JEDEC or CFI probe or both -- via
176 do_map_probe(). If a chip is recognised, the probe code will invoke the
177 appropriate chip driver (if present) and return a struct mtd_info.
178 At which point, you fill in the mtd->module with your own module
179 address, and register it with the MTD core code. Or you could partition
180 it and register the partitions instead, or keep it for your own private
181 use; whatever.
182
183 The mtd->priv field will point to the struct map_info, and any further
184 private data required by the chip driver is linked from the
185 mtd->priv->fldrv_priv field. This allows the map driver to get at
186 the destructor function map->fldrv_destroy() when it's tired
187 of living.
188 */
189
190 struct map_info {
191 const char *name;
192 unsigned long size;
193 resource_size_t phys;
194 #define NO_XIP (-1UL)
195
196 void __iomem *virt;
197 void *cached;
198
199 int bankwidth; /* in octets. This isn't necessarily the width
200 of actual bus cycles -- it's the repeat interval
201 in bytes, before you are talking to the first chip again.
202 */
203
204 #ifdef CONFIG_MTD_COMPLEX_MAPPINGS
205 map_word (*read)(struct map_info *, unsigned long);
206 void (*copy_from)(struct map_info *, void *, unsigned long, ssize_t);
207
208 void (*write)(struct map_info *, const map_word, unsigned long);
209 void (*copy_to)(struct map_info *, unsigned long, const void *, ssize_t);
210
211 /* We can perhaps put in 'point' and 'unpoint' methods, if we really
212 want to enable XIP for non-linear mappings. Not yet though. */
213 #endif
214 /* It's possible for the map driver to use cached memory in its
215 copy_from implementation (and _only_ with copy_from). However,
216 when the chip driver knows some flash area has changed contents,
217 it will signal it to the map driver through this routine to let
218 the map driver invalidate the corresponding cache as needed.
219 If there is no cache to care about this can be set to NULL. */
220 void (*inval_cache)(struct map_info *, unsigned long, ssize_t);
221
222 /* set_vpp() must handle being reentered -- enable, enable, disable
223 must leave it enabled. */
224 void (*set_vpp)(struct map_info *, int);
225
226 unsigned long pfow_base;
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
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
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 }
296
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
352 #if BITS_PER_LONG < 64
353 #define MAP_FF_LIMIT 4
354 #else
355 #define MAP_FF_LIMIT 8
356 #endif
357
358 static inline map_word map_word_ff(struct map_info *map)
359 {
360 map_word r;
361 int i;
362
363 if (map_bankwidth(map) < MAP_FF_LIMIT) {
364 int bw = 8 * map_bankwidth(map);
365 r.x[0] = (1 << bw) - 1;
366 } else {
367 for (i=0; i<map_words(map); i++)
368 r.x[i] = ~0UL;
369 }
370 return r;
371 }
372
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))
440 #define map_is_linear(map) ({ (void)(map); 1; })
441
442 #endif /* !CONFIG_MTD_COMPLEX_MAPPINGS */
443
444 #endif /* __LINUX_MTD_MAP_H__ */
445
|
This page was automatically generated by the
LXR engine.
|