/*--------------------------------------------------------------------------------------*\

    $Header: //avm-fs01/Entwicklung/basis/Generierung/Firmware/Bluetooth_AccessPoint/generate/src/rcs/crc_all.c 1.2 2003/03/04 10:20:33Z hjortmann Exp $

    $Id: crc_all.c 1.2 2003/03/04 10:20:33Z hjortmann Exp $

    $Log: crc_all.c $
    Revision 1.2  2003/03/04 10:20:33Z  hjortmann
    _UINT64 eingeführt
    Revision 1.1  2001/07/24 10:23:33Z  MPommerenke
    Initial revision
    Revision 1.1  2000/10/31 09:31:56Z  MPommerenke
    Initial revision

\*-------------------------------------------------------------------------------------*/

#include "revbyte.c"

/*-------------------------------------------------------------------------------------*\
    32-Bit ISO-3309  32-Bit ISO-3309  32-Bit ISO-3309  32-Bit ISO-3309  32-Bit ISO-3309  
\*-------------------------------------------------------------------------------------*/
#define CRC_NAME              "ISO-3309 32-Bit CRC"
#define CRC_BITS              32
#define USE_BITS              8

#define POLYNOM     (unsigned int)(     \
                ( 1 << (31 - 26)) | \
                ( 1 << (31 - 23)) | \
                ( 1 << (31 - 22)) | \
                ( 1 << (31 - 16)) | \
                ( 1 << (31 - 12)) | \
                ( 1 << (31 - 11)) | \
                ( 1 << (31 - 10)) | \
                ( 1 << (31 -  8)) | \
                ( 1 << (31 -  7)) | \
                ( 1 << (31 -  5)) | \
                ( 1 << (31 -  4)) | \
                ( 1 << (31 -  2)) | \
                ( 1 << (31 -  1)) | \
                ((unsigned int)1 << (31 -  0)))

/*-------------------------------------------------------------------------------------*\
\*-------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char Name[64];
FILE *fp;

/*-------------------------------------------------------------------------------------*\
\*-------------------------------------------------------------------------------------*/
#define CRC_TYPE             unsigned int
#define CRC_TYPE_STRING     "unsigned int"
#define CRC_FORMAT          "0x%08X"

/*-------------------------------------------------------------------------------------*\
\*-------------------------------------------------------------------------------------*/
#define USE_TYPE        unsigned int

/*-------------------------------------------------------------------------------------*\
\*-------------------------------------------------------------------------------------*/
#define USE_BITS_MASK   (((USE_TYPE)1 << USE_BITS) - 1)
#define CRC_BITS_MASK   0xFFFFFFFF


/*-------------------------------------------------------------------------------------*\
\*-------------------------------------------------------------------------------------*/
CRC_TYPE CrcTab[1 << USE_BITS];

/*-------------------------------------------------------------------------------------*\
\*-------------------------------------------------------------------------------------*/
CRC_TYPE Crc_SwapBits(CRC_TYPE Value) {
    unsigned int BitPosSource, BitPosDest;
    unsigned int Bit;
    CRC_TYPE     SwapValue = (CRC_TYPE)0;

    for(BitPosSource = 0, BitPosDest = CRC_BITS - 1 ; BitPosSource < CRC_BITS ; BitPosSource++, BitPosDest--) {
        Bit = (Value >> BitPosSource) & 0x01;
        SwapValue |= (CRC_TYPE)Bit << BitPosDest;
    }
    return SwapValue;
}

/*-------------------------------------------------------------------------------------*\
\*-------------------------------------------------------------------------------------*/
void Crc_Init(void) {

    CRC_TYPE v;
    unsigned long long b;

    int     i;

    for (b = 0 ; b < (1 << USE_BITS) ; b++) {

        v = (CRC_TYPE)b;

        for (i = 0 ; i < USE_BITS ; i++) {
            if(v & 0x01) {
                v = ((CRC_TYPE)(v >> 1) ^ POLYNOM);
            } else {
                v = (CRC_TYPE)(v >> 1);
            }
            /*--- v = (CRC_TYPE)(v & 0x01 ? ((CRC_TYPE)(v >> 1) ^ POLYNOM) : (v >> 1)); ---*/
        }

        CrcTab[b] = v;
        if((b & 0x07) == 0x00)
            fprintf(fp, "\n\t /*--- 0x%02LX ---*/ ", b);
        fprintf(fp, CRC_FORMAT, v);
        if(CRC_BITS > 32)
            fprintf(fp, "ULL");
        if(b != (1 << USE_BITS) - 1)
            fprintf(fp, ", ");
    }
}

/*-------------------------------------------------------------------------------------*\
\*-------------------------------------------------------------------------------------*/
CRC_TYPE DoCrc(CRC_TYPE CRC, USE_TYPE c) {
    /*--- printf("(CRC(%x) >> %u) ^ CrcTab[ CRC(%x) ^ c(%x) = %x]      (USE_BITS_MASK=%x)\n", ---*/
        /*--- CRC, USE_BITS, CRC, c, (CRC ^ c) & 0xFF, USE_BITS_MASK); ---*/
    return (CRC_TYPE)(
                      ((CRC_TYPE)CRC >> USE_BITS) ^ 
                       CrcTab[ ((USE_TYPE)CRC ^ (c & USE_BITS_MASK)) & USE_BITS_MASK ]
                     );
}

/*-------------------------------------------------------------------------------------*\
\*-------------------------------------------------------------------------------------*/
CRC_TYPE FinishCrc(CRC_TYPE CRC) {
    return (CRC_TYPE)((~(CRC_TYPE)CRC) & CRC_BITS_MASK);
}

/*-------------------------------------------------------------------------------------*\
\*-------------------------------------------------------------------------------------*/
CRC_TYPE InitCrc(void) {
    return CRC_BITS_MASK;
}

/*-------------------------------------------------------------------------------------*\
\*-------------------------------------------------------------------------------------*/
int main(int argc, char *argv[]) {
    USE_TYPE Buffer[USE_BITS + 100];
    CRC_TYPE Crc;
    unsigned long long Polynom;
    unsigned long long v = (unsigned long long)POLYNOM;
    unsigned int Count, n, CrcLen;
    
    if(argc > 1) {
        strcpy(Name, argv[1]);
    } else {
        sprintf(Name, "crc%u-%u.h", CRC_BITS, USE_BITS);
    }

    fp = fopen(Name, "w");
    if(!fp) return -1;

    Count = CRC_BITS & 0x03 ? (CRC_BITS >> 2) + 1 : (CRC_BITS >> 2);
    fprintf(fp, "/*-------------------------------------------------------------------------------------*\\\n");
    fprintf(fp, "     Table generated byte make-crc-table-tool with:\n\t\tUSE_BITS=%u \n\t\tCRC_BITS=%u \n\t\tPolynom=0x%x\n",
                    USE_BITS, CRC_BITS, POLYNOM);
    fprintf(fp, "     Name des Polynoms: \"%s\"\n", CRC_NAME);
    fprintf(fp, "\\*-------------------------------------------------------------------------------------*/\n");
    fprintf(fp, "#ifndef _CRC%u_%u_H_\n", CRC_BITS, USE_BITS);
    fprintf(fp, "#define _CRC%u_%u_H_\n\n", CRC_BITS, USE_BITS);
    fprintf(fp, "#if defined(DEFINE_CRC%u_TABLE)\n", CRC_BITS);
    fprintf(fp, "const " CRC_TYPE_STRING " CrcTab%u_%u[1 << %u] = {", CRC_BITS, USE_BITS, USE_BITS);

    Crc_Init();

    fprintf(fp, "\n};\n");
    fprintf(fp, "#else /*--- #if defined(DEFINE_CRC%u_TABLE) ---*/\n", CRC_BITS);
    fprintf(fp, "extern const " CRC_TYPE_STRING " CrcTab%u_%u[1 << %u];\n", CRC_BITS, USE_BITS, USE_BITS);
    fprintf(fp, "#endif /*--- #else ---*//*--- #if defined(DEFINE_CRC%u_TABLE) ---*/\n\n", CRC_BITS);

    /*---------------------------------------------------------------------------------*\
        folgender Code funktioniert nur wenn USE_BITS % 8 == 0
    \*---------------------------------------------------------------------------------*/
    CrcLen = CRC_BITS / USE_BITS;
    Polynom = (unsigned long long)Crc_SwapBits(POLYNOM) | (unsigned long long)1 << CRC_BITS;

    /*---------------------------------------------------------------------------------*\
        CRC Prüfen
    \*---------------------------------------------------------------------------------*/
    v <<= 1;
    v  |= 1;
    Crc = 0;
    printf("Input: %LX\n", v);
    printf("Check CRC: ");

    for(Count = 0 ; Count < (CRC_BITS / USE_BITS) + 1 ; Count++) {
        Buffer[Count] = (USE_TYPE)((v >> (Count * USE_BITS)) & ((1 << USE_BITS) - 1));
        printf("0x%02X ", Buffer[Count]);
    }

    for(Count = 0 ; Count < (CRC_BITS / USE_BITS) + 1 ; Count++) {
        Crc = DoCrc(Crc, Buffer[Count]);
    }

    printf("Crc= " CRC_FORMAT "\n", Crc);

    /*---------------------------------------------------------------------------------*\
    \*---------------------------------------------------------------------------------*/
    if(CRC_BITS % USE_BITS) {
        printf("ACHTUNG: Der Algorithmus zum Ermitteln von GOOD_CRC funktioniert nur wenn:\n\t CRC_BITS %% USE_BITS == 0\n");
    } else {

        /*-----------------------------------------------------------------------------*\
            CRC Ermitteln
        \*-----------------------------------------------------------------------------*/
        Crc = InitCrc();

        for(Count = 0 ; Count < USE_BITS ; Count++) {
            Buffer[Count] = (USE_TYPE)(0xA0 + Count);
            Crc = DoCrc(Crc, Buffer[Count]);
        }
        Crc = FinishCrc(Crc);

        /*-----------------------------------------------------------------------------*\
            Anhängen an String
        \*-----------------------------------------------------------------------------*/
        for(n = Count ; n < Count + CrcLen ; n++) {
            Buffer[n] = (USE_TYPE)(Crc >> ((n - Count) * USE_BITS)); 
        }
printf("CrcLen= %u\n", CrcLen);

        /*-----------------------------------------------------------------------------*\
            Ermitteln des Gesammt Crc
        \*-----------------------------------------------------------------------------*/
        Crc = InitCrc();

        for(n = 0 ; n < Count  + CrcLen ; n++) {
            Crc = DoCrc(Crc, Buffer[n]);
        }

        fprintf(fp, "#define GOOD_CRC%u_%u          " CRC_FORMAT "\n", CRC_BITS, USE_BITS, Crc);
        Crc = FinishCrc(Crc);
        fprintf(fp, "#define REVERSE_GOOD_CRC%u_%u  " CRC_FORMAT "\n", CRC_BITS, USE_BITS, Crc);

    }
    fprintf(fp, "#define POLYNOM_%u_%u          " CRC_FORMAT "\n", CRC_BITS, USE_BITS, POLYNOM);
    fprintf(fp, "#define REVERSE_POLYNOM_%u_%u  0x%LX\n\n", CRC_BITS, USE_BITS, Polynom);

    /*---------------------------------------------------------------------------------*\
    \*---------------------------------------------------------------------------------*/
    fprintf(fp, "#define InitCrc%u_%u()         (((%s)1 << %u) - 1)\n", CRC_BITS, USE_BITS, CRC_TYPE_STRING, CRC_BITS);
    fprintf(fp, "#define FinishCrc%u_%u(Crc)    (~(Crc) & (((%s)1 << %u) - 1))\n", CRC_BITS, USE_BITS, CRC_TYPE_STRING, CRC_BITS);
    fprintf(fp, "#define DoCrc%u_%u(Crc, ch)    (%s)(((Crc) >> %u) ^ CrcTab%u_%u[((Crc) ^ ((ch) & ((1 << %u) - 1))) & ((1 << %u) - 1)])\n",
        CRC_BITS, USE_BITS, CRC_TYPE_STRING, USE_BITS, CRC_BITS, USE_BITS, USE_BITS, USE_BITS);
    fprintf(fp, "\n");
    fprintf(fp, "#if !defined(POLYNOM_NAME)\n");
    fprintf(fp, "#define POLYNOM_NAME           \"%s\"\n", CRC_NAME);
    fprintf(fp, "#endif /*--- #if !defined(POLYNOM_NAME) ---*/\n");

    fprintf(fp, "\n");
    fprintf(fp, "#endif /*--- #ifndef _CRC%u_%u_H_ ---*/\n", CRC_BITS, USE_BITS);

    fclose(fp);

    printf("Table generation for %u bit CRC with %u bit per sample done\n", CRC_BITS, USE_BITS);
    return 0;
}