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