8 files changed, 557 insertions, 428 deletions

diff --git a/drivers/mtd/chips/cfi_cmdset_0001.c b/drivers/mtd/chips/cfi_cmdset_0001.c
index 5fbf29e1e64f..62f3ea9de848 100644
--- a/drivers/mtd/chips/cfi_cmdset_0001.c
+++ b/drivers/mtd/chips/cfi_cmdset_0001.c
@@ -615,10 +615,8 @@ static struct mtd_info *cfi_intelext_setup(struct mtd_info *mtd)
         return mtd;
 
  setup_err:
-        if(mtd) {
-                kfree(mtd->eraseregions);
-                kfree(mtd);
-        }
+        kfree(mtd->eraseregions);
+        kfree(mtd);
         kfree(cfi->cmdset_priv);
         return NULL;
 }
@@ -727,8 +725,7 @@ static int cfi_intelext_partition_fixup(struct mtd_info *mtd,
                                 /* those should be reset too since
                                    they create memory references. */
                                 init_waitqueue_head(&chip->wq);
-                                spin_lock_init(&chip->_spinlock);
-                                chip->mutex = &chip->_spinlock;
+                                mutex_init(&chip->mutex);
                                 chip++;
                         }
                 }
@@ -774,9 +771,9 @@ static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long
                         if (chip->priv && map_word_andequal(map, status, status_PWS, status_PWS))
                                 break;
 
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         cfi_udelay(1);
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         /* Someone else might have been playing with it. */
                         return -EAGAIN;
                 }
@@ -823,9 +820,9 @@ static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long
                                 return -EIO;
                         }
 
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         cfi_udelay(1);
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         /* Nobody will touch it while it's in state FL_ERASE_SUSPENDING.
                            So we can just loop here. */
                 }
@@ -852,10 +849,10 @@ static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long
         sleep:
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
                 return -EAGAIN;
         }
 }
@@ -901,20 +898,20 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
                          * it'll happily send us to sleep.  In any case, when
                          * get_chip returns success we're clear to go ahead.
                          */
-                        ret = spin_trylock(contender->mutex);
+                        ret = mutex_trylock(&contender->mutex);
                         spin_unlock(&shared->lock);
                         if (!ret)
                                 goto retry;
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         ret = chip_ready(map, contender, contender->start, mode);
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
 
                         if (ret == -EAGAIN) {
-                                spin_unlock(contender->mutex);
+                                mutex_unlock(&contender->mutex);
                                 goto retry;
                         }
                         if (ret) {
-                                spin_unlock(contender->mutex);
+                                mutex_unlock(&contender->mutex);
                                 return ret;
                         }
                         spin_lock(&shared->lock);
@@ -923,10 +920,10 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
                          * in FL_SYNCING state. Put contender and retry. */
                         if (chip->state == FL_SYNCING) {
                                 put_chip(map, contender, contender->start);
-                                spin_unlock(contender->mutex);
+                                mutex_unlock(&contender->mutex);
                                 goto retry;
                         }
-                        spin_unlock(contender->mutex);
+                        mutex_unlock(&contender->mutex);
                 }
 
                 /* Check if we already have suspended erase
@@ -936,10 +933,10 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
                         spin_unlock(&shared->lock);
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         goto retry;
                 }
 
@@ -969,12 +966,12 @@ static void put_chip(struct map_info *map, struct flchip *chip, unsigned long ad
                         if (shared->writing && shared->writing != chip) {
                                 /* give back ownership to who we loaned it from */
                                 struct flchip *loaner = shared->writing;
-                                spin_lock(loaner->mutex);
+                                mutex_lock(&loaner->mutex);
                                 spin_unlock(&shared->lock);
-                                spin_unlock(chip->mutex);
+                                mutex_unlock(&chip->mutex);
                                 put_chip(map, loaner, loaner->start);
-                                spin_lock(chip->mutex);
-                                spin_unlock(loaner->mutex);
+                                mutex_lock(&chip->mutex);
+                                mutex_unlock(&loaner->mutex);
                                 wake_up(&chip->wq);
                                 return;
                         }
@@ -1144,7 +1141,7 @@ static int __xipram xip_wait_for_operation(
                         (void) map_read(map, adr);
                         xip_iprefetch();
                         local_irq_enable();
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         xip_iprefetch();
                         cond_resched();
 
@@ -1154,15 +1151,15 @@ static int __xipram xip_wait_for_operation(
                          * a suspended erase state.  If so let's wait
                          * until it's done.
                          */
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         while (chip->state != newstate) {
                                 DECLARE_WAITQUEUE(wait, current);
                                 set_current_state(TASK_UNINTERRUPTIBLE);
                                 add_wait_queue(&chip->wq, &wait);
-                                spin_unlock(chip->mutex);
+                                mutex_unlock(&chip->mutex);
                                 schedule();
                                 remove_wait_queue(&chip->wq, &wait);
-                                spin_lock(chip->mutex);
+                                mutex_lock(&chip->mutex);
                         }
                         /* Disallow XIP again */
                         local_irq_disable();
@@ -1218,10 +1215,10 @@ static int inval_cache_and_wait_for_operation(
         int chip_state = chip->state;
         unsigned int timeo, sleep_time, reset_timeo;
 
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         if (inval_len)
                 INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         timeo = chip_op_time_max;
         if (!timeo)
@@ -1241,7 +1238,7 @@ static int inval_cache_and_wait_for_operation(
                 }
 
                 /* OK Still waiting. Drop the lock, wait a while and retry. */
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 if (sleep_time >= 1000000/HZ) {
                         /*
                          * Half of the normal delay still remaining
@@ -1256,17 +1253,17 @@ static int inval_cache_and_wait_for_operation(
                         cond_resched();
                         timeo--;
                 }
-                spin_lock(chip->mutex);
+                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);
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                 }
                 if (chip->erase_suspended && chip_state == FL_ERASING)  {
                         /* Erase suspend occured while sleep: reset timeout */
@@ -1302,7 +1299,7 @@ static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t a
         /* Ensure cmd read/writes are aligned. */
         cmd_addr = adr & ~(map_bankwidth(map)-1);
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         ret = get_chip(map, chip, cmd_addr, FL_POINT);
 
@@ -1313,7 +1310,7 @@ static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t a
                 chip->state = FL_POINT;
                 chip->ref_point_counter++;
         }
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
 
         return ret;
 }
@@ -1398,7 +1395,7 @@ static void cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
                 else
                         thislen = len;
 
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
                 if (chip->state == FL_POINT) {
                         chip->ref_point_counter--;
                         if(chip->ref_point_counter == 0)
@@ -1407,7 +1404,7 @@ static void cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
                         printk(KERN_ERR "%s: Warning: unpoint called on non pointed region\n", map->name); /* Should this give an error? */
 
                 put_chip(map, chip, chip->start);
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
 
                 len -= thislen;
                 ofs = 0;
@@ -1426,10 +1423,10 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
         /* Ensure cmd read/writes are aligned. */
         cmd_addr = adr & ~(map_bankwidth(map)-1);
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, cmd_addr, FL_READY);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -1443,7 +1440,7 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
 
         put_chip(map, chip, cmd_addr);
 
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return 0;
 }
 
@@ -1506,10 +1503,10 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
                 return -EINVAL;
         }
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, adr, mode);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -1555,7 +1552,7 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
 
         xip_enable(map, chip, adr);
  out:   put_chip(map, chip, adr);
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return ret;
 }
 
@@ -1664,10 +1661,10 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
         /* Let's determine this according to the interleave only once */
         write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0xe8) : CMD(0xe9);
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, cmd_adr, FL_WRITING);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -1798,7 +1795,7 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
 
         xip_enable(map, chip, cmd_adr);
  out:   put_chip(map, chip, cmd_adr);
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return ret;
 }
 
@@ -1877,10 +1874,10 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
         adr += chip->start;
 
  retry:
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, adr, FL_ERASING);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -1936,7 +1933,7 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
                 } else if (chipstatus & 0x20 && retries--) {
                         printk(KERN_DEBUG "block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr, chipstatus);
                         put_chip(map, chip, adr);
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         goto retry;
                 } else {
                         printk(KERN_ERR "%s: block erase failed at 0x%08lx (status 0x%lx)\n", map->name, adr, chipstatus);
@@ -1948,7 +1945,7 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
 
         xip_enable(map, chip, adr);
  out:   put_chip(map, chip, adr);
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return ret;
 }
 
@@ -1981,7 +1978,7 @@ static void cfi_intelext_sync (struct mtd_info *mtd)
         for (i=0; !ret && i<cfi->numchips; i++) {
                 chip = &cfi->chips[i];
 
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
                 ret = get_chip(map, chip, chip->start, FL_SYNCING);
 
                 if (!ret) {
@@ -1992,7 +1989,7 @@ static void cfi_intelext_sync (struct mtd_info *mtd)
                          * with the chip now anyway.
                          */
                 }
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 
         /* Unlock the chips again */
@@ -2000,14 +1997,14 @@ static void cfi_intelext_sync (struct mtd_info *mtd)
         for (i--; i >=0; i--) {
                 chip = &cfi->chips[i];
 
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 if (chip->state == FL_SYNCING) {
                         chip->state = chip->oldstate;
                         chip->oldstate = FL_READY;
                         wake_up(&chip->wq);
                 }
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 }
 
@@ -2053,10 +2050,10 @@ static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip
 
         adr += chip->start;
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, adr, FL_LOCKING);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -2090,7 +2087,7 @@ static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip
 
         xip_enable(map, chip, adr);
 out:    put_chip(map, chip, adr);
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return ret;
 }
 
@@ -2155,10 +2152,10 @@ do_otp_read(struct map_info *map, struct flchip *chip, u_long offset,
         struct cfi_private *cfi = map->fldrv_priv;
         int ret;
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, chip->start, FL_JEDEC_QUERY);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -2177,7 +2174,7 @@ do_otp_read(struct map_info *map, struct flchip *chip, u_long offset,
         INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
 
         put_chip(map, chip, chip->start);
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return 0;
 }
 
@@ -2452,7 +2449,7 @@ static int cfi_intelext_suspend(struct mtd_info *mtd)
         for (i=0; !ret && i<cfi->numchips; i++) {
                 chip = &cfi->chips[i];
 
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 switch (chip->state) {
                 case FL_READY:
@@ -2484,7 +2481,7 @@ static int cfi_intelext_suspend(struct mtd_info *mtd)
                 case FL_PM_SUSPENDED:
                         break;
                 }
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 
         /* Unlock the chips again */
@@ -2493,7 +2490,7 @@ static int cfi_intelext_suspend(struct mtd_info *mtd)
                 for (i--; i >=0; i--) {
                         chip = &cfi->chips[i];
 
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
 
                         if (chip->state == FL_PM_SUSPENDED) {
                                 /* No need to force it into a known state here,
@@ -2503,7 +2500,7 @@ static int cfi_intelext_suspend(struct mtd_info *mtd)
                                 chip->oldstate = FL_READY;
                                 wake_up(&chip->wq);
                         }
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                 }
         }
 
@@ -2544,7 +2541,7 @@ static void cfi_intelext_resume(struct mtd_info *mtd)
 
                 chip = &cfi->chips[i];
 
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 /* Go to known state. Chip may have been power cycled */
                 if (chip->state == FL_PM_SUSPENDED) {
@@ -2553,7 +2550,7 @@ static void cfi_intelext_resume(struct mtd_info *mtd)
                         wake_up(&chip->wq);
                 }
 
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 
         if ((mtd->flags & MTD_POWERUP_LOCK)
@@ -2573,14 +2570,14 @@ static int cfi_intelext_reset(struct mtd_info *mtd)
                 /* force the completion of any ongoing operation
                    and switch to array mode so any bootloader in
                    flash is accessible for soft reboot. */
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
                 ret = get_chip(map, chip, chip->start, FL_SHUTDOWN);
                 if (!ret) {
                         map_write(map, CMD(0xff), chip->start);
                         chip->state = FL_SHUTDOWN;
                         put_chip(map, chip, chip->start);
                 }
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 
         return 0;
diff --git a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c
index f3600e8d5382..d81079ef91a5 100644
--- a/drivers/mtd/chips/cfi_cmdset_0002.c
+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
@@ -32,6 +32,7 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/reboot.h>
 #include <linux/mtd/compatmac.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/mtd.h>
@@ -43,10 +44,6 @@
 
 #define MAX_WORD_RETRIES 3
 
-#define MANUFACTURER_AMD        0x0001
-#define MANUFACTURER_ATMEL      0x001F
-#define MANUFACTURER_MACRONIX   0x00C2
-#define MANUFACTURER_SST        0x00BF
 #define SST49LF004B             0x0060
 #define SST49LF040B             0x0050
 #define SST49LF008A             0x005a
@@ -60,6 +57,7 @@ static int cfi_amdstd_erase_varsize(struct mtd_info *, struct erase_info *);
 static void cfi_amdstd_sync (struct mtd_info *);
 static int cfi_amdstd_suspend (struct mtd_info *);
 static void cfi_amdstd_resume (struct mtd_info *);
+static int cfi_amdstd_reboot(struct notifier_block *, unsigned long, void *);
 static int cfi_amdstd_secsi_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
 
 static void cfi_amdstd_destroy(struct mtd_info *);
@@ -168,7 +166,7 @@ static void fixup_amd_bootblock(struct mtd_info *mtd, void* param)
                          * This reduces the risk of false detection due to
                          * the 8-bit device ID.
                          */
-                        (cfi->mfr == MANUFACTURER_MACRONIX)) {
+                        (cfi->mfr == CFI_MFR_MACRONIX)) {
                         DEBUG(MTD_DEBUG_LEVEL1,
                                 "%s: Macronix MX29LV400C with bottom boot block"
                                 " detected\n", map->name);
@@ -260,6 +258,42 @@ static void fixup_use_atmel_lock(struct mtd_info *mtd, void *param)
         mtd->flags |= MTD_POWERUP_LOCK;
 }
 
+static void fixup_old_sst_eraseregion(struct mtd_info *mtd)
+{
+        struct map_info *map = mtd->priv;
+        struct cfi_private *cfi = map->fldrv_priv;
+
+        /*
+         * These flashes report two seperate 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.
+         */
+        cfi->cfiq->NumEraseRegions = 1;
+}
+
+static void fixup_sst39vf(struct mtd_info *mtd, void *param)
+{
+        struct map_info *map = mtd->priv;
+        struct cfi_private *cfi = map->fldrv_priv;
+
+        fixup_old_sst_eraseregion(mtd);
+
+        cfi->addr_unlock1 = 0x5555;
+        cfi->addr_unlock2 = 0x2AAA;
+}
+
+static void fixup_sst39vf_rev_b(struct mtd_info *mtd, void *param)
+{
+        struct map_info *map = mtd->priv;
+        struct cfi_private *cfi = map->fldrv_priv;
+
+        fixup_old_sst_eraseregion(mtd);
+
+        cfi->addr_unlock1 = 0x555;
+        cfi->addr_unlock2 = 0x2AA;
+}
+
 static void fixup_s29gl064n_sectors(struct mtd_info *mtd, void *param)
 {
         struct map_info *map = mtd->priv;
@@ -282,11 +316,24 @@ 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 }
+};
+
 static struct cfi_fixup cfi_fixup_table[] = {
         { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri, NULL },
 #ifdef AMD_BOOTLOC_BUG
         { CFI_MFR_AMD, CFI_ID_ANY, fixup_amd_bootblock, NULL },
-        { MANUFACTURER_MACRONIX, CFI_ID_ANY, fixup_amd_bootblock, NULL },
+        { CFI_MFR_MACRONIX, CFI_ID_ANY, fixup_amd_bootblock, NULL },
 #endif
         { CFI_MFR_AMD, 0x0050, fixup_use_secsi, NULL, },
         { CFI_MFR_AMD, 0x0053, fixup_use_secsi, NULL, },
@@ -304,9 +351,9 @@ static struct cfi_fixup cfi_fixup_table[] = {
         { 0, 0, NULL, NULL }
 };
 static struct cfi_fixup jedec_fixup_table[] = {
-        { MANUFACTURER_SST, SST49LF004B, fixup_use_fwh_lock, NULL, },
-        { MANUFACTURER_SST, SST49LF040B, fixup_use_fwh_lock, NULL, },
-        { MANUFACTURER_SST, SST49LF008A, fixup_use_fwh_lock, NULL, },
+        { 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 }
 };
 
@@ -355,67 +402,72 @@ struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
         mtd->name    = map->name;
         mtd->writesize = 1;
 
+        mtd->reboot_notifier.notifier_call = cfi_amdstd_reboot;
+
         if (cfi->cfi_mode==CFI_MODE_CFI){
                 unsigned char bootloc;
-                /*
-                 * It's a real CFI chip, not one for which the probe
-                 * routine faked a CFI structure. So we read the feature
-                 * table from it.
-                 */
                 __u16 adr = primary?cfi->cfiq->P_ADR:cfi->cfiq->A_ADR;
                 struct cfi_pri_amdstd *extp;
 
                 extp = (struct cfi_pri_amdstd*)cfi_read_pri(map, adr, sizeof(*extp), "Amd/Fujitsu");
-                if (!extp) {
-                        kfree(mtd);
-                        return NULL;
-                }
-
-                cfi_fixup_major_minor(cfi, extp);
-
-                if (extp->MajorVersion != '1' ||
-                    (extp->MinorVersion < '0' || extp->MinorVersion > '4')) {
-                        printk(KERN_ERR "  Unknown Amd/Fujitsu Extended Query "
-                               "version %c.%c.\n",  extp->MajorVersion,
-                               extp->MinorVersion);
-                        kfree(extp);
-                        kfree(mtd);
-                        return NULL;
-                }
+                if (extp) {
+                        /*
+                         * It's a real CFI chip, not one for which the probe
+                         * routine faked a CFI structure.
+                         */
+                        cfi_fixup_major_minor(cfi, extp);
+
+                        if (extp->MajorVersion != '1' ||
+                            (extp->MinorVersion < '0' || extp->MinorVersion > '4')) {
+                                printk(KERN_ERR "  Unknown Amd/Fujitsu Extended Query "
+                                       "version %c.%c.\n",  extp->MajorVersion,
+                                       extp->MinorVersion);
+                                kfree(extp);
+                                kfree(mtd);
+                                return NULL;
+                        }
 
-                /* Install our own private info structure */
-                cfi->cmdset_priv = extp;
+                        /* Install our own private info structure */
+                        cfi->cmdset_priv = extp;
 
-                /* Apply cfi device specific fixups */
-                cfi_fixup(mtd, cfi_fixup_table);
+                        /* Apply cfi device specific fixups */
+                        cfi_fixup(mtd, cfi_fixup_table);
 
 #ifdef DEBUG_CFI_FEATURES
-                /* Tell the user about it in lots of lovely detail */
-                cfi_tell_features(extp);
+                        /* Tell the user about it in lots of lovely detail */
+                        cfi_tell_features(extp);
 #endif
 
-                bootloc = extp->TopBottom;
-                if ((bootloc != 2) && (bootloc != 3)) {
-                        printk(KERN_WARNING "%s: CFI does not contain boot "
-                               "bank location. Assuming top.\n", map->name);
-                        bootloc = 2;
-                }
+                        bootloc = extp->TopBottom;
+                        if ((bootloc < 2) || (bootloc > 5)) {
+                                printk(KERN_WARNING "%s: CFI contains unrecognised boot "
+                                       "bank location (%d). Assuming bottom.\n",
+                                       map->name, bootloc);
+                                bootloc = 2;
+                        }
 
-                if (bootloc == 3 && cfi->cfiq->NumEraseRegions > 1) {
-                        printk(KERN_WARNING "%s: Swapping erase regions for broken CFI table.\n", map->name);
+                        if (bootloc == 3 && cfi->cfiq->NumEraseRegions > 1) {
+                                printk(KERN_WARNING "%s: Swapping erase regions for top-boot CFI table.\n", map->name);
 
-                        for (i=0; i<cfi->cfiq->NumEraseRegions / 2; i++) {
-                                int j = (cfi->cfiq->NumEraseRegions-1)-i;
-                                __u32 swap;
+                                for (i=0; i<cfi->cfiq->NumEraseRegions / 2; i++) {
+                                        int j = (cfi->cfiq->NumEraseRegions-1)-i;
+                                        __u32 swap;
 
-                                swap = cfi->cfiq->EraseRegionInfo[i];
-                                cfi->cfiq->EraseRegionInfo[i] = cfi->cfiq->EraseRegionInfo[j];
-                                cfi->cfiq->EraseRegionInfo[j] = swap;
+                                        swap = cfi->cfiq->EraseRegionInfo[i];
+                                        cfi->cfiq->EraseRegionInfo[i] = cfi->cfiq->EraseRegionInfo[j];
+                                        cfi->cfiq->EraseRegionInfo[j] = swap;
+                                }
                         }
+                        /* Set the default CFI lock/unlock addresses */
+                        cfi->addr_unlock1 = 0x555;
+                        cfi->addr_unlock2 = 0x2aa;
+                }
+                cfi_fixup(mtd, cfi_nopri_fixup_table);
+
+                if (!cfi->addr_unlock1 || !cfi->addr_unlock2) {
+                        kfree(mtd);
+                        return NULL;
                 }
-                /* Set the default CFI lock/unlock addresses */
-                cfi->addr_unlock1 = 0x555;
-                cfi->addr_unlock2 = 0x2aa;
 
         } /* CFI mode */
         else if (cfi->cfi_mode == CFI_MODE_JEDEC) {
@@ -437,7 +489,11 @@ struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
 
         return cfi_amdstd_setup(mtd);
 }
+struct mtd_info *cfi_cmdset_0006(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0002")));
+struct mtd_info *cfi_cmdset_0701(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0002")));
 EXPORT_SYMBOL_GPL(cfi_cmdset_0002);
+EXPORT_SYMBOL_GPL(cfi_cmdset_0006);
+EXPORT_SYMBOL_GPL(cfi_cmdset_0701);
 
 static struct mtd_info *cfi_amdstd_setup(struct mtd_info *mtd)
 {
@@ -491,13 +547,12 @@ static struct mtd_info *cfi_amdstd_setup(struct mtd_info *mtd)
 #endif
 
         __module_get(THIS_MODULE);
+        register_reboot_notifier(&mtd->reboot_notifier);
         return mtd;
 
  setup_err:
-        if(mtd) {
-                kfree(mtd->eraseregions);
-                kfree(mtd);
-        }
+        kfree(mtd->eraseregions);
+        kfree(mtd);
         kfree(cfi->cmdset_priv);
         kfree(cfi->cfiq);
         return NULL;
@@ -571,9 +626,9 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
                                 printk(KERN_ERR "Waiting for chip to be ready timed out.\n");
                                 return -EIO;
                         }
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         cfi_udelay(1);
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         /* Someone else might have been playing with it. */
                         goto retry;
                 }
@@ -617,9 +672,9 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
                                 return -EIO;
                         }
 
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         cfi_udelay(1);
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         /* Nobody will touch it while it's in state FL_ERASE_SUSPENDING.
                            So we can just loop here. */
                 }
@@ -634,6 +689,10 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
                 chip->state = FL_READY;
                 return 0;
 
+        case FL_SHUTDOWN:
+                /* The machine is rebooting */
+                return -EIO;
+
         case FL_POINT:
                 /* Only if there's no operation suspended... */
                 if (mode == FL_READY && chip->oldstate == FL_READY)
@@ -643,10 +702,10 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
         sleep:
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
                 goto resettime;
         }
 }
@@ -778,7 +837,7 @@ static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
                         (void) map_read(map, adr);
                         xip_iprefetch();
                         local_irq_enable();
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         xip_iprefetch();
                         cond_resched();
 
@@ -788,15 +847,15 @@ static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
                          * a suspended erase state.  If so let's wait
                          * until it's done.
                          */
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         while (chip->state != FL_XIP_WHILE_ERASING) {
                                 DECLARE_WAITQUEUE(wait, current);
                                 set_current_state(TASK_UNINTERRUPTIBLE);
                                 add_wait_queue(&chip->wq, &wait);
-                                spin_unlock(chip->mutex);
+                                mutex_unlock(&chip->mutex);
                                 schedule();
                                 remove_wait_queue(&chip->wq, &wait);
-                                spin_lock(chip->mutex);
+                                mutex_lock(&chip->mutex);
                         }
                         /* Disallow XIP again */
                         local_irq_disable();
@@ -858,17 +917,17 @@ static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
 
 #define UDELAY(map, chip, adr, usec)  \
 do {  \
-        spin_unlock(chip->mutex);  \
+        mutex_unlock(&chip->mutex);  \
         cfi_udelay(usec);  \
-        spin_lock(chip->mutex);  \
+        mutex_lock(&chip->mutex);  \
 } while (0)
 
 #define INVALIDATE_CACHE_UDELAY(map, chip, adr, len, usec)  \
 do {  \
-        spin_unlock(chip->mutex);  \
+        mutex_unlock(&chip->mutex);  \
         INVALIDATE_CACHED_RANGE(map, adr, len);  \
         cfi_udelay(usec);  \
-        spin_lock(chip->mutex);  \
+        mutex_lock(&chip->mutex);  \
 } while (0)
 
 #endif
@@ -884,10 +943,10 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
         /* Ensure cmd read/writes are aligned. */
         cmd_addr = adr & ~(map_bankwidth(map)-1);
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, cmd_addr, FL_READY);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -900,7 +959,7 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
 
         put_chip(map, chip, cmd_addr);
 
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return 0;
 }
 
@@ -954,7 +1013,7 @@ static inline int do_read_secsi_onechip(struct map_info *map, struct flchip *chi
         struct cfi_private *cfi = map->fldrv_priv;
 
  retry:
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         if (chip->state != FL_READY){
 #if 0
@@ -963,7 +1022,7 @@ static inline int do_read_secsi_onechip(struct map_info *map, struct flchip *chi
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
 
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
 
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
@@ -992,7 +1051,7 @@ static inline int do_read_secsi_onechip(struct map_info *map, struct flchip *chi
         cfi_send_gen_cmd(0x00, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
 
         wake_up(&chip->wq);
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
 
         return 0;
 }
@@ -1061,10 +1120,10 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
 
         adr += chip->start;
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, adr, FL_WRITING);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -1107,11 +1166,11 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
 
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
                         timeo = jiffies + (HZ / 2); /* FIXME */
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         continue;
                 }
 
@@ -1143,7 +1202,7 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
  op_done:
         chip->state = FL_READY;
         put_chip(map, chip, adr);
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
 
         return ret;
 }
@@ -1175,7 +1234,7 @@ static int cfi_amdstd_write_words(struct mtd_info *mtd, loff_t to, size_t len,
                 map_word tmp_buf;
 
  retry:
-                spin_lock(cfi->chips[chipnum].mutex);
+                mutex_lock(&cfi->chips[chipnum].mutex);
 
                 if (cfi->chips[chipnum].state != FL_READY) {
 #if 0
@@ -1184,7 +1243,7 @@ static int cfi_amdstd_write_words(struct mtd_info *mtd, loff_t to, size_t len,
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&cfi->chips[chipnum].wq, &wait);
 
-                        spin_unlock(cfi->chips[chipnum].mutex);
+                        mutex_unlock(&cfi->chips[chipnum].mutex);
 
                         schedule();
                         remove_wait_queue(&cfi->chips[chipnum].wq, &wait);
@@ -1198,7 +1257,7 @@ static int cfi_amdstd_write_words(struct mtd_info *mtd, loff_t to, size_t len,
                 /* Load 'tmp_buf' with old contents of flash */
                 tmp_buf = map_read(map, bus_ofs+chipstart);
 
-                spin_unlock(cfi->chips[chipnum].mutex);
+                mutex_unlock(&cfi->chips[chipnum].mutex);
 
                 /* Number of bytes to copy from buffer */
                 n = min_t(int, len, map_bankwidth(map)-i);
@@ -1253,7 +1312,7 @@ static int cfi_amdstd_write_words(struct mtd_info *mtd, loff_t to, size_t len,
                 map_word tmp_buf;
 
  retry1:
-                spin_lock(cfi->chips[chipnum].mutex);
+                mutex_lock(&cfi->chips[chipnum].mutex);
 
                 if (cfi->chips[chipnum].state != FL_READY) {
 #if 0
@@ -1262,7 +1321,7 @@ static int cfi_amdstd_write_words(struct mtd_info *mtd, loff_t to, size_t len,
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&cfi->chips[chipnum].wq, &wait);
 
-                        spin_unlock(cfi->chips[chipnum].mutex);
+                        mutex_unlock(&cfi->chips[chipnum].mutex);
 
                         schedule();
                         remove_wait_queue(&cfi->chips[chipnum].wq, &wait);
@@ -1275,7 +1334,7 @@ static int cfi_amdstd_write_words(struct mtd_info *mtd, loff_t to, size_t len,
 
                 tmp_buf = map_read(map, ofs + chipstart);
 
-                spin_unlock(cfi->chips[chipnum].mutex);
+                mutex_unlock(&cfi->chips[chipnum].mutex);
 
                 tmp_buf = map_word_load_partial(map, tmp_buf, buf, 0, len);
 
@@ -1310,10 +1369,10 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
         adr += chip->start;
         cmd_adr = adr;
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, adr, FL_WRITING);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -1368,11 +1427,11 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
 
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
                         timeo = jiffies + (HZ / 2); /* FIXME */
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         continue;
                 }
 
@@ -1400,7 +1459,7 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
  op_done:
         chip->state = FL_READY;
         put_chip(map, chip, adr);
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
 
         return ret;
 }
@@ -1500,10 +1559,10 @@ static int __xipram do_erase_chip(struct map_info *map, struct flchip *chip)
 
         adr = cfi->addr_unlock1;
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, adr, FL_WRITING);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -1536,10 +1595,10 @@ static int __xipram do_erase_chip(struct map_info *map, struct flchip *chip)
                         /* Someone's suspended the erase. Sleep */
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         continue;
                 }
                 if (chip->erase_suspended) {
@@ -1573,7 +1632,7 @@ static int __xipram do_erase_chip(struct map_info *map, struct flchip *chip)
         chip->state = FL_READY;
         xip_enable(map, chip, adr);
         put_chip(map, chip, adr);
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
 
         return ret;
 }
@@ -1588,10 +1647,10 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
 
         adr += chip->start;
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, adr, FL_ERASING);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -1624,10 +1683,10 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
                         /* Someone's suspended the erase. Sleep */
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         continue;
                 }
                 if (chip->erase_suspended) {
@@ -1663,7 +1722,7 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
 
         chip->state = FL_READY;
         put_chip(map, chip, adr);
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return ret;
 }
 
@@ -1715,7 +1774,7 @@ static int do_atmel_lock(struct map_info *map, struct flchip *chip,
         struct cfi_private *cfi = map->fldrv_priv;
         int ret;
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, adr + chip->start, FL_LOCKING);
         if (ret)
                 goto out_unlock;
@@ -1741,7 +1800,7 @@ static int do_atmel_lock(struct map_info *map, struct flchip *chip,
         ret = 0;
 
 out_unlock:
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return ret;
 }
 
@@ -1751,7 +1810,7 @@ static int do_atmel_unlock(struct map_info *map, struct flchip *chip,
         struct cfi_private *cfi = map->fldrv_priv;
         int ret;
 
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, adr + chip->start, FL_UNLOCKING);
         if (ret)
                 goto out_unlock;
@@ -1769,7 +1828,7 @@ static int do_atmel_unlock(struct map_info *map, struct flchip *chip,
         ret = 0;
 
 out_unlock:
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return ret;
 }
 
@@ -1797,7 +1856,7 @@ static void cfi_amdstd_sync (struct mtd_info *mtd)
                 chip = &cfi->chips[i];
 
         retry:
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 switch(chip->state) {
                 case FL_READY:
@@ -1811,7 +1870,7 @@ static void cfi_amdstd_sync (struct mtd_info *mtd)
                          * with the chip now anyway.
                          */
                 case FL_SYNCING:
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         break;
 
                 default:
@@ -1819,7 +1878,7 @@ static void cfi_amdstd_sync (struct mtd_info *mtd)
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
 
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
 
                         schedule();
 
@@ -1834,13 +1893,13 @@ static void cfi_amdstd_sync (struct mtd_info *mtd)
         for (i--; i >=0; i--) {
                 chip = &cfi->chips[i];
 
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 if (chip->state == FL_SYNCING) {
                         chip->state = chip->oldstate;
                         wake_up(&chip->wq);
                 }
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 }
 
@@ -1856,7 +1915,7 @@ static int cfi_amdstd_suspend(struct mtd_info *mtd)
         for (i=0; !ret && i<cfi->numchips; i++) {
                 chip = &cfi->chips[i];
 
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 switch(chip->state) {
                 case FL_READY:
@@ -1876,7 +1935,7 @@ static int cfi_amdstd_suspend(struct mtd_info *mtd)
                         ret = -EAGAIN;
                         break;
                 }
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 
         /* Unlock the chips again */
@@ -1885,13 +1944,13 @@ static int cfi_amdstd_suspend(struct mtd_info *mtd)
                 for (i--; i >=0; i--) {
                         chip = &cfi->chips[i];
 
-                        spin_lock(chip->mutex);
+                        mutex_lock(&chip->mutex);
 
                         if (chip->state == FL_PM_SUSPENDED) {
                                 chip->state = chip->oldstate;
                                 wake_up(&chip->wq);
                         }
-                        spin_unlock(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                 }
         }
 
@@ -1910,7 +1969,7 @@ static void cfi_amdstd_resume(struct mtd_info *mtd)
 
                 chip = &cfi->chips[i];
 
-                spin_lock(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 if (chip->state == FL_PM_SUSPENDED) {
                         chip->state = FL_READY;
@@ -1920,15 +1979,62 @@ static void cfi_amdstd_resume(struct mtd_info *mtd)
                 else
                         printk(KERN_ERR "Argh. Chip not in PM_SUSPENDED state upon resume()\n");
 
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 }
 
+
+/*
+ * Ensure that the flash device is put back into read array mode before
+ * unloading the driver or rebooting.  On some systems, rebooting while
+ * the flash is in query/program/erase mode will prevent the CPU from
+ * fetching the bootloader code, requiring a hard reset or power cycle.
+ */
+static int cfi_amdstd_reset(struct mtd_info *mtd)
+{
+        struct map_info *map = mtd->priv;
+        struct cfi_private *cfi = map->fldrv_priv;
+        int i, ret;
+        struct flchip *chip;
+
+        for (i = 0; i < cfi->numchips; i++) {
+
+                chip = &cfi->chips[i];
+
+                mutex_lock(&chip->mutex);
+
+                ret = get_chip(map, chip, chip->start, FL_SHUTDOWN);
+                if (!ret) {
+                        map_write(map, CMD(0xF0), chip->start);
+                        chip->state = FL_SHUTDOWN;
+                        put_chip(map, chip, chip->start);
+                }
+
+                mutex_unlock(&chip->mutex);
+        }
+
+        return 0;
+}
+
+
+static int cfi_amdstd_reboot(struct notifier_block *nb, unsigned long val,
+                               void *v)
+{
+        struct mtd_info *mtd;
+
+        mtd = container_of(nb, struct mtd_info, reboot_notifier);
+        cfi_amdstd_reset(mtd);
+        return NOTIFY_DONE;
+}
+
+
 static void cfi_amdstd_destroy(struct mtd_info *mtd)
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
 
+        cfi_amdstd_reset(mtd);
+        unregister_reboot_notifier(&mtd->reboot_notifier);
         kfree(cfi->cmdset_priv);
         kfree(cfi->cfiq);
         kfree(cfi);
@@ -1938,3 +2044,5 @@ static void cfi_amdstd_destroy(struct mtd_info *mtd)
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Crossnet Co. <info@crossnet.co.jp> et al.");
 MODULE_DESCRIPTION("MTD chip driver for AMD/Fujitsu flash chips");
+MODULE_ALIAS("cfi_cmdset_0006");
+MODULE_ALIAS("cfi_cmdset_0701");
diff --git a/drivers/mtd/chips/cfi_cmdset_0020.c b/drivers/mtd/chips/cfi_cmdset_0020.c
index 0667a671525d..e54e8c169d76 100644
--- a/drivers/mtd/chips/cfi_cmdset_0020.c
+++ b/drivers/mtd/chips/cfi_cmdset_0020.c
@@ -265,7 +265,7 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
 
         timeo = jiffies + HZ;
  retry:
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* Check that the chip's ready to talk to us.
          * If it's in FL_ERASING state, suspend it and make it talk now.
@@ -296,15 +296,15 @@ 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;
-                                spin_unlock_bh(chip->mutex);
+                                mutex_unlock(&chip->mutex);
                                 printk(KERN_ERR "Chip not ready after erase "
                                        "suspended: status = 0x%lx\n", status.x[0]);
                                 return -EIO;
                         }
 
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         cfi_udelay(1);
-                        spin_lock_bh(chip->mutex);
+                        mutex_lock(&chip->mutex);
                 }
 
                 suspended = 1;
@@ -335,13 +335,13 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
 
                 /* Urgh. Chip not yet ready to talk to us. */
                 if (time_after(jiffies, timeo)) {
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in read. WSM status = %lx\n", status.x[0]);
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 goto retry;
 
@@ -351,7 +351,7 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
                    someone changes the status */
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
                 timeo = jiffies + HZ;
@@ -376,7 +376,7 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
         }
 
         wake_up(&chip->wq);
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return 0;
 }
 
@@ -445,7 +445,7 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
 #ifdef DEBUG_CFI_FEATURES
        printk("%s: chip->state[%d]\n", __func__, chip->state);
 #endif
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* Check that the chip's ready to talk to us.
          * Later, we can actually think about interrupting it
@@ -470,14 +470,14 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                         break;
                 /* Urgh. Chip not yet ready to talk to us. */
                 if (time_after(jiffies, timeo)) {
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in buffer write Xstatus = %lx, status = %lx\n",
                                status.x[0], map_read(map, cmd_adr).x[0]);
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 goto retry;
 
@@ -486,7 +486,7 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                    someone changes the status */
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
                 timeo = jiffies + HZ;
@@ -503,16 +503,16 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                 if (map_word_andequal(map, status, status_OK, status_OK))
                         break;
 
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 if (++z > 100) {
                         /* Argh. Not ready for write to buffer */
                         DISABLE_VPP(map);
                         map_write(map, CMD(0x70), cmd_adr);
                         chip->state = FL_STATUS;
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "Chip not ready for buffer write. Xstatus = %lx\n", status.x[0]);
                         return -EIO;
                 }
@@ -532,9 +532,9 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
         map_write(map, CMD(0xd0), cmd_adr);
         chip->state = FL_WRITING;
 
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         cfi_udelay(chip->buffer_write_time);
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         timeo = jiffies + (HZ/2);
         z = 0;
@@ -543,11 +543,11 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                         /* Someone's suspended the write. Sleep */
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
                         timeo = jiffies + (HZ / 2); /* FIXME */
-                        spin_lock_bh(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         continue;
                 }
 
@@ -563,16 +563,16 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                         map_write(map, CMD(0x70), adr);
                         chip->state = FL_STATUS;
                         DISABLE_VPP(map);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in bufwrite\n");
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 z++;
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
         }
         if (!z) {
                 chip->buffer_write_time--;
@@ -596,11 +596,11 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                 /* put back into read status register mode */
                 map_write(map, CMD(0x70), adr);
                 wake_up(&chip->wq);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return map_word_bitsset(map, status, CMD(0x02)) ? -EROFS : -EIO;
         }
         wake_up(&chip->wq);
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
 
         return 0;
 }
@@ -749,7 +749,7 @@ static inline int do_erase_oneblock(struct map_info *map, struct flchip *chip, u
 
         timeo = jiffies + HZ;
 retry:
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* Check that the chip's ready to talk to us. */
         switch (chip->state) {
@@ -766,13 +766,13 @@ retry:
 
                 /* Urgh. Chip not yet ready to talk to us. */
                 if (time_after(jiffies, timeo)) {
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in erase\n");
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 goto retry;
 
@@ -781,7 +781,7 @@ retry:
                    someone changes the status */
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
                 timeo = jiffies + HZ;
@@ -797,9 +797,9 @@ retry:
         map_write(map, CMD(0xD0), adr);
         chip->state = FL_ERASING;
 
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         msleep(1000);
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* FIXME. Use a timer to check this, and return immediately. */
         /* Once the state machine's known to be working I'll do that */
@@ -810,11 +810,11 @@ retry:
                         /* Someone's suspended the erase. Sleep */
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
                         timeo = jiffies + (HZ*20); /* FIXME */
-                        spin_lock_bh(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         continue;
                 }
 
@@ -828,14 +828,14 @@ retry:
                         chip->state = FL_STATUS;
                         printk(KERN_ERR "waiting for erase to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
                         DISABLE_VPP(map);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
         }
 
         DISABLE_VPP(map);
@@ -878,7 +878,7 @@ retry:
                                 printk(KERN_DEBUG "Chip erase failed at 0x%08lx: status 0x%x. Retrying...\n", adr, chipstatus);
                                 timeo = jiffies + HZ;
                                 chip->state = FL_STATUS;
-                                spin_unlock_bh(chip->mutex);
+                                mutex_unlock(&chip->mutex);
                                 goto retry;
                         }
                         printk(KERN_DEBUG "Chip erase failed at 0x%08lx: status 0x%x\n", adr, chipstatus);
@@ -887,7 +887,7 @@ retry:
         }
 
         wake_up(&chip->wq);
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return ret;
 }
 
@@ -995,7 +995,7 @@ static void cfi_staa_sync (struct mtd_info *mtd)
                 chip = &cfi->chips[i];
 
         retry:
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 switch(chip->state) {
                 case FL_READY:
@@ -1009,7 +1009,7 @@ static void cfi_staa_sync (struct mtd_info *mtd)
                          * with the chip now anyway.
                          */
                 case FL_SYNCING:
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         break;
 
                 default:
@@ -1017,7 +1017,7 @@ static void cfi_staa_sync (struct mtd_info *mtd)
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
 
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
 
@@ -1030,13 +1030,13 @@ static void cfi_staa_sync (struct mtd_info *mtd)
         for (i--; i >=0; i--) {
                 chip = &cfi->chips[i];
 
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 if (chip->state == FL_SYNCING) {
                         chip->state = chip->oldstate;
                         wake_up(&chip->wq);
                 }
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 }
 
@@ -1054,7 +1054,7 @@ static inline int do_lock_oneblock(struct map_info *map, struct flchip *chip, un
 
         timeo = jiffies + HZ;
 retry:
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* Check that the chip's ready to talk to us. */
         switch (chip->state) {
@@ -1071,13 +1071,13 @@ retry:
 
                 /* Urgh. Chip not yet ready to talk to us. */
                 if (time_after(jiffies, timeo)) {
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in lock\n");
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 goto retry;
 
@@ -1086,7 +1086,7 @@ retry:
                    someone changes the status */
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
                 timeo = jiffies + HZ;
@@ -1098,9 +1098,9 @@ retry:
         map_write(map, CMD(0x01), adr);
         chip->state = FL_LOCKING;
 
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         msleep(1000);
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* FIXME. Use a timer to check this, and return immediately. */
         /* Once the state machine's known to be working I'll do that */
@@ -1118,21 +1118,21 @@ retry:
                         chip->state = FL_STATUS;
                         printk(KERN_ERR "waiting for lock to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
                         DISABLE_VPP(map);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
         }
 
         /* Done and happy. */
         chip->state = FL_STATUS;
         DISABLE_VPP(map);
         wake_up(&chip->wq);
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return 0;
 }
 static int cfi_staa_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
@@ -1203,7 +1203,7 @@ static inline int do_unlock_oneblock(struct map_info *map, struct flchip *chip,
 
         timeo = jiffies + HZ;
 retry:
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* Check that the chip's ready to talk to us. */
         switch (chip->state) {
@@ -1220,13 +1220,13 @@ retry:
 
                 /* Urgh. Chip not yet ready to talk to us. */
                 if (time_after(jiffies, timeo)) {
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in unlock\n");
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 goto retry;
 
@@ -1235,7 +1235,7 @@ retry:
                    someone changes the status */
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
                 timeo = jiffies + HZ;
@@ -1247,9 +1247,9 @@ retry:
         map_write(map, CMD(0xD0), adr);
         chip->state = FL_UNLOCKING;
 
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         msleep(1000);
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* FIXME. Use a timer to check this, and return immediately. */
         /* Once the state machine's known to be working I'll do that */
@@ -1267,21 +1267,21 @@ retry:
                         chip->state = FL_STATUS;
                         printk(KERN_ERR "waiting for unlock to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
                         DISABLE_VPP(map);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the unlock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
         }
 
         /* Done and happy. */
         chip->state = FL_STATUS;
         DISABLE_VPP(map);
         wake_up(&chip->wq);
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return 0;
 }
 static int cfi_staa_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
@@ -1334,7 +1334,7 @@ static int cfi_staa_suspend(struct mtd_info *mtd)
         for (i=0; !ret && i<cfi->numchips; i++) {
                 chip = &cfi->chips[i];
 
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 switch(chip->state) {
                 case FL_READY:
@@ -1354,7 +1354,7 @@ static int cfi_staa_suspend(struct mtd_info *mtd)
                         ret = -EAGAIN;
                         break;
                 }
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 
         /* Unlock the chips again */
@@ -1363,7 +1363,7 @@ static int cfi_staa_suspend(struct mtd_info *mtd)
                 for (i--; i >=0; i--) {
                         chip = &cfi->chips[i];
 
-                        spin_lock_bh(chip->mutex);
+                        mutex_lock(&chip->mutex);
 
                         if (chip->state == FL_PM_SUSPENDED) {
                                 /* No need to force it into a known state here,
@@ -1372,7 +1372,7 @@ static int cfi_staa_suspend(struct mtd_info *mtd)
                                 chip->state = chip->oldstate;
                                 wake_up(&chip->wq);
                         }
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                 }
         }
 
@@ -1390,7 +1390,7 @@ static void cfi_staa_resume(struct mtd_info *mtd)
 
                 chip = &cfi->chips[i];
 
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 /* Go to known state. Chip may have been power cycled */
                 if (chip->state == FL_PM_SUSPENDED) {
@@ -1399,7 +1399,7 @@ static void cfi_staa_resume(struct mtd_info *mtd)
                         wake_up(&chip->wq);
                 }
 
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 }
 
diff --git a/drivers/mtd/chips/cfi_probe.c b/drivers/mtd/chips/cfi_probe.c
index e63e6749429a..b2acd32f4fbf 100644
--- a/drivers/mtd/chips/cfi_probe.c
+++ b/drivers/mtd/chips/cfi_probe.c
@@ -158,6 +158,7 @@ static int __xipram cfi_chip_setup(struct map_info *map,
         __u32 base = 0;
         int num_erase_regions = cfi_read_query(map, base + (0x10 + 28)*ofs_factor);
         int i;
+        int addr_unlock1 = 0x555, addr_unlock2 = 0x2AA;
 
         xip_enable(base, map, cfi);
 #ifdef DEBUG_CFI
@@ -181,29 +182,6 @@ static int __xipram cfi_chip_setup(struct map_info *map,
         for (i=0; i<(sizeof(struct cfi_ident) + num_erase_regions * 4); i++)
                 ((unsigned char *)cfi->cfiq)[i] = cfi_read_query(map,base + (0x10 + i)*ofs_factor);
 
-        /* Note we put the device back into Read Mode BEFORE going into Auto
-         * Select Mode, as some devices support nesting of modes, others
-         * don't. This way should always work.
-         * On cmdset 0001 the writes of 0xaa and 0x55 are not needed, and
-         * so should be treated as nops or illegal (and so put the device
-         * back into Read Mode, which is a nop in this case).
-         */
-        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(0x90, 0x555, base, map, cfi, cfi->device_type, NULL);
-        cfi->mfr = cfi_read_query16(map, base);
-        cfi->id = cfi_read_query16(map, base + ofs_factor);
-
-        /* Get AMD/Spansion extended JEDEC ID */
-        if (cfi->mfr == CFI_MFR_AMD && (cfi->id & 0xff) == 0x7e)
-                cfi->id = cfi_read_query(map, base + 0xe * ofs_factor) << 8 |
-                          cfi_read_query(map, base + 0xf * ofs_factor);
-
-        /* Put it back into Read Mode */
-        cfi_qry_mode_off(base, map, cfi);
-        xip_allowed(base, map);
-
         /* Do any necessary byteswapping */
         cfi->cfiq->P_ID = le16_to_cpu(cfi->cfiq->P_ID);
 
@@ -228,6 +206,35 @@ static int __xipram cfi_chip_setup(struct map_info *map,
 #endif
         }
 
+        if (cfi->cfiq->P_ID == P_ID_SST_OLD) {
+                addr_unlock1 = 0x5555;
+                addr_unlock2 = 0x2AAA;
+        }
+
+        /*
+         * Note we put the device back into Read Mode BEFORE going into Auto
+         * Select Mode, as some devices support nesting of modes, others
+         * don't. This way should always work.
+         * On cmdset 0001 the writes of 0xaa and 0x55 are not needed, and
+         * so should be treated as nops or illegal (and so put the device
+         * back into Read Mode, which is a nop in this case).
+         */
+        cfi_send_gen_cmd(0xf0,     0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0xaa, addr_unlock1, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0x55, addr_unlock2, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0x90, addr_unlock1, base, map, cfi, cfi->device_type, NULL);
+        cfi->mfr = cfi_read_query16(map, base);
+        cfi->id = cfi_read_query16(map, base + ofs_factor);
+
+        /* Get AMD/Spansion extended JEDEC ID */
+        if (cfi->mfr == CFI_MFR_AMD && (cfi->id & 0xff) == 0x7e)
+                cfi->id = cfi_read_query(map, base + 0xe * ofs_factor) << 8 |
+                          cfi_read_query(map, base + 0xf * ofs_factor);
+
+        /* Put it back into Read Mode */
+        cfi_qry_mode_off(base, map, cfi);
+        xip_allowed(base, map);
+
         printk(KERN_INFO "%s: Found %d x%d devices at 0x%x in %d-bit bank\n",
                map->name, cfi->interleave, cfi->device_type*8, base,
                map->bankwidth*8);
@@ -269,6 +276,9 @@ static char *vendorname(__u16 vendor)
         case P_ID_SST_PAGE:
                 return "SST Page Write";
 
+        case P_ID_SST_OLD:
+                return "SST 39VF160x/39VF320x";
+
         case P_ID_INTEL_PERFORMANCE:
                 return "Intel Performance Code";
 
diff --git a/drivers/mtd/chips/cfi_util.c b/drivers/mtd/chips/cfi_util.c
index ca584d0380b4..d7c2c672757e 100644
--- a/drivers/mtd/chips/cfi_util.c
+++ b/drivers/mtd/chips/cfi_util.c
@@ -104,10 +104,11 @@ __xipram cfi_read_pri(struct map_info *map, __u16 adr, __u16 size, const char* n
         int i;
         struct cfi_extquery *extp = NULL;
 
-        printk(" %s Extended Query Table at 0x%4.4X\n", name, adr);
         if (!adr)
                 goto out;
 
+        printk(KERN_INFO "%s Extended Query Table at 0x%4.4X\n", name, adr);
+
         extp = kmalloc(size, GFP_KERNEL);
         if (!extp) {
                 printk(KERN_ERR "Failed to allocate memory\n");
diff --git a/drivers/mtd/chips/fwh_lock.h b/drivers/mtd/chips/fwh_lock.h
index 57e0e4e921f9..d18064977192 100644
--- a/drivers/mtd/chips/fwh_lock.h
+++ b/drivers/mtd/chips/fwh_lock.h
@@ -58,10 +58,10 @@ static int fwh_xxlock_oneblock(struct map_info *map, struct flchip *chip,
          * to flash memory - that means that we don't have to check status
          * and timeout.
          */
-        spin_lock(chip->mutex);
+        mutex_lock(&chip->mutex);
         ret = get_chip(map, chip, adr, FL_LOCKING);
         if (ret) {
-                spin_unlock(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return ret;
         }
 
@@ -72,7 +72,7 @@ static int fwh_xxlock_oneblock(struct map_info *map, struct flchip *chip,
         /* Done and happy. */
         chip->state = chip->oldstate;
         put_chip(map, chip, adr);
-        spin_unlock(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return 0;
 }
 
diff --git a/drivers/mtd/chips/gen_probe.c b/drivers/mtd/chips/gen_probe.c
index e2dc96441e05..3b9a2843c5f8 100644
--- a/drivers/mtd/chips/gen_probe.c
+++ b/drivers/mtd/chips/gen_probe.c
@@ -155,8 +155,7 @@ static struct cfi_private *genprobe_ident_chips(struct map_info *map, struct chi
                         pchip->start = (i << cfi.chipshift);
                         pchip->state = FL_READY;
                         init_waitqueue_head(&pchip->wq);
-                        spin_lock_init(&pchip->_spinlock);
-                        pchip->mutex = &pchip->_spinlock;
+                        mutex_init(&pchip->mutex);
                 }
         }
 
@@ -242,17 +241,19 @@ static struct mtd_info *check_cmd_set(struct map_info *map, int primary)
                 /* We need these for the !CONFIG_MODULES case,
                    because symbol_get() doesn't work there */
 #ifdef CONFIG_MTD_CFI_INTELEXT
-        case 0x0001:
-        case 0x0003:
-        case 0x0200:
+        case P_ID_INTEL_EXT:
+        case P_ID_INTEL_STD:
+        case P_ID_INTEL_PERFORMANCE:
                 return cfi_cmdset_0001(map, primary);
 #endif
 #ifdef CONFIG_MTD_CFI_AMDSTD
-        case 0x0002:
+        case P_ID_AMD_STD:
+        case P_ID_SST_OLD:
+        case P_ID_WINBOND:
                 return cfi_cmdset_0002(map, primary);
 #endif
 #ifdef CONFIG_MTD_CFI_STAA
-        case 0x0020:
+        case P_ID_ST_ADV:
                 return cfi_cmdset_0020(map, primary);
 #endif
         default:
diff --git a/drivers/mtd/chips/jedec_probe.c b/drivers/mtd/chips/jedec_probe.c
index 8db1148dfa47..d72a5fb2d041 100644
--- a/drivers/mtd/chips/jedec_probe.c
+++ b/drivers/mtd/chips/jedec_probe.c
@@ -22,24 +22,6 @@
 #include <linux/mtd/cfi.h>
 #include <linux/mtd/gen_probe.h>
 
-/* Manufacturers */
-#define MANUFACTURER_AMD        0x0001
-#define MANUFACTURER_ATMEL      0x001f
-#define MANUFACTURER_EON        0x001c
-#define MANUFACTURER_FUJITSU    0x0004
-#define MANUFACTURER_HYUNDAI    0x00AD
-#define MANUFACTURER_INTEL      0x0089
-#define MANUFACTURER_MACRONIX   0x00C2
-#define MANUFACTURER_NEC        0x0010
-#define MANUFACTURER_PMC        0x009D
-#define MANUFACTURER_SHARP      0x00b0
-#define MANUFACTURER_SST        0x00BF
-#define MANUFACTURER_ST         0x0020
-#define MANUFACTURER_TOSHIBA    0x0098
-#define MANUFACTURER_WINBOND    0x00da
-#define CONTINUATION_CODE       0x007f
-
-
 /* AMD */
 #define AM29DL800BB     0x22CB
 #define AM29DL800BT     0x224A
@@ -166,6 +148,8 @@
 #define SST39LF160      0x2782
 #define SST39VF1601     0x234b
 #define SST39VF3201     0x235b
+#define SST39WF1601     0x274b
+#define SST39WF1602     0x274a
 #define SST39LF512      0x00D4
 #define SST39LF010      0x00D5
 #define SST39LF020      0x00D6
@@ -309,7 +293,7 @@ struct amd_flash_info {
  */
 static const struct amd_flash_info jedec_table[] = {
         {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29F032B,
                 .name           = "AMD AM29F032B",
                 .uaddr          = MTD_UADDR_0x0555_0x02AA,
@@ -321,7 +305,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,64)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29LV160DT,
                 .name           = "AMD AM29LV160DT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -336,7 +320,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29LV160DB,
                 .name           = "AMD AM29LV160DB",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -351,7 +335,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,31)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29LV400BB,
                 .name           = "AMD AM29LV400BB",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -366,7 +350,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,7)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29LV400BT,
                 .name           = "AMD AM29LV400BT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -381,7 +365,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29LV800BB,
                 .name           = "AMD AM29LV800BB",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -397,7 +381,7 @@ static const struct amd_flash_info jedec_table[] = {
                 }
         }, {
 /* add DL */
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29DL800BB,
                 .name           = "AMD AM29DL800BB",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -414,7 +398,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,14)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29DL800BT,
                 .name           = "AMD AM29DL800BT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -431,7 +415,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29F800BB,
                 .name           = "AMD AM29F800BB",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -446,7 +430,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,15),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29LV800BT,
                 .name           = "AMD AM29LV800BT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -461,7 +445,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29F800BT,
                 .name           = "AMD AM29F800BT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -476,7 +460,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29F017D,
                 .name           = "AMD AM29F017D",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -488,7 +472,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,32),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29F016D,
                 .name           = "AMD AM29F016D",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -500,7 +484,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,32),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29F080,
                 .name           = "AMD AM29F080",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -512,7 +496,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,16),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29F040,
                 .name           = "AMD AM29F040",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -524,7 +508,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29LV040B,
                 .name           = "AMD AM29LV040B",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -536,7 +520,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29F002T,
                 .name           = "AMD AM29F002T",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -551,7 +535,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29SL800DT,
                 .name           = "AMD AM29SL800DT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -566,7 +550,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_AMD,
+                .mfr_id         = CFI_MFR_AMD,
                 .dev_id         = AM29SL800DB,
                 .name           = "AMD AM29SL800DB",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -581,7 +565,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,15),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ATMEL,
+                .mfr_id         = CFI_MFR_ATMEL,
                 .dev_id         = AT49BV512,
                 .name           = "Atmel AT49BV512",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -593,7 +577,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ATMEL,
+                .mfr_id         = CFI_MFR_ATMEL,
                 .dev_id         = AT29LV512,
                 .name           = "Atmel AT29LV512",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -606,7 +590,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x80,256)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ATMEL,
+                .mfr_id         = CFI_MFR_ATMEL,
                 .dev_id         = AT49BV16X,
                 .name           = "Atmel AT49BV16X",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -619,7 +603,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,31)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ATMEL,
+                .mfr_id         = CFI_MFR_ATMEL,
                 .dev_id         = AT49BV16XT,
                 .name           = "Atmel AT49BV16XT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -632,7 +616,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000,8)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ATMEL,
+                .mfr_id         = CFI_MFR_ATMEL,
                 .dev_id         = AT49BV32X,
                 .name           = "Atmel AT49BV32X",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -645,7 +629,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,63)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ATMEL,
+                .mfr_id         = CFI_MFR_ATMEL,
                 .dev_id         = AT49BV32XT,
                 .name           = "Atmel AT49BV32XT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -658,7 +642,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000,8)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_EON,
+                .mfr_id         = CFI_MFR_EON,
                 .dev_id         = EN29SL800BT,
                 .name           = "Eon EN29SL800BT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -673,7 +657,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_EON,
+                .mfr_id         = CFI_MFR_EON,
                 .dev_id         = EN29SL800BB,
                 .name           = "Eon EN29SL800BB",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -688,7 +672,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,15),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_FUJITSU,
+                .mfr_id         = CFI_MFR_FUJITSU,
                 .dev_id         = MBM29F040C,
                 .name           = "Fujitsu MBM29F040C",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -700,7 +684,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,8)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_FUJITSU,
+                .mfr_id         = CFI_MFR_FUJITSU,
                 .dev_id         = MBM29F800BA,
                 .name           = "Fujitsu MBM29F800BA",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -715,7 +699,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,15),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_FUJITSU,
+                .mfr_id         = CFI_MFR_FUJITSU,
                 .dev_id         = MBM29LV650UE,
                 .name           = "Fujitsu MBM29LV650UE",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -727,7 +711,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,128)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_FUJITSU,
+                .mfr_id         = CFI_MFR_FUJITSU,
                 .dev_id         = MBM29LV320TE,
                 .name           = "Fujitsu MBM29LV320TE",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -740,7 +724,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000,8)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_FUJITSU,
+                .mfr_id         = CFI_MFR_FUJITSU,
                 .dev_id         = MBM29LV320BE,
                 .name           = "Fujitsu MBM29LV320BE",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -753,7 +737,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,63)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_FUJITSU,
+                .mfr_id         = CFI_MFR_FUJITSU,
                 .dev_id         = MBM29LV160TE,
                 .name           = "Fujitsu MBM29LV160TE",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -768,7 +752,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_FUJITSU,
+                .mfr_id         = CFI_MFR_FUJITSU,
                 .dev_id         = MBM29LV160BE,
                 .name           = "Fujitsu MBM29LV160BE",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -783,7 +767,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,31)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_FUJITSU,
+                .mfr_id         = CFI_MFR_FUJITSU,
                 .dev_id         = MBM29LV800BA,
                 .name           = "Fujitsu MBM29LV800BA",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -798,7 +782,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,15)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_FUJITSU,
+                .mfr_id         = CFI_MFR_FUJITSU,
                 .dev_id         = MBM29LV800TA,
                 .name           = "Fujitsu MBM29LV800TA",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -813,7 +797,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_FUJITSU,
+                .mfr_id         = CFI_MFR_FUJITSU,
                 .dev_id         = MBM29LV400BC,
                 .name           = "Fujitsu MBM29LV400BC",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -828,7 +812,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,7)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_FUJITSU,
+                .mfr_id         = CFI_MFR_FUJITSU,
                 .dev_id         = MBM29LV400TC,
                 .name           = "Fujitsu MBM29LV400TC",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -843,7 +827,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_HYUNDAI,
+                .mfr_id         = CFI_MFR_HYUNDAI,
                 .dev_id         = HY29F002T,
                 .name           = "Hyundai HY29F002T",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -858,7 +842,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F004B3B,
                 .name           = "Intel 28F004B3B",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -871,7 +855,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000, 7),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F004B3T,
                 .name           = "Intel 28F004B3T",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -884,7 +868,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000, 8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F400B3B,
                 .name           = "Intel 28F400B3B",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -897,7 +881,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000, 7),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F400B3T,
                 .name           = "Intel 28F400B3T",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -910,7 +894,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000, 8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F008B3B,
                 .name           = "Intel 28F008B3B",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -923,7 +907,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000, 15),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F008B3T,
                 .name           = "Intel 28F008B3T",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -936,7 +920,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000, 8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F008S5,
                 .name           = "Intel 28F008S5",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -948,7 +932,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,16),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F016S5,
                 .name           = "Intel 28F016S5",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -960,7 +944,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,32),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F008SA,
                 .name           = "Intel 28F008SA",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -972,7 +956,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000, 16),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F800B3B,
                 .name           = "Intel 28F800B3B",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -985,7 +969,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000, 15),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F800B3T,
                 .name           = "Intel 28F800B3T",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -998,7 +982,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000, 8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F016B3B,
                 .name           = "Intel 28F016B3B",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1011,7 +995,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000, 31),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F016S3,
                 .name           = "Intel I28F016S3",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1023,7 +1007,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000, 32),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F016B3T,
                 .name           = "Intel 28F016B3T",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1036,7 +1020,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000, 8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F160B3B,
                 .name           = "Intel 28F160B3B",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1049,7 +1033,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000, 31),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F160B3T,
                 .name           = "Intel 28F160B3T",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1062,7 +1046,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000, 8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F320B3B,
                 .name           = "Intel 28F320B3B",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1075,7 +1059,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000, 63),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F320B3T,
                 .name           = "Intel 28F320B3T",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1088,7 +1072,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000, 8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F640B3B,
                 .name           = "Intel 28F640B3B",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1101,7 +1085,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000, 127),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F640B3T,
                 .name           = "Intel 28F640B3T",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1114,7 +1098,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000, 8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I28F640C3B,
                 .name           = "Intel 28F640C3B",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1127,7 +1111,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000, 127),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I82802AB,
                 .name           = "Intel 82802AB",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1139,7 +1123,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_INTEL,
+                .mfr_id         = CFI_MFR_INTEL,
                 .dev_id         = I82802AC,
                 .name           = "Intel 82802AC",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1151,7 +1135,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,16),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_MACRONIX,
+                .mfr_id         = CFI_MFR_MACRONIX,
                 .dev_id         = MX29LV040C,
                 .name           = "Macronix MX29LV040C",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1163,7 +1147,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_MACRONIX,
+                .mfr_id         = CFI_MFR_MACRONIX,
                 .dev_id         = MX29LV160T,
                 .name           = "MXIC MX29LV160T",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1178,7 +1162,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_NEC,
+                .mfr_id         = CFI_MFR_NEC,
                 .dev_id         = UPD29F064115,
                 .name           = "NEC uPD29F064115",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1192,7 +1176,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x2000,8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_MACRONIX,
+                .mfr_id         = CFI_MFR_MACRONIX,
                 .dev_id         = MX29LV160B,
                 .name           = "MXIC MX29LV160B",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1207,7 +1191,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,31)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_MACRONIX,
+                .mfr_id         = CFI_MFR_MACRONIX,
                 .dev_id         = MX29F040,
                 .name           = "Macronix MX29F040",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1219,7 +1203,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_MACRONIX,
+                .mfr_id         = CFI_MFR_MACRONIX,
                 .dev_id         = MX29F016,
                 .name           = "Macronix MX29F016",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1231,7 +1215,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,32),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_MACRONIX,
+                .mfr_id         = CFI_MFR_MACRONIX,
                 .dev_id         = MX29F004T,
                 .name           = "Macronix MX29F004T",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1246,7 +1230,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_MACRONIX,
+                .mfr_id         = CFI_MFR_MACRONIX,
                 .dev_id         = MX29F004B,
                 .name           = "Macronix MX29F004B",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1261,7 +1245,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,7),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_MACRONIX,
+                .mfr_id         = CFI_MFR_MACRONIX,
                 .dev_id         = MX29F002T,
                 .name           = "Macronix MX29F002T",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1276,7 +1260,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_PMC,
+                .mfr_id         = CFI_MFR_PMC,
                 .dev_id         = PM49FL002,
                 .name           = "PMC Pm49FL002",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1288,7 +1272,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO( 0x01000, 64 )
                 }
         }, {
-                .mfr_id         = MANUFACTURER_PMC,
+                .mfr_id         = CFI_MFR_PMC,
                 .dev_id         = PM49FL004,
                 .name           = "PMC Pm49FL004",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1300,7 +1284,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO( 0x01000, 128 )
                 }
         }, {
-                .mfr_id         = MANUFACTURER_PMC,
+                .mfr_id         = CFI_MFR_PMC,
                 .dev_id         = PM49FL008,
                 .name           = "PMC Pm49FL008",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1312,7 +1296,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO( 0x01000, 256 )
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SHARP,
+                .mfr_id         = CFI_MFR_SHARP,
                 .dev_id         = LH28F640BF,
                 .name           = "LH28F640BF",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1324,7 +1308,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x40000,16),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST39LF512,
                 .name           = "SST 39LF512",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1336,7 +1320,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,16),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST39LF010,
                 .name           = "SST 39LF010",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1348,8 +1332,8 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,32),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
-                .dev_id         = SST29EE020,
+                .mfr_id         = CFI_MFR_SST,
+                .dev_id         = SST29EE020,
                 .name           = "SST 29EE020",
                 .devtypes       = CFI_DEVICETYPE_X8,
                 .uaddr          = MTD_UADDR_0x5555_0x2AAA,
@@ -1359,9 +1343,9 @@ static const struct amd_flash_info jedec_table[] = {
                 .regions = {ERASEINFO(0x01000,64),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST29LE020,
-                .name           = "SST 29LE020",
+                .name           = "SST 29LE020",
                 .devtypes       = CFI_DEVICETYPE_X8,
                 .uaddr          = MTD_UADDR_0x5555_0x2AAA,
                 .dev_size       = SIZE_256KiB,
@@ -1370,7 +1354,7 @@ static const struct amd_flash_info jedec_table[] = {
                 .regions = {ERASEINFO(0x01000,64),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST39LF020,
                 .name           = "SST 39LF020",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1382,7 +1366,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,64),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST39LF040,
                 .name           = "SST 39LF040",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1394,7 +1378,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,128),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST39SF010A,
                 .name           = "SST 39SF010A",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1406,7 +1390,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,32),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST39SF020A,
                 .name           = "SST 39SF020A",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1418,7 +1402,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,64),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST39SF040,
                 .name           = "SST 39SF040",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1430,7 +1414,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,128),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST49LF040B,
                 .name           = "SST 49LF040B",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1443,7 +1427,7 @@ static const struct amd_flash_info jedec_table[] = {
                 }
         }, {
 
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST49LF004B,
                 .name           = "SST 49LF004B",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1455,7 +1439,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,128),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST49LF008A,
                 .name           = "SST 49LF008A",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1467,7 +1451,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,256),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST49LF030A,
                 .name           = "SST 49LF030A",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1479,7 +1463,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,96),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST49LF040A,
                 .name           = "SST 49LF040A",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1491,7 +1475,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,128),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST49LF080A,
                 .name           = "SST 49LF080A",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1503,7 +1487,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x01000,256),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,     /* should be CFI */
+                .mfr_id         = CFI_MFR_SST,     /* should be CFI */
                 .dev_id         = SST39LF160,
                 .name           = "SST 39LF160",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1516,7 +1500,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x1000,256)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,     /* should be CFI */
+                .mfr_id         = CFI_MFR_SST,     /* should be CFI */
                 .dev_id         = SST39VF1601,
                 .name           = "SST 39VF1601",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1529,7 +1513,35 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x1000,256)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,     /* should be CFI */
+                /* CFI is broken: reports AMD_STD, but needs custom uaddr */
+                .mfr_id         = CFI_MFR_SST,
+                .dev_id         = SST39WF1601,
+                .name           = "SST 39WF1601",
+                .devtypes       = CFI_DEVICETYPE_X16,
+                .uaddr          = MTD_UADDR_0xAAAA_0x5555,
+                .dev_size       = SIZE_2MiB,
+                .cmd_set        = P_ID_AMD_STD,
+                .nr_regions     = 2,
+                .regions        = {
+                        ERASEINFO(0x1000,256),
+                        ERASEINFO(0x1000,256)
+                }
+        }, {
+                /* CFI is broken: reports AMD_STD, but needs custom uaddr */
+                .mfr_id         = CFI_MFR_SST,
+                .dev_id         = SST39WF1602,
+                .name           = "SST 39WF1602",
+                .devtypes       = CFI_DEVICETYPE_X16,
+                .uaddr          = MTD_UADDR_0xAAAA_0x5555,
+                .dev_size       = SIZE_2MiB,
+                .cmd_set        = P_ID_AMD_STD,
+                .nr_regions     = 2,
+                .regions        = {
+                        ERASEINFO(0x1000,256),
+                        ERASEINFO(0x1000,256)
+                }
+        }, {
+                .mfr_id         = CFI_MFR_SST,     /* should be CFI */
                 .dev_id         = SST39VF3201,
                 .name           = "SST 39VF3201",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1544,7 +1556,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x1000,256)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_SST,
+                .mfr_id         = CFI_MFR_SST,
                 .dev_id         = SST36VF3203,
                 .name           = "SST 36VF3203",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1556,7 +1568,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,64),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,
+                .mfr_id         = CFI_MFR_ST,
                 .dev_id         = M29F800AB,
                 .name           = "ST M29F800AB",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1571,7 +1583,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,15),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,      /* FIXME - CFI device? */
+                .mfr_id         = CFI_MFR_ST,   /* FIXME - CFI device? */
                 .dev_id         = M29W800DT,
                 .name           = "ST M29W800DT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1586,7 +1598,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,      /* FIXME - CFI device? */
+                .mfr_id         = CFI_MFR_ST,   /* FIXME - CFI device? */
                 .dev_id         = M29W800DB,
                 .name           = "ST M29W800DB",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1601,7 +1613,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,15)
                 }
         },  {
-                .mfr_id         = MANUFACTURER_ST,
+                .mfr_id         = CFI_MFR_ST,
                 .dev_id         = M29W400DT,
                 .name           = "ST M29W400DT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1616,7 +1628,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,
+                .mfr_id         = CFI_MFR_ST,
                 .dev_id         = M29W400DB,
                 .name           = "ST M29W400DB",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1631,7 +1643,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,7)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,      /* FIXME - CFI device? */
+                .mfr_id         = CFI_MFR_ST,   /* FIXME - CFI device? */
                 .dev_id         = M29W160DT,
                 .name           = "ST M29W160DT",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1646,7 +1658,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,      /* FIXME - CFI device? */
+                .mfr_id         = CFI_MFR_ST,   /* FIXME - CFI device? */
                 .dev_id         = M29W160DB,
                 .name           = "ST M29W160DB",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1661,7 +1673,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,31)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,
+                .mfr_id         = CFI_MFR_ST,
                 .dev_id         = M29W040B,
                 .name           = "ST M29W040B",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1673,7 +1685,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,
+                .mfr_id         = CFI_MFR_ST,
                 .dev_id         = M50FW040,
                 .name           = "ST M50FW040",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1685,7 +1697,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,8),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,
+                .mfr_id         = CFI_MFR_ST,
                 .dev_id         = M50FW080,
                 .name           = "ST M50FW080",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1697,7 +1709,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,16),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,
+                .mfr_id         = CFI_MFR_ST,
                 .dev_id         = M50FW016,
                 .name           = "ST M50FW016",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1709,7 +1721,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,32),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,
+                .mfr_id         = CFI_MFR_ST,
                 .dev_id         = M50LPW080,
                 .name           = "ST M50LPW080",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1721,7 +1733,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,16),
                 },
         }, {
-                .mfr_id         = MANUFACTURER_ST,
+                .mfr_id         = CFI_MFR_ST,
                 .dev_id         = M50FLW080A,
                 .name           = "ST M50FLW080A",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1736,7 +1748,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x1000,16),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_ST,
+                .mfr_id         = CFI_MFR_ST,
                 .dev_id         = M50FLW080B,
                 .name           = "ST M50FLW080B",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1751,7 +1763,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x1000,16),
                 }
         }, {
-                .mfr_id         = 0xff00 | MANUFACTURER_ST,
+                .mfr_id         = 0xff00 | CFI_MFR_ST,
                 .dev_id         = 0xff00 | PSD4256G6V,
                 .name           = "ST PSD4256G6V",
                 .devtypes       = CFI_DEVICETYPE_X16,
@@ -1763,7 +1775,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,16),
                 }
         }, {
-                .mfr_id         = MANUFACTURER_TOSHIBA,
+                .mfr_id         = CFI_MFR_TOSHIBA,
                 .dev_id         = TC58FVT160,
                 .name           = "Toshiba TC58FVT160",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1778,7 +1790,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x04000,1)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_TOSHIBA,
+                .mfr_id         = CFI_MFR_TOSHIBA,
                 .dev_id         = TC58FVB160,
                 .name           = "Toshiba TC58FVB160",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1793,7 +1805,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,31)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_TOSHIBA,
+                .mfr_id         = CFI_MFR_TOSHIBA,
                 .dev_id         = TC58FVB321,
                 .name           = "Toshiba TC58FVB321",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1806,7 +1818,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,63)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_TOSHIBA,
+                .mfr_id         = CFI_MFR_TOSHIBA,
                 .dev_id         = TC58FVT321,
                 .name           = "Toshiba TC58FVT321",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1819,7 +1831,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000,8)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_TOSHIBA,
+                .mfr_id         = CFI_MFR_TOSHIBA,
                 .dev_id         = TC58FVB641,
                 .name           = "Toshiba TC58FVB641",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1832,7 +1844,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x10000,127)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_TOSHIBA,
+                .mfr_id         = CFI_MFR_TOSHIBA,
                 .dev_id         = TC58FVT641,
                 .name           = "Toshiba TC58FVT641",
                 .devtypes       = CFI_DEVICETYPE_X16|CFI_DEVICETYPE_X8,
@@ -1845,7 +1857,7 @@ static const struct amd_flash_info jedec_table[] = {
                         ERASEINFO(0x02000,8)
                 }
         }, {
-                .mfr_id         = MANUFACTURER_WINBOND,
+                .mfr_id         = CFI_MFR_WINBOND,
                 .dev_id         = W49V002A,
                 .name           = "Winbond W49V002A",
                 .devtypes       = CFI_DEVICETYPE_X8,
@@ -1878,7 +1890,7 @@ static inline u32 jedec_read_mfr(struct map_info *map, uint32_t base,
                 mask = (1 << (cfi->device_type * 8)) - 1;
                 result = map_read(map, base + ofs);
                 bank++;
-        } while ((result.x[0] & mask) == CONTINUATION_CODE);
+        } while ((result.x[0] & mask) == CFI_MFR_CONTINUATION);
 
         return result.x[0] & mask;
 }
@@ -1969,7 +1981,7 @@ static int cfi_jedec_setup(struct cfi_private *p_cfi, int index)
         p_cfi->addr_unlock1 = unlock_addrs[uaddr].addr1 / p_cfi->device_type;
         p_cfi->addr_unlock2 = unlock_addrs[uaddr].addr2 / p_cfi->device_type;
 
-        return 1;       /* ok */
+        return 1;       /* ok */
 }