mkyaffsimage doesn't work now. Are you going to merge this patch ?
> Linux mtd subsysterm has updated the nand spare data layout and YAFFS
> filesystem has changed to use yaffs_Packedtags1 data structure. Therefore,
> mkyaffsimage should discard the "yaffs_Spare" data structure and use
> "yaffs_Packedtags1" according to the new YAFFS filesystem implementation.
>
> Signed-off-by: Stanley.Miao <stanley.miao@windriver.com>
> ---
> utils/Makefile | 3 +-
> utils/mkyaffsimage.c | 167 ++++++++++++++-----------------------------------
> 2 files changed, 50 insertions(+), 120 deletions(-)
>
> diff --git a/utils/Makefile b/utils/Makefile
> index 49bf03b..45554eb 100644
> --- a/utils/Makefile
> +++ b/utils/Makefile
> @@ -29,7 +29,8 @@ COMMONLINKS = yaffs_ecc.c
> COMMONOBJS = $(COMMONLINKS:.c=.o)
>
> MKYAFFSSOURCES = mkyaffsimage.c
> -MKYAFFSIMAGEOBJS = $(MKYAFFSSOURCES:.c=.o)
> +MKYAFFSLINKS = yaffs_packedtags1.c yaffs_tagsvalidity.c
> +MKYAFFSIMAGEOBJS = $(MKYAFFSSOURCES:.c=.o) $(MKYAFFSLINKS:.c=.o)
>
> MKYAFFS2SOURCES = mkyaffs2image.c
> MKYAFFS2LINKS = yaffs_packedtags2.c yaffs_tagsvalidity.c
> diff --git a/utils/mkyaffsimage.c b/utils/mkyaffsimage.c
> index e8434e8..f9d9d76 100644
> --- a/utils/mkyaffsimage.c
> +++ b/utils/mkyaffsimage.c
> @@ -30,6 +30,9 @@
> #include "yaffs_ecc.h"
> #include "yaffs_guts.h"
>
> +#include "yaffs_tagsvalidity.h"
> +#include "yaffs_packedtags1.h"
> +
>
> #define MAX_OBJECTS 10000
>
> @@ -112,151 +115,77 @@ static int find_obj_in_list(dev_t dev, ino_t ino)
> return -1;
> }
>
> -// NCB added 10/9/2002
> -static __u16 yaffs_CalcNameSum(const char *name)
> +unsigned int yaffs_CalcTagsECC(yaffs_Tags *tags)
> {
> - __u16 sum = 0;
> - __u16 i = 1;
> -
> - __u8 *bname = (__u8 *)name;
> -
> - while (*bname)
> - {
> - sum += (*bname) * i;
> - i++;
> - bname++;
> - }
> - return sum;
> -}
> -
> -
> -static void yaffs_CalcECC(const __u8 *data, yaffs_Spare *spare)
> -{
> - yaffs_ECCCalculate(data , spare->ecc1);
> - yaffs_ECCCalculate(&data[256] , spare->ecc2);
> -}
> -
> -static void yaffs_CalcTagsECC(yaffs_Tags *tags)
> -{
> - // Todo don't do anything yet. Need to calculate ecc
> - unsigned char *b = ((yaffs_TagsUnion *)tags)->asBytes;
> - unsigned i,j;
> - unsigned ecc = 0;
> + /* Calculate an ecc */
> + unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
> + unsigned i, j;
> + unsigned ecc = 0;
> unsigned bit = 0;
>
> - // Clear ECC fields
> - if (!convert_endian)
> - {
> - tags->ecc = 0;
> - }
> - else
> - {
> - // Because we're in "munged tag" mode, we have to clear it manually
> - b[6] &= 0xC0;
> - b[7] &= 0x03;
> - }
> -
> - for(i = 0; i < 8; i++)
> - {
> -// NCB modified 20-9-02 for(j = 1; j &0x7f; j<<=1)
> - for(j = 1; j &0xff; j<<=1)
> - {
> + for (i = 0; i < 8; i++) {
> + for (j = 1; j & 0xff; j <<= 1) {
> bit++;
> - if(b[i] & j)
> - {
> + if (b[i] & j)
> ecc ^= bit;
> - }
> }
> }
> -
> - // Write out ECC
> - if (!convert_endian)
> - {
> - tags->ecc = ecc;
> - }
> - else
> - {
> - // We have to munge the ECC again.
> - b[6] |= ((ecc >> 6) & 0x3F);
> - b[7] |= ((ecc & 0x3F) << 2);
> - }
> -}
> -static void yaffs_LoadTagsIntoSpare(yaffs_Spare *sparePtr, yaffs_Tags *tagsPtr)
> -{
> - yaffs_TagsUnion *tu = (yaffs_TagsUnion *)tagsPtr;
> -
> - //yaffs_CalcTagsECC(tagsPtr);
> -
> - sparePtr->tagByte0 = tu->asBytes[0];
> - sparePtr->tagByte1 = tu->asBytes[1];
> - sparePtr->tagByte2 = tu->asBytes[2];
> - sparePtr->tagByte3 = tu->asBytes[3];
> - sparePtr->tagByte4 = tu->asBytes[4];
> - sparePtr->tagByte5 = tu->asBytes[5];
> - sparePtr->tagByte6 = tu->asBytes[6];
> - sparePtr->tagByte7 = tu->asBytes[7];
> +
> + return ecc;
> }
>
> /* This little function converts a little endian tag to a big endian tag.
> * NOTE: The tag is not usable after this other than calculating the CRC
> * with.
> */
> -static void little_to_big_endian(yaffs_Tags *tagsPtr)
> +static void little_to_big_endian(yaffs_TagsUnion *temp, yaffs_Tags *tagsPtr)
> {
> - yaffs_TagsUnion * tags = (yaffs_TagsUnion* )tagsPtr; // Work in bytes.
> - yaffs_TagsUnion temp;
> -
> - memset(&temp, 0, sizeof(temp));
> - // Ick, I hate magic numbers.
> - temp.asBytes[0] = ((tags->asBytes[2] & 0x0F) << 4) | ((tags->asBytes[1] & 0xF0) >> 4);
> - temp.asBytes[1] = ((tags->asBytes[1] & 0x0F) << 4) | ((tags->asBytes[0] & 0xF0) >> 4);
> - temp.asBytes[2] = ((tags->asBytes[0] & 0x0F) << 4) | ((tags->asBytes[2] & 0x30) >> 2) | ((tags->asBytes[3] & 0xC0) >> 6);
> - temp.asBytes[3] = ((tags->asBytes[3] & 0x3F) << 2) | ((tags->asBytes[2] & 0xC0) >> 6);
> - temp.asBytes[4] = ((tags->asBytes[6] & 0x03) << 6) | ((tags->asBytes[5] & 0xFC) >> 2);
> - temp.asBytes[5] = ((tags->asBytes[5] & 0x03) << 6) | ((tags->asBytes[4] & 0xFC) >> 2);
> - temp.asBytes[6] = ((tags->asBytes[4] & 0x03) << 6) | (tags->asBytes[7] & 0x3F);
> - temp.asBytes[7] = (tags->asBytes[6] & 0xFC) | ((tags->asBytes[7] & 0xC0) >> 6);
> -
> - // Now copy it back.
> - tags->asBytes[0] = temp.asBytes[0];
> - tags->asBytes[1] = temp.asBytes[1];
> - tags->asBytes[2] = temp.asBytes[2];
> - tags->asBytes[3] = temp.asBytes[3];
> - tags->asBytes[4] = temp.asBytes[4];
> - tags->asBytes[5] = temp.asBytes[5];
> - tags->asBytes[6] = temp.asBytes[6];
> - tags->asBytes[7] = temp.asBytes[7];
> + yaffs_TagsUnion * tags = (yaffs_TagsUnion *)tagsPtr;
> +
> + memset(temp, 0, sizeof(*temp));
> + temp->asBytes[0] = ((tags->asBytes[2] & 0x0F) << 4) | ((tags->asBytes[1] & 0xF0) >> 4);
> + temp->asBytes[1] = ((tags->asBytes[1] & 0x0F) << 4) | ((tags->asBytes[0] & 0xF0) >> 4);
> + temp->asBytes[2] = ((tags->asBytes[0] & 0x0F) << 4) | \
> + ((tags->asBytes[2] & 0x30) >> 2) | \
> + ((tags->asBytes[3] & 0xC0) >> 6);
> + temp->asBytes[3] = ((tags->asBytes[3] & 0x3F) << 2) | ((tags->asBytes[2] & 0xC0) >> 6);
> + temp->asBytes[4] = ((tags->asBytes[6] & 0x03) << 6) | ((tags->asBytes[5] & 0xFC) >> 2);
> + temp->asBytes[5] = ((tags->asBytes[5] & 0x03) << 6) | ((tags->asBytes[4] & 0xFC) >> 2);
> + temp->asBytes[6] = ((tags->asBytes[4] & 0x03) << 6) | (tags->asBytes[7] & 0x3F);
> + temp->asBytes[7] = (tags->asBytes[6] & 0xFC) | \
> + ((tags->asBytes[7] & 0x40) >> 5) | \
> + ((tags->asBytes[7] & 0x80) >> 7);
> }
>
> static int write_chunk(__u8 *data, __u32 objId, __u32 chunkId, __u32 nBytes)
> {
> - yaffs_Tags t;
> - yaffs_Spare s;
> + yaffs_ExtendedTags t;
> + yaffs_PackedTags1 pt;
> + yaffs_TagsUnion temp;
>
> error = write(outFile,data,512);
> if(error < 0) return error;
>
> - memset(&t,0xff,sizeof (yaffs_Tags));
> - memset(&s,0xff,sizeof (yaffs_Spare));
> -
> + yaffs_InitialiseTags(&t);
> +
> t.chunkId = chunkId;
> - t.serialNumber = 0;
> - t.byteCountLSB = nBytes;
> + t.serialNumber = 1;
> + t.byteCount = nBytes;
> t.objectId = objId;
> + t.chunkUsed = 1;
>
> - if (convert_endian)
> - {
> - little_to_big_endian(&t);
> - }
> -
> - yaffs_CalcTagsECC(&t);
> - yaffs_LoadTagsIntoSpare(&s,&t);
> - yaffs_CalcECC(data,&s);
> -
> + yaffs_PackTags1(&pt, &t);
> nPages++;
> -
> - return write(outFile,&s,sizeof(yaffs_Spare));
> -
> +
> + if (convert_endian) {
> + little_to_big_endian(&temp, &pt);
> + pt.ecc = yaffs_CalcTagsECC((yaffs_Tags *)&temp);
> + little_to_big_endian(&temp, &pt);
> + return write(outFile, &temp, 16);
> + } else {
> + pt.ecc = yaffs_CalcTagsECC((yaffs_Tags *)&pt);
> + return write(outFile, &pt, 16);
> + }
> }
>
> #define SWAP32(x) ((((x) & 0x000000FF) << 24) | \
>
(text/plain)