[MTD] update internal API to support 64-bit device size

MTD internal API presently uses 32-bit values to represent
device size.  This patch updates them to 64-bits but leaves
the external API unchanged.  Extending the external API
is a separate issue for several reasons.  First, no one
needs it at the moment.  Secondly, whether the implementation
is done with IOCTLs, sysfs or both is still debated.  Thirdly
external API changes require the internal API to be accepted
first.

Note that although the MTD API will be able to support 64-bit
device sizes, existing drivers do not and are not required
to do so, although NAND base has been updated.

In general, changing from 32-bit to 64-bit values cause little
or no changes to the majority of the code with the following
exceptions:
    	- printk message formats
    	- division and modulus of 64-bit values
    	- NAND base support
	- 32-bit local variables used by mtdpart and mtdconcat
	- naughtily assuming one structure maps to another
	in MEMERASE ioctl

Signed-off-by: Adrian Hunter <ext-adrian.hunter@nokia.com>
Signed-off-by: Artem Bityutskiy <Artem.Bityutskiy@nokia.com>
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>

1 files changed, 15 insertions, 16 deletions

diff --git a/drivers/mtd/nand/nand_bbt.c b/drivers/mtd/nand/nand_bbt.c
index 0b1c48595f12..55c23e5cd210 100644
--- a/drivers/mtd/nand/nand_bbt.c
+++ b/drivers/mtd/nand/nand_bbt.c
@@ -171,16 +171,16 @@ static int read_bbt(struct mtd_info *mtd, uint8_t *buf, int page, int num,
                                 if (tmp == msk)
                                         continue;
                                 if (reserved_block_code && (tmp == reserved_block_code)) {
-                                        printk(KERN_DEBUG "nand_read_bbt: Reserved block at 0x%08x\n",
-                                               ((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
+                                        printk(KERN_DEBUG "nand_read_bbt: Reserved block at 0x%012llx\n",
+                                               (loff_t)((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
                                         this->bbt[offs + (act >> 3)] |= 0x2 << (act & 0x06);
                                         mtd->ecc_stats.bbtblocks++;
                                         continue;
                                 }
                                 /* Leave it for now, if its matured we can move this
                                  * message to MTD_DEBUG_LEVEL0 */
-                                printk(KERN_DEBUG "nand_read_bbt: Bad block at 0x%08x\n",
-                                       ((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
+                                printk(KERN_DEBUG "nand_read_bbt: Bad block at 0x%012llx\n",
+                                       (loff_t)((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
                                 /* Factory marked bad or worn out ? */
                                 if (tmp == 0)
                                         this->bbt[offs + (act >> 3)] |= 0x3 << (act & 0x06);
@@ -284,7 +284,7 @@ static int read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
 
         /* Read the primary version, if available */
         if (td->options & NAND_BBT_VERSION) {
-                scan_read_raw(mtd, buf, td->pages[0] << this->page_shift,
+                scan_read_raw(mtd, buf, (loff_t)td->pages[0] << this->page_shift,
                               mtd->writesize);
                 td->version[0] = buf[mtd->writesize + td->veroffs];
                 printk(KERN_DEBUG "Bad block table at page %d, version 0x%02X\n",
@@ -293,7 +293,7 @@ static int read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
 
         /* Read the mirror version, if available */
         if (md && (md->options & NAND_BBT_VERSION)) {
-                scan_read_raw(mtd, buf, md->pages[0] << this->page_shift,
+                scan_read_raw(mtd, buf, (loff_t)md->pages[0] << this->page_shift,
                               mtd->writesize);
                 md->version[0] = buf[mtd->writesize + md->veroffs];
                 printk(KERN_DEBUG "Bad block table at page %d, version 0x%02X\n",
@@ -411,7 +411,7 @@ static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
                 numblocks = this->chipsize >> (this->bbt_erase_shift - 1);
                 startblock = chip * numblocks;
                 numblocks += startblock;
-                from = startblock << (this->bbt_erase_shift - 1);
+                from = (loff_t)startblock << (this->bbt_erase_shift - 1);
         }
 
         for (i = startblock; i < numblocks;) {
@@ -428,8 +428,8 @@ static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
 
                 if (ret) {
                         this->bbt[i >> 3] |= 0x03 << (i & 0x6);
-                        printk(KERN_WARNING "Bad eraseblock %d at 0x%08x\n",
-                               i >> 1, (unsigned int)from);
+                        printk(KERN_WARNING "Bad eraseblock %d at 0x%012llx\n",
+                               i >> 1, (unsigned long long)from);
                         mtd->ecc_stats.badblocks++;
                 }
 
@@ -495,7 +495,7 @@ static int search_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr
                 for (block = 0; block < td->maxblocks; block++) {
 
                         int actblock = startblock + dir * block;
-                        loff_t offs = actblock << this->bbt_erase_shift;
+                        loff_t offs = (loff_t)actblock << this->bbt_erase_shift;
 
                         /* Read first page */
                         scan_read_raw(mtd, buf, offs, mtd->writesize);
@@ -719,7 +719,7 @@ static int write_bbt(struct mtd_info *mtd, uint8_t *buf,
 
                 memset(&einfo, 0, sizeof(einfo));
                 einfo.mtd = mtd;
-                einfo.addr = (unsigned long)to;
+                einfo.addr = to;
                 einfo.len = 1 << this->bbt_erase_shift;
                 res = nand_erase_nand(mtd, &einfo, 1);
                 if (res < 0)
@@ -729,8 +729,8 @@ static int write_bbt(struct mtd_info *mtd, uint8_t *buf,
                 if (res < 0)
                         goto outerr;
 
-                printk(KERN_DEBUG "Bad block table written to 0x%08x, version "
-                       "0x%02X\n", (unsigned int)to, td->version[chip]);
+                printk(KERN_DEBUG "Bad block table written to 0x%012llx, version "
+                       "0x%02X\n", (unsigned long long)to, td->version[chip]);
 
                 /* Mark it as used */
                 td->pages[chip] = page;
@@ -910,7 +910,7 @@ static void mark_bbt_region(struct mtd_info *mtd, struct nand_bbt_descr *td)
                         newval = oldval | (0x2 << (block & 0x06));
                         this->bbt[(block >> 3)] = newval;
                         if ((oldval != newval) && td->reserved_block_code)
-                                nand_update_bbt(mtd, block << (this->bbt_erase_shift - 1));
+                                nand_update_bbt(mtd, (loff_t)block << (this->bbt_erase_shift - 1));
                         continue;
                 }
                 update = 0;
@@ -931,7 +931,7 @@ static void mark_bbt_region(struct mtd_info *mtd, struct nand_bbt_descr *td)
                    new ones have been marked, then we need to update the stored
                    bbts.  This should only happen once. */
                 if (update && td->reserved_block_code)
-                        nand_update_bbt(mtd, (block - 2) << (this->bbt_erase_shift - 1));
+                        nand_update_bbt(mtd, (loff_t)(block - 2) << (this->bbt_erase_shift - 1));
         }
 }
 
@@ -1027,7 +1027,6 @@ int nand_update_bbt(struct mtd_info *mtd, loff_t offs)
         if (!this->bbt || !td)
                 return -EINVAL;
 
-        len = mtd->size >> (this->bbt_erase_shift + 2);
         /* Allocate a temporary buffer for one eraseblock incl. oob */
         len = (1 << this->bbt_erase_shift);
         len += (len >> this->page_shift) * mtd->oobsize;