Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

8 files changed, 191 insertions, 169 deletions

diff --git a/drivers/mtd/chips/Kconfig b/drivers/mtd/chips/Kconfig
index 35c6a23b183b..b1e3c26edd6d 100644
--- a/drivers/mtd/chips/Kconfig
+++ b/drivers/mtd/chips/Kconfig
@@ -19,7 +19,7 @@ config MTD_JEDECPROBE
         help
           This option enables JEDEC-style probing of flash chips which are not
           compatible with the Common Flash Interface, but will use the common
-          CFI-targetted flash drivers for any chips which are identified which
+          CFI-targeted flash drivers for any chips which are identified which
           are in fact compatible in all but the probe method. This actually
           covers most AMD/Fujitsu-compatible chips and also non-CFI
           Intel chips.
diff --git a/drivers/mtd/chips/cfi_cmdset_0001.c b/drivers/mtd/chips/cfi_cmdset_0001.c
index 9e2b7e9e0ad9..e1e122f2f929 100644
--- a/drivers/mtd/chips/cfi_cmdset_0001.c
+++ b/drivers/mtd/chips/cfi_cmdset_0001.c
@@ -162,7 +162,7 @@ static void cfi_tell_features(struct cfi_pri_intelext *extp)
 #endif
 
 /* Atmel chips don't use the same PRI format as Intel chips */
-static void fixup_convert_atmel_pri(struct mtd_info *mtd, void *param)
+static void fixup_convert_atmel_pri(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -202,7 +202,7 @@ static void fixup_convert_atmel_pri(struct mtd_info *mtd, void *param)
         cfi->cfiq->BufWriteTimeoutMax = 0;
 }
 
-static void fixup_at49bv640dx_lock(struct mtd_info *mtd, void *param)
+static void fixup_at49bv640dx_lock(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -214,7 +214,7 @@ static void fixup_at49bv640dx_lock(struct mtd_info *mtd, void *param)
 
 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
 /* Some Intel Strata Flash prior to FPO revision C has bugs in this area */
-static void fixup_intel_strataflash(struct mtd_info *mtd, void* param)
+static void fixup_intel_strataflash(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -227,7 +227,7 @@ static void fixup_intel_strataflash(struct mtd_info *mtd, void* param)
 #endif
 
 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
-static void fixup_no_write_suspend(struct mtd_info *mtd, void* param)
+static void fixup_no_write_suspend(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -240,7 +240,7 @@ static void fixup_no_write_suspend(struct mtd_info *mtd, void* param)
 }
 #endif
 
-static void fixup_st_m28w320ct(struct mtd_info *mtd, void* param)
+static void fixup_st_m28w320ct(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -249,7 +249,7 @@ static void fixup_st_m28w320ct(struct mtd_info *mtd, void* param)
         cfi->cfiq->BufWriteTimeoutMax = 0;      /* Not supported */
 }
 
-static void fixup_st_m28w320cb(struct mtd_info *mtd, void* param)
+static void fixup_st_m28w320cb(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -259,7 +259,7 @@ static void fixup_st_m28w320cb(struct mtd_info *mtd, void* param)
                 (cfi->cfiq->EraseRegionInfo[1] & 0xffff0000) | 0x3e;
 };
 
-static void fixup_use_point(struct mtd_info *mtd, void *param)
+static void fixup_use_point(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         if (!mtd->point && map_is_linear(map)) {
@@ -268,7 +268,7 @@ static void fixup_use_point(struct mtd_info *mtd, void *param)
         }
 }
 
-static void fixup_use_write_buffers(struct mtd_info *mtd, void *param)
+static void fixup_use_write_buffers(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -282,7 +282,7 @@ static void fixup_use_write_buffers(struct mtd_info *mtd, void *param)
 /*
  * Some chips power-up with all sectors locked by default.
  */
-static void fixup_unlock_powerup_lock(struct mtd_info *mtd, void *param)
+static void fixup_unlock_powerup_lock(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -295,31 +295,31 @@ static void fixup_unlock_powerup_lock(struct mtd_info *mtd, void *param)
 }
 
 static struct cfi_fixup cfi_fixup_table[] = {
-        { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri, NULL },
-        { CFI_MFR_ATMEL, AT49BV640D, fixup_at49bv640dx_lock, NULL },
-        { CFI_MFR_ATMEL, AT49BV640DT, fixup_at49bv640dx_lock, NULL },
+        { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri },
+        { CFI_MFR_ATMEL, AT49BV640D, fixup_at49bv640dx_lock },
+        { CFI_MFR_ATMEL, AT49BV640DT, fixup_at49bv640dx_lock },
 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
-        { CFI_MFR_ANY, CFI_ID_ANY, fixup_intel_strataflash, NULL },
+        { CFI_MFR_ANY, CFI_ID_ANY, fixup_intel_strataflash },
 #endif
 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
-        { CFI_MFR_ANY, CFI_ID_ANY, fixup_no_write_suspend, NULL },
+        { CFI_MFR_ANY, CFI_ID_ANY, fixup_no_write_suspend },
 #endif
 #if !FORCE_WORD_WRITE
-        { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers, NULL },
+        { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers },
 #endif
-        { CFI_MFR_ST, 0x00ba, /* M28W320CT */ fixup_st_m28w320ct, NULL },
-        { CFI_MFR_ST, 0x00bb, /* M28W320CB */ fixup_st_m28w320cb, NULL },
-        { CFI_MFR_INTEL, CFI_ID_ANY, fixup_unlock_powerup_lock, NULL, },
-        { 0, 0, NULL, NULL }
+        { CFI_MFR_ST, 0x00ba, /* M28W320CT */ fixup_st_m28w320ct },
+        { CFI_MFR_ST, 0x00bb, /* M28W320CB */ fixup_st_m28w320cb },
+        { CFI_MFR_INTEL, CFI_ID_ANY, fixup_unlock_powerup_lock },
+        { 0, 0, NULL }
 };
 
 static struct cfi_fixup jedec_fixup_table[] = {
-        { CFI_MFR_INTEL, I82802AB,   fixup_use_fwh_lock, NULL, },
-        { CFI_MFR_INTEL, I82802AC,   fixup_use_fwh_lock, NULL, },
-        { CFI_MFR_ST,    M50LPW080,  fixup_use_fwh_lock, NULL, },
-        { CFI_MFR_ST,    M50FLW080A, fixup_use_fwh_lock, NULL, },
-        { CFI_MFR_ST,    M50FLW080B, fixup_use_fwh_lock, NULL, },
-        { 0, 0, NULL, NULL }
+        { CFI_MFR_INTEL, I82802AB,   fixup_use_fwh_lock },
+        { CFI_MFR_INTEL, I82802AC,   fixup_use_fwh_lock },
+        { CFI_MFR_ST,    M50LPW080,  fixup_use_fwh_lock },
+        { CFI_MFR_ST,    M50FLW080A, fixup_use_fwh_lock },
+        { CFI_MFR_ST,    M50FLW080B, fixup_use_fwh_lock },
+        { 0, 0, NULL }
 };
 static struct cfi_fixup fixup_table[] = {
         /* The CFI vendor ids and the JEDEC vendor IDs appear
@@ -327,8 +327,8 @@ static struct cfi_fixup fixup_table[] = {
          * well.  This table is to pick all cases where
          * we know that is the case.
          */
-        { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_point, NULL },
-        { 0, 0, NULL, NULL }
+        { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_point },
+        { 0, 0, NULL }
 };
 
 static void cfi_fixup_major_minor(struct cfi_private *cfi,
@@ -455,6 +455,7 @@ struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
         mtd->flags   = MTD_CAP_NORFLASH;
         mtd->name    = map->name;
         mtd->writesize = 1;
+        mtd->writebufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
 
         mtd->reboot_notifier.notifier_call = cfi_intelext_reboot;
 
@@ -811,12 +812,9 @@ static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long
                                 break;
 
                         if (time_after(jiffies, timeo)) {
-                                /* Urgh. Resume and pretend we weren't here.  */
-                                map_write(map, CMD(0xd0), adr);
-                                /* Make sure we're in 'read status' mode if it had finished */
-                                map_write(map, CMD(0x70), adr);
-                                chip->state = FL_ERASING;
-                                chip->oldstate = FL_READY;
+                                /* Urgh. Resume and pretend we weren't here.
+                                 * Make sure we're in 'read status' mode if it had finished */
+                                put_chip(map, chip, adr);
                                 printk(KERN_ERR "%s: Chip not ready after erase "
                                        "suspended: status = 0x%lx\n", map->name, status.x[0]);
                                 return -EIO;
@@ -996,7 +994,6 @@ static void put_chip(struct map_info *map, struct flchip *chip, unsigned long ad
 
         switch(chip->oldstate) {
         case FL_ERASING:
-                chip->state = chip->oldstate;
                 /* What if one interleaved chip has finished and the
                    other hasn't? The old code would leave the finished
                    one in READY mode. That's bad, and caused -EROFS
@@ -1229,10 +1226,32 @@ static int inval_cache_and_wait_for_operation(
         sleep_time = chip_op_time / 2;
 
         for (;;) {
+                if (chip->state != chip_state) {
+                        /* Someone's suspended the operation: sleep */
+                        DECLARE_WAITQUEUE(wait, current);
+                        set_current_state(TASK_UNINTERRUPTIBLE);
+                        add_wait_queue(&chip->wq, &wait);
+                        mutex_unlock(&chip->mutex);
+                        schedule();
+                        remove_wait_queue(&chip->wq, &wait);
+                        mutex_lock(&chip->mutex);
+                        continue;
+                }
+
                 status = map_read(map, cmd_adr);
                 if (map_word_andequal(map, status, status_OK, status_OK))
                         break;
 
+                if (chip->erase_suspended && chip_state == FL_ERASING)  {
+                        /* Erase suspend occurred while sleep: reset timeout */
+                        timeo = reset_timeo;
+                        chip->erase_suspended = 0;
+                }
+                if (chip->write_suspended && chip_state == FL_WRITING)  {
+                        /* Write suspend occurred while sleep: reset timeout */
+                        timeo = reset_timeo;
+                        chip->write_suspended = 0;
+                }
                 if (!timeo) {
                         map_write(map, CMD(0x70), cmd_adr);
                         chip->state = FL_STATUS;
@@ -1256,27 +1275,6 @@ static int inval_cache_and_wait_for_operation(
                         timeo--;
                 }
                 mutex_lock(&chip->mutex);
-
-                while (chip->state != chip_state) {
-                        /* Someone's suspended the operation: sleep */
-                        DECLARE_WAITQUEUE(wait, current);
-                        set_current_state(TASK_UNINTERRUPTIBLE);
-                        add_wait_queue(&chip->wq, &wait);
-                        mutex_unlock(&chip->mutex);
-                        schedule();
-                        remove_wait_queue(&chip->wq, &wait);
-                        mutex_lock(&chip->mutex);
-                }
-                if (chip->erase_suspended && chip_state == FL_ERASING)  {
-                        /* Erase suspend occured while sleep: reset timeout */
-                        timeo = reset_timeo;
-                        chip->erase_suspended = 0;
-                }
-                if (chip->write_suspended && chip_state == FL_WRITING)  {
-                        /* Write suspend occured while sleep: reset timeout */
-                        timeo = reset_timeo;
-                        chip->write_suspended = 0;
-                }
         }
 
         /* Done and happy. */
@@ -1496,7 +1494,7 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
 
         switch (mode) {
         case FL_WRITING:
-                write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0x40) : CMD(0x41);
+                write_cmd = (cfi->cfiq->P_ID != P_ID_INTEL_PERFORMANCE) ? CMD(0x40) : CMD(0x41);
                 break;
         case FL_OTP_WRITE:
                 write_cmd = CMD(0xc0);
@@ -1661,7 +1659,7 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
         cmd_adr = adr & ~(wbufsize-1);
 
         /* Let's determine this according to the interleave only once */
-        write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0xe8) : CMD(0xe9);
+        write_cmd = (cfi->cfiq->P_ID != P_ID_INTEL_PERFORMANCE) ? CMD(0xe8) : CMD(0xe9);
 
         mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, cmd_adr, FL_WRITING);
diff --git a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c
index 3e6c47bdce53..23175edd5634 100644
--- a/drivers/mtd/chips/cfi_cmdset_0002.c
+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
@@ -134,7 +134,7 @@ static void cfi_tell_features(struct cfi_pri_amdstd *extp)
 
 #ifdef AMD_BOOTLOC_BUG
 /* Wheee. Bring me the head of someone at AMD. */
-static void fixup_amd_bootblock(struct mtd_info *mtd, void* param)
+static void fixup_amd_bootblock(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -186,7 +186,7 @@ static void fixup_amd_bootblock(struct mtd_info *mtd, void* param)
 }
 #endif
 
-static void fixup_use_write_buffers(struct mtd_info *mtd, void *param)
+static void fixup_use_write_buffers(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -197,7 +197,7 @@ static void fixup_use_write_buffers(struct mtd_info *mtd, void *param)
 }
 
 /* Atmel chips don't use the same PRI format as AMD chips */
-static void fixup_convert_atmel_pri(struct mtd_info *mtd, void *param)
+static void fixup_convert_atmel_pri(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -228,14 +228,14 @@ static void fixup_convert_atmel_pri(struct mtd_info *mtd, void *param)
         cfi->cfiq->BufWriteTimeoutMax = 0;
 }
 
-static void fixup_use_secsi(struct mtd_info *mtd, void *param)
+static void fixup_use_secsi(struct mtd_info *mtd)
 {
         /* Setup for chips with a secsi area */
         mtd->read_user_prot_reg = cfi_amdstd_secsi_read;
         mtd->read_fact_prot_reg = cfi_amdstd_secsi_read;
 }
 
-static void fixup_use_erase_chip(struct mtd_info *mtd, void *param)
+static void fixup_use_erase_chip(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -250,7 +250,7 @@ static void fixup_use_erase_chip(struct mtd_info *mtd, void *param)
  * Some Atmel chips (e.g. the AT49BV6416) power-up with all sectors
  * locked by default.
  */
-static void fixup_use_atmel_lock(struct mtd_info *mtd, void *param)
+static void fixup_use_atmel_lock(struct mtd_info *mtd)
 {
         mtd->lock = cfi_atmel_lock;
         mtd->unlock = cfi_atmel_unlock;
@@ -263,7 +263,7 @@ static void fixup_old_sst_eraseregion(struct mtd_info *mtd)
         struct cfi_private *cfi = map->fldrv_priv;
 
         /*
-         * These flashes report two seperate eraseblock regions based on the
+         * These flashes report two separate eraseblock regions based on the
          * sector_erase-size and block_erase-size, although they both operate on the
          * same memory. This is not allowed according to CFI, so we just pick the
          * sector_erase-size.
@@ -271,7 +271,7 @@ static void fixup_old_sst_eraseregion(struct mtd_info *mtd)
         cfi->cfiq->NumEraseRegions = 1;
 }
 
-static void fixup_sst39vf(struct mtd_info *mtd, void *param)
+static void fixup_sst39vf(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -282,7 +282,7 @@ static void fixup_sst39vf(struct mtd_info *mtd, void *param)
         cfi->addr_unlock2 = 0x2AAA;
 }
 
-static void fixup_sst39vf_rev_b(struct mtd_info *mtd, void *param)
+static void fixup_sst39vf_rev_b(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -291,9 +291,26 @@ static void fixup_sst39vf_rev_b(struct mtd_info *mtd, void *param)
 
         cfi->addr_unlock1 = 0x555;
         cfi->addr_unlock2 = 0x2AA;
+
+        cfi->sector_erase_cmd = CMD(0x50);
+}
+
+static void fixup_sst38vf640x_sectorsize(struct mtd_info *mtd)
+{
+        struct map_info *map = mtd->priv;
+        struct cfi_private *cfi = map->fldrv_priv;
+
+        fixup_sst39vf_rev_b(mtd);
+
+        /*
+         * CFI reports 1024 sectors (0x03ff+1) of 64KBytes (0x0100*256) where
+         * it should report a size of 8KBytes (0x0020*256).
+         */
+        cfi->cfiq->EraseRegionInfo[0] = 0x002003ff;
+        pr_warning("%s: Bad 38VF640x CFI data; adjusting sector size from 64 to 8KiB\n", mtd->name);
 }
 
-static void fixup_s29gl064n_sectors(struct mtd_info *mtd, void *param)
+static void fixup_s29gl064n_sectors(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -304,7 +321,7 @@ static void fixup_s29gl064n_sectors(struct mtd_info *mtd, void *param)
         }
 }
 
-static void fixup_s29gl032n_sectors(struct mtd_info *mtd, void *param)
+static void fixup_s29gl032n_sectors(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
@@ -317,43 +334,48 @@ static void fixup_s29gl032n_sectors(struct mtd_info *mtd, void *param)
 
 /* Used to fix CFI-Tables of chips without Extended Query Tables */
 static struct cfi_fixup cfi_nopri_fixup_table[] = {
-        { CFI_MFR_SST, 0x234A, fixup_sst39vf, NULL, }, // SST39VF1602
-        { CFI_MFR_SST, 0x234B, fixup_sst39vf, NULL, }, // SST39VF1601
-        { CFI_MFR_SST, 0x235A, fixup_sst39vf, NULL, }, // SST39VF3202
-        { CFI_MFR_SST, 0x235B, fixup_sst39vf, NULL, }, // SST39VF3201
-        { CFI_MFR_SST, 0x235C, fixup_sst39vf_rev_b, NULL, }, // SST39VF3202B
-        { CFI_MFR_SST, 0x235D, fixup_sst39vf_rev_b, NULL, }, // SST39VF3201B
-        { CFI_MFR_SST, 0x236C, fixup_sst39vf_rev_b, NULL, }, // SST39VF6402B
-        { CFI_MFR_SST, 0x236D, fixup_sst39vf_rev_b, NULL, }, // SST39VF6401B
-        { 0, 0, NULL, NULL }
+        { CFI_MFR_SST, 0x234a, fixup_sst39vf }, /* SST39VF1602 */
+        { CFI_MFR_SST, 0x234b, fixup_sst39vf }, /* SST39VF1601 */
+        { CFI_MFR_SST, 0x235a, fixup_sst39vf }, /* SST39VF3202 */
+        { CFI_MFR_SST, 0x235b, fixup_sst39vf }, /* SST39VF3201 */
+        { CFI_MFR_SST, 0x235c, fixup_sst39vf_rev_b }, /* SST39VF3202B */
+        { CFI_MFR_SST, 0x235d, fixup_sst39vf_rev_b }, /* SST39VF3201B */
+        { CFI_MFR_SST, 0x236c, fixup_sst39vf_rev_b }, /* SST39VF6402B */
+        { CFI_MFR_SST, 0x236d, fixup_sst39vf_rev_b }, /* SST39VF6401B */
+        { 0, 0, NULL }
 };
 
 static struct cfi_fixup cfi_fixup_table[] = {
-        { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri, NULL },
+        { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri },
 #ifdef AMD_BOOTLOC_BUG
-        { CFI_MFR_AMD, CFI_ID_ANY, fixup_amd_bootblock, NULL },
-        { CFI_MFR_MACRONIX, CFI_ID_ANY, fixup_amd_bootblock, NULL },
+        { CFI_MFR_AMD, CFI_ID_ANY, fixup_amd_bootblock },
+        { CFI_MFR_AMIC, CFI_ID_ANY, fixup_amd_bootblock },
+        { CFI_MFR_MACRONIX, CFI_ID_ANY, fixup_amd_bootblock },
 #endif
-        { CFI_MFR_AMD, 0x0050, fixup_use_secsi, NULL, },
-        { CFI_MFR_AMD, 0x0053, fixup_use_secsi, NULL, },
-        { CFI_MFR_AMD, 0x0055, fixup_use_secsi, NULL, },
-        { CFI_MFR_AMD, 0x0056, fixup_use_secsi, NULL, },
-        { CFI_MFR_AMD, 0x005C, fixup_use_secsi, NULL, },
-        { CFI_MFR_AMD, 0x005F, fixup_use_secsi, NULL, },
-        { CFI_MFR_AMD, 0x0c01, fixup_s29gl064n_sectors, NULL, },
-        { CFI_MFR_AMD, 0x1301, fixup_s29gl064n_sectors, NULL, },
-        { CFI_MFR_AMD, 0x1a00, fixup_s29gl032n_sectors, NULL, },
-        { CFI_MFR_AMD, 0x1a01, fixup_s29gl032n_sectors, NULL, },
+        { CFI_MFR_AMD, 0x0050, fixup_use_secsi },
+        { CFI_MFR_AMD, 0x0053, fixup_use_secsi },
+        { CFI_MFR_AMD, 0x0055, fixup_use_secsi },
+        { CFI_MFR_AMD, 0x0056, fixup_use_secsi },
+        { CFI_MFR_AMD, 0x005C, fixup_use_secsi },
+        { CFI_MFR_AMD, 0x005F, fixup_use_secsi },
+        { CFI_MFR_AMD, 0x0c01, fixup_s29gl064n_sectors },
+        { CFI_MFR_AMD, 0x1301, fixup_s29gl064n_sectors },
+        { CFI_MFR_AMD, 0x1a00, fixup_s29gl032n_sectors },
+        { CFI_MFR_AMD, 0x1a01, fixup_s29gl032n_sectors },
+        { CFI_MFR_SST, 0x536a, fixup_sst38vf640x_sectorsize }, /* SST38VF6402 */
+        { CFI_MFR_SST, 0x536b, fixup_sst38vf640x_sectorsize }, /* SST38VF6401 */
+        { CFI_MFR_SST, 0x536c, fixup_sst38vf640x_sectorsize }, /* SST38VF6404 */
+        { CFI_MFR_SST, 0x536d, fixup_sst38vf640x_sectorsize }, /* SST38VF6403 */
 #if !FORCE_WORD_WRITE
-        { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers, NULL, },
+        { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers },
 #endif
-        { 0, 0, NULL, NULL }
+        { 0, 0, NULL }
 };
 static struct cfi_fixup jedec_fixup_table[] = {
-        { CFI_MFR_SST, SST49LF004B, fixup_use_fwh_lock, NULL, },
-        { CFI_MFR_SST, SST49LF040B, fixup_use_fwh_lock, NULL, },
-        { CFI_MFR_SST, SST49LF008A, fixup_use_fwh_lock, NULL, },
-        { 0, 0, NULL, NULL }
+        { CFI_MFR_SST, SST49LF004B, fixup_use_fwh_lock },
+        { CFI_MFR_SST, SST49LF040B, fixup_use_fwh_lock },
+        { CFI_MFR_SST, SST49LF008A, fixup_use_fwh_lock },
+        { 0, 0, NULL }
 };
 
 static struct cfi_fixup fixup_table[] = {
@@ -362,18 +384,37 @@ static struct cfi_fixup fixup_table[] = {
          * well.  This table is to pick all cases where
          * we know that is the case.
          */
-        { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_erase_chip, NULL },
-        { CFI_MFR_ATMEL, AT49BV6416, fixup_use_atmel_lock, NULL },
-        { 0, 0, NULL, NULL }
+        { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_erase_chip },
+        { CFI_MFR_ATMEL, AT49BV6416, fixup_use_atmel_lock },
+        { 0, 0, NULL }
 };
 
 
 static void cfi_fixup_major_minor(struct cfi_private *cfi,
                                   struct cfi_pri_amdstd *extp)
 {
-        if (cfi->mfr == CFI_MFR_SAMSUNG && cfi->id == 0x257e &&
-            extp->MajorVersion == '0')
+        if (cfi->mfr == CFI_MFR_SAMSUNG) {
+                if ((extp->MajorVersion == '0' && extp->MinorVersion == '0') ||
+                    (extp->MajorVersion == '3' && extp->MinorVersion == '3')) {
+                        /*
+                         * Samsung K8P2815UQB and K8D6x16UxM chips
+                         * report major=0 / minor=0.
+                         * K8D3x16UxC chips report major=3 / minor=3.
+                         */
+                        printk(KERN_NOTICE "  Fixing Samsung's Amd/Fujitsu"
+                               " Extended Query version to 1.%c\n",
+                               extp->MinorVersion);
+                        extp->MajorVersion = '1';
+                }
+        }
+
+        /*
+         * SST 38VF640x chips report major=0xFF / minor=0xFF.
+         */
+        if (cfi->mfr == CFI_MFR_SST && (cfi->id >> 4) == 0x0536) {
                 extp->MajorVersion = '1';
+                extp->MinorVersion = '0';
+        }
 }
 
 struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
@@ -400,6 +441,10 @@ struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
         mtd->flags   = MTD_CAP_NORFLASH;
         mtd->name    = map->name;
         mtd->writesize = 1;
+        mtd->writebufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
+
+        DEBUG(MTD_DEBUG_LEVEL3, "MTD %s(): write buffer size %d\n",
+                __func__, mtd->writebufsize);
 
         mtd->reboot_notifier.notifier_call = cfi_amdstd_reboot;
 
@@ -417,13 +462,14 @@ struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
                         cfi_fixup_major_minor(cfi, extp);
 
                         /*
-                         * Valid primary extension versions are: 1.0, 1.1, 1.2, 1.3, 1.4
-                         * see: http://www.amd.com/us-en/assets/content_type/DownloadableAssets/cfi_r20.pdf, page 19
-                         *      http://www.amd.com/us-en/assets/content_type/DownloadableAssets/cfi_100_20011201.pdf
+                         * Valid primary extension versions are: 1.0, 1.1, 1.2, 1.3, 1.4, 1.5
+                         * see: http://cs.ozerki.net/zap/pub/axim-x5/docs/cfi_r20.pdf, page 19 
+                         *      http://www.spansion.com/Support/AppNotes/cfi_100_20011201.pdf
                          *      http://www.spansion.com/Support/Datasheets/s29ws-p_00_a12_e.pdf
+                         *      http://www.spansion.com/Support/Datasheets/S29GL_128S_01GS_00_02_e.pdf
                          */
                         if (extp->MajorVersion != '1' ||
-                            (extp->MajorVersion == '1' && (extp->MinorVersion < '0' || extp->MinorVersion > '4'))) {
+                            (extp->MajorVersion == '1' && (extp->MinorVersion < '0' || extp->MinorVersion > '5'))) {
                                 printk(KERN_ERR "  Unknown Amd/Fujitsu Extended Query "
                                        "version %c.%c (%#02x/%#02x).\n",
                                        extp->MajorVersion, extp->MinorVersion,
@@ -545,15 +591,6 @@ static struct mtd_info *cfi_amdstd_setup(struct mtd_info *mtd)
                 printk(KERN_WARNING "Sum of regions (%lx) != total size of set of interleaved chips (%lx)\n", offset, devsize);
                 goto setup_err;
         }
-#if 0
-        // debug
-        for (i=0; i<mtd->numeraseregions;i++){
-                printk("%d: offset=0x%x,size=0x%x,blocks=%d\n",
-                       i,mtd->eraseregions[i].offset,
-                       mtd->eraseregions[i].erasesize,
-                       mtd->eraseregions[i].numblocks);
-        }
-#endif
 
         __module_get(THIS_MODULE);
         register_reboot_notifier(&mtd->reboot_notifier);
@@ -575,8 +612,8 @@ static struct mtd_info *cfi_amdstd_setup(struct mtd_info *mtd)
  *
  * Note that anything more complicated than checking if no bits are toggling
  * (including checking DQ5 for an error status) is tricky to get working
- * correctly and is therefore not done  (particulary with interleaved chips
- * as each chip must be checked independantly of the others).
+ * correctly and is therefore not done  (particularly with interleaved chips
+ * as each chip must be checked independently of the others).
  */
 static int __xipram chip_ready(struct map_info *map, unsigned long addr)
 {
@@ -599,8 +636,8 @@ static int __xipram chip_ready(struct map_info *map, unsigned long addr)
  *
  * Note that anything more complicated than checking if no bits are toggling
  * (including checking DQ5 for an error status) is tricky to get working
- * correctly and is therefore not done  (particulary with interleaved chips
- * as each chip must be checked independantly of the others).
+ * correctly and is therefore not done  (particularly with interleaved chips
+ * as each chip must be checked independently of the others).
  *
  */
 static int __xipram chip_good(struct map_info *map, unsigned long addr, map_word expected)
@@ -674,9 +711,7 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
                                  * there was an error (so leave the erase
                                  * routine to recover from it) or we trying to
                                  * use the erase-in-progress sector. */
-                                map_write(map, CMD(0x30), chip->in_progress_block_addr);
-                                chip->state = FL_ERASING;
-                                chip->oldstate = FL_READY;
+                                put_chip(map, chip, adr);
                                 printk(KERN_ERR "MTD %s(): chip not ready after erase suspend\n", __func__);
                                 return -EIO;
                         }
@@ -726,8 +761,7 @@ static void put_chip(struct map_info *map, struct flchip *chip, unsigned long ad
 
         switch(chip->oldstate) {
         case FL_ERASING:
-                chip->state = chip->oldstate;
-                map_write(map, CMD(0x30), chip->in_progress_block_addr);
+                map_write(map, cfi->sector_erase_cmd, chip->in_progress_block_addr);
                 chip->oldstate = FL_READY;
                 chip->state = FL_ERASING;
                 break;
@@ -870,7 +904,7 @@ static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
                         local_irq_disable();
 
                         /* Resume the write or erase operation */
-                        map_write(map, CMD(0x30), adr);
+                        map_write(map, cfi->sector_erase_cmd, adr);
                         chip->state = oldstate;
                         start = xip_currtime();
                 } else if (usec >= 1000000/HZ) {
@@ -1025,9 +1059,6 @@ static inline int do_read_secsi_onechip(struct map_info *map, struct flchip *chi
         mutex_lock(&chip->mutex);
 
         if (chip->state != FL_READY){
-#if 0
-                printk(KERN_DEBUG "Waiting for chip to read, status = %d\n", chip->state);
-#endif
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
 
@@ -1035,10 +1066,6 @@ static inline int do_read_secsi_onechip(struct map_info *map, struct flchip *chi
 
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
-#if 0
-                if(signal_pending(current))
-                        return -EINTR;
-#endif
                 timeo = jiffies + HZ;
 
                 goto retry;
@@ -1246,9 +1273,6 @@ static int cfi_amdstd_write_words(struct mtd_info *mtd, loff_t to, size_t len,
                 mutex_lock(&cfi->chips[chipnum].mutex);
 
                 if (cfi->chips[chipnum].state != FL_READY) {
-#if 0
-                        printk(KERN_DEBUG "Waiting for chip to write, status = %d\n", cfi->chips[chipnum].state);
-#endif
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&cfi->chips[chipnum].wq, &wait);
 
@@ -1256,10 +1280,6 @@ static int cfi_amdstd_write_words(struct mtd_info *mtd, loff_t to, size_t len,
 
                         schedule();
                         remove_wait_queue(&cfi->chips[chipnum].wq, &wait);
-#if 0
-                        if(signal_pending(current))
-                                return -EINTR;
-#endif
                         goto retry;
                 }
 
@@ -1324,9 +1344,6 @@ static int cfi_amdstd_write_words(struct mtd_info *mtd, loff_t to, size_t len,
                 mutex_lock(&cfi->chips[chipnum].mutex);
 
                 if (cfi->chips[chipnum].state != FL_READY) {
-#if 0
-                        printk(KERN_DEBUG "Waiting for chip to write, status = %d\n", cfi->chips[chipnum].state);
-#endif
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&cfi->chips[chipnum].wq, &wait);
 
@@ -1334,10 +1351,6 @@ static int cfi_amdstd_write_words(struct mtd_info *mtd, loff_t to, size_t len,
 
                         schedule();
                         remove_wait_queue(&cfi->chips[chipnum].wq, &wait);
-#if 0
-                        if(signal_pending(current))
-                                return -EINTR;
-#endif
                         goto retry1;
                 }
 
@@ -1396,7 +1409,6 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
 
         cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
         cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, cfi->device_type, NULL);
-        //cfi_send_gen_cmd(0xA0, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
 
         /* Write Buffer Load */
         map_write(map, CMD(0x25), cmd_adr);
@@ -1675,7 +1687,7 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
         cfi_send_gen_cmd(0x80, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
         cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
         cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, cfi->device_type, NULL);
-        map_write(map, CMD(0x30), adr);
+        map_write(map, cfi->sector_erase_cmd, adr);
 
         chip->state = FL_ERASING;
         chip->erase_suspended = 0;
diff --git a/drivers/mtd/chips/cfi_cmdset_0020.c b/drivers/mtd/chips/cfi_cmdset_0020.c
index 314af1f5a370..179814a95f3a 100644
--- a/drivers/mtd/chips/cfi_cmdset_0020.c
+++ b/drivers/mtd/chips/cfi_cmdset_0020.c
@@ -238,6 +238,7 @@ static struct mtd_info *cfi_staa_setup(struct map_info *map)
         mtd->resume = cfi_staa_resume;
         mtd->flags = MTD_CAP_NORFLASH & ~MTD_BIT_WRITEABLE;
         mtd->writesize = 8; /* FIXME: Should be 0 for STMicro flashes w/out ECC */
+        mtd->writebufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
         map->fldrv = &cfi_staa_chipdrv;
         __module_get(THIS_MODULE);
         mtd->name = map->name;
@@ -295,6 +296,7 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
                                 /* make sure we're in 'read status' mode */
                                 map_write(map, CMD(0x70), cmd_addr);
                                 chip->state = FL_ERASING;
+                                wake_up(&chip->wq);
                                 mutex_unlock(&chip->mutex);
                                 printk(KERN_ERR "Chip not ready after erase "
                                        "suspended: status = 0x%lx\n", status.x[0]);
diff --git a/drivers/mtd/chips/cfi_probe.c b/drivers/mtd/chips/cfi_probe.c
index 8f5b96aa87a0..d25535279404 100644
--- a/drivers/mtd/chips/cfi_probe.c
+++ b/drivers/mtd/chips/cfi_probe.c
@@ -177,6 +177,8 @@ static int __xipram cfi_chip_setup(struct map_info *map,
 
         cfi->cfi_mode = CFI_MODE_CFI;
 
+        cfi->sector_erase_cmd = CMD(0x30);
+
         /* Read the CFI info structure */
         xip_disable_qry(base, map, cfi);
         for (i=0; i<(sizeof(struct cfi_ident) + num_erase_regions * 4); i++)
diff --git a/drivers/mtd/chips/cfi_util.c b/drivers/mtd/chips/cfi_util.c
index e503b2ca894d..8e464054a631 100644
--- a/drivers/mtd/chips/cfi_util.c
+++ b/drivers/mtd/chips/cfi_util.c
@@ -1,6 +1,6 @@
 /*
  * Common Flash Interface support:
- *   Generic utility functions not dependant on command set
+ *   Generic utility functions not dependent on command set
  *
  * Copyright (C) 2002 Red Hat
  * Copyright (C) 2003 STMicroelectronics Limited
@@ -77,6 +77,13 @@ int __xipram cfi_qry_mode_on(uint32_t base, struct map_info *map,
         cfi_send_gen_cmd(0x98, 0x5555, base, map, cfi, cfi->device_type, NULL);
         if (cfi_qry_present(map, base, cfi))
                 return 1;
+        /* SST 39VF640xB */
+        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0xAA, 0x555, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0x55, 0x2AA, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0x98, 0x555, base, map, cfi, cfi->device_type, NULL);
+        if (cfi_qry_present(map, base, cfi))
+                return 1;
         /* QRY not found */
         return 0;
 }
@@ -149,7 +156,7 @@ void cfi_fixup(struct mtd_info *mtd, struct cfi_fixup *fixups)
         for (f=fixups; f->fixup; f++) {
                 if (((f->mfr == CFI_MFR_ANY) || (f->mfr == cfi->mfr)) &&
                     ((f->id  == CFI_ID_ANY)  || (f->id  == cfi->id))) {
-                        f->fixup(mtd, f->param);
+                        f->fixup(mtd);
                 }
         }
 }
diff --git a/drivers/mtd/chips/fwh_lock.h b/drivers/mtd/chips/fwh_lock.h
index d18064977192..5e3cc80128aa 100644
--- a/drivers/mtd/chips/fwh_lock.h
+++ b/drivers/mtd/chips/fwh_lock.h
@@ -98,7 +98,7 @@ static int fwh_unlock_varsize(struct mtd_info *mtd, loff_t ofs, uint64_t len)
         return ret;
 }
 
-static void fixup_use_fwh_lock(struct mtd_info *mtd, void *param)
+static void fixup_use_fwh_lock(struct mtd_info *mtd)
 {
         printk(KERN_NOTICE "using fwh lock/unlock method\n");
         /* Setup for the chips with the fwh lock method */
diff --git a/drivers/mtd/chips/jedec_probe.c b/drivers/mtd/chips/jedec_probe.c
index d72a5fb2d041..ea832ea0e4aa 100644
--- a/drivers/mtd/chips/jedec_probe.c
+++ b/drivers/mtd/chips/jedec_probe.c
@@ -1935,14 +1935,14 @@ static void jedec_reset(u32 base, struct map_info *map, struct cfi_private *cfi)
 }
 
 
-static int cfi_jedec_setup(struct cfi_private *p_cfi, int index)
+static int cfi_jedec_setup(struct map_info *map, struct cfi_private *cfi, int index)
 {
         int i,num_erase_regions;
         uint8_t uaddr;
 
-        if (! (jedec_table[index].devtypes & p_cfi->device_type)) {
+        if (!(jedec_table[index].devtypes & cfi->device_type)) {
                 DEBUG(MTD_DEBUG_LEVEL1, "Rejecting potential %s with incompatible %d-bit device type\n",
-                      jedec_table[index].name, 4 * (1<<p_cfi->device_type));
+                      jedec_table[index].name, 4 * (1<<cfi->device_type));
                 return 0;
         }
 
@@ -1950,27 +1950,28 @@ static int cfi_jedec_setup(struct cfi_private *p_cfi, int index)
 
         num_erase_regions = jedec_table[index].nr_regions;
 
-        p_cfi->cfiq = kmalloc(sizeof(struct cfi_ident) + num_erase_regions * 4, GFP_KERNEL);
-        if (!p_cfi->cfiq) {
+        cfi->cfiq = kmalloc(sizeof(struct cfi_ident) + num_erase_regions * 4, GFP_KERNEL);
+        if (!cfi->cfiq) {
                 //xx printk(KERN_WARNING "%s: kmalloc failed for CFI ident structure\n", map->name);
                 return 0;
         }
 
-        memset(p_cfi->cfiq,0,sizeof(struct cfi_ident));
+        memset(cfi->cfiq, 0, sizeof(struct cfi_ident));
 
-        p_cfi->cfiq->P_ID = jedec_table[index].cmd_set;
-        p_cfi->cfiq->NumEraseRegions = jedec_table[index].nr_regions;
-        p_cfi->cfiq->DevSize = jedec_table[index].dev_size;
-        p_cfi->cfi_mode = CFI_MODE_JEDEC;
+        cfi->cfiq->P_ID = jedec_table[index].cmd_set;
+        cfi->cfiq->NumEraseRegions = jedec_table[index].nr_regions;
+        cfi->cfiq->DevSize = jedec_table[index].dev_size;
+        cfi->cfi_mode = CFI_MODE_JEDEC;
+        cfi->sector_erase_cmd = CMD(0x30);
 
         for (i=0; i<num_erase_regions; i++){
-                p_cfi->cfiq->EraseRegionInfo[i] = jedec_table[index].regions[i];
+                cfi->cfiq->EraseRegionInfo[i] = jedec_table[index].regions[i];
         }
-        p_cfi->cmdset_priv = NULL;
+        cfi->cmdset_priv = NULL;
 
         /* This may be redundant for some cases, but it doesn't hurt */
-        p_cfi->mfr = jedec_table[index].mfr_id;
-        p_cfi->id = jedec_table[index].dev_id;
+        cfi->mfr = jedec_table[index].mfr_id;
+        cfi->id = jedec_table[index].dev_id;
 
         uaddr = jedec_table[index].uaddr;
 
@@ -1978,8 +1979,8 @@ static int cfi_jedec_setup(struct cfi_private *p_cfi, int index)
            our brains explode when we see the datasheets talking about address
            lines numbered from A-1 to A18. The CFI table has unlock addresses
            in device-words according to the mode the device is connected in */
-        p_cfi->addr_unlock1 = unlock_addrs[uaddr].addr1 / p_cfi->device_type;
-        p_cfi->addr_unlock2 = unlock_addrs[uaddr].addr2 / p_cfi->device_type;
+        cfi->addr_unlock1 = unlock_addrs[uaddr].addr1 / cfi->device_type;
+        cfi->addr_unlock2 = unlock_addrs[uaddr].addr2 / cfi->device_type;
 
         return 1;       /* ok */
 }
@@ -2074,7 +2075,7 @@ static inline int jedec_match( uint32_t base,
         }
 
         /*
-         * Make sure the ID's dissappear when the device is taken out of
+         * Make sure the ID's disappear when the device is taken out of
          * ID mode.  The only time this should fail when it should succeed
          * is when the ID's are written as data to the same
          * addresses.  For this rare and unfortunate case the chip
@@ -2175,7 +2176,7 @@ static int jedec_probe_chip(struct map_info *map, __u32 base,
                                        "MTD %s(): matched device 0x%x,0x%x unlock_addrs: 0x%.4x 0x%.4x\n",
                                        __func__, cfi->mfr, cfi->id,
                                        cfi->addr_unlock1, cfi->addr_unlock2 );
-                                if (!cfi_jedec_setup(cfi, i))
+                                if (!cfi_jedec_setup(map, cfi, i))
                                         return 0;
                                 goto ok_out;
                         }