+++ /dev/null
-diff -ur linux.old/drivers/mtd/Kconfig linux.dev/drivers/mtd/Kconfig
---- linux.old/drivers/mtd/Kconfig 2007-01-10 20:10:37.000000000 +0100
-+++ linux.dev/drivers/mtd/Kconfig 2007-02-19 23:00:53.739457000 +0100
-@@ -49,6 +49,11 @@
- devices. Partitioning on NFTL 'devices' is a different - that's the
- 'normal' form of partitioning used on a block device.
-
-+config MTD_SPLIT_ROOTFS
-+ bool "Automatically split rootfs partition for squashfs"
-+ depends on MTD_PARTITIONS
-+ default y
-+
- config MTD_REDBOOT_PARTS
- tristate "RedBoot partition table parsing"
- depends on MTD_PARTITIONS
-diff -ur linux.old/drivers/mtd/mtdpart.c linux.dev/drivers/mtd/mtdpart.c
---- linux.old/drivers/mtd/mtdpart.c 2007-01-10 20:10:37.000000000 +0100
-+++ linux.dev/drivers/mtd/mtdpart.c 2007-02-20 00:01:38.587355896 +0100
-@@ -20,6 +20,8 @@
- #include <linux/mtd/mtd.h>
- #include <linux/mtd/partitions.h>
- #include <linux/mtd/compatmac.h>
-+#include <linux/squashfs_fs.h>
-+#include <linux/root_dev.h>
-
- /* Our partition linked list */
- static LIST_HEAD(mtd_partitions);
-@@ -303,6 +305,173 @@
- return 0;
- }
-
-+static u_int32_t cur_offset = 0;
-+static int add_mtd_partition(struct mtd_info *master, const struct mtd_partition *part, int i)
-+{
-+ struct mtd_part *slave;
-+
-+ /* allocate the partition structure */
-+ slave = kmalloc (sizeof(*slave), GFP_KERNEL);
-+ if (!slave) {
-+ printk ("memory allocation error while creating partitions for \"%s\"\n",
-+ master->name);
-+ del_mtd_partitions(master);
-+ return -ENOMEM;
-+ }
-+ memset(slave, 0, sizeof(*slave));
-+ list_add(&slave->list, &mtd_partitions);
-+
-+ /* set up the MTD object for this partition */
-+ slave->mtd.type = master->type;
-+ slave->mtd.flags = master->flags & ~part->mask_flags;
-+ slave->mtd.size = part->size;
-+ slave->mtd.writesize = master->writesize;
-+ slave->mtd.oobsize = master->oobsize;
-+ slave->mtd.ecctype = master->ecctype;
-+ slave->mtd.eccsize = master->eccsize;
-+
-+ slave->mtd.name = part->name;
-+ slave->mtd.bank_size = master->bank_size;
-+ slave->mtd.owner = master->owner;
-+
-+ slave->mtd.read = part_read;
-+ slave->mtd.write = part_write;
-+
-+ if(master->point && master->unpoint){
-+ slave->mtd.point = part_point;
-+ slave->mtd.unpoint = part_unpoint;
-+ }
-+
-+ if (master->read_oob)
-+ slave->mtd.read_oob = part_read_oob;
-+ if (master->write_oob)
-+ slave->mtd.write_oob = part_write_oob;
-+ if(master->read_user_prot_reg)
-+ slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
-+ if(master->read_fact_prot_reg)
-+ slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
-+ if(master->write_user_prot_reg)
-+ slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
-+ if(master->lock_user_prot_reg)
-+ slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
-+ if(master->get_user_prot_info)
-+ slave->mtd.get_user_prot_info = part_get_user_prot_info;
-+ if(master->get_fact_prot_info)
-+ slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
-+ if (master->sync)
-+ slave->mtd.sync = part_sync;
-+ if (!i && master->suspend && master->resume) {
-+ slave->mtd.suspend = part_suspend;
-+ slave->mtd.resume = part_resume;
-+ }
-+ if (master->writev)
-+ slave->mtd.writev = part_writev;
-+ if (master->lock)
-+ slave->mtd.lock = part_lock;
-+ if (master->unlock)
-+ slave->mtd.unlock = part_unlock;
-+ if (master->block_isbad)
-+ slave->mtd.block_isbad = part_block_isbad;
-+ if (master->block_markbad)
-+ slave->mtd.block_markbad = part_block_markbad;
-+ slave->mtd.erase = part_erase;
-+ slave->master = master;
-+ slave->offset = part->offset;
-+ slave->index = i;
-+
-+ if (slave->offset == MTDPART_OFS_APPEND)
-+ slave->offset = cur_offset;
-+ if (slave->offset == MTDPART_OFS_NXTBLK) {
-+ slave->offset = cur_offset;
-+ if ((cur_offset % master->erasesize) != 0) {
-+ /* Round up to next erasesize */
-+ slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
-+ printk(KERN_NOTICE "Moving partition %d: "
-+ "0x%08x -> 0x%08x\n", i,
-+ cur_offset, slave->offset);
-+ }
-+ }
-+ if (slave->mtd.size == MTDPART_SIZ_FULL)
-+ slave->mtd.size = master->size - slave->offset;
-+ cur_offset = slave->offset + slave->mtd.size;
-+
-+ printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
-+ slave->offset + slave->mtd.size, slave->mtd.name);
-+
-+ /* let's do some sanity checks */
-+ if (slave->offset >= master->size) {
-+ /* let's register it anyway to preserve ordering */
-+ slave->offset = 0;
-+ slave->mtd.size = 0;
-+ printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
-+ part->name);
-+ }
-+ if (slave->offset + slave->mtd.size > master->size) {
-+ slave->mtd.size = master->size - slave->offset;
-+ printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
-+ part->name, master->name, slave->mtd.size);
-+ }
-+ if (master->numeraseregions>1) {
-+ /* Deal with variable erase size stuff */
-+ int i;
-+ struct mtd_erase_region_info *regions = master->eraseregions;
-+
-+ /* Find the first erase regions which is part of this partition. */
-+ for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++)
-+ ;
-+
-+ for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) {
-+ if (slave->mtd.erasesize < regions[i].erasesize) {
-+ slave->mtd.erasesize = regions[i].erasesize;
-+ }
-+ }
-+ } else {
-+ /* Single erase size */
-+ slave->mtd.erasesize = master->erasesize;
-+ }
-+
-+ if ((slave->mtd.flags & MTD_WRITEABLE) &&
-+ (slave->offset % slave->mtd.erasesize)) {
-+ /* Doesn't start on a boundary of major erase size */
-+ /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
-+ slave->mtd.flags &= ~MTD_WRITEABLE;
-+ printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
-+ part->name);
-+ }
-+ if ((slave->mtd.flags & MTD_WRITEABLE) &&
-+ (slave->mtd.size % slave->mtd.erasesize)) {
-+ slave->mtd.flags &= ~MTD_WRITEABLE;
-+ printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
-+ part->name);
-+ }
-+
-+ slave->mtd.ecclayout = master->ecclayout;
-+ if (master->block_isbad) {
-+ uint32_t offs = 0;
-+
-+ while(offs < slave->mtd.size) {
-+ if (master->block_isbad(master,
-+ offs + slave->offset))
-+ slave->mtd.ecc_stats.badblocks++;
-+ offs += slave->mtd.erasesize;
-+ }
-+ }
-+
-+ if(part->mtdp)
-+ { /* store the object pointer (caller may or may not register it */
-+ *part->mtdp = &slave->mtd;
-+ slave->registered = 0;
-+ }
-+ else
-+ {
-+ /* register our partition */
-+ add_mtd_device(&slave->mtd);
-+ slave->registered = 1;
-+ }
-+
-+ return 0;
-+}
-+
- /*
- * This function, given a master MTD object and a partition table, creates
- * and registers slave MTD objects which are bound to the master according to
-@@ -314,171 +483,53 @@
- const struct mtd_partition *parts,
- int nbparts)
- {
-- struct mtd_part *slave;
-- u_int32_t cur_offset = 0;
-- int i;
-+ struct mtd_partition *part;
-+ int i, ret = 0;
-
- printk (KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
-
- for (i = 0; i < nbparts; i++) {
-+ part = (struct mtd_partition *) &parts[i];
-+ ret = add_mtd_partition(master, part, i);
-+ if (ret)
-+ return ret;
-+ if (strcmp(part->name, "rootfs") == 0) {
-+#ifdef CONFIG_MTD_SPLIT_ROOTFS
-+ int len;
-+ char buf[512];
-+ struct squashfs_super_block *sb = (struct squashfs_super_block *) buf;
-+#define ROOTFS_SPLIT_NAME "rootfs_data"
-+ if ((master->read(master, part->offset, sizeof(struct squashfs_super_block), &len, buf) == 0) &&
-+ (len == sizeof(struct squashfs_super_block)) &&
-+ (*((u32 *) buf) == SQUASHFS_MAGIC) &&
-+ (sb->bytes_used > 0)) {
-+
-+
-+ part = kmalloc(sizeof(struct mtd_partition), GFP_KERNEL);
-+ memcpy(part, &parts[i], sizeof(struct mtd_partition));
-+
-+ part->name = kmalloc(sizeof(ROOTFS_SPLIT_NAME) + 1, GFP_KERNEL);
-+ strcpy(part->name, ROOTFS_SPLIT_NAME);
-+
-+ len = (u32) sb->bytes_used;
-+ len += (part->offset & 0x000fffff);
-+ len += (master->erasesize - 1);
-+ len &= ~(master->erasesize - 1);
-+ len -= (part->offset & 0x000fffff);
-+ part->offset += len;
-+ part->size -= len;
-+
-+ if (len + master->erasesize < part->size)
-+ ret = add_mtd_partition(master, part, i + 1);
-+ else
-+ kfree(part->name);
-+ if (ret)
-+ return ret;
-
-- /* allocate the partition structure */
-- slave = kmalloc (sizeof(*slave), GFP_KERNEL);
-- if (!slave) {
-- printk ("memory allocation error while creating partitions for \"%s\"\n",
-- master->name);
-- del_mtd_partitions(master);
-- return -ENOMEM;
-- }
-- memset(slave, 0, sizeof(*slave));
-- list_add(&slave->list, &mtd_partitions);
--
-- /* set up the MTD object for this partition */
-- slave->mtd.type = master->type;
-- slave->mtd.flags = master->flags & ~parts[i].mask_flags;
-- slave->mtd.size = parts[i].size;
-- slave->mtd.writesize = master->writesize;
-- slave->mtd.oobsize = master->oobsize;
-- slave->mtd.ecctype = master->ecctype;
-- slave->mtd.eccsize = master->eccsize;
--
-- slave->mtd.name = parts[i].name;
-- slave->mtd.bank_size = master->bank_size;
-- slave->mtd.owner = master->owner;
--
-- slave->mtd.read = part_read;
-- slave->mtd.write = part_write;
--
-- if(master->point && master->unpoint){
-- slave->mtd.point = part_point;
-- slave->mtd.unpoint = part_unpoint;
-- }
--
-- if (master->read_oob)
-- slave->mtd.read_oob = part_read_oob;
-- if (master->write_oob)
-- slave->mtd.write_oob = part_write_oob;
-- if(master->read_user_prot_reg)
-- slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
-- if(master->read_fact_prot_reg)
-- slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
-- if(master->write_user_prot_reg)
-- slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
-- if(master->lock_user_prot_reg)
-- slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
-- if(master->get_user_prot_info)
-- slave->mtd.get_user_prot_info = part_get_user_prot_info;
-- if(master->get_fact_prot_info)
-- slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
-- if (master->sync)
-- slave->mtd.sync = part_sync;
-- if (!i && master->suspend && master->resume) {
-- slave->mtd.suspend = part_suspend;
-- slave->mtd.resume = part_resume;
-- }
-- if (master->writev)
-- slave->mtd.writev = part_writev;
-- if (master->lock)
-- slave->mtd.lock = part_lock;
-- if (master->unlock)
-- slave->mtd.unlock = part_unlock;
-- if (master->block_isbad)
-- slave->mtd.block_isbad = part_block_isbad;
-- if (master->block_markbad)
-- slave->mtd.block_markbad = part_block_markbad;
-- slave->mtd.erase = part_erase;
-- slave->master = master;
-- slave->offset = parts[i].offset;
-- slave->index = i;
--
-- if (slave->offset == MTDPART_OFS_APPEND)
-- slave->offset = cur_offset;
-- if (slave->offset == MTDPART_OFS_NXTBLK) {
-- slave->offset = cur_offset;
-- if ((cur_offset % master->erasesize) != 0) {
-- /* Round up to next erasesize */
-- slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
-- printk(KERN_NOTICE "Moving partition %d: "
-- "0x%08x -> 0x%08x\n", i,
-- cur_offset, slave->offset);
-+ kfree(part);
- }
-- }
-- if (slave->mtd.size == MTDPART_SIZ_FULL)
-- slave->mtd.size = master->size - slave->offset;
-- cur_offset = slave->offset + slave->mtd.size;
--
-- printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
-- slave->offset + slave->mtd.size, slave->mtd.name);
--
-- /* let's do some sanity checks */
-- if (slave->offset >= master->size) {
-- /* let's register it anyway to preserve ordering */
-- slave->offset = 0;
-- slave->mtd.size = 0;
-- printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
-- parts[i].name);
-- }
-- if (slave->offset + slave->mtd.size > master->size) {
-- slave->mtd.size = master->size - slave->offset;
-- printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
-- parts[i].name, master->name, slave->mtd.size);
-- }
-- if (master->numeraseregions>1) {
-- /* Deal with variable erase size stuff */
-- int i;
-- struct mtd_erase_region_info *regions = master->eraseregions;
--
-- /* Find the first erase regions which is part of this partition. */
-- for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++)
-- ;
--
-- for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) {
-- if (slave->mtd.erasesize < regions[i].erasesize) {
-- slave->mtd.erasesize = regions[i].erasesize;
-- }
-- }
-- } else {
-- /* Single erase size */
-- slave->mtd.erasesize = master->erasesize;
-- }
--
-- if ((slave->mtd.flags & MTD_WRITEABLE) &&
-- (slave->offset % slave->mtd.erasesize)) {
-- /* Doesn't start on a boundary of major erase size */
-- /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
-- slave->mtd.flags &= ~MTD_WRITEABLE;
-- printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
-- parts[i].name);
-- }
-- if ((slave->mtd.flags & MTD_WRITEABLE) &&
-- (slave->mtd.size % slave->mtd.erasesize)) {
-- slave->mtd.flags &= ~MTD_WRITEABLE;
-- printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
-- parts[i].name);
-- }
--
-- slave->mtd.ecclayout = master->ecclayout;
-- if (master->block_isbad) {
-- uint32_t offs = 0;
--
-- while(offs < slave->mtd.size) {
-- if (master->block_isbad(master,
-- offs + slave->offset))
-- slave->mtd.ecc_stats.badblocks++;
-- offs += slave->mtd.erasesize;
-- }
-- }
--
-- if(parts[i].mtdp)
-- { /* store the object pointer (caller may or may not register it */
-- *parts[i].mtdp = &slave->mtd;
-- slave->registered = 0;
-- }
-- else
-- {
-- /* register our partition */
-- add_mtd_device(&slave->mtd);
-- slave->registered = 1;
-+#endif /* CONFIG_MTD_SPLIT_ROOTFS */
-+ ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, i);
- }
- }
-
CONFIG_MTD_BCM947XX=y
CONFIG_MTD_CFI_SSTSTD=y
CONFIG_MTD_SFLASH=y
+# CONFIG_MTD_SPLIT_ROOTFS is not set
# CONFIG_NATSEMI is not set
# CONFIG_NE2K_PCI is not set
# CONFIG_NE3210 is not set
# CONFIG_MTD_REDBOOT_PARTS is not set
# CONFIG_MTD_ROM is not set
# CONFIG_MTD_SLRAM is not set
+# CONFIG_MTD_SPLIT_ROOTFS is not set
# CONFIG_NATSEMI is not set
# CONFIG_NE2K_PCI is not set
# CONFIG_NETFILTER_XT_MATCH_COMMENT is not set
# CONFIG_MTD_REDBOOT_PARTS is not set
# CONFIG_MTD_ROM is not set
# CONFIG_MTD_SLRAM is not set
+# CONFIG_MTD_SPLIT_ROOTFS is not set
# CONFIG_NATSEMI is not set
# CONFIG_NE2K_PCI is not set
# CONFIG_NETFILTER_XT_MATCH_COMMENT is not set
# CONFIG_MODVERSIONS is not set
CONFIG_MSDOS_FS=m
CONFIG_MSDOS_PARTITION=y
+CONFIG_MTD_SPLIT_ROOTFS=y
# CONFIG_MYRI10GE is not set
# CONFIG_NCP_FS is not set
CONFIG_NET=y
--- /dev/null
+diff -ur linux.old/drivers/mtd/Kconfig linux.dev/drivers/mtd/Kconfig
+--- linux.old/drivers/mtd/Kconfig 2007-01-10 20:10:37.000000000 +0100
++++ linux.dev/drivers/mtd/Kconfig 2007-02-19 23:00:53.739457000 +0100
+@@ -49,6 +49,11 @@
+ devices. Partitioning on NFTL 'devices' is a different - that's the
+ 'normal' form of partitioning used on a block device.
+
++config MTD_SPLIT_ROOTFS
++ bool "Automatically split rootfs partition for squashfs"
++ depends on MTD_PARTITIONS
++ default y
++
+ config MTD_REDBOOT_PARTS
+ tristate "RedBoot partition table parsing"
+ depends on MTD_PARTITIONS
+diff -ur linux.old/drivers/mtd/mtdpart.c linux.dev/drivers/mtd/mtdpart.c
+--- linux.old/drivers/mtd/mtdpart.c 2007-01-10 20:10:37.000000000 +0100
++++ linux.dev/drivers/mtd/mtdpart.c 2007-02-20 00:01:38.587355896 +0100
+@@ -20,6 +20,8 @@
+ #include <linux/mtd/mtd.h>
+ #include <linux/mtd/partitions.h>
+ #include <linux/mtd/compatmac.h>
++#include <linux/squashfs_fs.h>
++#include <linux/root_dev.h>
+
+ /* Our partition linked list */
+ static LIST_HEAD(mtd_partitions);
+@@ -303,6 +305,173 @@
+ return 0;
+ }
+
++static u_int32_t cur_offset = 0;
++static int add_mtd_partition(struct mtd_info *master, const struct mtd_partition *part, int i)
++{
++ struct mtd_part *slave;
++
++ /* allocate the partition structure */
++ slave = kmalloc (sizeof(*slave), GFP_KERNEL);
++ if (!slave) {
++ printk ("memory allocation error while creating partitions for \"%s\"\n",
++ master->name);
++ del_mtd_partitions(master);
++ return -ENOMEM;
++ }
++ memset(slave, 0, sizeof(*slave));
++ list_add(&slave->list, &mtd_partitions);
++
++ /* set up the MTD object for this partition */
++ slave->mtd.type = master->type;
++ slave->mtd.flags = master->flags & ~part->mask_flags;
++ slave->mtd.size = part->size;
++ slave->mtd.writesize = master->writesize;
++ slave->mtd.oobsize = master->oobsize;
++ slave->mtd.ecctype = master->ecctype;
++ slave->mtd.eccsize = master->eccsize;
++
++ slave->mtd.name = part->name;
++ slave->mtd.bank_size = master->bank_size;
++ slave->mtd.owner = master->owner;
++
++ slave->mtd.read = part_read;
++ slave->mtd.write = part_write;
++
++ if(master->point && master->unpoint){
++ slave->mtd.point = part_point;
++ slave->mtd.unpoint = part_unpoint;
++ }
++
++ if (master->read_oob)
++ slave->mtd.read_oob = part_read_oob;
++ if (master->write_oob)
++ slave->mtd.write_oob = part_write_oob;
++ if(master->read_user_prot_reg)
++ slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
++ if(master->read_fact_prot_reg)
++ slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
++ if(master->write_user_prot_reg)
++ slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
++ if(master->lock_user_prot_reg)
++ slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
++ if(master->get_user_prot_info)
++ slave->mtd.get_user_prot_info = part_get_user_prot_info;
++ if(master->get_fact_prot_info)
++ slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
++ if (master->sync)
++ slave->mtd.sync = part_sync;
++ if (!i && master->suspend && master->resume) {
++ slave->mtd.suspend = part_suspend;
++ slave->mtd.resume = part_resume;
++ }
++ if (master->writev)
++ slave->mtd.writev = part_writev;
++ if (master->lock)
++ slave->mtd.lock = part_lock;
++ if (master->unlock)
++ slave->mtd.unlock = part_unlock;
++ if (master->block_isbad)
++ slave->mtd.block_isbad = part_block_isbad;
++ if (master->block_markbad)
++ slave->mtd.block_markbad = part_block_markbad;
++ slave->mtd.erase = part_erase;
++ slave->master = master;
++ slave->offset = part->offset;
++ slave->index = i;
++
++ if (slave->offset == MTDPART_OFS_APPEND)
++ slave->offset = cur_offset;
++ if (slave->offset == MTDPART_OFS_NXTBLK) {
++ slave->offset = cur_offset;
++ if ((cur_offset % master->erasesize) != 0) {
++ /* Round up to next erasesize */
++ slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
++ printk(KERN_NOTICE "Moving partition %d: "
++ "0x%08x -> 0x%08x\n", i,
++ cur_offset, slave->offset);
++ }
++ }
++ if (slave->mtd.size == MTDPART_SIZ_FULL)
++ slave->mtd.size = master->size - slave->offset;
++ cur_offset = slave->offset + slave->mtd.size;
++
++ printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
++ slave->offset + slave->mtd.size, slave->mtd.name);
++
++ /* let's do some sanity checks */
++ if (slave->offset >= master->size) {
++ /* let's register it anyway to preserve ordering */
++ slave->offset = 0;
++ slave->mtd.size = 0;
++ printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
++ part->name);
++ }
++ if (slave->offset + slave->mtd.size > master->size) {
++ slave->mtd.size = master->size - slave->offset;
++ printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
++ part->name, master->name, slave->mtd.size);
++ }
++ if (master->numeraseregions>1) {
++ /* Deal with variable erase size stuff */
++ int i;
++ struct mtd_erase_region_info *regions = master->eraseregions;
++
++ /* Find the first erase regions which is part of this partition. */
++ for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++)
++ ;
++
++ for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) {
++ if (slave->mtd.erasesize < regions[i].erasesize) {
++ slave->mtd.erasesize = regions[i].erasesize;
++ }
++ }
++ } else {
++ /* Single erase size */
++ slave->mtd.erasesize = master->erasesize;
++ }
++
++ if ((slave->mtd.flags & MTD_WRITEABLE) &&
++ (slave->offset % slave->mtd.erasesize)) {
++ /* Doesn't start on a boundary of major erase size */
++ /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
++ slave->mtd.flags &= ~MTD_WRITEABLE;
++ printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
++ part->name);
++ }
++ if ((slave->mtd.flags & MTD_WRITEABLE) &&
++ (slave->mtd.size % slave->mtd.erasesize)) {
++ slave->mtd.flags &= ~MTD_WRITEABLE;
++ printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
++ part->name);
++ }
++
++ slave->mtd.ecclayout = master->ecclayout;
++ if (master->block_isbad) {
++ uint32_t offs = 0;
++
++ while(offs < slave->mtd.size) {
++ if (master->block_isbad(master,
++ offs + slave->offset))
++ slave->mtd.ecc_stats.badblocks++;
++ offs += slave->mtd.erasesize;
++ }
++ }
++
++ if(part->mtdp)
++ { /* store the object pointer (caller may or may not register it */
++ *part->mtdp = &slave->mtd;
++ slave->registered = 0;
++ }
++ else
++ {
++ /* register our partition */
++ add_mtd_device(&slave->mtd);
++ slave->registered = 1;
++ }
++
++ return 0;
++}
++
+ /*
+ * This function, given a master MTD object and a partition table, creates
+ * and registers slave MTD objects which are bound to the master according to
+@@ -314,171 +483,53 @@
+ const struct mtd_partition *parts,
+ int nbparts)
+ {
+- struct mtd_part *slave;
+- u_int32_t cur_offset = 0;
+- int i;
++ struct mtd_partition *part;
++ int i, ret = 0;
+
+ printk (KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
+
+ for (i = 0; i < nbparts; i++) {
++ part = (struct mtd_partition *) &parts[i];
++ ret = add_mtd_partition(master, part, i);
++ if (ret)
++ return ret;
++ if (strcmp(part->name, "rootfs") == 0) {
++#ifdef CONFIG_MTD_SPLIT_ROOTFS
++ int len;
++ char buf[512];
++ struct squashfs_super_block *sb = (struct squashfs_super_block *) buf;
++#define ROOTFS_SPLIT_NAME "rootfs_data"
++ if ((master->read(master, part->offset, sizeof(struct squashfs_super_block), &len, buf) == 0) &&
++ (len == sizeof(struct squashfs_super_block)) &&
++ (*((u32 *) buf) == SQUASHFS_MAGIC) &&
++ (sb->bytes_used > 0)) {
++
++
++ part = kmalloc(sizeof(struct mtd_partition), GFP_KERNEL);
++ memcpy(part, &parts[i], sizeof(struct mtd_partition));
++
++ part->name = kmalloc(sizeof(ROOTFS_SPLIT_NAME) + 1, GFP_KERNEL);
++ strcpy(part->name, ROOTFS_SPLIT_NAME);
++
++ len = (u32) sb->bytes_used;
++ len += (part->offset & 0x000fffff);
++ len += (master->erasesize - 1);
++ len &= ~(master->erasesize - 1);
++ len -= (part->offset & 0x000fffff);
++ part->offset += len;
++ part->size -= len;
++
++ if (len + master->erasesize < part->size)
++ ret = add_mtd_partition(master, part, i + 1);
++ else
++ kfree(part->name);
++ if (ret)
++ return ret;
+
+- /* allocate the partition structure */
+- slave = kmalloc (sizeof(*slave), GFP_KERNEL);
+- if (!slave) {
+- printk ("memory allocation error while creating partitions for \"%s\"\n",
+- master->name);
+- del_mtd_partitions(master);
+- return -ENOMEM;
+- }
+- memset(slave, 0, sizeof(*slave));
+- list_add(&slave->list, &mtd_partitions);
+-
+- /* set up the MTD object for this partition */
+- slave->mtd.type = master->type;
+- slave->mtd.flags = master->flags & ~parts[i].mask_flags;
+- slave->mtd.size = parts[i].size;
+- slave->mtd.writesize = master->writesize;
+- slave->mtd.oobsize = master->oobsize;
+- slave->mtd.ecctype = master->ecctype;
+- slave->mtd.eccsize = master->eccsize;
+-
+- slave->mtd.name = parts[i].name;
+- slave->mtd.bank_size = master->bank_size;
+- slave->mtd.owner = master->owner;
+-
+- slave->mtd.read = part_read;
+- slave->mtd.write = part_write;
+-
+- if(master->point && master->unpoint){
+- slave->mtd.point = part_point;
+- slave->mtd.unpoint = part_unpoint;
+- }
+-
+- if (master->read_oob)
+- slave->mtd.read_oob = part_read_oob;
+- if (master->write_oob)
+- slave->mtd.write_oob = part_write_oob;
+- if(master->read_user_prot_reg)
+- slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
+- if(master->read_fact_prot_reg)
+- slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
+- if(master->write_user_prot_reg)
+- slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
+- if(master->lock_user_prot_reg)
+- slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
+- if(master->get_user_prot_info)
+- slave->mtd.get_user_prot_info = part_get_user_prot_info;
+- if(master->get_fact_prot_info)
+- slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
+- if (master->sync)
+- slave->mtd.sync = part_sync;
+- if (!i && master->suspend && master->resume) {
+- slave->mtd.suspend = part_suspend;
+- slave->mtd.resume = part_resume;
+- }
+- if (master->writev)
+- slave->mtd.writev = part_writev;
+- if (master->lock)
+- slave->mtd.lock = part_lock;
+- if (master->unlock)
+- slave->mtd.unlock = part_unlock;
+- if (master->block_isbad)
+- slave->mtd.block_isbad = part_block_isbad;
+- if (master->block_markbad)
+- slave->mtd.block_markbad = part_block_markbad;
+- slave->mtd.erase = part_erase;
+- slave->master = master;
+- slave->offset = parts[i].offset;
+- slave->index = i;
+-
+- if (slave->offset == MTDPART_OFS_APPEND)
+- slave->offset = cur_offset;
+- if (slave->offset == MTDPART_OFS_NXTBLK) {
+- slave->offset = cur_offset;
+- if ((cur_offset % master->erasesize) != 0) {
+- /* Round up to next erasesize */
+- slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
+- printk(KERN_NOTICE "Moving partition %d: "
+- "0x%08x -> 0x%08x\n", i,
+- cur_offset, slave->offset);
++ kfree(part);
+ }
+- }
+- if (slave->mtd.size == MTDPART_SIZ_FULL)
+- slave->mtd.size = master->size - slave->offset;
+- cur_offset = slave->offset + slave->mtd.size;
+-
+- printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
+- slave->offset + slave->mtd.size, slave->mtd.name);
+-
+- /* let's do some sanity checks */
+- if (slave->offset >= master->size) {
+- /* let's register it anyway to preserve ordering */
+- slave->offset = 0;
+- slave->mtd.size = 0;
+- printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
+- parts[i].name);
+- }
+- if (slave->offset + slave->mtd.size > master->size) {
+- slave->mtd.size = master->size - slave->offset;
+- printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
+- parts[i].name, master->name, slave->mtd.size);
+- }
+- if (master->numeraseregions>1) {
+- /* Deal with variable erase size stuff */
+- int i;
+- struct mtd_erase_region_info *regions = master->eraseregions;
+-
+- /* Find the first erase regions which is part of this partition. */
+- for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++)
+- ;
+-
+- for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) {
+- if (slave->mtd.erasesize < regions[i].erasesize) {
+- slave->mtd.erasesize = regions[i].erasesize;
+- }
+- }
+- } else {
+- /* Single erase size */
+- slave->mtd.erasesize = master->erasesize;
+- }
+-
+- if ((slave->mtd.flags & MTD_WRITEABLE) &&
+- (slave->offset % slave->mtd.erasesize)) {
+- /* Doesn't start on a boundary of major erase size */
+- /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
+- slave->mtd.flags &= ~MTD_WRITEABLE;
+- printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
+- parts[i].name);
+- }
+- if ((slave->mtd.flags & MTD_WRITEABLE) &&
+- (slave->mtd.size % slave->mtd.erasesize)) {
+- slave->mtd.flags &= ~MTD_WRITEABLE;
+- printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
+- parts[i].name);
+- }
+-
+- slave->mtd.ecclayout = master->ecclayout;
+- if (master->block_isbad) {
+- uint32_t offs = 0;
+-
+- while(offs < slave->mtd.size) {
+- if (master->block_isbad(master,
+- offs + slave->offset))
+- slave->mtd.ecc_stats.badblocks++;
+- offs += slave->mtd.erasesize;
+- }
+- }
+-
+- if(parts[i].mtdp)
+- { /* store the object pointer (caller may or may not register it */
+- *parts[i].mtdp = &slave->mtd;
+- slave->registered = 0;
+- }
+- else
+- {
+- /* register our partition */
+- add_mtd_device(&slave->mtd);
+- slave->registered = 1;
++#endif /* CONFIG_MTD_SPLIT_ROOTFS */
++ ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, i);
+ }
+ }
+