6 files changed, 178 insertions, 75 deletions

diff --git a/drivers/mtd/chips/Kconfig b/drivers/mtd/chips/Kconfig
index 479d32b57a1e..9408099eec48 100644
--- a/drivers/mtd/chips/Kconfig
+++ b/drivers/mtd/chips/Kconfig
@@ -6,6 +6,7 @@ menu "RAM/ROM/Flash chip drivers"
 config MTD_CFI
         tristate "Detect flash chips by Common Flash Interface (CFI) probe"
         select MTD_GEN_PROBE
+        select MTD_CFI_UTIL
         help
           The Common Flash Interface specification was developed by Intel,
           AMD and other flash manufactures that provides a universal method
@@ -154,6 +155,7 @@ config MTD_CFI_I8
 config MTD_OTP
         bool "Protection Registers aka one-time programmable (OTP) bits"
         depends on MTD_CFI_ADV_OPTIONS
+        select HAVE_MTD_OTP
         default n
         help
           This enables support for reading, writing and locking so called
@@ -187,7 +189,7 @@ config MTD_CFI_INTELEXT
           StrataFlash and other parts.
 
 config MTD_CFI_AMDSTD
-        tristate "Support for AMD/Fujitsu flash chips"
+        tristate "Support for AMD/Fujitsu/Spansion flash chips"
         depends on MTD_GEN_PROBE
         select MTD_CFI_UTIL
         help
diff --git a/drivers/mtd/chips/cfi_cmdset_0001.c b/drivers/mtd/chips/cfi_cmdset_0001.c
index 5f1b472137a0..c93a8be5d5f1 100644
--- a/drivers/mtd/chips/cfi_cmdset_0001.c
+++ b/drivers/mtd/chips/cfi_cmdset_0001.c
@@ -478,6 +478,28 @@ struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
                 else
                         cfi->chips[i].erase_time = 2000000;
 
+                if (cfi->cfiq->WordWriteTimeoutTyp &&
+                    cfi->cfiq->WordWriteTimeoutMax)
+                        cfi->chips[i].word_write_time_max =
+                                1<<(cfi->cfiq->WordWriteTimeoutTyp +
+                                    cfi->cfiq->WordWriteTimeoutMax);
+                else
+                        cfi->chips[i].word_write_time_max = 50000 * 8;
+
+                if (cfi->cfiq->BufWriteTimeoutTyp &&
+                    cfi->cfiq->BufWriteTimeoutMax)
+                        cfi->chips[i].buffer_write_time_max =
+                                1<<(cfi->cfiq->BufWriteTimeoutTyp +
+                                    cfi->cfiq->BufWriteTimeoutMax);
+
+                if (cfi->cfiq->BlockEraseTimeoutTyp &&
+                    cfi->cfiq->BlockEraseTimeoutMax)
+                        cfi->chips[i].erase_time_max =
+                                1000<<(cfi->cfiq->BlockEraseTimeoutTyp +
+                                       cfi->cfiq->BlockEraseTimeoutMax);
+                else
+                        cfi->chips[i].erase_time_max = 2000000 * 8;
+
                 cfi->chips[i].ref_point_counter = 0;
                 init_waitqueue_head(&(cfi->chips[i].wq));
         }
@@ -703,6 +725,10 @@ static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long
         struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
         unsigned long timeo = jiffies + HZ;
 
+        /* Prevent setting state FL_SYNCING for chip in suspended state. */
+        if (mode == FL_SYNCING && chip->oldstate != FL_READY)
+                goto sleep;
+
         switch (chip->state) {
 
         case FL_STATUS:
@@ -808,8 +834,9 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
         DECLARE_WAITQUEUE(wait, current);
 
  retry:
-        if (chip->priv && (mode == FL_WRITING || mode == FL_ERASING
-                           || mode == FL_OTP_WRITE || mode == FL_SHUTDOWN)) {
+        if (chip->priv &&
+            (mode == FL_WRITING || mode == FL_ERASING || mode == FL_OTP_WRITE
+            || mode == FL_SHUTDOWN) && chip->state != FL_SYNCING) {
                 /*
                  * OK. We have possibility for contention on the write/erase
                  * operations which are global to the real chip and not per
@@ -859,6 +886,14 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
                                 return ret;
                         }
                         spin_lock(&shared->lock);
+
+                        /* We should not own chip if it is already
+                         * in FL_SYNCING state. Put contender and retry. */
+                        if (chip->state == FL_SYNCING) {
+                                put_chip(map, contender, contender->start);
+                                spin_unlock(contender->mutex);
+                                goto retry;
+                        }
                         spin_unlock(contender->mutex);
                 }
 
@@ -1012,7 +1047,7 @@ static void __xipram xip_enable(struct map_info *map, struct flchip *chip,
 
 static int __xipram xip_wait_for_operation(
                 struct map_info *map, struct flchip *chip,
-                unsigned long adr, unsigned int chip_op_time )
+                unsigned long adr, unsigned int chip_op_time_max)
 {
         struct cfi_private *cfi = map->fldrv_priv;
         struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
@@ -1021,7 +1056,7 @@ static int __xipram xip_wait_for_operation(
         flstate_t oldstate, newstate;
 
         start = xip_currtime();
-        usec = chip_op_time * 8;
+        usec = chip_op_time_max;
         if (usec == 0)
                 usec = 500000;
         done = 0;
@@ -1131,8 +1166,8 @@ static int __xipram xip_wait_for_operation(
 #define XIP_INVAL_CACHED_RANGE(map, from, size)  \
         INVALIDATE_CACHED_RANGE(map, from, size)
 
-#define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec) \
-        xip_wait_for_operation(map, chip, cmd_adr, usec)
+#define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec, usec_max) \
+        xip_wait_for_operation(map, chip, cmd_adr, usec_max)
 
 #else
 
@@ -1144,7 +1179,7 @@ static int __xipram xip_wait_for_operation(
 static int inval_cache_and_wait_for_operation(
                 struct map_info *map, struct flchip *chip,
                 unsigned long cmd_adr, unsigned long inval_adr, int inval_len,
-                unsigned int chip_op_time)
+                unsigned int chip_op_time, unsigned int chip_op_time_max)
 {
         struct cfi_private *cfi = map->fldrv_priv;
         map_word status, status_OK = CMD(0x80);
@@ -1156,8 +1191,7 @@ static int inval_cache_and_wait_for_operation(
                 INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
         spin_lock(chip->mutex);
 
-        /* set our timeout to 8 times the expected delay */
-        timeo = chip_op_time * 8;
+        timeo = chip_op_time_max;
         if (!timeo)
                 timeo = 500000;
         reset_timeo = timeo;
@@ -1217,8 +1251,8 @@ static int inval_cache_and_wait_for_operation(
 
 #endif
 
-#define WAIT_TIMEOUT(map, chip, adr, udelay) \
-        INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay);
+#define WAIT_TIMEOUT(map, chip, adr, udelay, udelay_max) \
+        INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay, udelay_max);
 
 
 static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len)
@@ -1452,7 +1486,8 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
 
         ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
                                    adr, map_bankwidth(map),
-                                   chip->word_write_time);
+                                   chip->word_write_time,
+                                   chip->word_write_time_max);
         if (ret) {
                 xip_enable(map, chip, adr);
                 printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
@@ -1623,7 +1658,7 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
 
         chip->state = FL_WRITING_TO_BUFFER;
         map_write(map, write_cmd, cmd_adr);
-        ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0);
+        ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0, 0);
         if (ret) {
                 /* Argh. Not ready for write to buffer */
                 map_word Xstatus = map_read(map, cmd_adr);
@@ -1640,7 +1675,7 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
 
         /* Figure out the number of words to write */
         word_gap = (-adr & (map_bankwidth(map)-1));
-        words = (len - word_gap + map_bankwidth(map) - 1) / map_bankwidth(map);
+        words = DIV_ROUND_UP(len - word_gap, map_bankwidth(map));
         if (!word_gap) {
                 words--;
         } else {
@@ -1692,7 +1727,8 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
 
         ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
                                    initial_adr, initial_len,
-                                   chip->buffer_write_time);
+                                   chip->buffer_write_time,
+                                   chip->buffer_write_time_max);
         if (ret) {
                 map_write(map, CMD(0x70), cmd_adr);
                 chip->state = FL_STATUS;
@@ -1827,7 +1863,8 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
 
         ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
                                    adr, len,
-                                   chip->erase_time);
+                                   chip->erase_time,
+                                   chip->erase_time_max);
         if (ret) {
                 map_write(map, CMD(0x70), adr);
                 chip->state = FL_STATUS;
@@ -2006,7 +2043,7 @@ static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip
          */
         udelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1000000/HZ : 0;
 
-        ret = WAIT_TIMEOUT(map, chip, adr, udelay);
+        ret = WAIT_TIMEOUT(map, chip, adr, udelay, udelay * 100);
         if (ret) {
                 map_write(map, CMD(0x70), adr);
                 chip->state = FL_STATUS;
diff --git a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c
index a972cc6be436..3e6f5d8609e8 100644
--- a/drivers/mtd/chips/cfi_cmdset_0002.c
+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
@@ -13,6 +13,8 @@
  * XIP support hooks by Vitaly Wool (based on code for Intel flash
  * by Nicolas Pitre)
  *
+ * 25/09/2008 Christopher Moore: TopBottom fixup for many Macronix with CFI V1.0
+ *
  * Occasionally maintained by Thayne Harbaugh tharbaugh at lnxi dot com
  *
  * This code is GPL
@@ -43,6 +45,7 @@
 
 #define MANUFACTURER_AMD        0x0001
 #define MANUFACTURER_ATMEL      0x001F
+#define MANUFACTURER_MACRONIX   0x00C2
 #define MANUFACTURER_SST        0x00BF
 #define SST49LF004B             0x0060
 #define SST49LF040B             0x0050
@@ -144,12 +147,44 @@ static void fixup_amd_bootblock(struct mtd_info *mtd, void* param)
 
         if (((major << 8) | minor) < 0x3131) {
                 /* CFI version 1.0 => don't trust bootloc */
+
+                DEBUG(MTD_DEBUG_LEVEL1,
+                        "%s: JEDEC Vendor ID is 0x%02X Device ID is 0x%02X\n",
+                        map->name, cfi->mfr, cfi->id);
+
+                /* AFAICS all 29LV400 with a bottom boot block have a device ID
+                 * of 0x22BA in 16-bit mode and 0xBA in 8-bit mode.
+                 * These were badly detected as they have the 0x80 bit set
+                 * so treat them as a special case.
+                 */
+                if (((cfi->id == 0xBA) || (cfi->id == 0x22BA)) &&
+
+                        /* Macronix added CFI to their 2nd generation
+                         * MX29LV400C B/T but AFAICS no other 29LV400 (AMD,
+                         * Fujitsu, Spansion, EON, ESI and older Macronix)
+                         * has CFI.
+                         *
+                         * Therefore also check the manufacturer.
+                         * This reduces the risk of false detection due to
+                         * the 8-bit device ID.
+                         */
+                        (cfi->mfr == MANUFACTURER_MACRONIX)) {
+                        DEBUG(MTD_DEBUG_LEVEL1,
+                                "%s: Macronix MX29LV400C with bottom boot block"
+                                " detected\n", map->name);
+                        extp->TopBottom = 2;    /* bottom boot */
+                } else
                 if (cfi->id & 0x80) {
                         printk(KERN_WARNING "%s: JEDEC Device ID is 0x%02X. Assuming broken CFI table.\n", map->name, cfi->id);
                         extp->TopBottom = 3;    /* top boot */
                 } else {
                         extp->TopBottom = 2;    /* bottom boot */
                 }
+
+                DEBUG(MTD_DEBUG_LEVEL1,
+                        "%s: AMD CFI PRI V%c.%c has no boot block field;"
+                        " deduced %s from Device ID\n", map->name, major, minor,
+                        extp->TopBottom == 2 ? "bottom" : "top");
         }
 }
 #endif
@@ -178,10 +213,18 @@ static void fixup_convert_atmel_pri(struct mtd_info *mtd, void *param)
         if (atmel_pri.Features & 0x02)
                 extp->EraseSuspend = 2;
 
-        if (atmel_pri.BottomBoot)
-                extp->TopBottom = 2;
-        else
-                extp->TopBottom = 3;
+        /* Some chips got it backwards... */
+        if (cfi->id == AT49BV6416) {
+                if (atmel_pri.BottomBoot)
+                        extp->TopBottom = 3;
+                else
+                        extp->TopBottom = 2;
+        } else {
+                if (atmel_pri.BottomBoot)
+                        extp->TopBottom = 2;
+                else
+                        extp->TopBottom = 3;
+        }
 
         /* burst write mode not supported */
         cfi->cfiq->BufWriteTimeoutTyp = 0;
@@ -243,6 +286,7 @@ 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 },
 #endif
         { CFI_MFR_AMD, 0x0050, fixup_use_secsi, NULL, },
         { CFI_MFR_AMD, 0x0053, fixup_use_secsi, NULL, },
diff --git a/drivers/mtd/chips/cfi_probe.c b/drivers/mtd/chips/cfi_probe.c
index c418e92e1d92..e63e6749429a 100644
--- a/drivers/mtd/chips/cfi_probe.c
+++ b/drivers/mtd/chips/cfi_probe.c
@@ -44,17 +44,14 @@ do { \
 
 #define xip_enable(base, map, cfi) \
 do { \
-        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL); \
-        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL); \
+        cfi_qry_mode_off(base, map, cfi);               \
         xip_allowed(base, map); \
 } while (0)
 
 #define xip_disable_qry(base, map, cfi) \
 do { \
         xip_disable(); \
-        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL); \
-        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL); \
-        cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL); \
+        cfi_qry_mode_on(base, map, cfi); \
 } while (0)
 
 #else
@@ -70,32 +67,6 @@ do { \
    in: interleave,type,mode
    ret: table index, <0 for error
  */
-static int __xipram qry_present(struct map_info *map, __u32 base,
-                                struct cfi_private *cfi)
-{
-        int osf = cfi->interleave * cfi->device_type;   // scale factor
-        map_word val[3];
-        map_word qry[3];
-
-        qry[0] = cfi_build_cmd('Q', map, cfi);
-        qry[1] = cfi_build_cmd('R', map, cfi);
-        qry[2] = cfi_build_cmd('Y', map, cfi);
-
-        val[0] = map_read(map, base + osf*0x10);
-        val[1] = map_read(map, base + osf*0x11);
-        val[2] = map_read(map, base + osf*0x12);
-
-        if (!map_word_equal(map, qry[0], val[0]))
-                return 0;
-
-        if (!map_word_equal(map, qry[1], val[1]))
-                return 0;
-
-        if (!map_word_equal(map, qry[2], val[2]))
-                return 0;
-
-        return 1;       // "QRY" found
-}
 
 static int __xipram cfi_probe_chip(struct map_info *map, __u32 base,
                                    unsigned long *chip_map, struct cfi_private *cfi)
@@ -116,11 +87,7 @@ static int __xipram cfi_probe_chip(struct map_info *map, __u32 base,
         }
 
         xip_disable();
-        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
-        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
-        cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
-
-        if (!qry_present(map,base,cfi)) {
+        if (!cfi_qry_mode_on(base, map, cfi)) {
                 xip_enable(base, map, cfi);
                 return 0;
         }
@@ -141,14 +108,13 @@ static int __xipram cfi_probe_chip(struct map_info *map, __u32 base,
                 start = i << cfi->chipshift;
                 /* This chip should be in read mode if it's one
                    we've already touched. */
-                if (qry_present(map, start, cfi)) {
+                if (cfi_qry_present(map, start, cfi)) {
                         /* Eep. This chip also had the QRY marker.
                          * Is it an alias for the new one? */
-                        cfi_send_gen_cmd(0xF0, 0, start, map, cfi, cfi->device_type, NULL);
-                        cfi_send_gen_cmd(0xFF, 0, start, map, cfi, cfi->device_type, NULL);
+                        cfi_qry_mode_off(start, map, cfi);
 
                         /* If the QRY marker goes away, it's an alias */
-                        if (!qry_present(map, start, cfi)) {
+                        if (!cfi_qry_present(map, start, cfi)) {
                                 xip_allowed(base, map);
                                 printk(KERN_DEBUG "%s: Found an alias at 0x%x for the chip at 0x%lx\n",
                                        map->name, base, start);
@@ -158,10 +124,9 @@ static int __xipram cfi_probe_chip(struct map_info *map, __u32 base,
                          * unfortunate. Stick the new chip in read mode
                          * too and if it's the same, assume it's an alias. */
                         /* FIXME: Use other modes to do a proper check */
-                        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
-                        cfi_send_gen_cmd(0xFF, 0, start, map, cfi, cfi->device_type, NULL);
+                        cfi_qry_mode_off(base, map, cfi);
 
-                        if (qry_present(map, base, cfi)) {
+                        if (cfi_qry_present(map, base, cfi)) {
                                 xip_allowed(base, map);
                                 printk(KERN_DEBUG "%s: Found an alias at 0x%x for the chip at 0x%lx\n",
                                        map->name, base, start);
@@ -176,8 +141,7 @@ static int __xipram cfi_probe_chip(struct map_info *map, __u32 base,
         cfi->numchips++;
 
         /* Put it back into Read Mode */
-        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
-        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
+        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",
@@ -237,9 +201,7 @@ static int __xipram cfi_chip_setup(struct map_info *map,
                           cfi_read_query(map, base + 0xf * ofs_factor);
 
         /* Put it back into Read Mode */
-        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
-        /* ... even if it's an Intel chip */
-        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_qry_mode_off(base, map, cfi);
         xip_allowed(base, map);
 
         /* Do any necessary byteswapping */
diff --git a/drivers/mtd/chips/cfi_util.c b/drivers/mtd/chips/cfi_util.c
index 0ee457018016..34d40e25d312 100644
--- a/drivers/mtd/chips/cfi_util.c
+++ b/drivers/mtd/chips/cfi_util.c
@@ -24,6 +24,66 @@
 #include <linux/mtd/cfi.h>
 #include <linux/mtd/compatmac.h>
 
+int __xipram cfi_qry_present(struct map_info *map, __u32 base,
+                             struct cfi_private *cfi)
+{
+        int osf = cfi->interleave * cfi->device_type;   /* scale factor */
+        map_word val[3];
+        map_word qry[3];
+
+        qry[0] = cfi_build_cmd('Q', map, cfi);
+        qry[1] = cfi_build_cmd('R', map, cfi);
+        qry[2] = cfi_build_cmd('Y', map, cfi);
+
+        val[0] = map_read(map, base + osf*0x10);
+        val[1] = map_read(map, base + osf*0x11);
+        val[2] = map_read(map, base + osf*0x12);
+
+        if (!map_word_equal(map, qry[0], val[0]))
+                return 0;
+
+        if (!map_word_equal(map, qry[1], val[1]))
+                return 0;
+
+        if (!map_word_equal(map, qry[2], val[2]))
+                return 0;
+
+        return 1;       /* "QRY" found */
+}
+EXPORT_SYMBOL_GPL(cfi_qry_present);
+
+int __xipram cfi_qry_mode_on(uint32_t base, struct map_info *map,
+                             struct cfi_private *cfi)
+{
+        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
+        if (cfi_qry_present(map, base, cfi))
+                return 1;
+        /* QRY not found probably we deal with some odd CFI chips */
+        /* Some revisions of some old Intel chips? */
+        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
+        if (cfi_qry_present(map, base, cfi))
+                return 1;
+        /* ST M29DW chips */
+        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0x98, 0x555, base, map, cfi, cfi->device_type, NULL);
+        if (cfi_qry_present(map, base, cfi))
+                return 1;
+        /* QRY not found */
+        return 0;
+}
+EXPORT_SYMBOL_GPL(cfi_qry_mode_on);
+
+void __xipram cfi_qry_mode_off(uint32_t base, struct map_info *map,
+                               struct cfi_private *cfi)
+{
+        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
+}
+EXPORT_SYMBOL_GPL(cfi_qry_mode_off);
+
 struct cfi_extquery *
 __xipram cfi_read_pri(struct map_info *map, __u16 adr, __u16 size, const char* name)
 {
@@ -48,8 +108,7 @@ __xipram cfi_read_pri(struct map_info *map, __u16 adr, __u16 size, const char* n
 #endif
 
         /* Switch it into Query Mode */
-        cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
-
+        cfi_qry_mode_on(base, map, cfi);
         /* Read in the Extended Query Table */
         for (i=0; i<size; i++) {
                 ((unsigned char *)extp)[i] =
@@ -57,8 +116,7 @@ __xipram cfi_read_pri(struct map_info *map, __u16 adr, __u16 size, const char* n
         }
 
         /* Make sure it returns to read mode */
-        cfi_send_gen_cmd(0xf0, 0, base, map, cfi, cfi->device_type, NULL);
-        cfi_send_gen_cmd(0xff, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_qry_mode_off(base, map, cfi);
 
 #ifdef CONFIG_MTD_XIP
         (void) map_read(map, base);
diff --git a/drivers/mtd/chips/gen_probe.c b/drivers/mtd/chips/gen_probe.c
index f061885b2812..e2dc96441e05 100644
--- a/drivers/mtd/chips/gen_probe.c
+++ b/drivers/mtd/chips/gen_probe.c
@@ -111,7 +111,7 @@ static struct cfi_private *genprobe_ident_chips(struct map_info *map, struct chi
                 max_chips = 1;
         }
 
-        mapsize = sizeof(long) * ( (max_chips + BITS_PER_LONG-1) / BITS_PER_LONG );
+        mapsize = sizeof(long) * DIV_ROUND_UP(max_chips, BITS_PER_LONG);
         chip_map = kzalloc(mapsize, GFP_KERNEL);
         if (!chip_map) {
                 printk(KERN_WARNING "%s: kmalloc failed for CFI chip map\n", map->name);