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
1508         wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1509         adr += chip->start;
1510         cmd_adr = adr & ~(wbufsize-1);
1511
1512         /* Let's determine this according to the interleave only once */
1513         write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0xe8) : CMD(0xe9);
1514
1515         spin_lock(chip->mutex);
1516         ret = get_chip(map, chip, cmd_adr, FL_WRITING);
1517         if (ret) {
1518                 spin_unlock(chip->mutex);
1519                 return ret;
1520         }
1521
1522         XIP_INVAL_CACHED_RANGE(map, adr, len);
1523         ENABLE_VPP(map);
1524         xip_disable(map, chip, cmd_adr);
1525
1526         /* §4.8 of the 28FxxxJ3A datasheet says "Any time SR.4 and/or SR.5 is set
1527            [...], the device will not accept any more Write to Buffer commands".
1528            So we must check here and reset those bits if they're set. Otherwise
1529            we're just pissing in the wind */
1530         if (chip->state != FL_STATUS) {
1531                 map_write(map, CMD(0x70), cmd_adr);
1532                 chip->state = FL_STATUS;
1533         }
1534         status = map_read(map, cmd_adr);
1535         if (map_word_bitsset(map, status, CMD(0x30))) {
1536                 xip_enable(map, chip, cmd_adr);
1537                 printk(KERN_WARNING "SR.4 or SR.5 bits set in buffer write (status %lx). Clearing.\n", status.x[0]);
1538                 xip_disable(map, chip, cmd_adr);
1539                 map_write(map, CMD(0x50), cmd_adr);
1540                 map_write(map, CMD(0x70), cmd_adr);
1541         }
1542
1543         chip->state = FL_WRITING_TO_BUFFER;
1544         map_write(map, write_cmd, cmd_adr);
1545         ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0);
1546         if (ret) {
1547                 /* Argh. Not ready for write to buffer */
1548                 map_word Xstatus = map_read(map, cmd_adr);
1549                 map_write(map, CMD(0x70), cmd_adr);
1550                 chip->state = FL_STATUS;
1551                 status = map_read(map, cmd_adr);
1552                 map_write(map, CMD(0x50), cmd_adr);
1553                 map_write(map, CMD(0x70), cmd_adr);
1554                 xip_enable(map, chip, cmd_adr);
1555                 printk(KERN_ERR "%s: Chip not ready for buffer write. Xstatus = %lx, status = %lx\n",
1556                                 map->name, Xstatus.x[0], status.x[0]);
1557                 goto out;
1558         }
1559
1560         /* Figure out the number of words to write */
1561         word_gap = (-adr & (map_bankwidth(map)-1));
1562         words = (len - word_gap + map_bankwidth(map) - 1) / map_bankwidth(map);
1563         if (!word_gap) {
1564                 words--;
1565         } else {
1566                 word_gap = map_bankwidth(map) - word_gap;
1567                 adr -= word_gap;
1568                 datum = map_word_ff(map);
1569         }
1570
1571         /* Write length of data to come */
1572         map_write(map, CMD(words), cmd_adr );
1573
1574         /* Write data */
1575         vec = *pvec;
1576         vec_seek = *pvec_seek;
1577         do {
1578                 int n = map_bankwidth(map) - word_gap;
1579                 if (n > vec->iov_len - vec_seek)
1580                         n = vec->iov_len - vec_seek;
1581                 if (n > len)
1582                         n = len;
1583
1584                 if (!word_gap && len < map_bankwidth(map))
1585                         datum = map_word_ff(map);
1586
1587                 datum = map_word_load_partial(map, datum,
1588                                               vec->iov_base + vec_seek,
1589                                               word_gap, n);
1590
1591                 len -= n;
1592                 word_gap += n;
1593                 if (!len || word_gap == map_bankwidth(map)) {
1594                         map_write(map, datum, adr);
1595                         adr += map_bankwidth(map);
1596                         word_gap = 0;
1597                 }
1598
1599                 vec_seek += n;
1600                 if (vec_seek == vec->iov_len) {
1601                         vec++;
1602                         vec_seek = 0;
1603                 }
1604         } while (len);
1605         *pvec = vec;
1606         *pvec_seek = vec_seek;
1607
1608         /* GO GO GO */
1609         map_write(map, CMD(0xd0), cmd_adr);
1610         chip->state = FL_WRITING;
1611
1612         ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
1613                                    adr, len,
1614                                    chip->buffer_write_time);
1615         if (ret) {
1616                 map_write(map, CMD(0x70), cmd_adr);
1617                 chip->state = FL_STATUS;
1618                 xip_enable(map, chip, cmd_adr);
1619                 printk(KERN_ERR "%s: buffer write error (status timeout)\n", map->name);
1620                 goto out;
1621         }
1622
1623         /* check for errors */
1624         status = map_read(map, cmd_adr);
1625         if (map_word_bitsset(map, status, CMD(0x1a))) {
1626                 unsigned long chipstatus = MERGESTATUS(status);
1627
1628                 /* reset status */
1629                 map_write(map, CMD(0x50), cmd_adr);
1630                 map_write(map, CMD(0x70), cmd_adr);
1631                 xip_enable(map, chip, cmd_adr);
1632
1633                 if (chipstatus & 0x02) {
1634                         ret = -EROFS;
1635                 } else if (chipstatus & 0x08) {
1636                         printk(KERN_ERR "%s: buffer write error (bad VPP)\n", map->name);
1637                         ret = -EIO;
1638                 } else {
1639                         printk(KERN_ERR "%s: buffer write error (status 0x%lx)\n", map->name, chipstatus);
1640                         ret = -EINVAL;
1641                 }
1642
1643                 goto out;
1644         }
1645
1646         xip_enable(map, chip, cmd_adr);
1647  out:   put_chip(map, chip, cmd_adr);
1648         spin_unlock(chip->mutex);
1649         return ret;
1650 }
1651
1652 static int cfi_intelext_writev (struct mtd_info *mtd, const struct kvec *vecs,
1653                                 unsigned long count, loff_t to, size_t *retlen)
1654 {
1655         struct map_info *map = mtd->priv;
1656         struct cfi_private *cfi = map->fldrv_priv;
1657         int wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1658         int ret = 0;
1659         int chipnum;
1660         unsigned long ofs, vec_seek, i;
1661         size_t len = 0;
1662
1663         for (i = 0; i < count; i++)
1664                 len += vecs[i].iov_len;
1665
1666         *retlen = 0;
1667         if (!len)
1668                 return 0;
1669
1670         chipnum = to >> cfi->chipshift;
1671         ofs = to - (chipnum << cfi->chipshift);
1672         vec_seek = 0;
1673
1674         do {
1675                 /* We must not cross write block boundaries */
1676                 int size = wbufsize - (ofs & (wbufsize-1));
1677
1678                 if (size > len)
1679                         size = len;
1680                 ret = do_write_buffer(map, &cfi->chips[chipnum],
1681                                       ofs, &vecs, &vec_seek, size);
1682                 if (ret)
1683                         return ret;
1684
1685                 ofs += size;
1686                 (*retlen) += size;
1687                 len -= size;
1688
1689                 if (ofs >> cfi->chipshift) {
1690                         chipnum ++;
1691                         ofs = 0;
1692                         if (chipnum == cfi->numchips)
1693                                 return 0;
1694                 }
1695
1696                 /* Be nice and reschedule with the chip in a usable state for other
1697                    processes. */
1698                 cond_resched();
1699
1700         } while (len);
1701
1702         return 0;
1703 }
1704
1705 static int cfi_intelext_write_buffers (struct mtd_info *mtd, loff_t to,
1706                                        size_t len, size_t *retlen, const u_char *buf)
1707 {
1708         struct kvec vec;
1709
1710         vec.iov_base = (void *) buf;
1711         vec.iov_len = len;
1712
1713         return cfi_intelext_writev(mtd, &vec, 1, to, retlen);
1714 }
1715
1716 static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
1717                                       unsigned long adr, int len, void *thunk)
1718 {
1719         struct cfi_private *cfi = map->fldrv_priv;
1720         map_word status;
1721         int retries = 3;
1722         int ret;
1723
1724         adr += chip->start;
1725
1726  retry:
1727         spin_lock(chip->mutex);
1728         ret = get_chip(map, chip, adr, FL_ERASING);
1729         if (ret) {
1730                 spin_unlock(chip->mutex);
1731                 return ret;
1732         }
1733
1734         XIP_INVAL_CACHED_RANGE(map, adr, len);
1735         ENABLE_VPP(map);
1736         xip_disable(map, chip, adr);
1737
1738         /* Clear the status register first */
1739         map_write(map, CMD(0x50), adr);
1740
1741         /* Now erase */
1742         map_write(map, CMD(0x20), adr);
1743         map_write(map, CMD(0xD0), adr);
1744         chip->state = FL_ERASING;
1745         chip->erase_suspended = 0;
1746
1747         ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1748                                    adr, len,
1749                                    chip->erase_time);
1750         if (ret) {
1751                 map_write(map, CMD(0x70), adr);
1752                 chip->state = FL_STATUS;
1753                 xip_enable(map, chip, adr);
1754                 printk(KERN_ERR "%s: block erase error: (status timeout)\n", map->name);
1755                 goto out;
1756         }
1757
1758         /* We've broken this before. It doesn't hurt to be safe */
1759         map_write(map, CMD(0x70), adr);
1760         chip->state = FL_STATUS;
1761         status = map_read(map, adr);
1762
1763         /* check for errors */
1764         if (map_word_bitsset(map, status, CMD(0x3a))) {
1765                 unsigned long chipstatus = MERGESTATUS(status);
1766
1767                 /* Reset the error bits */
1768                 map_write(map, CMD(0x50), adr);
1769                 map_write(map, CMD(0x70), adr);
1770                 xip_enable(map, chip, adr);
1771
1772                 if ((chipstatus & 0x30) == 0x30) {
1773                         printk(KERN_ERR "%s: block erase error: (bad command sequence, status 0x%lx)\n", map->name, chipstatus);
1774                         ret = -EINVAL;
1775                 } else if (chipstatus & 0x02) {
1776                         /* Protection bit set */
1777                         ret = -EROFS;
1778                 } else if (chipstatus & 0x8) {
1779                         /* Voltage */
1780                         printk(KERN_ERR "%s: block erase error: (bad VPP)\n", map->name);
1781                         ret = -EIO;
1782                 } else if (chipstatus & 0x20 && retries--) {
1783                         printk(KERN_DEBUG "block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr, chipstatus);
1784                         put_chip(map, chip, adr);
1785                         spin_unlock(chip->mutex);
1786                         goto retry;
1787                 } else {
1788                         printk(KERN_ERR "%s: block erase failed at 0x%08lx (status 0x%lx)\n", map->name, adr, chipstatus);
1789                         ret = -EIO;
1790                 }
1791
1792                 goto out;
1793         }
1794
1795         xip_enable(map, chip, adr);
1796  out:   put_chip(map, chip, adr);
1797         spin_unlock(chip->mutex);
1798         return ret;
1799 }
1800
1801 static int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
1802 {
1803         unsigned long ofs, len;
1804         int ret;
1805
1806         ofs = instr->addr;
1807         len = instr->len;
1808
1809         ret = cfi_varsize_frob(mtd, do_erase_oneblock, ofs, len, NULL);
1810         if (ret)
1811                 return ret;
1812
1813         instr->state = MTD_ERASE_DONE;
1814         mtd_erase_callback(instr);
1815
1816         return 0;
1817 }
1818
1819 static void cfi_intelext_sync (struct mtd_info *mtd)
1820 {
1821         struct map_info *map = mtd->priv;
1822         struct cfi_private *cfi = map->fldrv_priv;
1823         int i;
1824         struct flchip *chip;
1825         int ret = 0;
1826
1827         for (i=0; !ret && i<cfi->numchips; i++) {
1828                 chip = &cfi->chips[i];
1829
1830                 spin_lock(chip->mutex);
1831                 ret = get_chip(map, chip, chip->start, FL_SYNCING);
1832
1833                 if (!ret) {
1834                         chip->oldstate = chip->state;
1835                         chip->state = FL_SYNCING;
1836                         /* No need to wake_up() on this state change -
1837                          * as the whole point is that nobody can do anything
1838                          * with the chip now anyway.
1839                          */
1840                 }
1841                 spin_unlock(chip->mutex);
1842         }
1843
1844         /* Unlock the chips again */
1845
1846         for (i--; i >=0; i--) {
1847                 chip = &cfi->chips[i];
1848
1849                 spin_lock(chip->mutex);
1850
1851                 if (chip->state == FL_SYNCING) {
1852                         chip->state = chip->oldstate;
1853                         chip->oldstate = FL_READY;
1854                         wake_up(&chip->wq);
1855                 }
1856                 spin_unlock(chip->mutex);
1857         }
1858 }
1859
1860 static int __xipram do_getlockstatus_oneblock(struct map_info *map,
1861                                                 struct flchip *chip,
1862                                                 unsigned long adr,
1863                                                 int len, void *thunk)
1864 {
1865         struct cfi_private *cfi = map->fldrv_priv;
1866         int status, ofs_factor = cfi->interleave * cfi->device_type;
1867
1868         adr += chip->start;
1869         xip_disable(map, chip, adr+(2*ofs_factor));
1870         map_write(map, CMD(0x90), adr+(2*ofs_factor));
1871         chip->state = FL_JEDEC_QUERY;
1872         status = cfi_read_query(map, adr+(2*ofs_factor));
1873         xip_enable(map, chip, 0);
1874         return status;
1875 }
1876
1877 #ifdef DEBUG_LOCK_BITS
1878 static int __xipram do_printlockstatus_oneblock(struct map_info *map,
1879                                                 struct flchip *chip,
1880                                                 unsigned long adr,
1881                                                 int len, void *thunk)
1882 {
1883         printk(KERN_DEBUG "block status register for 0x%08lx is %x\n",
1884                adr, do_getlockstatus_oneblock(map, chip, adr, len, thunk));
1885         return 0;
1886 }
1887 #endif
1888
1889 #define DO_XXLOCK_ONEBLOCK_LOCK         ((void *) 1)
1890 #define DO_XXLOCK_ONEBLOCK_UNLOCK       ((void *) 2)
1891
1892 static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip,
1893                                        unsigned long adr, int len, void *thunk)
1894 {
1895         struct cfi_private *cfi = map->fldrv_priv;
1896         struct cfi_pri_intelext *extp = cfi->cmdset_priv;
1897         int udelay;
1898         int ret;
1899
1900         adr += chip->start;
1901
1902         spin_lock(chip->mutex);
1903         ret = get_chip(map, chip, adr, FL_LOCKING);
1904         if (ret) {
1905                 spin_unlock(chip->mutex);
1906                 return ret;
1907         }
1908
1909         ENABLE_VPP(map);
1910         xip_disable(map, chip, adr);
1911
1912         map_write(map, CMD(0x60), adr);
1913         if (thunk == DO_XXLOCK_ONEBLOCK_LOCK) {
1914                 map_write(map, CMD(0x01), adr);
1915                 chip->state = FL_LOCKING;
1916         } else if (thunk == DO_XXLOCK_ONEBLOCK_UNLOCK) {
1917                 map_write(map, CMD(0xD0), adr);
1918                 chip->state = FL_UNLOCKING;
1919         } else
1920                 BUG();
1921
1922         /*
1923          * If Instant Individual Block Locking supported then no need
1924          * to delay.
1925          */
1926         udelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1000000/HZ : 0;
1927
1928         ret = WAIT_TIMEOUT(map, chip, adr, udelay);
1929         if (ret) {
1930                 map_write(map, CMD(0x70), adr);
1931                 chip->state = FL_STATUS;
1932                 xip_enable(map, chip, adr);
1933                 printk(KERN_ERR "%s: block unlock error: (status timeout)\n", map->name);
1934                 goto out;
1935         }
1936
1937         xip_enable(map, chip, adr);
1938 out:    put_chip(map, chip, adr);
1939         spin_unlock(chip->mutex);
1940         return ret;
1941 }
1942
1943 static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, size_t len)
1944 {
1945         int ret;
1946
1947 #ifdef DEBUG_LOCK_BITS
1948         printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
1949                __FUNCTION__, ofs, len);
1950         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
1951                 ofs, len, NULL);
1952 #endif
1953
1954         ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
1955                 ofs, len, DO_XXLOCK_ONEBLOCK_LOCK);
1956
1957 #ifdef DEBUG_LOCK_BITS
1958         printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
1959                __FUNCTION__, ret);
1960         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
1961                 ofs, len, NULL);
1962 #endif
1963
1964         return ret;
1965 }
1966
1967 static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, size_t len)
1968 {
1969         int ret;
1970
1971 #ifdef DEBUG_LOCK_BITS
1972         printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
1973                __FUNCTION__, ofs, len);
1974         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
1975                 ofs, len, NULL);
1976 #endif
1977
1978         ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
1979                                         ofs, len, DO_XXLOCK_ONEBLOCK_UNLOCK);
1980
1981 #ifdef DEBUG_LOCK_BITS
1982         printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
1983                __FUNCTION__, ret);
1984         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
1985                 ofs, len, NULL);
1986 #endif
1987
1988         return ret;
1989 }
1990
1991 #ifdef CONFIG_MTD_OTP
1992
1993 typedef int (*otp_op_t)(struct map_info *map, struct flchip *chip,
1994                         u_long data_offset, u_char *buf, u_int size,
1995                         u_long prot_offset, u_int groupno, u_int groupsize);
1996
1997 static int __xipram
1998 do_otp_read(struct map_info *map, struct flchip *chip, u_long offset,
1999             u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2000 {
2001         struct cfi_private *cfi = map->fldrv_priv;
2002         int ret;
2003
2004         spin_lock(chip->mutex);
2005         ret = get_chip(map, chip, chip->start, FL_JEDEC_QUERY);
2006         if (ret) {
2007                 spin_unlock(chip->mutex);
2008                 return ret;
2009         }
2010
2011         /* let's ensure we're not reading back cached data from array mode */
2012         INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2013
2014         xip_disable(map, chip, chip->start);
2015         if (chip->state != FL_JEDEC_QUERY) {
2016                 map_write(map, CMD(0x90), chip->start);
2017                 chip->state = FL_JEDEC_QUERY;
2018         }
2019         map_copy_from(map, buf, chip->start + offset, size);
2020         xip_enable(map, chip, chip->start);
2021
2022         /* then ensure we don't keep OTP data in the cache */
2023         INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2024
2025         put_chip(map, chip, chip->start);
2026         spin_unlock(chip->mutex);
2027         return 0;
2028 }
2029
2030 static int
2031 do_otp_write(struct map_info *map, struct flchip *chip, u_long offset,
2032              u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2033 {
2034         int ret;
2035
2036         while (size) {
2037                 unsigned long bus_ofs = offset & ~(map_bankwidth(map)-1);
2038                 int gap = offset - bus_ofs;
2039                 int n = min_t(int, size, map_bankwidth(map)-gap);
2040                 map_word datum = map_word_ff(map);
2041
2042                 datum = map_word_load_partial(map, datum, buf, gap, n);
2043                 ret = do_write_oneword(map, chip, bus_ofs, datum, FL_OTP_WRITE);
2044                 if (ret)
2045                         return ret;
2046
2047                 offset += n;
2048                 buf += n;
2049                 size -= n;
2050         }
2051
2052         return 0;
2053 }
2054
2055 static int
2056 do_otp_lock(struct map_info *map, struct flchip *chip, u_long offset,
2057             u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2058 {
2059         struct cfi_private *cfi = map->fldrv_priv;
2060         map_word datum;
2061
2062         /* make sure area matches group boundaries */
2063         if (size != grpsz)
2064                 return -EXDEV;
2065
2066         datum = map_word_ff(map);
2067         datum = map_word_clr(map, datum, CMD(1 << grpno));
2068         return do_write_oneword(map, chip, prot, datum, FL_OTP_WRITE);
2069 }
2070
2071 static int cfi_intelext_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
2072                                  size_t *retlen, u_char *buf,
2073                                  otp_op_t action, int user_regs)
2074 {
2075         struct map_info *map = mtd->priv;
2076         struct cfi_private *cfi = map->fldrv_priv;
2077         struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2078         struct flchip *chip;
2079         struct cfi_intelext_otpinfo *otp;
2080         u_long devsize, reg_prot_offset, data_offset;
2081         u_int chip_num, chip_step, field, reg_fact_size, reg_user_size;
2082         u_int groups, groupno, groupsize, reg_fact_groups, reg_user_groups;
2083         int ret;
2084
2085         *retlen = 0;
2086
2087         /* Check that we actually have some OTP registers */
2088         if (!extp || !(extp->FeatureSupport & 64) || !extp->NumProtectionFields)
2089                 return -ENODATA;
2090
2091         /* we need real chips here not virtual ones */
2092         devsize = (1 << cfi->cfiq->DevSize) * cfi->interleave;
2093         chip_step = devsize >> cfi->chipshift;
2094         chip_num = 0;
2095
2096         /* Some chips have OTP located in the _top_ partition only.
2097            For example: Intel 28F256L18T (T means top-parameter device) */
2098         if (cfi->mfr == MANUFACTURER_INTEL) {
2099                 switch (cfi->id) {
2100                 case 0x880b:
2101                 case 0x880c:
2102                 case 0x880d:
2103                         chip_num = chip_step - 1;
2104                 }
2105         }
2106
2107         for ( ; chip_num < cfi->numchips; chip_num += chip_step) {
2108                 chip = &cfi->chips[chip_num];
2109                 otp = (struct cfi_intelext_otpinfo *)&extp->extra[0];
2110
2111                 /* first OTP region */
2112                 field = 0;
2113                 reg_prot_offset = extp->ProtRegAddr;
2114                 reg_fact_groups = 1;
2115                 reg_fact_size = 1 << extp->FactProtRegSize;
2116                 reg_user_groups = 1;
2117                 reg_user_size = 1 << extp->UserProtRegSize;
2118
2119                 while (len > 0) {
2120                         /* flash geometry fixup */
2121                         data_offset = reg_prot_offset + 1;
2122                         data_offset *= cfi->interleave * cfi->device_type;
2123                         reg_prot_offset *= cfi->interleave * cfi->device_type;
2124                         reg_fact_size *= cfi->interleave;
2125                         reg_user_size *= cfi->interleave;
2126
2127                         if (user_regs) {
2128                                 groups = reg_user_groups;
2129                                 groupsize = reg_user_size;
2130                                 /* skip over factory reg area */
2131                                 groupno = reg_fact_groups;
2132                                 data_offset += reg_fact_groups * reg_fact_size;
2133                         } else {
2134                                 groups = reg_fact_groups;
2135                                 groupsize = reg_fact_size;
2136                                 groupno = 0;
2137                         }
2138
2139                         while (len > 0 && groups > 0) {
2140                                 if (!action) {
2141                                         /*
2142                                          * Special case: if action is NULL
2143                                          * we fill buf with otp_info records.
2144                                          */
2145                                         struct otp_info *otpinfo;
2146                                         map_word lockword;
2147                                         len -= sizeof(struct otp_info);
2148                                         if (len <= 0)
2149                                                 return -ENOSPC;
2150                                         ret = do_otp_read(map, chip,
2151                                                           reg_prot_offset,
2152                                                           (u_char *)&lockword,
2153                                                           map_bankwidth(map),
2154                                                           0, 0,  0);
2155                                         if (ret)
2156                                                 return ret;
2157                                         otpinfo = (struct otp_info *)buf;
2158                                         otpinfo->start = from;
2159                                         otpinfo->length = groupsize;
2160                                         otpinfo->locked =
2161                                            !map_word_bitsset(map, lockword,
2162                                                              CMD(1 << groupno));
2163                                         from += groupsize;
2164                                         buf += sizeof(*otpinfo);
2165                                         *retlen += sizeof(*otpinfo);
2166                                 } else if (from >= groupsize) {
2167                                         from -= groupsize;
2168                                         data_offset += groupsize;
2169                                 } else {
2170                                         int size = groupsize;
2171                                         data_offset += from;
2172                                         size -= from;
2173                                         from = 0;
2174                                         if (size > len)
2175                                                 size = len;
2176                                         ret = action(map, chip, data_offset,
2177                                                      buf, size, reg_prot_offset,
2178                                                      groupno, groupsize);
2179                                         if (ret < 0)
2180                                                 return ret;
2181                                         buf += size;
2182                                         len -= size;
2183                                         *retlen += size;
2184                                         data_offset += size;
2185                                 }
2186                                 groupno++;
2187                                 groups--;
2188                         }
2189
2190                         /* next OTP region */
2191                         if (++field == extp->NumProtectionFields)
2192                                 break;
2193                         reg_prot_offset = otp->ProtRegAddr;
2194                         reg_fact_groups = otp->FactGroups;
2195                         reg_fact_size = 1 << otp->FactProtRegSize;
2196                         reg_user_groups = otp->UserGroups;
2197                         reg_user_size = 1 << otp->UserProtRegSize;
2198                         otp++;
2199                 }
2200         }
2201
2202         return 0;
2203 }
2204
2205 static int cfi_intelext_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
2206                                            size_t len, size_t *retlen,
2207                                             u_char *buf)
2208 {
2209         return cfi_intelext_otp_walk(mtd, from, len, retlen,
2210                                      buf, do_otp_read, 0);
2211 }
2212
2213 static int cfi_intelext_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
2214                                            size_t len, size_t *retlen,
2215                                             u_char *buf)
2216 {
2217         return cfi_intelext_otp_walk(mtd, from, len, retlen,
2218                                      buf, do_otp_read, 1);
2219 }
2220
2221 static int cfi_intelext_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
2222                                             size_t len, size_t *retlen,
2223                                              u_char *buf)
2224 {
2225         return cfi_intelext_otp_walk(mtd, from, len, retlen,
2226                                      buf, do_otp_write, 1);
2227 }
2228
2229 static int cfi_intelext_lock_user_prot_reg(struct mtd_info *mtd,
2230                                            loff_t from, size_t len)
2231 {
2232         size_t retlen;
2233         return cfi_intelext_otp_walk(mtd, from, len, &retlen,
2234                                      NULL, do_otp_lock, 1);
2235 }
2236
2237 static int cfi_intelext_get_fact_prot_info(struct mtd_info *mtd,
2238                                            struct otp_info *buf, size_t len)
2239 {
2240         size_t retlen;
2241         int ret;
2242
2243         ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 0);
2244         return ret ? : retlen;
2245 }
2246
2247 static int cfi_intelext_get_user_prot_info(struct mtd_info *mtd,
2248                                            struct otp_info *buf, size_t len)
2249 {
2250         size_t retlen;
2251         int ret;
2252
2253         ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 1);
2254         return ret ? : retlen;
2255 }
2256
2257 #endif
2258
2259 static void cfi_intelext_save_locks(struct mtd_info *mtd)
2260 {
2261         struct mtd_erase_region_info *region;
2262         int block, status, i;
2263         unsigned long adr;
2264         size_t len;
2265
2266         for (i = 0; i < mtd->numeraseregions; i++) {
2267                 region = &mtd->eraseregions[i];
2268                 if (!region->lockmap)
2269                         continue;
2270
2271                 for (block = 0; block < region->numblocks; block++){
2272                         len = region->erasesize;
2273                         adr = region->offset + block * len;
2274
2275                         status = cfi_varsize_frob(mtd,
2276                                         do_getlockstatus_oneblock, adr, len, NULL);
2277                         if (status)
2278                                 set_bit(block, region->lockmap);
2279                         else
2280                                 clear_bit(block, region->lockmap);
2281                 }
2282         }
2283 }
2284
2285 static int cfi_intelext_suspend(struct mtd_info *mtd)
2286 {
2287         struct map_info *map = mtd->priv;
2288         struct cfi_private *cfi = map->fldrv_priv;
2289         struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2290         int i;
2291         struct flchip *chip;
2292         int ret = 0;
2293
2294         if ((mtd->flags & MTD_STUPID_LOCK)
2295             && extp && (extp->FeatureSupport & (1 << 5)))
2296                 cfi_intelext_save_locks(mtd);
2297
2298         for (i=0; !ret && i<cfi->numchips; i++) {
2299                 chip = &cfi->chips[i];
2300
2301                 spin_lock(chip->mutex);
2302
2303                 switch (chip->state) {
2304                 case FL_READY:
2305                 case FL_STATUS:
2306                 case FL_CFI_QUERY:
2307                 case FL_JEDEC_QUERY:
2308                         if (chip->oldstate == FL_READY) {
2309                                 /* place the chip in a known state before suspend */
2310                                 map_write(map, CMD(0xFF), cfi->chips[i].start);
2311                                 chip->oldstate = chip->state;
2312                                 chip->state = FL_PM_SUSPENDED;
2313                                 /* No need to wake_up() on this state change -
2314                                  * as the whole point is that nobody can do anything
2315                                  * with the chip now anyway.
2316                                  */
2317                         } else {
2318                                 /* There seems to be an operation pending. We must wait for it. */
2319                                 printk(KERN_NOTICE "Flash device refused suspend due to pending operation (oldstate %d)\n", chip->oldstate);
2320                                 ret = -EAGAIN;
2321                         }
2322                         break;
2323                 default:
2324                         /* Should we actually wait? Once upon a time these routines weren't
2325                            allowed to. Or should we return -EAGAIN, because the upper layers
2326                            ought to have already shut down anything which was using the device
2327                            anyway? The latter for now. */
2328                         printk(KERN_NOTICE "Flash device refused suspend due to active operation (state %d)\n", chip->oldstate);
2329                         ret = -EAGAIN;
2330                 case FL_PM_SUSPENDED:
2331                         break;
2332                 }
2333                 spin_unlock(chip->mutex);
2334         }
2335
2336         /* Unlock the chips again */
2337
2338         if (ret) {
2339                 for (i--; i >=0; i--) {
2340                         chip = &cfi->chips[i];
2341
2342                         spin_lock(chip->mutex);
2343
2344                         if (chip->state == FL_PM_SUSPENDED) {
2345                                 /* No need to force it into a known state here,
2346                                    because we're returning failure, and it didn't
2347                                    get power cycled */
2348                                 chip->state = chip->oldstate;
2349                                 chip->oldstate = FL_READY;
2350                                 wake_up(&chip->wq);
2351                         }
2352                         spin_unlock(chip->mutex);
2353                 }
2354         }
2355
2356         return ret;
2357 }
2358
2359 static void cfi_intelext_restore_locks(struct mtd_info *mtd)
2360 {
2361         struct mtd_erase_region_info *region;
2362         int block, i;
2363         unsigned long adr;
2364         size_t len;
2365
2366         for (i = 0; i < mtd->numeraseregions; i++) {
2367                 region = &mtd->eraseregions[i];
2368                 if (!region->lockmap)
2369                         continue;
2370
2371                 for (block = 0; block < region->numblocks; block++) {
2372                         len = region->erasesize;
2373                         adr = region->offset + block * len;
2374
2375                         if (!test_bit(block, region->lockmap))
2376                                 cfi_intelext_unlock(mtd, adr, len);
2377                 }
2378         }
2379 }
2380
2381 static void cfi_intelext_resume(struct mtd_info *mtd)
2382 {
2383         struct map_info *map = mtd->priv;
2384         struct cfi_private *cfi = map->fldrv_priv;
2385         struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2386         int i;
2387         struct flchip *chip;
2388
2389         for (i=0; i<cfi->numchips; i++) {
2390
2391                 chip = &cfi->chips[i];
2392
2393                 spin_lock(chip->mutex);
2394
2395                 /* Go to known state. Chip may have been power cycled */
2396                 if (chip->state == FL_PM_SUSPENDED) {
2397                         map_write(map, CMD(0xFF), cfi->chips[i].start);
2398                         chip->oldstate = chip->state = FL_READY;
2399                         wake_up(&chip->wq);
2400                 }
2401
2402                 spin_unlock(chip->mutex);
2403         }
2404
2405         if ((mtd->flags & MTD_STUPID_LOCK)
2406             && extp && (extp->FeatureSupport & (1 << 5)))
2407                 cfi_intelext_restore_locks(mtd);
2408 }
2409
2410 static int cfi_intelext_reset(struct mtd_info *mtd)
2411 {
2412         struct map_info *map = mtd->priv;
2413         struct cfi_private *cfi = map->fldrv_priv;
2414         int i, ret;
2415
2416         for (i=0; i < cfi->numchips; i++) {
2417                 struct flchip *chip = &cfi->chips[i];
2418
2419                 /* force the completion of any ongoing operation
2420                    and switch to array mode so any bootloader in
2421                    flash is accessible for soft reboot. */
2422                 spin_lock(chip->mutex);
2423                 ret = get_chip(map, chip, chip->start, FL_SHUTDOWN);
2424                 if (!ret) {
2425                         map_write(map, CMD(0xff), chip->start);
2426                         chip->state = FL_SHUTDOWN;
2427                 }
2428                 spin_unlock(chip->mutex);
2429         }
2430
2431         return 0;
2432 }
2433
2434 static int cfi_intelext_reboot(struct notifier_block *nb, unsigned long val,
2435                                void *v)
2436 {
2437         struct mtd_info *mtd;
2438
2439         mtd = container_of(nb, struct mtd_info, reboot_notifier);
2440         cfi_intelext_reset(mtd);
2441         return NOTIFY_DONE;
2442 }
2443
2444 static void cfi_intelext_destroy(struct mtd_info *mtd)
2445 {
2446         struct map_info *map = mtd->priv;
2447         struct cfi_private *cfi = map->fldrv_priv;
2448         struct mtd_erase_region_info *region;
2449         int i;
2450         cfi_intelext_reset(mtd);
2451         unregister_reboot_notifier(&mtd->reboot_notifier);
2452         kfree(cfi->cmdset_priv);
2453         kfree(cfi->cfiq);
2454         kfree(cfi->chips[0].priv);
2455         kfree(cfi);
2456         for (i = 0; i < mtd->numeraseregions; i++) {
2457                 region = &mtd->eraseregions[i];
2458                 if (region->lockmap)
2459                         kfree(region->lockmap);
2460         }
2461         kfree(mtd->eraseregions);
2462 }
2463
2464 MODULE_LICENSE("GPL");
2465 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
2466 MODULE_DESCRIPTION("MTD chip driver for Intel/Sharp flash chips");
2467 MODULE_ALIAS("cfi_cmdset_0003");
2468 MODULE_ALIAS("cfi_cmdset_0200");