* Back out Patch by Christian Hohnstaedt, 23 Apr 2004:

  (JFFS2 speed enhancements) because of using non-public
  data (PHYS_FLASH_SECT_SIZE)

* Patch by Travis Sawyer, 23 Apr 2004:
  Fix VSC/CIS 8201 phy descrambler interoperability timing due to
  errata from Vitesse Semiconductor.

diff --git a/CHANGELOG b/CHANGELOG
index e1f8e834cd134264caeed93825df289640247602..67856c8399267c090e1dc3bab70605b82875dca4 100644 (file)
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -2,14 +2,9 @@
 Changes for U-Boot 1.1.1:
 ======================================================================
 
-* Patch by Christian Hohnstaedt, 23 Apr 2004:
-  JFFS2 speed enhancements:
-  - repair header CRC calculation in jffs2_1pass.c
-  - add eraseblock size to the partition information to skip empty
-    eraseblocks if we find more then 4k of free space.
-  - The JFFS2 scanner is now fast enough to remove the spinning wheel
-    so #ifdef-ed out.
-  - add watchdog calls in long running loops
+* Patch by Travis Sawyer, 23 Apr 2004:
+  Fix VSC/CIS 8201 phy descrambler interoperability timing due to
+  errata from Vitesse Semiconductor.
 
 * Patch by Philippe Robin, 22 Apr 2004:
   Fix ethernet configuration for "versatile" board 

diff --git a/common/cmd_jffs2.c b/common/cmd_jffs2.c
index 11e3cc663e4732b8064cf44bc3f2692626afb286..3cf00b8e29b4d0db3871f587db19b98fc7448f63 100644 (file)
--- a/common/cmd_jffs2.c
+++ b/common/cmd_jffs2.c
@@ -80,14 +80,8 @@ jffs2_part_info(int part_num)
                        flash_info[CFG_JFFS2_FIRST_BANK].start[0];
 #endif
 
-               /* FIXME: Fast hack to get erase size set */
-
-               /* We assume that our JFFS2 partition has
-                * all erase blocks with the same size
-                * If we have a clue about the erasesize
-                * we can skip empty blocks
-                */
-               part.erasesize = PHYS_FLASH_SECT_SIZE;
+               /* unused in current jffs2 loader */
+               part.erasesize = 0;
 
                /* Mark the struct as ready */
                part.usr_priv=(void*)1;

diff --git a/cpu/ppc4xx/440gx_enet.c b/cpu/ppc4xx/440gx_enet.c
index 91cf240ac6a458afd397e4517d5fddd610cd2b44..54b25a56c521dcca31ec933b0d13c5e2a02a5498 100644 (file)
--- a/cpu/ppc4xx/440gx_enet.c
+++ b/cpu/ppc4xx/440gx_enet.c
@@ -437,6 +437,22 @@ static int ppc_440x_eth_init (struct eth_device *dev, bd_t * bis)
         */
        if ( ((devnum == 2) || (devnum ==3)) && (4 == ethgroup) ) {
                miiphy_write (reg, 23, 0x1200);
+               /*
+                * Vitesse VSC8201/Cicada CIS8201 errata:
+                * Interoperability problem with Intel 82547EI phys
+                * This work around (provided by Vitesse) changes
+                * the default timer convergence from 8ms to 12ms
+                */
+               miiphy_write (reg, 0x1f, 0x2a30);
+               miiphy_write (reg, 0x08, 0x0200);
+               miiphy_write (reg, 0x1f, 0x52b5);
+               miiphy_write (reg, 0x02, 0x0004);
+               miiphy_write (reg, 0x01, 0x0671);
+               miiphy_write (reg, 0x00, 0x8fae);
+               miiphy_write (reg, 0x1f, 0x2a30);
+               miiphy_write (reg, 0x08, 0x0000);
+               miiphy_write (reg, 0x1f, 0x0000);
+               /* end Vitesse/Cicada errata */
        }
 #endif
 #endif
@@ -917,7 +933,7 @@ int enetInt (struct eth_device *dev)
                        mtdcr (uic0sr, UIC_MTE);
                }
                /* handle MAL RX EOB  interupt from a receive */
-               /* check for EOB on valid channels            */
+               /* check for EOB on valid channels            */
                if (my_uic0msr & UIC_MRE) {
                        mal_rx_eob = mfdcr (malrxeobisr);
                        if ((mal_rx_eob & (0x80000000 >> hw_p->devnum)) != 0) { /* call emac routine for channel x */
@@ -1033,9 +1049,9 @@ static void enet_rcv (struct eth_device *dev, unsigned long malisr)
                                                    MAX_ERR_LOG)
                                                        hw_p->rx_err_index =
                                                                0;
-                                       }       /* emac_erros         */
+                                       }       /* emac_erros */
                                }       /* data_len < max mtu */
-                       }       /* if data_len        */
+                       }       /* if data_len */
                        if (!data_len) {        /* no data */
                                hw_p->rx[i].ctrl |= MAL_RX_CTRL_EMPTY;  /* Free Recv Buffer */
 

diff --git a/fs/jffs2/jffs2_1pass.c b/fs/jffs2/jffs2_1pass.c
index 5d0192cb801da8e7a7924a9977db18935aeec2f3..10e6df8e18929b646a4454bc20ead93695579891 100644 (file)
--- a/fs/jffs2/jffs2_1pass.c
+++ b/fs/jffs2/jffs2_1pass.c
@@ -114,7 +114,6 @@
 #include <common.h>
 #include <config.h>
 #include <malloc.h>
-#include <watchdog.h>
 #include <linux/stat.h>
 #include <linux/time.h>
 
@@ -127,7 +126,7 @@
 
 
 #define        NODE_CHUNK      1024    /* size of memory allocation chunk in b_nodes */
-#define        SPIN_BLKSIZE    20      /* spin after having scanned 1<<BLKSIZE bytes */
+#define        SPIN_BLKSIZE    18      /* spin after having scanned 1<<BLKSIZE bytes */
 
 /* Debugging switches */
 #undef DEBUG_DIRENTS           /* print directory entry list after scan */
@@ -277,10 +276,8 @@ static char *compr_names[] = {
        "ZLIB"
 };
 
-#if 0  /* Use spinning wheel */
 /* Spinning wheel */
 static char spinner[] = { '|', '/', '-', '\\' };
-#endif
 
 /* Memory management */
 struct mem_block {
@@ -457,24 +454,15 @@ jffs2_scan_empty(u32 start_offset, struct part_info *part)
 {
        char *max = part->offset + part->size - sizeof(struct jffs2_raw_inode);
        char *offset = part->offset + start_offset;
-       int cntr = 0;
        u32 off;
 
        while (offset < max &&
               *(u32*)get_fl_mem((u32)offset, sizeof(u32), &off) == 0xFFFFFFFF) {
                offset += sizeof(u32);
-               cntr++;
-#if 0  /* Use spinning wheel */
                /* return if spinning is due */
                if (((u32)offset & ((1 << SPIN_BLKSIZE)-1)) == 0) break;
-#endif
-               if (cntr > 1024 && part->erasesize > 0) { /* 4k */
-                       /* round up to next erase block border */
-                       (u32)offset |= part->erasesize-1;
-                       offset++;
-                       cntr = 0;
-               }
        }
+
        return offset - part->offset;
 }
 
@@ -933,9 +921,6 @@ jffs2_1pass_search_list_inodes(struct b_lists * pL, const char *fname, u32 pino)
                for (i = 0; i < strlen(c) - 1; i++)
                        tmp[i] = c[i + 1];
                tmp[i] = '\0';
-
-               WATCHDOG_RESET();
-
                /* only a failure if we arent looking at top level */
                if (!(pino = jffs2_1pass_find_inode(pL, working_tmp, pino)) &&
                    (working_tmp[0])) {
@@ -1076,15 +1061,12 @@ jffs2_1pass_build_lists(struct part_info * part)
 {
        struct b_lists *pL;
        struct jffs2_unknown_node *node;
-       struct jffs2_unknown_node crcnode;
        u32 offset, oldoffset = 0;
        u32 max = part->size - sizeof(struct jffs2_raw_inode);
        u32 counter = 0;
        u32 counter4 = 0;
        u32 counterF = 0;
        u32 counterN = 0;
-       u32 counterCRC = 0;
-       u32 counterUNK = 0;
 
 #if defined(CONFIG_JFFS2_NAND) && (CONFIG_COMMANDS & CFG_CMD_NAND)
        nanddev = (int)part->usr_priv - 1;
@@ -1105,26 +1087,14 @@ jffs2_1pass_build_lists(struct part_info * part)
        /* start at the beginning of the partition */
        while (offset < max) {
                if ((oldoffset >> SPIN_BLKSIZE) != (offset >> SPIN_BLKSIZE)) {
-                       WATCHDOG_RESET();
-#if 0  /* Use spinning wheel */
                        printf("\b\b%c ", spinner[counter++ % sizeof(spinner)]);
-#endif
                        oldoffset = offset;
                }
+
                node = (struct jffs2_unknown_node *) get_node_mem((u32)part->offset + offset);
-               if (node->magic == JFFS2_MAGIC_BITMASK) {
+               if (node->magic == JFFS2_MAGIC_BITMASK && hdr_crc(node)) {
                        /* if its a fragment add it */
-                       /* check crc by readding a JFFS2_NODE_ACCURATE */
-                       crcnode.magic = node->magic;
-                       crcnode.nodetype = node->nodetype | JFFS2_NODE_ACCURATE;
-                       crcnode.totlen = node->totlen;
-                       crcnode.hdr_crc = node->hdr_crc;
-
-                       if (!hdr_crc(&crcnode)) {
-                               offset += 4;
-                               counterCRC++;
-                               continue;
-                       } else if (node->nodetype == JFFS2_NODETYPE_INODE &&
+                       if (node->nodetype == JFFS2_NODETYPE_INODE &&
                                    inode_crc((struct jffs2_raw_inode *) node)) {
                                if (insert_node(&pL->frag, (u32) part->offset +
                                                offset) == NULL) {
@@ -1134,12 +1104,8 @@ jffs2_1pass_build_lists(struct part_info * part)
                        } else if (node->nodetype == JFFS2_NODETYPE_DIRENT &&
                                   dirent_crc((struct jffs2_raw_dirent *) node)  &&
                                   dirent_name_crc((struct jffs2_raw_dirent *) node)) {
-                               if (! (counterN%128))
-#if 0  /* Use spinning wheel */
+                               if (! (counterN%100))
                                        puts ("\b\b.  ");
-#else
-                                       puts (".");
-#endif
                                if (insert_node(&pL->dir, (u32) part->offset +
                                                offset) == NULL) {
                                        put_fl_mem(node);
@@ -1157,14 +1123,16 @@ jffs2_1pass_build_lists(struct part_info * part)
                                                "%d < %d\n", node->totlen,
                                                sizeof(struct jffs2_unknown_node));
                        } else {
-                               counterUNK++;
+                               printf("Unknown node type: %x len %d "
+                                       "offset 0x%x\n", node->nodetype,
+                                       node->totlen, offset);
                        }
                        offset += ((node->totlen + 3) & ~3);
                        counterF++;
                } else if (node->magic == JFFS2_EMPTY_BITMASK &&
                           node->nodetype == JFFS2_EMPTY_BITMASK) {
                        offset = jffs2_scan_empty(offset, part);
-               } else { /* if we know nothing, we just step and look. */
+               } else {        /* if we know nothing, we just step and look. */
                        offset += 4;
                        counter4++;
                }
@@ -1181,8 +1149,6 @@ jffs2_1pass_build_lists(struct part_info * part)
        putLabeledWord("frag entries = ", pL->frag.listCount);
        putLabeledWord("+4 increments = ", counter4);
        putLabeledWord("+file_offset increments = ", counterF);
-       putLabeledWord("Unknown node types = ", counterUNK);
-       putLabeledWord("Bad hdr_crc = ", counterCRC);
 
 #endif
 
@@ -1238,7 +1204,6 @@ jffs2_get_list(struct part_info * part, const char *who)
                        return NULL;
                }
        }
-       WATCHDOG_RESET();
        return (struct b_lists *)part->jffs2_priv;
 }
 
@@ -1248,21 +1213,24 @@ u32
 jffs2_1pass_ls(struct part_info * part, const char *fname)
 {
        struct b_lists *pl;
+       long ret = 0;
        u32 inode;
 
        if (! (pl = jffs2_get_list(part, "ls")))
                return 0;
 
-
        if (! (inode = jffs2_1pass_search_list_inodes(pl, fname, 1))) {
                putstr("ls: Failed to scan jffs2 file structure\r\n");
                return 0;
        }
+
+
 #if 0
        putLabeledWord("found file at inode = ", inode);
        putLabeledWord("read_inode returns = ", ret);
 #endif
-       return inode;
+
+       return ret;
 }