Matthias Biermann
138 lines
3.7 KiB
C
138 lines
3.7 KiB
C
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "axi_crc_dma.h"
|
|
|
|
// Berechnen einer 32 Bit CRC-Pruefsumme mit allen Parametern
|
|
uint32_t calcCRC32(
|
|
uint8_t* inBytes,
|
|
size_t size,
|
|
uint32_t polynomial,
|
|
uint32_t initialValue,
|
|
uint32_t finalXOR,
|
|
uint8_t inputReflected,
|
|
uint8_t outputReflected
|
|
);
|
|
|
|
#define PACKET_SIZE 10
|
|
#define PACKET_NUMBER 10
|
|
|
|
static char msg[] = "Hello World!ABCDEFGHIJKL";
|
|
volatile static uint32_t dest[8];
|
|
|
|
static uint32_t crc_sw[PACKET_NUMBER];
|
|
static uint32_t crc_hw[PACKET_NUMBER];
|
|
|
|
volatile uint32_t data[PACKET_SIZE*PACKET_NUMBER];
|
|
volatile uint32_t data_dest[(PACKET_SIZE + 1)*PACKET_NUMBER];
|
|
|
|
int main()
|
|
{
|
|
PCRC_DMA_Typedef CRC = (PCRC_DMA_Typedef) 0x43c00000;
|
|
|
|
const CrcParameterSet CRC32_AXIM = {
|
|
.Polynomial = 0x814141ab,
|
|
.InitalValue = 0x0,
|
|
.FinalXOR = 0x0,
|
|
.InputReflected = false,
|
|
.OutputReflected = false
|
|
};
|
|
|
|
for (uint32_t i = 0; i < PACKET_SIZE*PACKET_NUMBER*4; i++) {
|
|
((uint8_t*) data)[i] = (uint8_t) i;
|
|
}
|
|
|
|
// axi_crc_dam Komponete parametrieren
|
|
CRC->ReadAddress = (uint32_t) msg;
|
|
CRC->WriteAddress = (uint32_t) dest;
|
|
CRC->PacketSize = PACKET_SIZE - 1;
|
|
CRC->NumberPackets = PACKET_NUMBER - 1;
|
|
CRC->Polynomial = CRC32_AXIM.Polynomial;
|
|
CRC->InitialValue = CRC32_AXIM.InitalValue;
|
|
CRC->FinalXOR = CRC32_AXIM.FinalXOR;
|
|
if (CRC32_AXIM.InputReflected) {CRC->InOutReflected |= (1<<0);}
|
|
else {CRC->InOutReflected &= ~(1<<0);}
|
|
if (CRC32_AXIM.OutputReflected) {CRC->InOutReflected |= (1<<1);}
|
|
else {CRC->InOutReflected &= ~(1<<1);}
|
|
|
|
// Interrupt aktivieren
|
|
// CRC->Control |= (1<<1);
|
|
|
|
// IP starten
|
|
CRC->Control = 1;
|
|
|
|
while (1) {
|
|
// Status abfragen
|
|
if ((CRC->Control & (1<<0)) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Interrupt zuruecksetzen
|
|
CRC->InterruptStatus = 0;
|
|
|
|
// Hardwareergebnis und Softwareergebnisse ablegen
|
|
for (int i = 0; i < PACKET_NUMBER; i++) {
|
|
uint8_t* pData = (uint8_t*) (CRC->ReadAddress + 4*i*PACKET_SIZE);
|
|
uint32_t* pCRC = (uint32_t*) (CRC->WriteAddress + 4*PACKET_SIZE + 4*i*(PACKET_SIZE+1));
|
|
crc_sw[i] = calcCRC32(pData, PACKET_SIZE*4, CRC32_AXIM.Polynomial, CRC32_AXIM.InitalValue, CRC32_AXIM.FinalXOR, CRC32_AXIM.InputReflected ? 1 : 0, CRC32_AXIM.OutputReflected ? 1 : 0);
|
|
crc_hw[i] = *pCRC;
|
|
}
|
|
|
|
CRC->Polynomial = 0x0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
uint32_t calcCRC32(
|
|
uint8_t* inBytes,
|
|
size_t size,
|
|
uint32_t polynomial,
|
|
uint32_t initialValue,
|
|
uint32_t finalXOR,
|
|
uint8_t inputReflected,
|
|
uint8_t outputReflected
|
|
) {
|
|
uint32_t crc = initialValue;
|
|
uint8_t byte;
|
|
|
|
for (size_t i = 0; i < size; i++) {
|
|
byte = inBytes[i];
|
|
|
|
if (inputReflected != 0) {
|
|
uint8_t reflected = 0;
|
|
|
|
for (int b = 0; b < 8; b++) {
|
|
if ((byte & (1<<b)) != 0) {
|
|
reflected |= (uint8_t) (1<<(7-b));
|
|
}
|
|
}
|
|
byte = reflected;
|
|
}
|
|
|
|
crc ^= (uint32_t) (byte << 24);
|
|
|
|
for (int bit = 0; bit < 8; bit++) {
|
|
if ((crc & (uint32_t)(1<<31)) != 0) {
|
|
crc = (uint32_t) (crc << 1) ^ polynomial;
|
|
} else {
|
|
crc <<= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (outputReflected != 0) {
|
|
uint32_t reflected = 0;
|
|
|
|
for (int i = 0; i < 32; i++) {
|
|
if ((crc & (uint32_t) (1<<i)) != 0) {
|
|
reflected |= (uint32_t) (1<<(31-i));
|
|
}
|
|
}
|
|
crc = reflected;
|
|
}
|
|
|
|
return crc ^ finalXOR;
|
|
}
|