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