Changeset 4155


Ignore:
Timestamp:
2006-07-18T19:54:37+02:00 (12 years ago)
Author:
nbd
Message:

backport jffs2 changes and flash map from buildroot-ng

Location:
branches/whiterussian/openwrt
Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed
  • branches/whiterussian/openwrt/package/base-files/default/sbin/mount_root

    r3667 r4155  
    1313        mount | grep jffs2 >&- 
    1414        if [ $? = 0 ] ; then 
    15                 if [ $(cat /proc/mtd | wc -l) = 6 ]; then 
    16                         mtd erase OpenWrt 
    17                         jffs2root --move 
    18                 else 
    19                         mount -o remount,rw /dev/root / 
    20                 fi 
     15                mount -o remount,rw /dev/root / 
    2116        else 
    2217                . /bin/firstboot 
  • branches/whiterussian/openwrt/target/linux/image/jffs2.mk

    r1976 r4155  
    1515        @rm -rf $(KDIR)/root/jffs 
    1616        $(STAGING_DIR)/bin/mkfs.jffs2 $(JFFS2OPTS) -e 0x10000 -o $@ -d $(KDIR)/root 
     17        echo -ne '\xde\xad\xc0\xde' >> $@ 
    1718 
    1819$(KDIR)/root.jffs2-8MB: install-prepare 
    1920        @rm -rf $(KDIR)/root/jffs 
    2021        $(STAGING_DIR)/bin/mkfs.jffs2 $(JFFS2OPTS) -e 0x20000 -o $@ -d $(KDIR)/root 
     22        echo -ne '\xde\xad\xc0\xde' >> $@ 
    2123 
    2224jffs2-install: $(KDIR)/root.jffs2-4MB $(KDIR)/root.jffs2-8MB 
  • branches/whiterussian/openwrt/target/linux/linux-2.4/patches/brcm/001-bcm47xx.patch

    r3868 r4155  
    84558455--- linux.old/arch/mips/bcm947xx/setup.c        1970-01-01 01:00:00.000000000 +0100 
    84568456+++ linux.dev/arch/mips/bcm947xx/setup.c        2005-08-26 13:44:34.313391368 +0200 
    8457 @@ -0,0 +1,261 @@ 
     8457@@ -0,0 +1,168 @@ 
    84588458+/* 
    84598459+ * Generic setup routines for Broadcom MIPS boards 
     
    84798479+#include <asm/reboot.h> 
    84808480+ 
    8481 +#ifdef CONFIG_MTD_PARTITIONS 
    8482 +#include <linux/mtd/mtd.h> 
    8483 +#include <linux/mtd/partitions.h> 
    8484 +#endif 
    8485 + 
    84868481+#include <typedefs.h> 
    84878482+#include <bcmutils.h> 
     
    86298624+} 
    86308625+ 
    8631 +#ifdef CONFIG_MTD_PARTITIONS 
    8632 + 
    8633 +static struct mtd_partition bcm947xx_parts[] = { 
    8634 +       { name: "pmon", offset: 0, size: 0, mask_flags: MTD_WRITEABLE, }, 
    8635 +       { name: "linux", offset: 0, size: 0, }, 
    8636 +       { name: "rootfs", offset: 0, size: 0, }, 
    8637 +       { name: "nvram", offset: 0, size: 0, }, 
    8638 +       { name: "OpenWrt", offset: 0, size: 0, }, 
    8639 +       { name: NULL, }, 
    8640 +}; 
    8641 + 
    8642 +static int __init 
    8643 +find_root(struct mtd_info *mtd, size_t size, struct mtd_partition *part) 
    8644 +{ 
    8645 +       struct trx_header *trx; 
    8646 +       unsigned char buf[512]; 
    8647 +       int off; 
    8648 +       size_t len; 
    8649 + 
    8650 +       trx = (struct trx_header *) buf; 
    8651 + 
    8652 +       for (off = (256*1024); off < size; off += mtd->erasesize) { 
    8653 +               memset(buf, 0xe5, sizeof(buf)); 
    8654 + 
    8655 +               /* 
    8656 +                * Read into buffer  
    8657 +                */ 
    8658 +               if (MTD_READ(mtd, off, sizeof(buf), &len, buf) || 
    8659 +                   len != sizeof(buf)) 
    8660 +                       continue; 
    8661 + 
    8662 +               /* found a TRX header */ 
    8663 +               if (le32_to_cpu(trx->magic) == TRX_MAGIC) { 
    8664 +                       part->offset = le32_to_cpu(trx->offsets[2]) ? :  
    8665 +                               le32_to_cpu(trx->offsets[1]); 
    8666 +                       part->size = le32_to_cpu(trx->len);  
    8667 + 
    8668 +                       part->size -= part->offset; 
    8669 +                       part->offset += off; 
    8670 + 
    8671 +                       goto done; 
    8672 +               } 
    8673 +       } 
    8674 + 
    8675 +       printk(KERN_NOTICE 
    8676 +              "%s: Couldn't find root filesystem\n", 
    8677 +              mtd->name); 
    8678 +       return -1; 
    8679 + 
    8680 + done: 
    8681 +               return part->size; 
    8682 +} 
    8683 + 
    8684 +struct mtd_partition * __init 
    8685 +init_mtd_partitions(struct mtd_info *mtd, size_t size) 
    8686 +{ 
    8687 + 
    8688 +       /* boot loader */ 
    8689 +       bcm947xx_parts[0].offset=0; 
    8690 +       bcm947xx_parts[0].size=256*1024; 
    8691 + 
    8692 +       /* nvram */ 
    8693 +       bcm947xx_parts[3].offset = size - ROUNDUP(NVRAM_SPACE, mtd->erasesize); 
    8694 +       bcm947xx_parts[3].size   = size - bcm947xx_parts[3].offset; 
    8695 + 
    8696 +       /* Size linux (kernel and rootfs) */ 
    8697 +       bcm947xx_parts[1].offset = bcm947xx_parts[0].size; 
    8698 +       bcm947xx_parts[1].size   = bcm947xx_parts[3].offset - bcm947xx_parts[1].offset; 
    8699 + 
    8700 +       /* Find and size rootfs */ 
    8701 +       if (find_root(mtd,size,&bcm947xx_parts[2])==0) { 
    8702 +               /* entirely jffs2 */ 
    8703 +               bcm947xx_parts[2].size = bcm947xx_parts[3].offset - bcm947xx_parts[2].offset;  
    8704 +               bcm947xx_parts[4].name = NULL; 
    8705 +       } else { 
    8706 +               /* legacy setup */ 
    8707 +               /* calculate leftover flash, and assign it to the jffs2 partition */ 
    8708 +               bcm947xx_parts[4].offset = bcm947xx_parts[2].offset + bcm947xx_parts[2].size; 
    8709 +               bcm947xx_parts[4].offset = ROUNDUP(bcm947xx_parts[4].offset, mtd->erasesize); 
    8710 +               bcm947xx_parts[4].size = bcm947xx_parts[3].offset - bcm947xx_parts[4].offset; 
    8711 +       } 
    8712 + 
    8713 +       return bcm947xx_parts; 
    8714 +} 
    8715 + 
    8716 +EXPORT_SYMBOL(init_mtd_partitions); 
    8717 + 
    8718 +#endif 
    87198626diff -urN linux.old/arch/mips/bcm947xx/time.c linux.dev/arch/mips/bcm947xx/time.c 
    87208627--- linux.old/arch/mips/bcm947xx/time.c 1970-01-01 01:00:00.000000000 +0100 
     
    1018610093--- linux.old/drivers/mtd/maps/bcm947xx-flash.c 1970-01-01 01:00:00.000000000 +0100 
    1018710094+++ linux.dev/drivers/mtd/maps/bcm947xx-flash.c 2005-08-26 13:44:34.346386352 +0200 
    10188 @@ -0,0 +1,236 @@ 
     10095@@ -0,0 +1,547 @@ 
    1018910096+/* 
    10190 + * Flash mapping for BCM947XX boards 
     10097+ *  Copyright (C) 2006 Felix Fietkau <nbd@openwrt.org> 
     10098+ *  Copyright (C) 2005 Waldemar Brodkorb <wbx@openwrt.org> 
     10099+ *  Copyright (C) 2004 Florian Schirmer (jolt@tuxbox.org) 
     10100+ * 
     10101+ *  original functions for finding root filesystem from Mike Baker  
     10102+ * 
     10103+ *  This program is free software; you can redistribute  it and/or modify it 
     10104+ *  under  the terms of  the GNU General  Public License as published by the 
     10105+ *  Free Software Foundation;  either version 2 of the  License, or (at your 
     10106+ *  option) any later version. 
     10107+ * 
     10108+ *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED 
     10109+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF 
     10110+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN 
     10111+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT, 
     10112+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
     10113+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF 
     10114+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
     10115+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT 
     10116+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 
     10117+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     10118+ * 
     10119+ *  You should have received a copy of the  GNU General Public License along 
     10120+ *  with this program; if not, write  to the Free Software Foundation, Inc., 
     10121+ *  675 Mass Ave, Cambridge, MA 02139, USA. 
     10122+ *  
    1019110123+ * 
    1019210124+ * Copyright 2004, Broadcom Corporation 
     
    1019810130+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE. 
    1019910131+ * 
    10200 + * $Id: bcm947xx-flash.c,v 1.1 2005/03/16 13:50:00 wbx Exp $ 
     10132+ * Flash mapping for BCM947XX boards 
     10133+ * 
    1020110134+ */ 
    1020210135+ 
     
    1020410137+#include <linux/types.h> 
    1020510138+#include <linux/kernel.h> 
    10206 +#include <asm/io.h> 
     10139+#include <linux/wait.h> 
    1020710140+#include <linux/mtd/mtd.h> 
    1020810141+#include <linux/mtd/map.h> 
     10142+#ifdef CONFIG_MTD_PARTITIONS 
    1020910143+#include <linux/mtd/partitions.h> 
     10144+#endif 
    1021010145+#include <linux/config.h> 
     10146+#include <linux/squashfs_fs.h> 
     10147+#include <linux/jffs2.h> 
     10148+#include <linux/crc32.h> 
     10149+#include <asm/io.h> 
    1021110150+ 
    1021210151+#include <typedefs.h> 
     10152+#include <osl.h> 
    1021310153+#include <bcmnvram.h> 
    1021410154+#include <bcmutils.h> 
     
    1022610166+#define sbh_lock bcm947xx_sbh_lock 
    1022710167+ 
    10228 +#ifdef CONFIG_MTD_PARTITIONS 
    10229 +extern struct mtd_partition * init_mtd_partitions(struct mtd_info *mtd, size_t size); 
    10230 +#endif 
    10231 + 
    1023210168+#define WINDOW_ADDR 0x1fc00000 
    1023310169+#define WINDOW_SIZE 0x400000 
    1023410170+#define BUSWIDTH 2 
    10235 + 
    10236 +/* e.g., flash=2M or flash=4M */ 
    10237 +static int flash = 0; 
    10238 +MODULE_PARM(flash, "i"); 
    10239 +static int __init 
    10240 +bcm947xx_setup(char *str) 
    10241 +{ 
    10242 +       flash = memparse(str, &str); 
    10243 +       return 1; 
    10244 +} 
    10245 +__setup("flash=", bcm947xx_setup); 
    1024610171+ 
    1024710172+static struct mtd_info *bcm947xx_mtd; 
     
    1032210247+}; 
    1032310248+ 
    10324 +#if LINUX_VERSION_CODE < 0x20212 && defined(MODULE) 
    10325 +#define init_bcm947xx_map init_module 
    10326 +#define cleanup_bcm947xx_map cleanup_module 
     10249+#ifdef CONFIG_MTD_PARTITIONS 
     10250+ 
     10251+static struct mtd_partition bcm947xx_parts[] = { 
     10252+       { name: "cfe",  offset: 0, size: 0, mask_flags: MTD_WRITEABLE, }, 
     10253+       { name: "linux", offset: 0, size: 0, }, 
     10254+       { name: "rootfs", offset: 0, size: 0, }, 
     10255+       { name: "nvram", offset: 0, size: 0, }, 
     10256+       { name: "OpenWrt", offset: 0, size: 0, }, 
     10257+       { name: NULL, }, 
     10258+}; 
     10259+ 
     10260+static int __init 
     10261+find_cfe_size(struct mtd_info *mtd, size_t size) 
     10262+{ 
     10263+       struct trx_header *trx; 
     10264+       unsigned char buf[512]; 
     10265+       int off; 
     10266+       size_t len; 
     10267+       int blocksize; 
     10268+ 
     10269+       trx = (struct trx_header *) buf; 
     10270+ 
     10271+       blocksize = mtd->erasesize; 
     10272+       if (blocksize < 0x10000) 
     10273+               blocksize = 0x10000; 
     10274+ 
     10275+       for (off = (128*1024); off < size; off += blocksize) { 
     10276+               memset(buf, 0xe5, sizeof(buf)); 
     10277+ 
     10278+               /* 
     10279+                * Read into buffer  
     10280+                */ 
     10281+               if (MTD_READ(mtd, off, sizeof(buf), &len, buf) || 
     10282+                   len != sizeof(buf)) 
     10283+                       continue; 
     10284+ 
     10285+               /* found a TRX header */ 
     10286+               if (le32_to_cpu(trx->magic) == TRX_MAGIC) { 
     10287+                       goto found; 
     10288+               } 
     10289+       } 
     10290+ 
     10291+       printk(KERN_NOTICE 
     10292+              "%s: Couldn't find bootloader size\n", 
     10293+              mtd->name); 
     10294+       return -1; 
     10295+ 
     10296+ found: 
     10297+       printk(KERN_NOTICE "bootloader size: %d\n", off); 
     10298+       return off; 
     10299+ 
     10300+} 
     10301+ 
     10302+/* 
     10303+ * Copied from mtdblock.c 
     10304+ * 
     10305+ * Cache stuff... 
     10306+ *  
     10307+ * Since typical flash erasable sectors are much larger than what Linux's 
     10308+ * buffer cache can handle, we must implement read-modify-write on flash 
     10309+ * sectors for each block write requests.  To avoid over-erasing flash sectors 
     10310+ * and to speed things up, we locally cache a whole flash sector while it is 
     10311+ * being written to until a different sector is required. 
     10312+ */ 
     10313+ 
     10314+static void erase_callback(struct erase_info *done) 
     10315+{ 
     10316+       wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv; 
     10317+       wake_up(wait_q); 
     10318+} 
     10319+ 
     10320+static int erase_write (struct mtd_info *mtd, unsigned long pos,  
     10321+                       int len, const char *buf) 
     10322+{ 
     10323+       struct erase_info erase; 
     10324+       DECLARE_WAITQUEUE(wait, current); 
     10325+       wait_queue_head_t wait_q; 
     10326+       size_t retlen; 
     10327+       int ret; 
     10328+ 
     10329+       /* 
     10330+        * First, let's erase the flash block. 
     10331+        */ 
     10332+ 
     10333+       init_waitqueue_head(&wait_q); 
     10334+       erase.mtd = mtd; 
     10335+       erase.callback = erase_callback; 
     10336+       erase.addr = pos; 
     10337+       erase.len = len; 
     10338+       erase.priv = (u_long)&wait_q; 
     10339+ 
     10340+       set_current_state(TASK_INTERRUPTIBLE); 
     10341+       add_wait_queue(&wait_q, &wait); 
     10342+ 
     10343+       ret = MTD_ERASE(mtd, &erase); 
     10344+       if (ret) { 
     10345+               set_current_state(TASK_RUNNING); 
     10346+               remove_wait_queue(&wait_q, &wait); 
     10347+               printk (KERN_WARNING "erase of region [0x%lx, 0x%x] " 
     10348+                                    "on \"%s\" failed\n", 
     10349+                       pos, len, mtd->name); 
     10350+               return ret; 
     10351+       } 
     10352+ 
     10353+       schedule();  /* Wait for erase to finish. */ 
     10354+       remove_wait_queue(&wait_q, &wait); 
     10355+ 
     10356+       /* 
     10357+        * Next, writhe data to flash. 
     10358+        */ 
     10359+ 
     10360+       ret = MTD_WRITE (mtd, pos, len, &retlen, buf); 
     10361+       if (ret) 
     10362+               return ret; 
     10363+       if (retlen != len) 
     10364+               return -EIO; 
     10365+       return 0; 
     10366+} 
     10367+ 
     10368+ 
     10369+ 
     10370+ 
     10371+static int __init 
     10372+find_root(struct mtd_info *mtd, size_t size, struct mtd_partition *part) 
     10373+{ 
     10374+       struct trx_header trx, *trx2; 
     10375+       unsigned char buf[512], *block; 
     10376+       int off, blocksize; 
     10377+       u32 i, crc = ~0; 
     10378+       size_t len; 
     10379+       struct squashfs_super_block *sb = (struct squashfs_super_block *) buf; 
     10380+ 
     10381+       blocksize = mtd->erasesize; 
     10382+       if (blocksize < 0x10000) 
     10383+               blocksize = 0x10000; 
     10384+ 
     10385+       for (off = (128*1024); off < size; off += blocksize) { 
     10386+               memset(&trx, 0xe5, sizeof(trx)); 
     10387+ 
     10388+               /* 
     10389+                * Read into buffer  
     10390+                */ 
     10391+               if (MTD_READ(mtd, off, sizeof(trx), &len, (char *) &trx) || 
     10392+                   len != sizeof(trx)) 
     10393+                       continue; 
     10394+ 
     10395+               /* found a TRX header */ 
     10396+               if (le32_to_cpu(trx.magic) == TRX_MAGIC) { 
     10397+                       part->offset = le32_to_cpu(trx.offsets[2]) ? :  
     10398+                               le32_to_cpu(trx.offsets[1]); 
     10399+                       part->size = le32_to_cpu(trx.len);  
     10400+ 
     10401+                       part->size -= part->offset; 
     10402+                       part->offset += off; 
     10403+ 
     10404+                       goto found; 
     10405+               } 
     10406+       } 
     10407+ 
     10408+       printk(KERN_NOTICE 
     10409+              "%s: Couldn't find root filesystem\n", 
     10410+              mtd->name); 
     10411+       return -1; 
     10412+ 
     10413+ found: 
     10414+       if (part->size == 0) 
     10415+               return 0; 
     10416+        
     10417+       if (MTD_READ(mtd, part->offset, sizeof(buf), &len, buf) || len != sizeof(buf)) 
     10418+               return 0; 
     10419+ 
     10420+       if (*((__u32 *) buf) == SQUASHFS_MAGIC) { 
     10421+               printk(KERN_INFO "%s: Filesystem type: squashfs, size=0x%x\n", mtd->name, (u32) sb->bytes_used); 
     10422+ 
     10423+               /* Update the squashfs partition size based on the superblock info */ 
     10424+               part->size = sb->bytes_used; 
     10425+               len = part->offset + part->size; 
     10426+               len +=  (mtd->erasesize - 1); 
     10427+               len &= ~(mtd->erasesize - 1); 
     10428+               part->size = len - part->offset; 
     10429+       } else if (*((__u16 *) buf) == JFFS2_MAGIC_BITMASK) { 
     10430+               printk(KERN_INFO "%s: Filesystem type: jffs2\n", mtd->name); 
     10431+ 
     10432+               /* Move the squashfs outside of the trx */ 
     10433+               part->size = 0; 
     10434+       } else { 
     10435+               printk(KERN_INFO "%s: Filesystem type: unknown\n", mtd->name); 
     10436+               return 0; 
     10437+       } 
     10438+ 
     10439+       if (trx.len != part->offset + part->size - off) { 
     10440+               /* Update the trx offsets and length */ 
     10441+               trx.len = part->offset + part->size - off; 
     10442+        
     10443+               /* Update the trx crc32 */ 
     10444+               for (i = (u32) &(((struct trx_header *)NULL)->flag_version); i <= trx.len; i += sizeof(buf)) { 
     10445+                       if (MTD_READ(mtd, off + i, sizeof(buf), &len, buf) || len != sizeof(buf)) 
     10446+                               return 0; 
     10447+                       crc = crc32_le(crc, buf, min(sizeof(buf), trx.len - i)); 
     10448+               } 
     10449+               trx.crc32 = crc; 
     10450+ 
     10451+               /* read first eraseblock from the trx */ 
     10452+               trx2 = block = kmalloc(mtd->erasesize, GFP_KERNEL); 
     10453+               if (MTD_READ(mtd, off, mtd->erasesize, &len, block) || len != mtd->erasesize) { 
     10454+                       printk("Error accessing the first trx eraseblock\n"); 
     10455+                       return 0; 
     10456+               } 
     10457+                
     10458+               printk("Updating TRX offsets and length:\n"); 
     10459+               printk("old trx = [0x%08x, 0x%08x, 0x%08x], len=0x%08x crc32=0x%08x\n", trx2->offsets[0], trx2->offsets[1], trx2->offsets[2], trx2->len, trx2->crc32); 
     10460+               printk("new trx = [0x%08x, 0x%08x, 0x%08x], len=0x%08x crc32=0x%08x\n",   trx.offsets[0],   trx.offsets[1],   trx.offsets[2],   trx.len, trx.crc32); 
     10461+ 
     10462+               /* Write updated trx header to the flash */ 
     10463+               memcpy(block, &trx, sizeof(trx)); 
     10464+               if (mtd->unlock) 
     10465+                       mtd->unlock(mtd, off, mtd->erasesize); 
     10466+               erase_write(mtd, off, mtd->erasesize, block); 
     10467+               if (mtd->sync) 
     10468+                       mtd->sync(mtd); 
     10469+               kfree(block); 
     10470+               printk("Done\n"); 
     10471+       } 
     10472+        
     10473+       return part->size; 
     10474+} 
     10475+ 
     10476+struct mtd_partition * __init 
     10477+init_mtd_partitions(struct mtd_info *mtd, size_t size) 
     10478+{ 
     10479+       int cfe_size; 
     10480+ 
     10481+       cfe_size = find_cfe_size(mtd,size); 
     10482+ 
     10483+       /* boot loader */ 
     10484+       bcm947xx_parts[0].offset = 0; 
     10485+       bcm947xx_parts[0].size   = cfe_size; 
     10486+ 
     10487+       /* nvram */ 
     10488+       if (cfe_size != 384 * 1024) { 
     10489+               bcm947xx_parts[3].offset = size - ROUNDUP(NVRAM_SPACE, mtd->erasesize); 
     10490+               bcm947xx_parts[3].size   = ROUNDUP(NVRAM_SPACE, mtd->erasesize); 
     10491+       } else { 
     10492+               /* nvram (old 128kb config partition on netgear wgt634u) */ 
     10493+               bcm947xx_parts[3].offset = bcm947xx_parts[0].size; 
     10494+               bcm947xx_parts[3].size   = ROUNDUP(NVRAM_SPACE, mtd->erasesize); 
     10495+       } 
     10496+ 
     10497+       /* linux (kernel and rootfs) */ 
     10498+       if (cfe_size != 384 * 1024) { 
     10499+               bcm947xx_parts[1].offset = bcm947xx_parts[0].size; 
     10500+               bcm947xx_parts[1].size   = bcm947xx_parts[3].offset -  
     10501+                       bcm947xx_parts[1].offset; 
     10502+       } else { 
     10503+               /* do not count the elf loader, which is on one block */ 
     10504+               bcm947xx_parts[1].offset = bcm947xx_parts[0].size +  
     10505+                       bcm947xx_parts[3].size + mtd->erasesize; 
     10506+               bcm947xx_parts[1].size   = size -  
     10507+                       bcm947xx_parts[0].size -  
     10508+                       (2*bcm947xx_parts[3].size) -  
     10509+                       mtd->erasesize; 
     10510+       } 
     10511+ 
     10512+       /* find and size rootfs */ 
     10513+       if (find_root(mtd,size,&bcm947xx_parts[2])==0) { 
     10514+               /* entirely jffs2 */ 
     10515+               bcm947xx_parts[4].name = NULL; 
     10516+               bcm947xx_parts[2].size = size - bcm947xx_parts[2].offset -  
     10517+                               bcm947xx_parts[3].size; 
     10518+       } else { 
     10519+               /* legacy setup */ 
     10520+               /* calculate leftover flash, and assign it to the jffs2 partition */ 
     10521+               if (cfe_size != 384 * 1024) { 
     10522+                       bcm947xx_parts[4].offset = bcm947xx_parts[2].offset +  
     10523+                               bcm947xx_parts[2].size; 
     10524+                       if ((bcm947xx_parts[4].offset % mtd->erasesize) > 0) { 
     10525+                               bcm947xx_parts[4].offset += mtd->erasesize -  
     10526+                                       (bcm947xx_parts[4].offset % mtd->erasesize); 
     10527+                       } 
     10528+                       bcm947xx_parts[4].size = bcm947xx_parts[3].offset -  
     10529+                               bcm947xx_parts[4].offset; 
     10530+               } else { 
     10531+                       bcm947xx_parts[4].offset = bcm947xx_parts[2].offset +  
     10532+                               bcm947xx_parts[2].size; 
     10533+                       if ((bcm947xx_parts[4].offset % mtd->erasesize) > 0) { 
     10534+                               bcm947xx_parts[4].offset += mtd->erasesize -  
     10535+                                       (bcm947xx_parts[4].offset % mtd->erasesize); 
     10536+                       } 
     10537+                       bcm947xx_parts[4].size = size - bcm947xx_parts[3].size -  
     10538+                               bcm947xx_parts[4].offset; 
     10539+               } 
     10540+       } 
     10541+ 
     10542+       return bcm947xx_parts; 
     10543+} 
     10544+ 
    1032710545+#endif 
     10546+ 
    1032810547+ 
    1032910548+mod_init_t init_bcm947xx_map(void) 
     
    1037110590+ 
    1037210591+       bcm947xx_map.map_priv_1 = (unsigned long) ioremap(window_addr, window_size); 
     10592+ 
    1037310593+       if (!bcm947xx_map.map_priv_1) { 
    10374 +               printk(KERN_ERR "pflash: ioremap failed\n"); 
    10375 +               ret = -EIO; 
    10376 +               goto fail; 
     10594+               printk(KERN_ERR "Failed to ioremap\n"); 
     10595+               return -EIO; 
    1037710596+       } 
    1037810597+ 
    1037910598+       if (!(bcm947xx_mtd = do_map_probe("cfi_probe", &bcm947xx_map))) { 
    1038010599+               printk(KERN_ERR "pflash: cfi_probe failed\n"); 
    10381 +               ret = -ENXIO; 
    10382 +               goto fail; 
     10600+               iounmap((void *)bcm947xx_map.map_priv_1); 
     10601+               return -ENXIO; 
    1038310602+       } 
    1038410603+ 
    1038510604+       bcm947xx_mtd->module = THIS_MODULE; 
    1038610605+ 
    10387 +       /* Allow size override for testing */ 
    10388 +       size = flash ? : bcm947xx_mtd->size; 
     10606+       size = bcm947xx_mtd->size; 
    1038910607+ 
    1039010608+       printk(KERN_NOTICE "Flash device: 0x%x at 0x%x\n", size, window_addr); 
     
    1039510613+       ret = add_mtd_partitions(bcm947xx_mtd, parts, i); 
    1039610614+       if (ret) { 
    10397 +               printk(KERN_ERR "pflash: add_mtd_partitions failed\n"); 
     10615+               printk(KERN_ERR "Flash: add_mtd_partitions failed\n"); 
    1039810616+               goto fail; 
    1039910617+       } 
Note: See TracChangeset for help on using the changeset viewer.