drivers/mtd/chips/cfi_cmdset_0001.c

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