kernel/drivers/mtd/chips/cfi_util.c

   1 /*
   2  * Common Flash Interface support:
   3  *   Generic utility functions not dependent on command set
   4  *
   5  * Copyright (C) 2002 Red Hat
   6  * Copyright (C) 2003 STMicroelectronics Limited
   7  *
   8  * This code is covered by the GPL.
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/types.h>
  13 #include <linux/kernel.h>
  14 #include <asm/io.h>
  15 #include <asm/byteorder.h>
  16
  17 #include <linux/errno.h>
  18 #include <linux/slab.h>
  19 #include <linux/delay.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/mtd/xip.h>
  22 #include <linux/mtd/mtd.h>
  23 #include <linux/mtd/map.h>
  24 #include <linux/mtd/cfi.h>
  25
  26 void cfi_udelay(int us)
  27 {
  28         if (us >= 1000) {
  29                 msleep((us+999)/1000);
  30         } else {
  31                 udelay(us);
  32                 cond_resched();
  33         }
  34 }
  35 EXPORT_SYMBOL(cfi_udelay);
  36
  37 /*
  38  * Returns the command address according to the given geometry.
  39  */
  40 uint32_t cfi_build_cmd_addr(uint32_t cmd_ofs,
  41                                 struct map_info *map, struct cfi_private *cfi)
  42 {
  43         unsigned bankwidth = map_bankwidth(map);
  44         unsigned interleave = cfi_interleave(cfi);
  45         unsigned type = cfi->device_type;
  46         uint32_t addr;
  47
  48         addr = (cmd_ofs * type) * interleave;
  49
  50         /* Modify the unlock address if we are in compatibility mode.
  51          * For 16bit devices on 8 bit busses
  52          * and 32bit devices on 16 bit busses
  53          * set the low bit of the alternating bit sequence of the address.
  54          */
  55         if (((type * interleave) > bankwidth) && ((cmd_ofs & 0xff) == 0xaa))
  56                 addr |= (type >> 1)*interleave;
  57
  58         return  addr;
  59 }
  60 EXPORT_SYMBOL(cfi_build_cmd_addr);
  61
  62 /*
  63  * Transforms the CFI command for the given geometry (bus width & interleave).
  64  * It looks too long to be inline, but in the common case it should almost all
  65  * get optimised away.
  66  */
  67 map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cfi_private *cfi)
  68 {
  69         map_word val = { {0} };
  70         int wordwidth, words_per_bus, chip_mode, chips_per_word;
  71         unsigned long onecmd;
  72         int i;
  73
  74         /* We do it this way to give the compiler a fighting chance
  75            of optimising away all the crap for 'bankwidth' larger than
  76            an unsigned long, in the common case where that support is
  77            disabled */
  78         if (map_bankwidth_is_large(map)) {
  79                 wordwidth = sizeof(unsigned long);
  80                 words_per_bus = (map_bankwidth(map)) / wordwidth; // i.e. normally 1
  81         } else {
  82                 wordwidth = map_bankwidth(map);
  83                 words_per_bus = 1;
  84         }
  85
  86         chip_mode = map_bankwidth(map) / cfi_interleave(cfi);
  87         chips_per_word = wordwidth * cfi_interleave(cfi) / map_bankwidth(map);
  88
  89         /* First, determine what the bit-pattern should be for a single
  90            device, according to chip mode and endianness... */
  91         switch (chip_mode) {
  92         default: BUG();
  93         case 1:
  94                 onecmd = cmd;
  95                 break;
  96         case 2:
  97                 onecmd = cpu_to_cfi16(map, cmd);
  98                 break;
  99         case 4:
 100                 onecmd = cpu_to_cfi32(map, cmd);
 101                 break;
 102         }
 103
 104         /* Now replicate it across the size of an unsigned long, or
 105            just to the bus width as appropriate */
 106         switch (chips_per_word) {
 107         default: BUG();
 108 #if BITS_PER_LONG >= 64
 109         case 8:
 110                 onecmd |= (onecmd << (chip_mode * 32));
 111 #endif
 112         case 4:
 113                 onecmd |= (onecmd << (chip_mode * 16));
 114         case 2:
 115                 onecmd |= (onecmd << (chip_mode * 8));
 116         case 1:
 117                 ;
 118         }
 119
 120         /* And finally, for the multi-word case, replicate it
 121            in all words in the structure */
 122         for (i=0; i < words_per_bus; i++) {
 123                 val.x[i] = onecmd;
 124         }
 125
 126         return val;
 127 }
 128 EXPORT_SYMBOL(cfi_build_cmd);
 129
 130 unsigned long cfi_merge_status(map_word val, struct map_info *map,
 131                                            struct cfi_private *cfi)
 132 {
 133         int wordwidth, words_per_bus, chip_mode, chips_per_word;
 134         unsigned long onestat, res = 0;
 135         int i;
 136
 137         /* We do it this way to give the compiler a fighting chance
 138            of optimising away all the crap for 'bankwidth' larger than
 139            an unsigned long, in the common case where that support is
 140            disabled */
 141         if (map_bankwidth_is_large(map)) {
 142                 wordwidth = sizeof(unsigned long);
 143                 words_per_bus = (map_bankwidth(map)) / wordwidth; // i.e. normally 1
 144         } else {
 145                 wordwidth = map_bankwidth(map);
 146                 words_per_bus = 1;
 147         }
 148
 149         chip_mode = map_bankwidth(map) / cfi_interleave(cfi);
 150         chips_per_word = wordwidth * cfi_interleave(cfi) / map_bankwidth(map);
 151
 152         onestat = val.x[0];
 153         /* Or all status words together */
 154         for (i=1; i < words_per_bus; i++) {
 155                 onestat |= val.x[i];
 156         }
 157
 158         res = onestat;
 159         switch(chips_per_word) {
 160         default: BUG();
 161 #if BITS_PER_LONG >= 64
 162         case 8:
 163                 res |= (onestat >> (chip_mode * 32));
 164 #endif
 165         case 4:
 166                 res |= (onestat >> (chip_mode * 16));
 167         case 2:
 168                 res |= (onestat >> (chip_mode * 8));
 169         case 1:
 170                 ;
 171         }
 172
 173         /* Last, determine what the bit-pattern should be for a single
 174            device, according to chip mode and endianness... */
 175         switch (chip_mode) {
 176         case 1:
 177                 break;
 178         case 2:
 179                 res = cfi16_to_cpu(map, res);
 180                 break;
 181         case 4:
 182                 res = cfi32_to_cpu(map, res);
 183                 break;
 184         default: BUG();
 185         }
 186         return res;
 187 }
 188 EXPORT_SYMBOL(cfi_merge_status);
 189
 190 /*
 191  * Sends a CFI command to a bank of flash for the given geometry.
 192  *
 193  * Returns the offset in flash where the command was written.
 194  * If prev_val is non-null, it will be set to the value at the command address,
 195  * before the command was written.
 196  */
 197 uint32_t cfi_send_gen_cmd(u_char cmd, uint32_t cmd_addr, uint32_t base,
 198                                 struct map_info *map, struct cfi_private *cfi,
 199                                 int type, map_word *prev_val)
 200 {
 201         map_word val;
 202         uint32_t addr = base + cfi_build_cmd_addr(cmd_addr, map, cfi);
 203         val = cfi_build_cmd(cmd, map, cfi);
 204
 205         if (prev_val)
 206                 *prev_val = map_read(map, addr);
 207
 208         map_write(map, val, addr);
 209
 210         return addr - base;
 211 }
 212 EXPORT_SYMBOL(cfi_send_gen_cmd);
 213
 214 int __xipram cfi_qry_present(struct map_info *map, __u32 base,
 215                              struct cfi_private *cfi)
 216 {
 217         int osf = cfi->interleave * cfi->device_type;   /* scale factor */
 218         map_word val[3];
 219         map_word qry[3];
 220
 221         qry[0] = cfi_build_cmd('Q', map, cfi);
 222         qry[1] = cfi_build_cmd('R', map, cfi);
 223         qry[2] = cfi_build_cmd('Y', map, cfi);
 224
 225         val[0] = map_read(map, base + osf*0x10);
 226         val[1] = map_read(map, base + osf*0x11);
 227         val[2] = map_read(map, base + osf*0x12);
 228
 229         if (!map_word_equal(map, qry[0], val[0]))
 230                 return 0;
 231
 232         if (!map_word_equal(map, qry[1], val[1]))
 233                 return 0;
 234
 235         if (!map_word_equal(map, qry[2], val[2]))
 236                 return 0;
 237
 238         return 1;       /* "QRY" found */
 239 }
 240 EXPORT_SYMBOL_GPL(cfi_qry_present);
 241
 242 int __xipram cfi_qry_mode_on(uint32_t base, struct map_info *map,
 243                              struct cfi_private *cfi)
 244 {
 245         cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
 246         cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
 247         if (cfi_qry_present(map, base, cfi))
 248                 return 1;
 249         /* QRY not found probably we deal with some odd CFI chips */
 250         /* Some revisions of some old Intel chips? */
 251         cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
 252         cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
 253         cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
 254         if (cfi_qry_present(map, base, cfi))
 255                 return 1;
 256         /* ST M29DW chips */
 257         cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
 258         cfi_send_gen_cmd(0x98, 0x555, base, map, cfi, cfi->device_type, NULL);
 259         if (cfi_qry_present(map, base, cfi))
 260                 return 1;
 261         /* some old SST chips, e.g. 39VF160x/39VF320x */
 262         cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
 263         cfi_send_gen_cmd(0xAA, 0x5555, base, map, cfi, cfi->device_type, NULL);
 264         cfi_send_gen_cmd(0x55, 0x2AAA, base, map, cfi, cfi->device_type, NULL);
 265         cfi_send_gen_cmd(0x98, 0x5555, base, map, cfi, cfi->device_type, NULL);
 266         if (cfi_qry_present(map, base, cfi))
 267                 return 1;
 268         /* SST 39VF640xB */
 269         cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
 270         cfi_send_gen_cmd(0xAA, 0x555, base, map, cfi, cfi->device_type, NULL);
 271         cfi_send_gen_cmd(0x55, 0x2AA, base, map, cfi, cfi->device_type, NULL);
 272         cfi_send_gen_cmd(0x98, 0x555, base, map, cfi, cfi->device_type, NULL);
 273         if (cfi_qry_present(map, base, cfi))
 274                 return 1;
 275         /* QRY not found */
 276         return 0;
 277 }
 278 EXPORT_SYMBOL_GPL(cfi_qry_mode_on);
 279
 280 void __xipram cfi_qry_mode_off(uint32_t base, struct map_info *map,
 281                                struct cfi_private *cfi)
 282 {
 283         cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
 284         cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
 285         /* M29W128G flashes require an additional reset command
 286            when exit qry mode */
 287         if ((cfi->mfr == CFI_MFR_ST) && (cfi->id == 0x227E || cfi->id == 0x7E))
 288                 cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
 289 }
 290 EXPORT_SYMBOL_GPL(cfi_qry_mode_off);
 291
 292 struct cfi_extquery *
 293 __xipram cfi_read_pri(struct map_info *map, __u16 adr, __u16 size, const char* name)
 294 {
 295         struct cfi_private *cfi = map->fldrv_priv;
 296         __u32 base = 0; // cfi->chips[0].start;
 297         int ofs_factor = cfi->interleave * cfi->device_type;
 298         int i;
 299         struct cfi_extquery *extp = NULL;
 300
 301         if (!adr)
 302                 goto out;
 303
 304         printk(KERN_INFO "%s Extended Query Table at 0x%4.4X\n", name, adr);
 305
 306         extp = kmalloc(size, GFP_KERNEL);
 307         if (!extp)
 308                 goto out;
 309
 310 #ifdef CONFIG_MTD_XIP
 311         local_irq_disable();
 312 #endif
 313
 314         /* Switch it into Query Mode */
 315         cfi_qry_mode_on(base, map, cfi);
 316         /* Read in the Extended Query Table */
 317         for (i=0; i<size; i++) {
 318                 ((unsigned char *)extp)[i] =
 319                         cfi_read_query(map, base+((adr+i)*ofs_factor));
 320         }
 321
 322         /* Make sure it returns to read mode */
 323         cfi_qry_mode_off(base, map, cfi);
 324
 325 #ifdef CONFIG_MTD_XIP
 326         (void) map_read(map, base);
 327         xip_iprefetch();
 328         local_irq_enable();
 329 #endif
 330
 331  out:   return extp;
 332 }
 333
 334 EXPORT_SYMBOL(cfi_read_pri);
 335
 336 void cfi_fixup(struct mtd_info *mtd, struct cfi_fixup *fixups)
 337 {
 338         struct map_info *map = mtd->priv;
 339         struct cfi_private *cfi = map->fldrv_priv;
 340         struct cfi_fixup *f;
 341
 342         for (f=fixups; f->fixup; f++) {
 343                 if (((f->mfr == CFI_MFR_ANY) || (f->mfr == cfi->mfr)) &&
 344                     ((f->id  == CFI_ID_ANY)  || (f->id  == cfi->id))) {
 345                         f->fixup(mtd);
 346                 }
 347         }
 348 }
 349
 350 EXPORT_SYMBOL(cfi_fixup);
 351
 352 int cfi_varsize_frob(struct mtd_info *mtd, varsize_frob_t frob,
 353                                      loff_t ofs, size_t len, void *thunk)
 354 {
 355         struct map_info *map = mtd->priv;
 356         struct cfi_private *cfi = map->fldrv_priv;
 357         unsigned long adr;
 358         int chipnum, ret = 0;
 359         int i, first;
 360         struct mtd_erase_region_info *regions = mtd->eraseregions;
 361
 362         /* Check that both start and end of the requested erase are
 363          * aligned with the erasesize at the appropriate addresses.
 364          */
 365
 366         i = 0;
 367
 368         /* Skip all erase regions which are ended before the start of
 369            the requested erase. Actually, to save on the calculations,
 370            we skip to the first erase region which starts after the
 371            start of the requested erase, and then go back one.
 372         */
 373
 374         while (i < mtd->numeraseregions && ofs >= regions[i].offset)
 375                i++;
 376         i--;
 377
 378         /* OK, now i is pointing at the erase region in which this
 379            erase request starts. Check the start of the requested
 380            erase range is aligned with the erase size which is in
 381            effect here.
 382         */
 383
 384         if (ofs & (regions[i].erasesize-1))
 385                 return -EINVAL;
 386
 387         /* Remember the erase region we start on */
 388         first = i;
 389
 390         /* Next, check that the end of the requested erase is aligned
 391          * with the erase region at that address.
 392          */
 393
 394         while (i<mtd->numeraseregions && (ofs + len) >= regions[i].offset)
 395                 i++;
 396
 397         /* As before, drop back one to point at the region in which
 398            the address actually falls
 399         */
 400         i--;
 401
 402         if ((ofs + len) & (regions[i].erasesize-1))
 403                 return -EINVAL;
 404
 405         chipnum = ofs >> cfi->chipshift;
 406         adr = ofs - (chipnum << cfi->chipshift);
 407
 408         i=first;
 409
 410         while(len) {
 411                 int size = regions[i].erasesize;
 412
 413                 ret = (*frob)(map, &cfi->chips[chipnum], adr, size, thunk);
 414
 415                 if (ret)
 416                         return ret;
 417
 418                 adr += size;
 419                 ofs += size;
 420                 len -= size;
 421
 422                 if (ofs == regions[i].offset + size * regions[i].numblocks)
 423                         i++;
 424
 425                 if (adr >> cfi->chipshift) {
 426                         adr = 0;
 427                         chipnum++;
 428
 429                         if (chipnum >= cfi->numchips)
 430                                 break;
 431                 }
 432         }
 433
 434         return 0;
 435 }
 436
 437 EXPORT_SYMBOL(cfi_varsize_frob);
 438
 439 MODULE_LICENSE("GPL");