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