Re: [Yaffs] [PATCH] mkyaffsimage: update yaffs tags data str…

> Signed-off-by: Stanley.Miao <stanley.miao@windriver.com>
> ---
>  utils/Makefile       |    3 +-
>  utils/mkyaffsimage.c |  167 ++++++++++++++-----------------------------------
>  2 files changed, 50 insertions(+), 120 deletions(-)

> @@ -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);
> +    }
>  }