IWR6843: CRC 64 bit software model

Marco:

Before we get started can you please provide the paths to the files that you are referencing so that I am looking at the same files as you are. Additionally, can you provide some context to what you are trying do that requires computing a 64 bit CRC?

Best regards,

Connor Desmond

Hi Connor,

the CRC test source file I referred to is part of the MMWave SDK (CRC driver) at this path:

mmwave_sdk_03_05_00_04/packages/ti/drivers/crc/test/common/crc_test.c

I am using a modified version of the Secondary Boot Loader provided by TI in the MMWave SDK. This bootloader decodes a multicore image whose header contains 64 bit CRCs which are generated at build time by the tool "mmwave_sdk_03_05_00_04/packages/scripts/ImageCreator/crc_multicore_image/crc_multicore_image.exe" (as explained here: mmwave_sdk_03_05_00_04/packages/scripts/ImageCreator/Image_Creator_User_Guide.pdf) . This tool is not available on OSX (Mac) and I never found the source code anywhere. The documentation by TI is pretty clear about what the tool does so I would like to write my own tool but I need to understand how to generate these CRC on the build machine.

If I manage to generete these CRC I think I have all the bits and pieces to properly build binaries on OSX without relying on Windows emulation.

Thanks,

Marco 

Hello Connor,

thank you very much for the information, I managed to solve my problem this way.

In case it may help others please find below the C code that computes CRC64 with byte swap enabled.

Best regards,

Marco

#include <stdio.h>
#include <stdint.h>

uint64_t poly = 0x000000000000001B;
//uint64_t poly = 0xC96C5795D7870F42;

uint64_t table[256];

void generate_table()
{
    for(int32_t i=0; i<256; ++i)
    {
    	uint64_t crc = i;
        // Shift left because we want byte swap enabled
        crc = (crc << 56) & 0xFFFFFFFFFFFFFFFFU;

    	for(uint32_t j=0; j<8; ++j)
    	{
            if ((crc & 0x8000000000000000U) != 0) {
                crc  = crc << 1;
                crc ^= poly;
            } else {
                crc  = crc << 1;
            }
        }
    
        table[i] = crc;
        //printf("Table[%d] = %llx\n",i,crc);
    }
}

uint64_t calculate_crc(uint8_t* stream, uint32_t n)
{
    uint64_t crc = 0;
    for (int i = 0; i < n; i++) {

        uint8_t curByte = stream[i] & 0xFF;

        // Should we handle bit inversion this is the place to take care of it

        // update the MSB of crc value with next input byte
        // Shift left because we want byte swap enabled
        uint64_t curByteShifted56 = ((uint64_t)curByte) << 56; 
        crc ^= curByteShifted56;

        /* this MSB byte value is the index into the lookup table */
        uint32_t pos = (crc >> 56) & 0xFFU;
        /* shift out this index */
        crc = crc << 8;
        /* XOR-in remainder from lookup table using the calculated index */
        crc ^= table[pos];
    }
    // XOR with the final value
    crc ^= 0;
    return crc;
}

int main(int ac, char **av)
{
    generate_table();

    uint64_t result;

    uint8_t realData[] = { 0x70, 0x61, 0x6e, 0x6b, 0x61, 0x6a, 0x20, 0x6b, 0x61, 0x70, 0x6f, 0x6f, 0x72, 0x21, 0x21, 0x21 };
    result = calculate_crc(realData, 16);
    printf("CRC 64: %llx\n", result);

    return 0;
}