git.oblomov.eu Git - linux-2.6/blob - drivers/mtd/chips/cfi_cmdset_0001.c

   1 /*
   2  * Common Flash Interface support:
   3  *   Intel Extended Vendor Command Set (ID 0x0001)
   4  *
   5  * (C) 2000 Red Hat. GPL'd
   6  *
   7  * $Id: cfi_cmdset_0001.c,v 1.186 2005/11/23 22:07:52 nico Exp $
   8  *
   9  *
  10  * 10/10/2000   Nicolas Pitre <nico@cam.org>
  11  *      - completely revamped method functions so they are aware and
  12  *        independent of the flash geometry (buswidth, interleave, etc.)
  13  *      - scalability vs code size is completely set at compile-time
  14  *        (see include/linux/mtd/cfi.h for selection)
  15  *      - optimized write buffer method
  16  * 02/05/2002   Christopher Hoover <ch@hpl.hp.com>/<ch@murgatroid.com>
  17  *      - reworked lock/unlock/erase support for var size flash
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/types.h>
  22 #include <linux/kernel.h>
  23 #include <linux/sched.h>
  24 #include <linux/init.h>
  25 #include <asm/io.h>
  26 #include <asm/byteorder.h>
  27
  28 #include <linux/errno.h>
  29 #include <linux/slab.h>
  30 #include <linux/delay.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/reboot.h>
  33 #include <linux/mtd/xip.h>
  34 #include <linux/mtd/map.h>
  35 #include <linux/mtd/mtd.h>
  36 #include <linux/mtd/compatmac.h>
  37 #include <linux/mtd/cfi.h>
  38
  39 /* #define CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE */
  40 /* #define CMDSET0001_DISABLE_WRITE_SUSPEND */
  41
  42 // debugging, turns off buffer write mode if set to 1
  43 #define FORCE_WORD_WRITE 0
  44
  45 #define MANUFACTURER_INTEL      0x0089
  46 #define I82802AB        0x00ad
  47 #define I82802AC        0x00ac
  48 #define MANUFACTURER_ST         0x0020
  49 #define M50LPW080       0x002F
  50
  51 static int cfi_intelext_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
  52 static int cfi_intelext_write_words(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
  53 static int cfi_intelext_write_buffers(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
  54 static int cfi_intelext_writev(struct mtd_info *, const struct kvec *, unsigned long, loff_t, size_t *);
  55 static int cfi_intelext_erase_varsize(struct mtd_info *, struct erase_info *);
  56 static void cfi_intelext_sync (struct mtd_info *);
  57 static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, size_t len);
  58 static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, size_t len);
  59 #ifdef CONFIG_MTD_OTP
  60 static int cfi_intelext_read_fact_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
  61 static int cfi_intelext_read_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
  62 static int cfi_intelext_write_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
  63 static int cfi_intelext_lock_user_prot_reg (struct mtd_info *, loff_t, size_t);
  64 static int cfi_intelext_get_fact_prot_info (struct mtd_info *,
  65                                             struct otp_info *, size_t);
  66 static int cfi_intelext_get_user_prot_info (struct mtd_info *,
  67                                             struct otp_info *, size_t);
  68 #endif
  69 static int cfi_intelext_suspend (struct mtd_info *);
  70 static void cfi_intelext_resume (struct mtd_info *);
  71 static int cfi_intelext_reboot (struct notifier_block *, unsigned long, void *);
  72
  73 static void cfi_intelext_destroy(struct mtd_info *);
  74
  75 struct mtd_info *cfi_cmdset_0001(struct map_info *, int);
  76
  77 static struct mtd_info *cfi_intelext_setup (struct mtd_info *);
  78 static int cfi_intelext_partition_fixup(struct mtd_info *, struct cfi_private **);
  79
  80 static int cfi_intelext_point (struct mtd_info *mtd, loff_t from, size_t len,
  81                      size_t *retlen, u_char **mtdbuf);
  82 static void cfi_intelext_unpoint (struct mtd_info *mtd, u_char *addr, loff_t from,
  83                         size_t len);
  84
  85 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
  86 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr);
  87 #include "fwh_lock.h"
  88
  89
  90
  91 /*
  92  *  *********** SETUP AND PROBE BITS  ***********
  93  */
  94
  95 static struct mtd_chip_driver cfi_intelext_chipdrv = {
  96         .probe          = NULL, /* Not usable directly */
  97         .destroy        = cfi_intelext_destroy,
  98         .name           = "cfi_cmdset_0001",
  99         .module         = THIS_MODULE
 100 };
 101
 102 /* #define DEBUG_LOCK_BITS */
 103 /* #define DEBUG_CFI_FEATURES */
 104
 105 #ifdef DEBUG_CFI_FEATURES
 106 static void cfi_tell_features(struct cfi_pri_intelext *extp)
 107 {
 108         int i;
 109         printk("  Extended Query version %c.%c\n", extp->MajorVersion, extp->MinorVersion);
 110         printk("  Feature/Command Support:      %4.4X\n", extp->FeatureSupport);
 111         printk("     - Chip Erase:              %s\n", extp->FeatureSupport&1?"supported":"unsupported");
 112         printk("     - Suspend Erase:           %s\n", extp->FeatureSupport&2?"supported":"unsupported");
 113         printk("     - Suspend Program:         %s\n", extp->FeatureSupport&4?"supported":"unsupported");
 114         printk("     - Legacy Lock/Unlock:      %s\n", extp->FeatureSupport&8?"supported":"unsupported");
 115         printk("     - Queued Erase:            %s\n", extp->FeatureSupport&16?"supported":"unsupported");
 116         printk("     - Instant block lock:      %s\n", extp->FeatureSupport&32?"supported":"unsupported");
 117         printk("     - Protection Bits:         %s\n", extp->FeatureSupport&64?"supported":"unsupported");
 118         printk("     - Page-mode read:          %s\n", extp->FeatureSupport&128?"supported":"unsupported");
 119         printk("     - Synchronous read:        %s\n", extp->FeatureSupport&256?"supported":"unsupported");
 120         printk("     - Simultaneous operations: %s\n", extp->FeatureSupport&512?"supported":"unsupported");
 121         printk("     - Extended Flash Array:    %s\n", extp->FeatureSupport&1024?"supported":"unsupported");
 122         for (i=11; i<32; i++) {
 123                 if (extp->FeatureSupport & (1<<i))
 124                         printk("     - Unknown Bit %X:      supported\n", i);
 125         }
 126
 127         printk("  Supported functions after Suspend: %2.2X\n", extp->SuspendCmdSupport);
 128         printk("     - Program after Erase Suspend: %s\n", extp->SuspendCmdSupport&1?"supported":"unsupported");
 129         for (i=1; i<8; i++) {
 130                 if (extp->SuspendCmdSupport & (1<<i))
 131                         printk("     - Unknown Bit %X:               supported\n", i);
 132         }
 133
 134         printk("  Block Status Register Mask: %4.4X\n", extp->BlkStatusRegMask);
 135         printk("     - Lock Bit Active:      %s\n", extp->BlkStatusRegMask&1?"yes":"no");
 136         printk("     - Lock-Down Bit Active: %s\n", extp->BlkStatusRegMask&2?"yes":"no");
 137         for (i=2; i<3; i++) {
 138                 if (extp->BlkStatusRegMask & (1<<i))
 139                         printk("     - Unknown Bit %X Active: yes\n",i);
 140         }
 141         printk("     - EFA Lock Bit:         %s\n", extp->BlkStatusRegMask&16?"yes":"no");
 142         printk("     - EFA Lock-Down Bit:    %s\n", extp->BlkStatusRegMask&32?"yes":"no");
 143         for (i=6; i<16; i++) {
 144                 if (extp->BlkStatusRegMask & (1<<i))
 145                         printk("     - Unknown Bit %X Active: yes\n",i);
 146         }
 147
 148         printk("  Vcc Logic Supply Optimum Program/Erase Voltage: %d.%d V\n",
 149                extp->VccOptimal >> 4, extp->VccOptimal & 0xf);
 150         if (extp->VppOptimal)
 151                 printk("  Vpp Programming Supply Optimum Program/Erase Voltage: %d.%d V\n",
 152                        extp->VppOptimal >> 4, extp->VppOptimal & 0xf);
 153 }
 154 #endif
 155
 156 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
 157 /* Some Intel Strata Flash prior to FPO revision C has bugs in this area */
 158 static void fixup_intel_strataflash(struct mtd_info *mtd, void* param)
 159 {
 160         struct map_info *map = mtd->priv;
 161         struct cfi_private *cfi = map->fldrv_priv;
 162         struct cfi_pri_amdstd *extp = cfi->cmdset_priv;
 163
 164         printk(KERN_WARNING "cfi_cmdset_0001: Suspend "
 165                             "erase on write disabled.\n");
 166         extp->SuspendCmdSupport &= ~1;
 167 }
 168 #endif
 169
 170 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
 171 static void fixup_no_write_suspend(struct mtd_info *mtd, void* param)
 172 {
 173         struct map_info *map = mtd->priv;
 174         struct cfi_private *cfi = map->fldrv_priv;
 175         struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
 176
 177         if (cfip && (cfip->FeatureSupport&4)) {
 178                 cfip->FeatureSupport &= ~4;
 179                 printk(KERN_WARNING "cfi_cmdset_0001: write suspend disabled\n");
 180         }
 181 }
 182 #endif
 183
 184 static void fixup_st_m28w320ct(struct mtd_info *mtd, void* param)
 185 {
 186         struct map_info *map = mtd->priv;
 187         struct cfi_private *cfi = map->fldrv_priv;
 188
 189         cfi->cfiq->BufWriteTimeoutTyp = 0;      /* Not supported */
 190         cfi->cfiq->BufWriteTimeoutMax = 0;      /* Not supported */
 191 }
 192
 193 static void fixup_st_m28w320cb(struct mtd_info *mtd, void* param)
 194 {
 195         struct map_info *map = mtd->priv;
 196         struct cfi_private *cfi = map->fldrv_priv;
 197
 198         /* Note this is done after the region info is endian swapped */
 199         cfi->cfiq->EraseRegionInfo[1] =
 200                 (cfi->cfiq->EraseRegionInfo[1] & 0xffff0000) | 0x3e;
 201 };
 202
 203 static void fixup_use_point(struct mtd_info *mtd, void *param)
 204 {
 205         struct map_info *map = mtd->priv;
 206         if (!mtd->point && map_is_linear(map)) {
 207                 mtd->point   = cfi_intelext_point;
 208                 mtd->unpoint = cfi_intelext_unpoint;
 209         }
 210 }
 211
 212 static void fixup_use_write_buffers(struct mtd_info *mtd, void *param)
 213 {
 214         struct map_info *map = mtd->priv;
 215         struct cfi_private *cfi = map->fldrv_priv;
 216         if (cfi->cfiq->BufWriteTimeoutTyp) {
 217                 printk(KERN_INFO "Using buffer write method\n" );
 218                 mtd->write = cfi_intelext_write_buffers;
 219                 mtd->writev = cfi_intelext_writev;
 220         }
 221 }
 222
 223 static struct cfi_fixup cfi_fixup_table[] = {
 224 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
 225         { CFI_MFR_ANY, CFI_ID_ANY, fixup_intel_strataflash, NULL },
 226 #endif
 227 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
 228         { CFI_MFR_ANY, CFI_ID_ANY, fixup_no_write_suspend, NULL },
 229 #endif
 230 #if !FORCE_WORD_WRITE
 231         { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers, NULL },
 232 #endif
 233         { CFI_MFR_ST, 0x00ba, /* M28W320CT */ fixup_st_m28w320ct, NULL },
 234         { CFI_MFR_ST, 0x00bb, /* M28W320CB */ fixup_st_m28w320cb, NULL },
 235         { 0, 0, NULL, NULL }
 236 };
 237
 238 static struct cfi_fixup jedec_fixup_table[] = {
 239         { MANUFACTURER_INTEL, I82802AB,   fixup_use_fwh_lock, NULL, },
 240         { MANUFACTURER_INTEL, I82802AC,   fixup_use_fwh_lock, NULL, },
 241         { MANUFACTURER_ST,    M50LPW080,  fixup_use_fwh_lock, NULL, },
 242         { 0, 0, NULL, NULL }
 243 };
 244 static struct cfi_fixup fixup_table[] = {
 245         /* The CFI vendor ids and the JEDEC vendor IDs appear
 246          * to be common.  It is like the devices id's are as
 247          * well.  This table is to pick all cases where
 248          * we know that is the case.
 249          */
 250         { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_point, NULL },
 251         { 0, 0, NULL, NULL }
 252 };
 253
 254 static inline struct cfi_pri_intelext *
 255 read_pri_intelext(struct map_info *map, __u16 adr)
 256 {
 257         struct cfi_pri_intelext *extp;
 258         unsigned int extp_size = sizeof(*extp);
 259
 260  again:
 261         extp = (struct cfi_pri_intelext *)cfi_read_pri(map, adr, extp_size, "Intel/Sharp");
 262         if (!extp)
 263                 return NULL;
 264
 265         if (extp->MajorVersion != '1' ||
 266             (extp->MinorVersion < '0' || extp->MinorVersion > '4')) {
 267                 printk(KERN_ERR "  Unknown Intel/Sharp Extended Query "
 268                        "version %c.%c.\n",  extp->MajorVersion,
 269                        extp->MinorVersion);
 270                 kfree(extp);
 271                 return NULL;
 272         }
 273
 274         /* Do some byteswapping if necessary */
 275         extp->FeatureSupport = le32_to_cpu(extp->FeatureSupport);
 276         extp->BlkStatusRegMask = le16_to_cpu(extp->BlkStatusRegMask);
 277         extp->ProtRegAddr = le16_to_cpu(extp->ProtRegAddr);
 278
 279         if (extp->MajorVersion == '1' && extp->MinorVersion >= '3') {
 280                 unsigned int extra_size = 0;
 281                 int nb_parts, i;
 282
 283                 /* Protection Register info */
 284                 extra_size += (extp->NumProtectionFields - 1) *
 285                               sizeof(struct cfi_intelext_otpinfo);
 286
 287                 /* Burst Read info */
 288                 extra_size += 2;
 289                 if (extp_size < sizeof(*extp) + extra_size)
 290                         goto need_more;
 291                 extra_size += extp->extra[extra_size-1];
 292
 293                 /* Number of hardware-partitions */
 294                 extra_size += 1;
 295                 if (extp_size < sizeof(*extp) + extra_size)
 296                         goto need_more;
 297                 nb_parts = extp->extra[extra_size - 1];
 298
 299                 /* skip the sizeof(partregion) field in CFI 1.4 */
 300                 if (extp->MinorVersion >= '4')
 301                         extra_size += 2;
 302
 303                 for (i = 0; i < nb_parts; i++) {
 304                         struct cfi_intelext_regioninfo *rinfo;
 305                         rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[extra_size];
 306                         extra_size += sizeof(*rinfo);
 307                         if (extp_size < sizeof(*extp) + extra_size)
 308                                 goto need_more;
 309                         rinfo->NumIdentPartitions=le16_to_cpu(rinfo->NumIdentPartitions);
 310                         extra_size += (rinfo->NumBlockTypes - 1)
 311                                       * sizeof(struct cfi_intelext_blockinfo);
 312                 }
 313
 314                 if (extp->MinorVersion >= '4')
 315                         extra_size += sizeof(struct cfi_intelext_programming_regioninfo);
 316
 317                 if (extp_size < sizeof(*extp) + extra_size) {
 318                         need_more:
 319                         extp_size = sizeof(*extp) + extra_size;
 320                         kfree(extp);
 321                         if (extp_size > 4096) {
 322                                 printk(KERN_ERR
 323                                         "%s: cfi_pri_intelext is too fat\n",
 324                                         __FUNCTION__);
 325                                 return NULL;
 326                         }
 327                         goto again;
 328                 }
 329         }
 330
 331         return extp;
 332 }
 333
 334 struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
 335 {
 336         struct cfi_private *cfi = map->fldrv_priv;
 337         struct mtd_info *mtd;
 338         int i;
 339
 340         mtd = kmalloc(sizeof(*mtd), GFP_KERNEL);
 341         if (!mtd) {
 342                 printk(KERN_ERR "Failed to allocate memory for MTD device\n");
 343                 return NULL;
 344         }
 345         memset(mtd, 0, sizeof(*mtd));
 346         mtd->priv = map;
 347         mtd->type = MTD_NORFLASH;
 348
 349         /* Fill in the default mtd operations */
 350         mtd->erase   = cfi_intelext_erase_varsize;
 351         mtd->read    = cfi_intelext_read;
 352         mtd->write   = cfi_intelext_write_words;
 353         mtd->sync    = cfi_intelext_sync;
 354         mtd->lock    = cfi_intelext_lock;
 355         mtd->unlock  = cfi_intelext_unlock;
 356         mtd->suspend = cfi_intelext_suspend;
 357         mtd->resume  = cfi_intelext_resume;
 358         mtd->flags   = MTD_CAP_NORFLASH;
 359         mtd->name    = map->name;
 360         mtd->writesize = 1;
 361
 362         mtd->reboot_notifier.notifier_call = cfi_intelext_reboot;
 363
 364         if (cfi->cfi_mode == CFI_MODE_CFI) {
 365                 /*
 366                  * It's a real CFI chip, not one for which the probe
 367                  * routine faked a CFI structure. So we read the feature
 368                  * table from it.
 369                  */
 370                 __u16 adr = primary?cfi->cfiq->P_ADR:cfi->cfiq->A_ADR;
 371                 struct cfi_pri_intelext *extp;
 372
 373                 extp = read_pri_intelext(map, adr);
 374                 if (!extp) {
 375                         kfree(mtd);
 376                         return NULL;
 377                 }
 378
 379                 /* Install our own private info structure */
 380                 cfi->cmdset_priv = extp;
 381
 382                 cfi_fixup(mtd, cfi_fixup_table);
 383
 384 #ifdef DEBUG_CFI_FEATURES
 385                 /* Tell the user about it in lots of lovely detail */
 386                 cfi_tell_features(extp);
 387 #endif
 388
 389                 if(extp->SuspendCmdSupport & 1) {
 390                         printk(KERN_NOTICE "cfi_cmdset_0001: Erase suspend on write enabled\n");
 391                 }
 392         }
 393         else if (cfi->cfi_mode == CFI_MODE_JEDEC) {
 394                 /* Apply jedec specific fixups */
 395                 cfi_fixup(mtd, jedec_fixup_table);
 396         }
 397         /* Apply generic fixups */
 398         cfi_fixup(mtd, fixup_table);
 399
 400         for (i=0; i< cfi->numchips; i++) {
 401                 cfi->chips[i].word_write_time = 1<<cfi->cfiq->WordWriteTimeoutTyp;
 402                 cfi->chips[i].buffer_write_time = 1<<cfi->cfiq->BufWriteTimeoutTyp;
 403                 cfi->chips[i].erase_time = 1000<<cfi->cfiq->BlockEraseTimeoutTyp;
 404                 cfi->chips[i].ref_point_counter = 0;
 405                 init_waitqueue_head(&(cfi->chips[i].wq));
 406         }
 407
 408         map->fldrv = &cfi_intelext_chipdrv;
 409
 410         return cfi_intelext_setup(mtd);
 411 }
 412 struct mtd_info *cfi_cmdset_0003(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
 413 struct mtd_info *cfi_cmdset_0200(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
 414 EXPORT_SYMBOL_GPL(cfi_cmdset_0001);
 415 EXPORT_SYMBOL_GPL(cfi_cmdset_0003);
 416 EXPORT_SYMBOL_GPL(cfi_cmdset_0200);
 417
 418 static struct mtd_info *cfi_intelext_setup(struct mtd_info *mtd)
 419 {
 420         struct map_info *map = mtd->priv;
 421         struct cfi_private *cfi = map->fldrv_priv;
 422         unsigned long offset = 0;
 423         int i,j;
 424         unsigned long devsize = (1<<cfi->cfiq->DevSize) * cfi->interleave;
 425
 426         //printk(KERN_DEBUG "number of CFI chips: %d\n", cfi->numchips);
 427
 428         mtd->size = devsize * cfi->numchips;
 429
 430         mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips;
 431         mtd->eraseregions = kmalloc(sizeof(struct mtd_erase_region_info)
 432                         * mtd->numeraseregions, GFP_KERNEL);
 433         if (!mtd->eraseregions) {
 434                 printk(KERN_ERR "Failed to allocate memory for MTD erase region info\n");
 435                 goto setup_err;
 436         }
 437
 438         for (i=0; i<cfi->cfiq->NumEraseRegions; i++) {
 439                 unsigned long ernum, ersize;
 440                 ersize = ((cfi->cfiq->EraseRegionInfo[i] >> 8) & ~0xff) * cfi->interleave;
 441                 ernum = (cfi->cfiq->EraseRegionInfo[i] & 0xffff) + 1;
 442
 443                 if (mtd->erasesize < ersize) {
 444                         mtd->erasesize = ersize;
 445                 }
 446                 for (j=0; j<cfi->numchips; j++) {
 447                         mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].offset = (j*devsize)+offset;
 448                         mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].erasesize = ersize;
 449                         mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].numblocks = ernum;
 450                 }
 451                 offset += (ersize * ernum);
 452         }
 453
 454         if (offset != devsize) {
 455                 /* Argh */
 456                 printk(KERN_WARNING "Sum of regions (%lx) != total size of set of interleaved chips (%lx)\n", offset, devsize);
 457                 goto setup_err;
 458         }
 459
 460         for (i=0; i<mtd->numeraseregions;i++){
 461                 printk(KERN_DEBUG "erase region %d: offset=0x%x,size=0x%x,blocks=%d\n",
 462                        i,mtd->eraseregions[i].offset,
 463                        mtd->eraseregions[i].erasesize,
 464                        mtd->eraseregions[i].numblocks);
 465         }
 466
 467 #ifdef CONFIG_MTD_OTP
 468         mtd->read_fact_prot_reg = cfi_intelext_read_fact_prot_reg;
 469         mtd->read_user_prot_reg = cfi_intelext_read_user_prot_reg;
 470         mtd->write_user_prot_reg = cfi_intelext_write_user_prot_reg;
 471         mtd->lock_user_prot_reg = cfi_intelext_lock_user_prot_reg;
 472         mtd->get_fact_prot_info = cfi_intelext_get_fact_prot_info;
 473         mtd->get_user_prot_info = cfi_intelext_get_user_prot_info;
 474 #endif
 475
 476         /* This function has the potential to distort the reality
 477            a bit and therefore should be called last. */
 478         if (cfi_intelext_partition_fixup(mtd, &cfi) != 0)
 479                 goto setup_err;
 480
 481         __module_get(THIS_MODULE);
 482         register_reboot_notifier(&mtd->reboot_notifier);
 483         return mtd;
 484
 485  setup_err:
 486         if(mtd) {
 487                 kfree(mtd->eraseregions);
 488                 kfree(mtd);
 489         }
 490         kfree(cfi->cmdset_priv);
 491         return NULL;
 492 }
 493
 494 static int cfi_intelext_partition_fixup(struct mtd_info *mtd,
 495                                         struct cfi_private **pcfi)
 496 {
 497         struct map_info *map = mtd->priv;
 498         struct cfi_private *cfi = *pcfi;
 499         struct cfi_pri_intelext *extp = cfi->cmdset_priv;
 500
 501         /*
 502          * Probing of multi-partition flash ships.
 503          *
 504          * To support multiple partitions when available, we simply arrange
 505          * for each of them to have their own flchip structure even if they
 506          * are on the same physical chip.  This means completely recreating
 507          * a new cfi_private structure right here which is a blatent code
 508          * layering violation, but this is still the least intrusive
 509          * arrangement at this point. This can be rearranged in the future
 510          * if someone feels motivated enough.  --nico
 511          */
 512         if (extp && extp->MajorVersion == '1' && extp->MinorVersion >= '3'
 513             && extp->FeatureSupport & (1 << 9)) {
 514                 struct cfi_private *newcfi;
 515                 struct flchip *chip;
 516                 struct flchip_shared *shared;
 517                 int offs, numregions, numparts, partshift, numvirtchips, i, j;
 518
 519                 /* Protection Register info */
 520                 offs = (extp->NumProtectionFields - 1) *
 521                        sizeof(struct cfi_intelext_otpinfo);
 522
 523                 /* Burst Read info */
 524                 offs += extp->extra[offs+1]+2;
 525
 526                 /* Number of partition regions */
 527                 numregions = extp->extra[offs];
 528                 offs += 1;
 529
 530                 /* skip the sizeof(partregion) field in CFI 1.4 */
 531                 if (extp->MinorVersion >= '4')
 532                         offs += 2;
 533
 534                 /* Number of hardware partitions */
 535                 numparts = 0;
 536                 for (i = 0; i < numregions; i++) {
 537                         struct cfi_intelext_regioninfo *rinfo;
 538                         rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[offs];
 539                         numparts += rinfo->NumIdentPartitions;
 540                         offs += sizeof(*rinfo)
 541                                 + (rinfo->NumBlockTypes - 1) *
 542                                   sizeof(struct cfi_intelext_blockinfo);
 543                 }
 544
 545                 /* Programming Region info */
 546                 if (extp->MinorVersion >= '4') {
 547                         struct cfi_intelext_programming_regioninfo *prinfo;
 548                         prinfo = (struct cfi_intelext_programming_regioninfo *)&extp->extra[offs];
 549                         mtd->writesize = cfi->interleave << prinfo->ProgRegShift;
 550                         MTD_PROGREGION_CTRLMODE_VALID(mtd) = cfi->interleave * prinfo->ControlValid;
 551                         MTD_PROGREGION_CTRLMODE_INVALID(mtd) = cfi->interleave * prinfo->ControlInvalid;
 552                         mtd->flags &= ~MTD_BIT_WRITEABLE;
 553                         printk(KERN_DEBUG "%s: program region size/ctrl_valid/ctrl_inval = %d/%d/%d\n",
 554                                map->name, mtd->writesize,
 555                                MTD_PROGREGION_CTRLMODE_VALID(mtd),
 556                                MTD_PROGREGION_CTRLMODE_INVALID(mtd));
 557                 }
 558
 559                 /*
 560                  * All functions below currently rely on all chips having
 561                  * the same geometry so we'll just assume that all hardware
 562                  * partitions are of the same size too.
 563                  */
 564                 partshift = cfi->chipshift - __ffs(numparts);
 565
 566                 if ((1 << partshift) < mtd->erasesize) {
 567                         printk( KERN_ERR
 568                                 "%s: bad number of hw partitions (%d)\n",
 569                                 __FUNCTION__, numparts);
 570                         return -EINVAL;
 571                 }
 572
 573                 numvirtchips = cfi->numchips * numparts;
 574                 newcfi = kmalloc(sizeof(struct cfi_private) + numvirtchips * sizeof(struct flchip), GFP_KERNEL);
 575                 if (!newcfi)
 576                         return -ENOMEM;
 577                 shared = kmalloc(sizeof(struct flchip_shared) * cfi->numchips, GFP_KERNEL);
 578                 if (!shared) {
 579                         kfree(newcfi);
 580                         return -ENOMEM;
 581                 }
 582                 memcpy(newcfi, cfi, sizeof(struct cfi_private));
 583                 newcfi->numchips = numvirtchips;
 584                 newcfi->chipshift = partshift;
 585
 586                 chip = &newcfi->chips[0];
 587                 for (i = 0; i < cfi->numchips; i++) {
 588                         shared[i].writing = shared[i].erasing = NULL;
 589                         spin_lock_init(&shared[i].lock);
 590                         for (j = 0; j < numparts; j++) {
 591                                 *chip = cfi->chips[i];
 592                                 chip->start += j << partshift;
 593                                 chip->priv = &shared[i];
 594                                 /* those should be reset too since
 595                                    they create memory references. */
 596                                 init_waitqueue_head(&chip->wq);
 597                                 spin_lock_init(&chip->_spinlock);
 598                                 chip->mutex = &chip->_spinlock;
 599                                 chip++;
 600                         }
 601                 }
 602
 603                 printk(KERN_DEBUG "%s: %d set(s) of %d interleaved chips "
 604                                   "--> %d partitions of %d KiB\n",
 605                                   map->name, cfi->numchips, cfi->interleave,
 606                                   newcfi->numchips, 1<<(newcfi->chipshift-10));
 607
 608                 map->fldrv_priv = newcfi;
 609                 *pcfi = newcfi;
 610                 kfree(cfi);
 611         }
 612
 613         return 0;
 614 }
 615
 616 /*
 617  *  *********** CHIP ACCESS FUNCTIONS ***********
 618  */
 619
 620 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
 621 {
 622         DECLARE_WAITQUEUE(wait, current);
 623         struct cfi_private *cfi = map->fldrv_priv;
 624         map_word status, status_OK = CMD(0x80), status_PWS = CMD(0x01);
 625         unsigned long timeo;
 626         struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
 627
 628  resettime:
 629         timeo = jiffies + HZ;
 630  retry:
 631         if (chip->priv && (mode == FL_WRITING || mode == FL_ERASING || mode == FL_OTP_WRITE)) {
 632                 /*
 633                  * OK. We have possibility for contension on the write/erase
 634                  * operations which are global to the real chip and not per
 635                  * partition.  So let's fight it over in the partition which
 636                  * currently has authority on the operation.
 637                  *
 638                  * The rules are as follows:
 639                  *
 640                  * - any write operation must own shared->writing.
 641                  *
 642                  * - any erase operation must own _both_ shared->writing and
 643                  *   shared->erasing.
 644                  *
 645                  * - contension arbitration is handled in the owner's context.
 646                  *
 647                  * The 'shared' struct can be read and/or written only when
 648                  * its lock is taken.
 649                  */
 650                 struct flchip_shared *shared = chip->priv;
 651                 struct flchip *contender;
 652                 spin_lock(&shared->lock);
 653                 contender = shared->writing;
 654                 if (contender && contender != chip) {
 655                         /*
 656                          * The engine to perform desired operation on this
 657                          * partition is already in use by someone else.
 658                          * Let's fight over it in the context of the chip
 659                          * currently using it.  If it is possible to suspend,
 660                          * that other partition will do just that, otherwise
 661                          * it'll happily send us to sleep.  In any case, when
 662                          * get_chip returns success we're clear to go ahead.
 663                          */
 664                         int ret = spin_trylock(contender->mutex);
 665                         spin_unlock(&shared->lock);
 666                         if (!ret)
 667                                 goto retry;
 668                         spin_unlock(chip->mutex);
 669                         ret = get_chip(map, contender, contender->start, mode);
 670                         spin_lock(chip->mutex);
 671                         if (ret) {
 672                                 spin_unlock(contender->mutex);
 673                                 return ret;
 674                         }
 675                         timeo = jiffies + HZ;
 676                         spin_lock(&shared->lock);
 677                         spin_unlock(contender->mutex);
 678                 }
 679
 680                 /* We now own it */
 681                 shared->writing = chip;
 682                 if (mode == FL_ERASING)
 683                         shared->erasing = chip;
 684                 spin_unlock(&shared->lock);
 685         }
 686
 687         switch (chip->state) {
 688
 689         case FL_STATUS:
 690                 for (;;) {
 691                         status = map_read(map, adr);
 692                         if (map_word_andequal(map, status, status_OK, status_OK))
 693                                 break;
 694
 695                         /* At this point we're fine with write operations
 696                            in other partitions as they don't conflict. */
 697                         if (chip->priv && map_word_andequal(map, status, status_PWS, status_PWS))
 698                                 break;
 699
 700                         if (time_after(jiffies, timeo)) {
 701                                 printk(KERN_ERR "%s: Waiting for chip to be ready timed out. Status %lx\n",
 702                                        map->name, status.x[0]);
 703                                 return -EIO;
 704                         }
 705                         spin_unlock(chip->mutex);
 706                         cfi_udelay(1);
 707                         spin_lock(chip->mutex);
 708                         /* Someone else might have been playing with it. */
 709                         goto retry;
 710                 }
 711
 712         case FL_READY:
 713         case FL_CFI_QUERY:
 714         case FL_JEDEC_QUERY:
 715                 return 0;
 716
 717         case FL_ERASING:
 718                 if (!cfip ||
 719                     !(cfip->FeatureSupport & 2) ||
 720                     !(mode == FL_READY || mode == FL_POINT ||
 721                      (mode == FL_WRITING && (cfip->SuspendCmdSupport & 1))))
 722                         goto sleep;
 723
 724
 725                 /* Erase suspend */
 726                 map_write(map, CMD(0xB0), adr);
 727
 728                 /* If the flash has finished erasing, then 'erase suspend'
 729                  * appears to make some (28F320) flash devices switch to
 730                  * 'read' mode.  Make sure that we switch to 'read status'
 731                  * mode so we get the right data. --rmk
 732                  */
 733                 map_write(map, CMD(0x70), adr);
 734                 chip->oldstate = FL_ERASING;
 735                 chip->state = FL_ERASE_SUSPENDING;
 736                 chip->erase_suspended = 1;
 737                 for (;;) {
 738                         status = map_read(map, adr);
 739                         if (map_word_andequal(map, status, status_OK, status_OK))
 740                                 break;
 741
 742                         if (time_after(jiffies, timeo)) {
 743                                 /* Urgh. Resume and pretend we weren't here.  */
 744                                 map_write(map, CMD(0xd0), adr);
 745                                 /* Make sure we're in 'read status' mode if it had finished */
 746                                 map_write(map, CMD(0x70), adr);
 747                                 chip->state = FL_ERASING;
 748                                 chip->oldstate = FL_READY;
 749                                 printk(KERN_ERR "%s: Chip not ready after erase "
 750                                        "suspended: status = 0x%lx\n", map->name, status.x[0]);
 751                                 return -EIO;
 752                         }
 753
 754                         spin_unlock(chip->mutex);
 755                         cfi_udelay(1);
 756                         spin_lock(chip->mutex);
 757                         /* Nobody will touch it while it's in state FL_ERASE_SUSPENDING.
 758                            So we can just loop here. */
 759                 }
 760                 chip->state = FL_STATUS;
 761                 return 0;
 762
 763         case FL_XIP_WHILE_ERASING:
 764                 if (mode != FL_READY && mode != FL_POINT &&
 765                     (mode != FL_WRITING || !cfip || !(cfip->SuspendCmdSupport&1)))
 766                         goto sleep;
 767                 chip->oldstate = chip->state;
 768                 chip->state = FL_READY;
 769                 return 0;
 770
 771         case FL_POINT:
 772                 /* Only if there's no operation suspended... */
 773                 if (mode == FL_READY && chip->oldstate == FL_READY)
 774                         return 0;
 775
 776         default:
 777         sleep:
 778                 set_current_state(TASK_UNINTERRUPTIBLE);
 779                 add_wait_queue(&chip->wq, &wait);
 780                 spin_unlock(chip->mutex);
 781                 schedule();
 782                 remove_wait_queue(&chip->wq, &wait);
 783                 spin_lock(chip->mutex);
 784                 goto resettime;
 785         }
 786 }
 787
 788 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr)
 789 {
 790         struct cfi_private *cfi = map->fldrv_priv;
 791
 792         if (chip->priv) {
 793                 struct flchip_shared *shared = chip->priv;
 794                 spin_lock(&shared->lock);
 795                 if (shared->writing == chip && chip->oldstate == FL_READY) {
 796                         /* We own the ability to write, but we're done */
 797                         shared->writing = shared->erasing;
 798                         if (shared->writing && shared->writing != chip) {
 799                                 /* give back ownership to who we loaned it from */
 800                                 struct flchip *loaner = shared->writing;
 801                                 spin_lock(loaner->mutex);
 802                                 spin_unlock(&shared->lock);
 803                                 spin_unlock(chip->mutex);
 804                                 put_chip(map, loaner, loaner->start);
 805                                 spin_lock(chip->mutex);
 806                                 spin_unlock(loaner->mutex);
 807                                 wake_up(&chip->wq);
 808                                 return;
 809                         }
 810                         shared->erasing = NULL;
 811                         shared->writing = NULL;
 812                 } else if (shared->erasing == chip && shared->writing != chip) {
 813                         /*
 814                          * We own the ability to erase without the ability
 815                          * to write, which means the erase was suspended
 816                          * and some other partition is currently writing.
 817                          * Don't let the switch below mess things up since
 818                          * we don't have ownership to resume anything.
 819                          */
 820                         spin_unlock(&shared->lock);
 821                         wake_up(&chip->wq);
 822                         return;
 823                 }
 824                 spin_unlock(&shared->lock);
 825         }
 826
 827         switch(chip->oldstate) {
 828         case FL_ERASING:
 829                 chip->state = chip->oldstate;
 830                 /* What if one interleaved chip has finished and the
 831                    other hasn't? The old code would leave the finished
 832                    one in READY mode. That's bad, and caused -EROFS
 833                    errors to be returned from do_erase_oneblock because
 834                    that's the only bit it checked for at the time.
 835                    As the state machine appears to explicitly allow
 836                    sending the 0x70 (Read Status) command to an erasing
 837                    chip and expecting it to be ignored, that's what we
 838                    do. */
 839                 map_write(map, CMD(0xd0), adr);
 840                 map_write(map, CMD(0x70), adr);
 841                 chip->oldstate = FL_READY;
 842                 chip->state = FL_ERASING;
 843                 break;
 844
 845         case FL_XIP_WHILE_ERASING:
 846                 chip->state = chip->oldstate;
 847                 chip->oldstate = FL_READY;
 848                 break;
 849
 850         case FL_READY:
 851         case FL_STATUS:
 852         case FL_JEDEC_QUERY:
 853                 /* We should really make set_vpp() count, rather than doing this */
 854                 DISABLE_VPP(map);
 855                 break;
 856         default:
 857                 printk(KERN_ERR "%s: put_chip() called with oldstate %d!!\n", map->name, chip->oldstate);
 858         }
 859         wake_up(&chip->wq);
 860 }
 861
 862 #ifdef CONFIG_MTD_XIP
 863
 864 /*
 865  * No interrupt what so ever can be serviced while the flash isn't in array
 866  * mode.  This is ensured by the xip_disable() and xip_enable() functions
 867  * enclosing any code path where the flash is known not to be in array mode.
 868  * And within a XIP disabled code path, only functions marked with __xipram
 869  * may be called and nothing else (it's a good thing to inspect generated
 870  * assembly to make sure inline functions were actually inlined and that gcc
 871  * didn't emit calls to its own support functions). Also configuring MTD CFI
 872  * support to a single buswidth and a single interleave is also recommended.
 873  */
 874
 875 static void xip_disable(struct map_info *map, struct flchip *chip,
 876                         unsigned long adr)
 877 {
 878         /* TODO: chips with no XIP use should ignore and return */
 879         (void) map_read(map, adr); /* ensure mmu mapping is up to date */
 880         local_irq_disable();
 881 }
 882
 883 static void __xipram xip_enable(struct map_info *map, struct flchip *chip,
 884                                 unsigned long adr)
 885 {
 886         struct cfi_private *cfi = map->fldrv_priv;
 887         if (chip->state != FL_POINT && chip->state != FL_READY) {
 888                 map_write(map, CMD(0xff), adr);
 889                 chip->state = FL_READY;
 890         }
 891         (void) map_read(map, adr);
 892         xip_iprefetch();
 893         local_irq_enable();
 894 }
 895
 896 /*
 897  * When a delay is required for the flash operation to complete, the
 898  * xip_wait_for_operation() function is polling for both the given timeout
 899  * and pending (but still masked) hardware interrupts.  Whenever there is an
 900  * interrupt pending then the flash erase or write operation is suspended,
 901  * array mode restored and interrupts unmasked.  Task scheduling might also
 902  * happen at that point.  The CPU eventually returns from the interrupt or
 903  * the call to schedule() and the suspended flash operation is resumed for
 904  * the remaining of the delay period.
 905  *
 906  * Warning: this function _will_ fool interrupt latency tracing tools.
 907  */
 908
 909 static int __xipram xip_wait_for_operation(
 910                 struct map_info *map, struct flchip *chip,
 911                 unsigned long adr, unsigned int chip_op_time )
 912 {
 913         struct cfi_private *cfi = map->fldrv_priv;
 914         struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
 915         map_word status, OK = CMD(0x80);
 916         unsigned long usec, suspended, start, done;
 917         flstate_t oldstate, newstate;
 918
 919         start = xip_currtime();
 920         usec = chip_op_time * 8;
 921         if (usec == 0)
 922                 usec = 500000;
 923         done = 0;
 924
 925         do {
 926                 cpu_relax();
 927                 if (xip_irqpending() && cfip &&
 928                     ((chip->state == FL_ERASING && (cfip->FeatureSupport&2)) ||
 929                      (chip->state == FL_WRITING && (cfip->FeatureSupport&4))) &&
 930                     (cfi_interleave_is_1(cfi) || chip->oldstate == FL_READY)) {
 931                         /*
 932                          * Let's suspend the erase or write operation when
 933                          * supported.  Note that we currently don't try to
 934                          * suspend interleaved chips if there is already
 935                          * another operation suspended (imagine what happens
 936                          * when one chip was already done with the current
 937                          * operation while another chip suspended it, then
 938                          * we resume the whole thing at once).  Yes, it
 939                          * can happen!
 940                          */
 941                         usec -= done;
 942                         map_write(map, CMD(0xb0), adr);
 943                         map_write(map, CMD(0x70), adr);
 944                         suspended = xip_currtime();
 945                         do {
 946                                 if (xip_elapsed_since(suspended) > 100000) {
 947                                         /*
 948                                          * The chip doesn't want to suspend
 949                                          * after waiting for 100 msecs.
 950                                          * This is a critical error but there
 951                                          * is not much we can do here.
 952                                          */
 953                                         return -EIO;
 954                                 }
 955                                 status = map_read(map, adr);
 956                         } while (!map_word_andequal(map, status, OK, OK));
 957
 958                         /* Suspend succeeded */
 959                         oldstate = chip->state;
 960                         if (oldstate == FL_ERASING) {
 961                                 if (!map_word_bitsset(map, status, CMD(0x40)))
 962                                         break;
 963                                 newstate = FL_XIP_WHILE_ERASING;
 964                                 chip->erase_suspended = 1;
 965                         } else {
 966                                 if (!map_word_bitsset(map, status, CMD(0x04)))
 967                                         break;
 968                                 newstate = FL_XIP_WHILE_WRITING;
 969                                 chip->write_suspended = 1;
 970                         }
 971                         chip->state = newstate;
 972                         map_write(map, CMD(0xff), adr);
 973                         (void) map_read(map, adr);
 974                         asm volatile (".rep 8; nop; .endr");
 975                         local_irq_enable();
 976                         spin_unlock(chip->mutex);
 977                         asm volatile (".rep 8; nop; .endr");
 978                         cond_resched();
 979
 980                         /*
 981                          * We're back.  However someone else might have
 982                          * decided to go write to the chip if we are in
 983                          * a suspended erase state.  If so let's wait
 984                          * until it's done.
 985                          */
 986                         spin_lock(chip->mutex);
 987                         while (chip->state != newstate) {
 988                                 DECLARE_WAITQUEUE(wait, current);
 989                                 set_current_state(TASK_UNINTERRUPTIBLE);
 990                                 add_wait_queue(&chip->wq, &wait);
 991                                 spin_unlock(chip->mutex);
 992                                 schedule();
 993                                 remove_wait_queue(&chip->wq, &wait);
 994                                 spin_lock(chip->mutex);
 995                         }
 996                         /* Disallow XIP again */
 997                         local_irq_disable();
 998
 999                         /* Resume the write or erase operation */
1000                         map_write(map, CMD(0xd0), adr);
1001                         map_write(map, CMD(0x70), adr);
1002                         chip->state = oldstate;
1003                         start = xip_currtime();
1004                 } else if (usec >= 1000000/HZ) {
1005                         /*
1006                          * Try to save on CPU power when waiting delay
1007                          * is at least a system timer tick period.
1008                          * No need to be extremely accurate here.
1009                          */
1010                         xip_cpu_idle();
1011                 }
1012                 status = map_read(map, adr);
1013                 done = xip_elapsed_since(start);
1014         } while (!map_word_andequal(map, status, OK, OK)
1015                  && done < usec);
1016
1017         return (done >= usec) ? -ETIME : 0;
1018 }
1019
1020 /*
1021  * The INVALIDATE_CACHED_RANGE() macro is normally used in parallel while
1022  * the flash is actively programming or erasing since we have to poll for
1023  * the operation to complete anyway.  We can't do that in a generic way with
1024  * a XIP setup so do it before the actual flash operation in this case
1025  * and stub it out from INVAL_CACHE_AND_WAIT.
1026  */
1027 #define XIP_INVAL_CACHED_RANGE(map, from, size)  \
1028         INVALIDATE_CACHED_RANGE(map, from, size)
1029
1030 #define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec) \
1031         xip_wait_for_operation(map, chip, cmd_adr, usec)
1032
1033 #else
1034
1035 #define xip_disable(map, chip, adr)
1036 #define xip_enable(map, chip, adr)
1037 #define XIP_INVAL_CACHED_RANGE(x...)
1038 #define INVAL_CACHE_AND_WAIT inval_cache_and_wait_for_operation
1039
1040 static int inval_cache_and_wait_for_operation(
1041                 struct map_info *map, struct flchip *chip,
1042                 unsigned long cmd_adr, unsigned long inval_adr, int inval_len,
1043                 unsigned int chip_op_time)
1044 {
1045         struct cfi_private *cfi = map->fldrv_priv;
1046         map_word status, status_OK = CMD(0x80);
1047         int chip_state = chip->state;
1048         unsigned int timeo, sleep_time;
1049
1050         spin_unlock(chip->mutex);
1051         if (inval_len)
1052                 INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
1053         spin_lock(chip->mutex);
1054
1055         /* set our timeout to 8 times the expected delay */
1056         timeo = chip_op_time * 8;
1057         if (!timeo)
1058                 timeo = 500000;
1059         sleep_time = chip_op_time / 2;
1060
1061         for (;;) {
1062                 status = map_read(map, cmd_adr);
1063                 if (map_word_andequal(map, status, status_OK, status_OK))
1064                         break;
1065
1066                 if (!timeo) {
1067                         map_write(map, CMD(0x70), cmd_adr);
1068                         chip->state = FL_STATUS;
1069                         return -ETIME;
1070                 }
1071
1072                 /* OK Still waiting. Drop the lock, wait a while and retry. */
1073                 spin_unlock(chip->mutex);
1074                 if (sleep_time >= 1000000/HZ) {
1075                         /*
1076                          * Half of the normal delay still remaining
1077                          * can be performed with a sleeping delay instead
1078                          * of busy waiting.
1079                          */
1080                         msleep(sleep_time/1000);
1081                         timeo -= sleep_time;
1082                         sleep_time = 1000000/HZ;
1083                 } else {
1084                         udelay(1);
1085                         cond_resched();
1086                         timeo--;
1087                 }
1088                 spin_lock(chip->mutex);
1089
1090                 if (chip->state != chip_state) {
1091                         /* Someone's suspended the operation: sleep */
1092                         DECLARE_WAITQUEUE(wait, current);
1093                         set_current_state(TASK_UNINTERRUPTIBLE);
1094                         add_wait_queue(&chip->wq, &wait);
1095                         spin_unlock(chip->mutex);
1096                         schedule();
1097                         remove_wait_queue(&chip->wq, &wait);
1098                         spin_lock(chip->mutex);
1099                 }
1100         }
1101
1102         /* Done and happy. */
1103         chip->state = FL_STATUS;
1104         return 0;
1105 }
1106
1107 #endif
1108
1109 #define WAIT_TIMEOUT(map, chip, adr, udelay) \
1110         INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay);
1111
1112
1113 static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len)
1114 {
1115         unsigned long cmd_addr;
1116         struct cfi_private *cfi = map->fldrv_priv;
1117         int ret = 0;
1118
1119         adr += chip->start;
1120
1121         /* Ensure cmd read/writes are aligned. */
1122         cmd_addr = adr & ~(map_bankwidth(map)-1);
1123
1124         spin_lock(chip->mutex);
1125
1126         ret = get_chip(map, chip, cmd_addr, FL_POINT);
1127
1128         if (!ret) {
1129                 if (chip->state != FL_POINT && chip->state != FL_READY)
1130                         map_write(map, CMD(0xff), cmd_addr);
1131
1132                 chip->state = FL_POINT;
1133                 chip->ref_point_counter++;
1134         }
1135         spin_unlock(chip->mutex);
1136
1137         return ret;
1138 }
1139
1140 static int cfi_intelext_point (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char **mtdbuf)
1141 {
1142         struct map_info *map = mtd->priv;
1143         struct cfi_private *cfi = map->fldrv_priv;
1144         unsigned long ofs;
1145         int chipnum;
1146         int ret = 0;
1147
1148         if (!map->virt || (from + len > mtd->size))
1149                 return -EINVAL;
1150
1151         *mtdbuf = (void *)map->virt + from;
1152         *retlen = 0;
1153
1154         /* Now lock the chip(s) to POINT state */
1155
1156         /* ofs: offset within the first chip that the first read should start */
1157         chipnum = (from >> cfi->chipshift);
1158         ofs = from - (chipnum << cfi->chipshift);
1159
1160         while (len) {
1161                 unsigned long thislen;
1162
1163                 if (chipnum >= cfi->numchips)
1164                         break;
1165
1166                 if ((len + ofs -1) >> cfi->chipshift)
1167                         thislen = (1<<cfi->chipshift) - ofs;
1168                 else
1169                         thislen = len;
1170
1171                 ret = do_point_onechip(map, &cfi->chips[chipnum], ofs, thislen);
1172                 if (ret)
1173                         break;
1174
1175                 *retlen += thislen;
1176                 len -= thislen;
1177
1178                 ofs = 0;
1179                 chipnum++;
1180         }
1181         return 0;
1182 }
1183
1184 static void cfi_intelext_unpoint (struct mtd_info *mtd, u_char *addr, loff_t from, size_t len)
1185 {
1186         struct map_info *map = mtd->priv;
1187         struct cfi_private *cfi = map->fldrv_priv;
1188         unsigned long ofs;
1189         int chipnum;
1190
1191         /* Now unlock the chip(s) POINT state */
1192
1193         /* ofs: offset within the first chip that the first read should start */
1194         chipnum = (from >> cfi->chipshift);
1195         ofs = from - (chipnum <<  cfi->chipshift);
1196
1197         while (len) {
1198                 unsigned long thislen;
1199                 struct flchip *chip;
1200
1201                 chip = &cfi->chips[chipnum];
1202                 if (chipnum >= cfi->numchips)
1203                         break;
1204
1205                 if ((len + ofs -1) >> cfi->chipshift)
1206                         thislen = (1<<cfi->chipshift) - ofs;
1207                 else
1208                         thislen = len;
1209
1210                 spin_lock(chip->mutex);
1211                 if (chip->state == FL_POINT) {
1212                         chip->ref_point_counter--;
1213                         if(chip->ref_point_counter == 0)
1214                                 chip->state = FL_READY;
1215                 } else
1216                         printk(KERN_ERR "%s: Warning: unpoint called on non pointed region\n", map->name); /* Should this give an error? */
1217
1218                 put_chip(map, chip, chip->start);
1219                 spin_unlock(chip->mutex);
1220
1221                 len -= thislen;
1222                 ofs = 0;
1223                 chipnum++;
1224         }
1225 }
1226
1227 static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf)
1228 {
1229         unsigned long cmd_addr;
1230         struct cfi_private *cfi = map->fldrv_priv;
1231         int ret;
1232
1233         adr += chip->start;
1234
1235         /* Ensure cmd read/writes are aligned. */
1236         cmd_addr = adr & ~(map_bankwidth(map)-1);
1237
1238         spin_lock(chip->mutex);
1239         ret = get_chip(map, chip, cmd_addr, FL_READY);
1240         if (ret) {
1241                 spin_unlock(chip->mutex);
1242                 return ret;
1243         }
1244
1245         if (chip->state != FL_POINT && chip->state != FL_READY) {
1246                 map_write(map, CMD(0xff), cmd_addr);
1247
1248                 chip->state = FL_READY;
1249         }
1250
1251         map_copy_from(map, buf, adr, len);
1252
1253         put_chip(map, chip, cmd_addr);
1254
1255         spin_unlock(chip->mutex);
1256         return 0;
1257 }
1258
1259 static int cfi_intelext_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
1260 {
1261         struct map_info *map = mtd->priv;
1262         struct cfi_private *cfi = map->fldrv_priv;
1263         unsigned long ofs;
1264         int chipnum;
1265         int ret = 0;
1266
1267         /* ofs: offset within the first chip that the first read should start */
1268         chipnum = (from >> cfi->chipshift);
1269         ofs = from - (chipnum <<  cfi->chipshift);
1270
1271         *retlen = 0;
1272
1273         while (len) {
1274                 unsigned long thislen;
1275
1276                 if (chipnum >= cfi->numchips)
1277                         break;
1278
1279                 if ((len + ofs -1) >> cfi->chipshift)
1280                         thislen = (1<<cfi->chipshift) - ofs;
1281                 else
1282                         thislen = len;
1283
1284                 ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf);
1285                 if (ret)
1286                         break;
1287
1288                 *retlen += thislen;
1289                 len -= thislen;
1290                 buf += thislen;
1291
1292                 ofs = 0;
1293                 chipnum++;
1294         }
1295         return ret;
1296 }
1297
1298 static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
1299                                      unsigned long adr, map_word datum, int mode)
1300 {
1301         struct cfi_private *cfi = map->fldrv_priv;
1302         map_word status, write_cmd;
1303         int ret=0;
1304
1305         adr += chip->start;
1306
1307         switch (mode) {
1308         case FL_WRITING:
1309                 write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0x40) : CMD(0x41);
1310                 break;
1311         case FL_OTP_WRITE:
1312                 write_cmd = CMD(0xc0);
1313                 break;
1314         default:
1315                 return -EINVAL;
1316         }
1317
1318         spin_lock(chip->mutex);
1319         ret = get_chip(map, chip, adr, mode);
1320         if (ret) {
1321                 spin_unlock(chip->mutex);
1322                 return ret;
1323         }
1324
1325         XIP_INVAL_CACHED_RANGE(map, adr, map_bankwidth(map));
1326         ENABLE_VPP(map);
1327         xip_disable(map, chip, adr);
1328         map_write(map, write_cmd, adr);
1329         map_write(map, datum, adr);
1330         chip->state = mode;
1331
1332         ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1333                                    adr, map_bankwidth(map),
1334                                    chip->word_write_time);
1335         if (ret) {
1336                 xip_enable(map, chip, adr);
1337                 printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
1338                 goto out;
1339         }
1340
1341         /* check for errors */
1342         status = map_read(map, adr);
1343         if (map_word_bitsset(map, status, CMD(0x1a))) {
1344                 unsigned long chipstatus = MERGESTATUS(status);
1345
1346                 /* reset status */
1347                 map_write(map, CMD(0x50), adr);
1348                 map_write(map, CMD(0x70), adr);
1349                 xip_enable(map, chip, adr);
1350
1351                 if (chipstatus & 0x02) {
1352                         ret = -EROFS;
1353                 } else if (chipstatus & 0x08) {
1354                         printk(KERN_ERR "%s: word write error (bad VPP)\n", map->name);
1355                         ret = -EIO;
1356                 } else {
1357                         printk(KERN_ERR "%s: word write error (status 0x%lx)\n", map->name, chipstatus);
1358                         ret = -EINVAL;
1359                 }
1360
1361                 goto out;
1362         }
1363
1364         xip_enable(map, chip, adr);
1365  out:   put_chip(map, chip, adr);
1366         spin_unlock(chip->mutex);
1367         return ret;
1368 }
1369
1370
1371 static int cfi_intelext_write_words (struct mtd_info *mtd, loff_t to , size_t len, size_t *retlen, const u_char *buf)
1372 {
1373         struct map_info *map = mtd->priv;
1374         struct cfi_private *cfi = map->fldrv_priv;
1375         int ret = 0;
1376         int chipnum;
1377         unsigned long ofs;
1378
1379         *retlen = 0;
1380         if (!len)
1381                 return 0;
1382
1383         chipnum = to >> cfi->chipshift;
1384         ofs = to  - (chipnum << cfi->chipshift);
1385
1386         /* If it's not bus-aligned, do the first byte write */
1387         if (ofs & (map_bankwidth(map)-1)) {
1388                 unsigned long bus_ofs = ofs & ~(map_bankwidth(map)-1);
1389                 int gap = ofs - bus_ofs;
1390                 int n;
1391                 map_word datum;
1392
1393                 n = min_t(int, len, map_bankwidth(map)-gap);
1394                 datum = map_word_ff(map);
1395                 datum = map_word_load_partial(map, datum, buf, gap, n);
1396
1397                 ret = do_write_oneword(map, &cfi->chips[chipnum],
1398                                                bus_ofs, datum, FL_WRITING);
1399                 if (ret)
1400                         return ret;
1401
1402                 len -= n;
1403                 ofs += n;
1404                 buf += n;
1405                 (*retlen) += n;
1406
1407                 if (ofs >> cfi->chipshift) {
1408                         chipnum ++;
1409                         ofs = 0;
1410                         if (chipnum == cfi->numchips)
1411                                 return 0;
1412                 }
1413         }
1414
1415         while(len >= map_bankwidth(map)) {
1416                 map_word datum = map_word_load(map, buf);
1417
1418                 ret = do_write_oneword(map, &cfi->chips[chipnum],
1419                                        ofs, datum, FL_WRITING);
1420                 if (ret)
1421                         return ret;
1422
1423                 ofs += map_bankwidth(map);
1424                 buf += map_bankwidth(map);
1425                 (*retlen) += map_bankwidth(map);
1426                 len -= map_bankwidth(map);
1427
1428                 if (ofs >> cfi->chipshift) {
1429                         chipnum ++;
1430                         ofs = 0;
1431                         if (chipnum == cfi->numchips)
1432                                 return 0;
1433                 }
1434         }
1435
1436         if (len & (map_bankwidth(map)-1)) {
1437                 map_word datum;
1438
1439                 datum = map_word_ff(map);
1440                 datum = map_word_load_partial(map, datum, buf, 0, len);
1441
1442                 ret = do_write_oneword(map, &cfi->chips[chipnum],
1443                                        ofs, datum, FL_WRITING);
1444                 if (ret)
1445                         return ret;
1446
1447                 (*retlen) += len;
1448         }
1449
1450         return 0;
1451 }
1452
1453
1454 static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
1455                                     unsigned long adr, const struct kvec **pvec,
1456                                     unsigned long *pvec_seek, int len)
1457 {
1458         struct cfi_private *cfi = map->fldrv_priv;
1459         map_word status, write_cmd, datum;
1460         unsigned long cmd_adr;
1461         int ret, wbufsize, word_gap, words;
1462         const struct kvec *vec;
1463         unsigned long vec_seek;
1464
1465         wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1466         adr += chip->start;
1467         cmd_adr = adr & ~(wbufsize-1);
1468
1469         /* Let's determine this according to the interleave only once */
1470         write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0xe8) : CMD(0xe9);
1471
1472         spin_lock(chip->mutex);
1473         ret = get_chip(map, chip, cmd_adr, FL_WRITING);
1474         if (ret) {
1475                 spin_unlock(chip->mutex);
1476                 return ret;
1477         }
1478
1479         XIP_INVAL_CACHED_RANGE(map, adr, len);
1480         ENABLE_VPP(map);
1481         xip_disable(map, chip, cmd_adr);
1482
1483         /* §4.8 of the 28FxxxJ3A datasheet says "Any time SR.4 and/or SR.5 is set
1484            [...], the device will not accept any more Write to Buffer commands".
1485            So we must check here and reset those bits if they're set. Otherwise
1486            we're just pissing in the wind */
1487         if (chip->state != FL_STATUS) {
1488                 map_write(map, CMD(0x70), cmd_adr);
1489                 chip->state = FL_STATUS;
1490         }
1491         status = map_read(map, cmd_adr);
1492         if (map_word_bitsset(map, status, CMD(0x30))) {
1493                 xip_enable(map, chip, cmd_adr);
1494                 printk(KERN_WARNING "SR.4 or SR.5 bits set in buffer write (status %lx). Clearing.\n", status.x[0]);
1495                 xip_disable(map, chip, cmd_adr);
1496                 map_write(map, CMD(0x50), cmd_adr);
1497                 map_write(map, CMD(0x70), cmd_adr);
1498         }
1499
1500         chip->state = FL_WRITING_TO_BUFFER;
1501         map_write(map, write_cmd, cmd_adr);
1502         ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0);
1503         if (ret) {
1504                 /* Argh. Not ready for write to buffer */
1505                 map_word Xstatus = map_read(map, cmd_adr);
1506                 map_write(map, CMD(0x70), cmd_adr);
1507                 chip->state = FL_STATUS;
1508                 status = map_read(map, cmd_adr);
1509                 map_write(map, CMD(0x50), cmd_adr);
1510                 map_write(map, CMD(0x70), cmd_adr);
1511                 xip_enable(map, chip, cmd_adr);
1512                 printk(KERN_ERR "%s: Chip not ready for buffer write. Xstatus = %lx, status = %lx\n",
1513                                 map->name, Xstatus.x[0], status.x[0]);
1514                 goto out;
1515         }
1516
1517         /* Figure out the number of words to write */
1518         word_gap = (-adr & (map_bankwidth(map)-1));
1519         words = (len - word_gap + map_bankwidth(map) - 1) / map_bankwidth(map);
1520         if (!word_gap) {
1521                 words--;
1522         } else {
1523                 word_gap = map_bankwidth(map) - word_gap;
1524                 adr -= word_gap;
1525                 datum = map_word_ff(map);
1526         }
1527
1528         /* Write length of data to come */
1529         map_write(map, CMD(words), cmd_adr );
1530
1531         /* Write data */
1532         vec = *pvec;
1533         vec_seek = *pvec_seek;
1534         do {
1535                 int n = map_bankwidth(map) - word_gap;
1536                 if (n > vec->iov_len - vec_seek)
1537                         n = vec->iov_len - vec_seek;
1538                 if (n > len)
1539                         n = len;
1540
1541                 if (!word_gap && len < map_bankwidth(map))
1542                         datum = map_word_ff(map);
1543
1544                 datum = map_word_load_partial(map, datum,
1545                                               vec->iov_base + vec_seek,
1546                                               word_gap, n);
1547
1548                 len -= n;
1549                 word_gap += n;
1550                 if (!len || word_gap == map_bankwidth(map)) {
1551                         map_write(map, datum, adr);
1552                         adr += map_bankwidth(map);
1553                         word_gap = 0;
1554                 }
1555
1556                 vec_seek += n;
1557                 if (vec_seek == vec->iov_len) {
1558                         vec++;
1559                         vec_seek = 0;
1560                 }
1561         } while (len);
1562         *pvec = vec;
1563         *pvec_seek = vec_seek;
1564
1565         /* GO GO GO */
1566         map_write(map, CMD(0xd0), cmd_adr);
1567         chip->state = FL_WRITING;
1568
1569         ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
1570                                    adr, len,
1571                                    chip->buffer_write_time);
1572         if (ret) {
1573                 map_write(map, CMD(0x70), cmd_adr);
1574                 chip->state = FL_STATUS;
1575                 xip_enable(map, chip, cmd_adr);
1576                 printk(KERN_ERR "%s: buffer write error (status timeout)\n", map->name);
1577                 goto out;
1578         }
1579
1580         /* check for errors */
1581         status = map_read(map, cmd_adr);
1582         if (map_word_bitsset(map, status, CMD(0x1a))) {
1583                 unsigned long chipstatus = MERGESTATUS(status);
1584
1585                 /* reset status */
1586                 map_write(map, CMD(0x50), cmd_adr);
1587                 map_write(map, CMD(0x70), cmd_adr);
1588                 xip_enable(map, chip, cmd_adr);
1589
1590                 if (chipstatus & 0x02) {
1591                         ret = -EROFS;
1592                 } else if (chipstatus & 0x08) {
1593                         printk(KERN_ERR "%s: buffer write error (bad VPP)\n", map->name);
1594                         ret = -EIO;
1595                 } else {
1596                         printk(KERN_ERR "%s: buffer write error (status 0x%lx)\n", map->name, chipstatus);
1597                         ret = -EINVAL;
1598                 }
1599
1600                 goto out;
1601         }
1602
1603         xip_enable(map, chip, cmd_adr);
1604  out:   put_chip(map, chip, cmd_adr);
1605         spin_unlock(chip->mutex);
1606         return ret;
1607 }
1608
1609 static int cfi_intelext_writev (struct mtd_info *mtd, const struct kvec *vecs,
1610                                 unsigned long count, loff_t to, size_t *retlen)
1611 {
1612         struct map_info *map = mtd->priv;
1613         struct cfi_private *cfi = map->fldrv_priv;
1614         int wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1615         int ret = 0;
1616         int chipnum;
1617         unsigned long ofs, vec_seek, i;
1618         size_t len = 0;
1619
1620         for (i = 0; i < count; i++)
1621                 len += vecs[i].iov_len;
1622
1623         *retlen = 0;
1624         if (!len)
1625                 return 0;
1626
1627         chipnum = to >> cfi->chipshift;
1628         ofs = to - (chipnum << cfi->chipshift);
1629         vec_seek = 0;
1630
1631         do {
1632                 /* We must not cross write block boundaries */
1633                 int size = wbufsize - (ofs & (wbufsize-1));
1634
1635                 if (size > len)
1636                         size = len;
1637                 ret = do_write_buffer(map, &cfi->chips[chipnum],
1638                                       ofs, &vecs, &vec_seek, size);
1639                 if (ret)
1640                         return ret;
1641
1642                 ofs += size;
1643                 (*retlen) += size;
1644                 len -= size;
1645
1646                 if (ofs >> cfi->chipshift) {
1647                         chipnum ++;
1648                         ofs = 0;
1649                         if (chipnum == cfi->numchips)
1650                                 return 0;
1651                 }
1652
1653                 /* Be nice and reschedule with the chip in a usable state for other
1654                    processes. */
1655                 cond_resched();
1656
1657         } while (len);
1658
1659         return 0;
1660 }
1661
1662 static int cfi_intelext_write_buffers (struct mtd_info *mtd, loff_t to,
1663                                        size_t len, size_t *retlen, const u_char *buf)
1664 {
1665         struct kvec vec;
1666
1667         vec.iov_base = (void *) buf;
1668         vec.iov_len = len;
1669
1670         return cfi_intelext_writev(mtd, &vec, 1, to, retlen);
1671 }
1672
1673 static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
1674                                       unsigned long adr, int len, void *thunk)
1675 {
1676         struct cfi_private *cfi = map->fldrv_priv;
1677         map_word status;
1678         int retries = 3;
1679         int ret;
1680
1681         adr += chip->start;
1682
1683  retry:
1684         spin_lock(chip->mutex);
1685         ret = get_chip(map, chip, adr, FL_ERASING);
1686         if (ret) {
1687                 spin_unlock(chip->mutex);
1688                 return ret;
1689         }
1690
1691         XIP_INVAL_CACHED_RANGE(map, adr, len);
1692         ENABLE_VPP(map);
1693         xip_disable(map, chip, adr);
1694
1695         /* Clear the status register first */
1696         map_write(map, CMD(0x50), adr);
1697
1698         /* Now erase */
1699         map_write(map, CMD(0x20), adr);
1700         map_write(map, CMD(0xD0), adr);
1701         chip->state = FL_ERASING;
1702         chip->erase_suspended = 0;
1703
1704         ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1705                                    adr, len,
1706                                    chip->erase_time);
1707         if (ret) {
1708                 map_write(map, CMD(0x70), adr);
1709                 chip->state = FL_STATUS;
1710                 xip_enable(map, chip, adr);
1711                 printk(KERN_ERR "%s: block erase error: (status timeout)\n", map->name);
1712                 goto out;
1713         }
1714
1715         /* We've broken this before. It doesn't hurt to be safe */
1716         map_write(map, CMD(0x70), adr);
1717         chip->state = FL_STATUS;
1718         status = map_read(map, adr);
1719
1720         /* check for errors */
1721         if (map_word_bitsset(map, status, CMD(0x3a))) {
1722                 unsigned long chipstatus = MERGESTATUS(status);
1723
1724                 /* Reset the error bits */
1725                 map_write(map, CMD(0x50), adr);
1726                 map_write(map, CMD(0x70), adr);
1727                 xip_enable(map, chip, adr);
1728
1729                 if ((chipstatus & 0x30) == 0x30) {
1730                         printk(KERN_ERR "%s: block erase error: (bad command sequence, status 0x%lx)\n", map->name, chipstatus);
1731                         ret = -EINVAL;
1732                 } else if (chipstatus & 0x02) {
1733                         /* Protection bit set */
1734                         ret = -EROFS;
1735                 } else if (chipstatus & 0x8) {
1736                         /* Voltage */
1737                         printk(KERN_ERR "%s: block erase error: (bad VPP)\n", map->name);
1738                         ret = -EIO;
1739                 } else if (chipstatus & 0x20 && retries--) {
1740                         printk(KERN_DEBUG "block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr, chipstatus);
1741                         put_chip(map, chip, adr);
1742                         spin_unlock(chip->mutex);
1743                         goto retry;
1744                 } else {
1745                         printk(KERN_ERR "%s: block erase failed at 0x%08lx (status 0x%lx)\n", map->name, adr, chipstatus);
1746                         ret = -EIO;
1747                 }
1748
1749                 goto out;
1750         }
1751
1752         xip_enable(map, chip, adr);
1753  out:   put_chip(map, chip, adr);
1754         spin_unlock(chip->mutex);
1755         return ret;
1756 }
1757
1758 int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
1759 {
1760         unsigned long ofs, len;
1761         int ret;
1762
1763         ofs = instr->addr;
1764         len = instr->len;
1765
1766         ret = cfi_varsize_frob(mtd, do_erase_oneblock, ofs, len, NULL);
1767         if (ret)
1768                 return ret;
1769
1770         instr->state = MTD_ERASE_DONE;
1771         mtd_erase_callback(instr);
1772
1773         return 0;
1774 }
1775
1776 static void cfi_intelext_sync (struct mtd_info *mtd)
1777 {
1778         struct map_info *map = mtd->priv;
1779         struct cfi_private *cfi = map->fldrv_priv;
1780         int i;
1781         struct flchip *chip;
1782         int ret = 0;
1783
1784         for (i=0; !ret && i<cfi->numchips; i++) {
1785                 chip = &cfi->chips[i];
1786
1787                 spin_lock(chip->mutex);
1788                 ret = get_chip(map, chip, chip->start, FL_SYNCING);
1789
1790                 if (!ret) {
1791                         chip->oldstate = chip->state;
1792                         chip->state = FL_SYNCING;
1793                         /* No need to wake_up() on this state change -
1794                          * as the whole point is that nobody can do anything
1795                          * with the chip now anyway.
1796                          */
1797                 }
1798                 spin_unlock(chip->mutex);
1799         }
1800
1801         /* Unlock the chips again */
1802
1803         for (i--; i >=0; i--) {
1804                 chip = &cfi->chips[i];
1805
1806                 spin_lock(chip->mutex);
1807
1808                 if (chip->state == FL_SYNCING) {
1809                         chip->state = chip->oldstate;
1810                         chip->oldstate = FL_READY;
1811                         wake_up(&chip->wq);
1812                 }
1813                 spin_unlock(chip->mutex);
1814         }
1815 }
1816
1817 #ifdef DEBUG_LOCK_BITS
1818 static int __xipram do_printlockstatus_oneblock(struct map_info *map,
1819                                                 struct flchip *chip,
1820                                                 unsigned long adr,
1821                                                 int len, void *thunk)
1822 {
1823         struct cfi_private *cfi = map->fldrv_priv;
1824         int status, ofs_factor = cfi->interleave * cfi->device_type;
1825
1826         adr += chip->start;
1827         xip_disable(map, chip, adr+(2*ofs_factor));
1828         map_write(map, CMD(0x90), adr+(2*ofs_factor));
1829         chip->state = FL_JEDEC_QUERY;
1830         status = cfi_read_query(map, adr+(2*ofs_factor));
1831         xip_enable(map, chip, 0);
1832         printk(KERN_DEBUG "block status register for 0x%08lx is %x\n",
1833                adr, status);
1834         return 0;
1835 }
1836 #endif
1837
1838 #define DO_XXLOCK_ONEBLOCK_LOCK         ((void *) 1)
1839 #define DO_XXLOCK_ONEBLOCK_UNLOCK       ((void *) 2)
1840
1841 static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip,
1842                                        unsigned long adr, int len, void *thunk)
1843 {
1844         struct cfi_private *cfi = map->fldrv_priv;
1845         struct cfi_pri_intelext *extp = cfi->cmdset_priv;
1846         int udelay;
1847         int ret;
1848
1849         adr += chip->start;
1850
1851         spin_lock(chip->mutex);
1852         ret = get_chip(map, chip, adr, FL_LOCKING);
1853         if (ret) {
1854                 spin_unlock(chip->mutex);
1855                 return ret;
1856         }
1857
1858         ENABLE_VPP(map);
1859         xip_disable(map, chip, adr);
1860
1861         map_write(map, CMD(0x60), adr);
1862         if (thunk == DO_XXLOCK_ONEBLOCK_LOCK) {
1863                 map_write(map, CMD(0x01), adr);
1864                 chip->state = FL_LOCKING;
1865         } else if (thunk == DO_XXLOCK_ONEBLOCK_UNLOCK) {
1866                 map_write(map, CMD(0xD0), adr);
1867                 chip->state = FL_UNLOCKING;
1868         } else
1869                 BUG();
1870
1871         /*
1872          * If Instant Individual Block Locking supported then no need
1873          * to delay.
1874          */
1875         udelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1000000/HZ : 0;
1876
1877         ret = WAIT_TIMEOUT(map, chip, adr, udelay);
1878         if (ret) {
1879                 map_write(map, CMD(0x70), adr);
1880                 chip->state = FL_STATUS;
1881                 xip_enable(map, chip, adr);
1882                 printk(KERN_ERR "%s: block unlock error: (status timeout)\n", map->name);
1883                 goto out;
1884         }
1885
1886         xip_enable(map, chip, adr);
1887 out:    put_chip(map, chip, adr);
1888         spin_unlock(chip->mutex);
1889         return ret;
1890 }
1891
1892 static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, size_t len)
1893 {
1894         int ret;
1895
1896 #ifdef DEBUG_LOCK_BITS
1897         printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
1898                __FUNCTION__, ofs, len);
1899         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
1900                 ofs, len, 0);
1901 #endif
1902
1903         ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
1904                 ofs, len, DO_XXLOCK_ONEBLOCK_LOCK);
1905
1906 #ifdef DEBUG_LOCK_BITS
1907         printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
1908                __FUNCTION__, ret);
1909         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
1910                 ofs, len, 0);
1911 #endif
1912
1913         return ret;
1914 }
1915
1916 static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, size_t len)
1917 {
1918         int ret;
1919
1920 #ifdef DEBUG_LOCK_BITS
1921         printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
1922                __FUNCTION__, ofs, len);
1923         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
1924                 ofs, len, 0);
1925 #endif
1926
1927         ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
1928                                         ofs, len, DO_XXLOCK_ONEBLOCK_UNLOCK);
1929
1930 #ifdef DEBUG_LOCK_BITS
1931         printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
1932                __FUNCTION__, ret);
1933         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
1934                 ofs, len, 0);
1935 #endif
1936
1937         return ret;
1938 }
1939
1940 #ifdef CONFIG_MTD_OTP
1941
1942 typedef int (*otp_op_t)(struct map_info *map, struct flchip *chip,
1943                         u_long data_offset, u_char *buf, u_int size,
1944                         u_long prot_offset, u_int groupno, u_int groupsize);
1945
1946 static int __xipram
1947 do_otp_read(struct map_info *map, struct flchip *chip, u_long offset,
1948             u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
1949 {
1950         struct cfi_private *cfi = map->fldrv_priv;
1951         int ret;
1952
1953         spin_lock(chip->mutex);
1954         ret = get_chip(map, chip, chip->start, FL_JEDEC_QUERY);
1955         if (ret) {
1956                 spin_unlock(chip->mutex);
1957                 return ret;
1958         }
1959
1960         /* let's ensure we're not reading back cached data from array mode */
1961         INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
1962
1963         xip_disable(map, chip, chip->start);
1964         if (chip->state != FL_JEDEC_QUERY) {
1965                 map_write(map, CMD(0x90), chip->start);
1966                 chip->state = FL_JEDEC_QUERY;
1967         }
1968         map_copy_from(map, buf, chip->start + offset, size);
1969         xip_enable(map, chip, chip->start);
1970
1971         /* then ensure we don't keep OTP data in the cache */
1972         INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
1973
1974         put_chip(map, chip, chip->start);
1975         spin_unlock(chip->mutex);
1976         return 0;
1977 }
1978
1979 static int
1980 do_otp_write(struct map_info *map, struct flchip *chip, u_long offset,
1981              u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
1982 {
1983         int ret;
1984
1985         while (size) {
1986                 unsigned long bus_ofs = offset & ~(map_bankwidth(map)-1);
1987                 int gap = offset - bus_ofs;
1988                 int n = min_t(int, size, map_bankwidth(map)-gap);
1989                 map_word datum = map_word_ff(map);
1990
1991                 datum = map_word_load_partial(map, datum, buf, gap, n);
1992                 ret = do_write_oneword(map, chip, bus_ofs, datum, FL_OTP_WRITE);
1993                 if (ret)
1994                         return ret;
1995
1996                 offset += n;
1997                 buf += n;
1998                 size -= n;
1999         }
2000
2001         return 0;
2002 }
2003
2004 static int
2005 do_otp_lock(struct map_info *map, struct flchip *chip, u_long offset,
2006             u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2007 {
2008         struct cfi_private *cfi = map->fldrv_priv;
2009         map_word datum;
2010
2011         /* make sure area matches group boundaries */
2012         if (size != grpsz)
2013                 return -EXDEV;
2014
2015         datum = map_word_ff(map);
2016         datum = map_word_clr(map, datum, CMD(1 << grpno));
2017         return do_write_oneword(map, chip, prot, datum, FL_OTP_WRITE);
2018 }
2019
2020 static int cfi_intelext_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
2021                                  size_t *retlen, u_char *buf,
2022                                  otp_op_t action, int user_regs)
2023 {
2024         struct map_info *map = mtd->priv;
2025         struct cfi_private *cfi = map->fldrv_priv;
2026         struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2027         struct flchip *chip;
2028         struct cfi_intelext_otpinfo *otp;
2029         u_long devsize, reg_prot_offset, data_offset;
2030         u_int chip_num, chip_step, field, reg_fact_size, reg_user_size;
2031         u_int groups, groupno, groupsize, reg_fact_groups, reg_user_groups;
2032         int ret;
2033
2034         *retlen = 0;
2035
2036         /* Check that we actually have some OTP registers */
2037         if (!extp || !(extp->FeatureSupport & 64) || !extp->NumProtectionFields)
2038                 return -ENODATA;
2039
2040         /* we need real chips here not virtual ones */
2041         devsize = (1 << cfi->cfiq->DevSize) * cfi->interleave;
2042         chip_step = devsize >> cfi->chipshift;
2043         chip_num = 0;
2044
2045         /* Some chips have OTP located in the _top_ partition only.
2046            For example: Intel 28F256L18T (T means top-parameter device) */
2047         if (cfi->mfr == MANUFACTURER_INTEL) {
2048                 switch (cfi->id) {
2049                 case 0x880b:
2050                 case 0x880c:
2051                 case 0x880d:
2052                         chip_num = chip_step - 1;
2053                 }
2054         }
2055
2056         for ( ; chip_num < cfi->numchips; chip_num += chip_step) {
2057                 chip = &cfi->chips[chip_num];
2058                 otp = (struct cfi_intelext_otpinfo *)&extp->extra[0];
2059
2060                 /* first OTP region */
2061                 field = 0;
2062                 reg_prot_offset = extp->ProtRegAddr;
2063                 reg_fact_groups = 1;
2064                 reg_fact_size = 1 << extp->FactProtRegSize;
2065                 reg_user_groups = 1;
2066                 reg_user_size = 1 << extp->UserProtRegSize;
2067
2068                 while (len > 0) {
2069                         /* flash geometry fixup */
2070                         data_offset = reg_prot_offset + 1;
2071                         data_offset *= cfi->interleave * cfi->device_type;
2072                         reg_prot_offset *= cfi->interleave * cfi->device_type;
2073                         reg_fact_size *= cfi->interleave;
2074                         reg_user_size *= cfi->interleave;
2075
2076                         if (user_regs) {
2077                                 groups = reg_user_groups;
2078                                 groupsize = reg_user_size;
2079                                 /* skip over factory reg area */
2080                                 groupno = reg_fact_groups;
2081                                 data_offset += reg_fact_groups * reg_fact_size;
2082                         } else {
2083                                 groups = reg_fact_groups;
2084                                 groupsize = reg_fact_size;
2085                                 groupno = 0;
2086                         }
2087
2088                         while (len > 0 && groups > 0) {
2089                                 if (!action) {
2090                                         /*
2091                                          * Special case: if action is NULL
2092                                          * we fill buf with otp_info records.
2093                                          */
2094                                         struct otp_info *otpinfo;
2095                                         map_word lockword;
2096                                         len -= sizeof(struct otp_info);
2097                                         if (len <= 0)
2098                                                 return -ENOSPC;
2099                                         ret = do_otp_read(map, chip,
2100                                                           reg_prot_offset,
2101                                                           (u_char *)&lockword,
2102                                                           map_bankwidth(map),
2103                                                           0, 0,  0);
2104                                         if (ret)
2105                                                 return ret;
2106                                         otpinfo = (struct otp_info *)buf;
2107                                         otpinfo->start = from;
2108                                         otpinfo->length = groupsize;
2109                                         otpinfo->locked =
2110                                            !map_word_bitsset(map, lockword,
2111                                                              CMD(1 << groupno));
2112                                         from += groupsize;
2113                                         buf += sizeof(*otpinfo);
2114                                         *retlen += sizeof(*otpinfo);
2115                                 } else if (from >= groupsize) {
2116                                         from -= groupsize;
2117                                         data_offset += groupsize;
2118                                 } else {
2119                                         int size = groupsize;
2120                                         data_offset += from;
2121                                         size -= from;
2122                                         from = 0;
2123                                         if (size > len)
2124                                                 size = len;
2125                                         ret = action(map, chip, data_offset,
2126                                                      buf, size, reg_prot_offset,
2127                                                      groupno, groupsize);
2128                                         if (ret < 0)
2129                                                 return ret;
2130                                         buf += size;
2131                                         len -= size;
2132                                         *retlen += size;
2133                                         data_offset += size;
2134                                 }
2135                                 groupno++;
2136                                 groups--;
2137                         }
2138
2139                         /* next OTP region */
2140                         if (++field == extp->NumProtectionFields)
2141                                 break;
2142                         reg_prot_offset = otp->ProtRegAddr;
2143                         reg_fact_groups = otp->FactGroups;
2144                         reg_fact_size = 1 << otp->FactProtRegSize;
2145                         reg_user_groups = otp->UserGroups;
2146                         reg_user_size = 1 << otp->UserProtRegSize;
2147                         otp++;
2148                 }
2149         }
2150
2151         return 0;
2152 }
2153
2154 static int cfi_intelext_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
2155                                            size_t len, size_t *retlen,
2156                                             u_char *buf)
2157 {
2158         return cfi_intelext_otp_walk(mtd, from, len, retlen,
2159                                      buf, do_otp_read, 0);
2160 }
2161
2162 static int cfi_intelext_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
2163                                            size_t len, size_t *retlen,
2164                                             u_char *buf)
2165 {
2166         return cfi_intelext_otp_walk(mtd, from, len, retlen,
2167                                      buf, do_otp_read, 1);
2168 }
2169
2170 static int cfi_intelext_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
2171                                             size_t len, size_t *retlen,
2172                                              u_char *buf)
2173 {
2174         return cfi_intelext_otp_walk(mtd, from, len, retlen,
2175                                      buf, do_otp_write, 1);
2176 }
2177
2178 static int cfi_intelext_lock_user_prot_reg(struct mtd_info *mtd,
2179                                            loff_t from, size_t len)
2180 {
2181         size_t retlen;
2182         return cfi_intelext_otp_walk(mtd, from, len, &retlen,
2183                                      NULL, do_otp_lock, 1);
2184 }
2185
2186 static int cfi_intelext_get_fact_prot_info(struct mtd_info *mtd,
2187                                            struct otp_info *buf, size_t len)
2188 {
2189         size_t retlen;
2190         int ret;
2191
2192         ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 0);
2193         return ret ? : retlen;
2194 }
2195
2196 static int cfi_intelext_get_user_prot_info(struct mtd_info *mtd,
2197                                            struct otp_info *buf, size_t len)
2198 {
2199         size_t retlen;
2200         int ret;
2201
2202         ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 1);
2203         return ret ? : retlen;
2204 }
2205
2206 #endif
2207
2208 static int cfi_intelext_suspend(struct mtd_info *mtd)
2209 {
2210         struct map_info *map = mtd->priv;
2211         struct cfi_private *cfi = map->fldrv_priv;
2212         int i;
2213         struct flchip *chip;
2214         int ret = 0;
2215
2216         for (i=0; !ret && i<cfi->numchips; i++) {
2217                 chip = &cfi->chips[i];
2218
2219                 spin_lock(chip->mutex);
2220
2221                 switch (chip->state) {
2222                 case FL_READY:
2223                 case FL_STATUS:
2224                 case FL_CFI_QUERY:
2225                 case FL_JEDEC_QUERY:
2226                         if (chip->oldstate == FL_READY) {
2227                                 chip->oldstate = chip->state;
2228                                 chip->state = FL_PM_SUSPENDED;
2229                                 /* No need to wake_up() on this state change -
2230                                  * as the whole point is that nobody can do anything
2231                                  * with the chip now anyway.
2232                                  */
2233                         } else {
2234                                 /* There seems to be an operation pending. We must wait for it. */
2235                                 printk(KERN_NOTICE "Flash device refused suspend due to pending operation (oldstate %d)\n", chip->oldstate);
2236                                 ret = -EAGAIN;
2237                         }
2238                         break;
2239                 default:
2240                         /* Should we actually wait? Once upon a time these routines weren't
2241                            allowed to. Or should we return -EAGAIN, because the upper layers
2242                            ought to have already shut down anything which was using the device
2243                            anyway? The latter for now. */
2244                         printk(KERN_NOTICE "Flash device refused suspend due to active operation (state %d)\n", chip->oldstate);
2245                         ret = -EAGAIN;
2246                 case FL_PM_SUSPENDED:
2247                         break;
2248                 }
2249                 spin_unlock(chip->mutex);
2250         }
2251
2252         /* Unlock the chips again */
2253
2254         if (ret) {
2255                 for (i--; i >=0; i--) {
2256                         chip = &cfi->chips[i];
2257
2258                         spin_lock(chip->mutex);
2259
2260                         if (chip->state == FL_PM_SUSPENDED) {
2261                                 /* No need to force it into a known state here,
2262                                    because we're returning failure, and it didn't
2263                                    get power cycled */
2264                                 chip->state = chip->oldstate;
2265                                 chip->oldstate = FL_READY;
2266                                 wake_up(&chip->wq);
2267                         }
2268                         spin_unlock(chip->mutex);
2269                 }
2270         }
2271
2272         return ret;
2273 }
2274
2275 static void cfi_intelext_resume(struct mtd_info *mtd)
2276 {
2277         struct map_info *map = mtd->priv;
2278         struct cfi_private *cfi = map->fldrv_priv;
2279         int i;
2280         struct flchip *chip;
2281
2282         for (i=0; i<cfi->numchips; i++) {
2283
2284                 chip = &cfi->chips[i];
2285
2286                 spin_lock(chip->mutex);
2287
2288                 /* Go to known state. Chip may have been power cycled */
2289                 if (chip->state == FL_PM_SUSPENDED) {
2290                         map_write(map, CMD(0xFF), cfi->chips[i].start);
2291                         chip->oldstate = chip->state = FL_READY;
2292                         wake_up(&chip->wq);
2293                 }
2294
2295                 spin_unlock(chip->mutex);
2296         }
2297 }
2298
2299 static int cfi_intelext_reset(struct mtd_info *mtd)
2300 {
2301         struct map_info *map = mtd->priv;
2302         struct cfi_private *cfi = map->fldrv_priv;
2303         int i, ret;
2304
2305         for (i=0; i < cfi->numchips; i++) {
2306                 struct flchip *chip = &cfi->chips[i];
2307
2308                 /* force the completion of any ongoing operation
2309                    and switch to array mode so any bootloader in
2310                    flash is accessible for soft reboot. */
2311                 spin_lock(chip->mutex);
2312                 ret = get_chip(map, chip, chip->start, FL_SYNCING);
2313                 if (!ret) {
2314                         map_write(map, CMD(0xff), chip->start);
2315                         chip->state = FL_READY;
2316                 }
2317                 spin_unlock(chip->mutex);
2318         }
2319
2320         return 0;
2321 }
2322
2323 static int cfi_intelext_reboot(struct notifier_block *nb, unsigned long val,
2324                                void *v)
2325 {
2326         struct mtd_info *mtd;
2327
2328         mtd = container_of(nb, struct mtd_info, reboot_notifier);
2329         cfi_intelext_reset(mtd);
2330         return NOTIFY_DONE;
2331 }
2332
2333 static void cfi_intelext_destroy(struct mtd_info *mtd)
2334 {
2335         struct map_info *map = mtd->priv;
2336         struct cfi_private *cfi = map->fldrv_priv;
2337         cfi_intelext_reset(mtd);
2338         unregister_reboot_notifier(&mtd->reboot_notifier);
2339         kfree(cfi->cmdset_priv);
2340         kfree(cfi->cfiq);
2341         kfree(cfi->chips[0].priv);
2342         kfree(cfi);
2343         kfree(mtd->eraseregions);
2344 }
2345
2346 MODULE_LICENSE("GPL");
2347 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
2348 MODULE_DESCRIPTION("MTD chip driver for Intel/Sharp flash chips");
2349 MODULE_ALIAS("cfi_cmdset_0003");
2350 MODULE_ALIAS("cfi_cmdset_0200");