summaryrefslogtreecommitdiff
path: root/target/linux/generic-2.6/patches
diff options
context:
space:
mode:
authorFelix Fietkau <nbd@openwrt.org>2007-03-01 23:52:19 +0000
committerFelix Fietkau <nbd@openwrt.org>2007-03-01 23:52:19 +0000
commita256c81dd99148e289dc7a73c01b9108701ad9d3 (patch)
tree6d78fce4402a743c7139527f7793dcbeb482dae4 /target/linux/generic-2.6/patches
parent7b73e474d6ad3b66190bf9c5b0d54c949f8a265a (diff)
downloadmtk-20170518-a256c81dd99148e289dc7a73c01b9108701ad9d3.zip
mtk-20170518-a256c81dd99148e289dc7a73c01b9108701ad9d3.tar.gz
mtk-20170518-a256c81dd99148e289dc7a73c01b9108701ad9d3.tar.bz2
move mtd rootfs split patch to generic-2.6, disabled for broadcom targets until the flash map driver is updated and tested
SVN-Revision: 6449
Diffstat (limited to 'target/linux/generic-2.6/patches')
-rw-r--r--target/linux/generic-2.6/patches/060-rootfs_split.patch414
1 files changed, 414 insertions, 0 deletions
diff --git a/target/linux/generic-2.6/patches/060-rootfs_split.patch b/target/linux/generic-2.6/patches/060-rootfs_split.patch
new file mode 100644
index 0000000..e2e52f6
--- /dev/null
+++ b/target/linux/generic-2.6/patches/060-rootfs_split.patch
@@ -0,0 +1,414 @@
+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);
+ }
+ }
+