1 2 /* Overhauled routines for dealing with different mmap regions of flash */ 3 /* $Id: map.h,v 1.54 2005/11/07 11:14:54 gleixner Exp $ */ 4 5 #ifndef __LINUX_MTD_MAP_H__ 6 #define __LINUX_MTD_MAP_H__ 7 8 #include <linux/types.h> 9 #include <linux/list.h> 10 #include <linux/string.h> 11 12 #include <linux/mtd/compatmac.h> 13 14 #include <asm/unaligned.h> 15 #include <asm/system.h> 16 #include <asm/io.h> 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 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 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. 179 At which point, you fill in the mtd->module with your own module 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. 183 184 The mtd->priv field will point to the struct map_info, and any further 185 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 187 the destructor function map->fldrv_destroy() when it's tired 188 of living. 189 */ 190 191 struct map_info { 192 const char *name; 193 unsigned long size; 194 resource_size_t phys; 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 223 /* set_vpp() must handle being reentered -- enable, enable, disable 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 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