1010/refactor bfin write block (#1664)

* refactoring such that the operations done of reg addresses is limited to the blackfin,nios and arm files

* binaries in

* binaries in after merge

* include non incrememnting offsets in the fpga for block read and write (fpga register is constant) for example to read from fifo or write pattern to a reg etc

* binaries in

* bug fix: for loop in write block

* binaries in
This commit is contained in:
maliakal_d authored and GitHub committed 2026-11-10 12:03:29 +01:00
1 parent 2896a8db70
commit 2ab700de1b
23 files changed
+327 -234

No files matched your search

Binary file not shown.
@@ -1875,10 +1875,9 @@ int configureMAC() {
calcChecksum(udp);
// force FPGA writes to be aligned and in order
uint32_t words[sizeof(udp_header) / sizeof(uint32_t)];
memcpy(words, udp, sizeof(udp_header));
for (size_t i = 0; i != sizeof(words) / sizeof(words[0]); ++i) {
bus_w(addr + i * 2, words[i]);
if (bus_w_block(addr, udp, sizeof(udp_header), false) == FAIL) {
LOG(logERROR, ("Failed to write UDP header\n"));
return FAIL;
}
cleanFifos(); // FIXME: resetPerpheral() for ctb?
@@ -1965,9 +1965,9 @@ void setFirstUDPDestination(int value) {
PKT_CONFIG_RXR_START_ID_MSK));
}
void setupHeader(int iRxEntry, int vetoInterface, uint32_t destip,
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
uint32_t sourceip, uint16_t sourceport) {
int setupHeader(int iRxEntry, int vetoInterface, uint32_t destip,
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
uint32_t sourceip, uint16_t sourceport) {
// start addr
uint32_t addr = BASE_UDP_RAM;
@@ -2011,15 +2011,15 @@ void setupHeader(int iRxEntry, int vetoInterface, uint32_t destip,
calcChecksum(udp);
// force FPGA writes to be aligned and in order
uint32_t words[sizeof(udp_header) / sizeof(uint32_t)];
memcpy(words, udp, sizeof(udp_header));
for (size_t i = 0; i != sizeof(words) / sizeof(words[0]); ++i) {
bus_w(addr + i * sizeof(uint32_t), words[i]);
if (bus_w_block(addr, udp, sizeof(udp_header), false) == FAIL) {
LOG(logERROR, ("Failed to write UDP header\n"));
return FAIL;
}
if (iRxEntry < numUdpDestinations) {
LOG(logINFO, ("\tIP checksum : 0x%lx\n\n", udp->ip_checksum));
}
return OK;
}
void calcChecksum(udp_header *udp) {
@@ -2133,13 +2133,23 @@ int configureMAC() {
}
#endif
// data
setupHeader(iRxEntry, 0, dstip, dstmac, dstport, srcmac, srcip,
srcport);
if (setupHeader(iRxEntry, 0, dstip, dstmac, dstport, srcmac, srcip,
srcport) == FAIL) {
LOG(logERROR, ("could not set udp destination IP and port for "
"data interface [entry:%d] \n",
iRxEntry));
return FAIL;
}
// veto
if (i10gbe) {
setupHeader(iRxEntry, 1, dstip2, dstmac2, dstport2, srcmac2, srcip2,
srcport2);
if (setupHeader(iRxEntry, 1, dstip2, dstmac2, dstport2, srcmac2,
srcip2, srcport2) == FAIL) {
LOG(logERROR, ("could not set udp destination IP and port for "
"veto interface [entry:%d] \n",
iRxEntry));
return FAIL;
}
}
}
cleanFifos();
@@ -1776,9 +1776,9 @@ int getPrimaryInterface() {
return ((bus_r(CONFIG_REG) & CONFIG_INNR_PRIMRY_INTRFCE_MSK) ? 1 : 0);
}
void setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip,
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
uint32_t sourceip, uint16_t sourceport) {
int setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip,
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
uint32_t sourceip, uint16_t sourceport) {
// start addr
uint32_t addr = (type == INNER ? RXR_ENDPOINT_INNER_START_REG
@@ -1820,15 +1820,15 @@ void setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip,
calcChecksum(udp);
// force FPGA writes to be aligned and in order
uint32_t words[sizeof(udp_header) / sizeof(uint32_t)];
memcpy(words, udp, sizeof(udp_header));
for (size_t i = 0; i != sizeof(words) / sizeof(words[0]); ++i) {
bus_w(addr + i * 2, words[i]);
if (bus_w_block(addr, udp, sizeof(udp_header), false) == FAIL) {
LOG(logERROR, ("Failed to write UDP header\n"));
return FAIL;
}
if (iRxEntry < numUdpDestinations) {
LOG(logINFO, ("\tIP checksum : 0x%lx\n\n", udp->ip_checksum));
}
return OK;
}
void calcChecksum(udp_header *udp) {
@@ -1945,21 +1945,41 @@ int configureMAC() {
#endif
if (numInterfaces == 2) {
// bottom
setupHeader(iRxEntry, OUTER, dstip, dstmac, dstport, srcmac, srcip,
srcport);
if (setupHeader(iRxEntry, OUTER, dstip, dstmac, dstport, srcmac,
srcip, srcport) == FAIL) {
LOG(logERROR, ("could not set udp header for outer interface "
"[entry:%d]\n",
iRxEntry));
return FAIL;
}
// top
setupHeader(iRxEntry, INNER, dstip2, dstmac2, dstport2, srcmac2,
srcip2, srcport2);
if (setupHeader(iRxEntry, INNER, dstip2, dstmac2, dstport2, srcmac2,
srcip2, srcport2) == FAIL) {
LOG(logERROR, ("could not set udp header for inner interface "
"[entry:%d]\n",
iRxEntry));
return FAIL;
}
}
// single interface
else {
// default
if (selInterface == 0) {
setupHeader(iRxEntry, OUTER, dstip, dstmac, dstport, srcmac,
srcip, srcport);
if (setupHeader(iRxEntry, OUTER, dstip, dstmac, dstport, srcmac,
srcip, srcport) == FAIL) {
LOG(logERROR, ("could not set udp header for outer "
"interface [entry:%d]\n",
iRxEntry));
return FAIL;
}
} else {
setupHeader(iRxEntry, INNER, dstip, dstmac, dstport, srcmac,
srcip, srcport2);
if (setupHeader(iRxEntry, INNER, dstip, dstmac, dstport, srcmac,
srcip, srcport2) == FAIL) {
LOG(logERROR, ("could not set udp header for inner "
"interface [entry:%d]\n",
iRxEntry));
return FAIL;
}
}
}
}
@@ -1120,9 +1120,9 @@ int getPrimaryInterface() {
return ((bus_r(CONFIG_REG) & CONFIG_INNR_PRIMRY_INTRFCE_MSK) ? 1 : 0);
}
void setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip,
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
uint32_t sourceip, uint16_t sourceport) {
int setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip,
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
uint32_t sourceip, uint16_t sourceport) {
// start addr
uint32_t addr = (type == INNER ? RXR_ENDPOINT_INNER_START_REG
@@ -1164,15 +1164,15 @@ void setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip,
calcChecksum(udp);
// force FPGA writes to be aligned and in order
uint32_t words[sizeof(udp_header) / sizeof(uint32_t)];
memcpy(words, udp, sizeof(udp_header));
for (size_t i = 0; i != sizeof(words) / sizeof(words[0]); ++i) {
bus_w(addr + i * 2, words[i]);
if (bus_w_block(addr, udp, sizeof(udp_header), false) == FAIL) {
LOG(logERROR, ("Failed to write UDP header\n"));
return FAIL;
}
if (iRxEntry < numUdpDestinations) {
LOG(logINFO, ("\tIP checksum : 0x%lx\n\n", udp->ip_checksum));
}
return OK;
}
void calcChecksum(udp_header *udp) {
@@ -1289,21 +1289,41 @@ int configureMAC() {
#endif
if (numInterfaces == 2) {
// bottom
setupHeader(iRxEntry, OUTER, dstip, dstmac, dstport, srcmac, srcip,
srcport);
if (setupHeader(iRxEntry, OUTER, dstip, dstmac, dstport, srcmac,
srcip, srcport) == FAIL) {
LOG(logERROR, ("could not set udp header for outer interface "
"[entry:%d]\n",
iRxEntry));
return FAIL;
}
// top
setupHeader(iRxEntry, INNER, dstip2, dstmac2, dstport2, srcmac2,
srcip2, srcport2);
if (setupHeader(iRxEntry, INNER, dstip2, dstmac2, dstport2, srcmac2,
srcip2, srcport2) == FAIL) {
LOG(logERROR, ("could not set udp header for inner interface "
"[entry:%d]\n",
iRxEntry));
return FAIL;
}
}
// single interface
else {
// default
if (selInterface == 0) {
setupHeader(iRxEntry, OUTER, dstip, dstmac, dstport, srcmac,
srcip, srcport);
if (setupHeader(iRxEntry, OUTER, dstip, dstmac, dstport, srcmac,
srcip, srcport) == FAIL) {
LOG(logERROR, ("could not set udp header for outer "
"interface [entry:%d]\n",
iRxEntry));
return FAIL;
}
} else {
setupHeader(iRxEntry, INNER, dstip, dstmac, dstport, srcmac,
srcip, srcport2);
if (setupHeader(iRxEntry, INNER, dstip, dstmac, dstport, srcmac,
srcip, srcport2) == FAIL) {
LOG(logERROR, ("could not set udp header for inner "
"interface [entry:%d]\n",
iRxEntry));
return FAIL;
}
}
}
}
@@ -2044,10 +2044,9 @@ int configureMAC() {
calcChecksum(udp);
// force FPGA writes to be aligned and in order
uint32_t words[sizeof(udp_header) / sizeof(uint32_t)];
memcpy(words, udp, sizeof(udp_header));
for (size_t i = 0; i != sizeof(words) / sizeof(words[0]); ++i) {
bus_w(addr + i * sizeof(uint32_t), words[i]);
if (bus_w_block(addr, udp, sizeof(udp_header), false) == FAIL) {
LOG(logERROR, ("Failed to write UDP header\n"));
return FAIL;
}
if (iRxEntry < numUdpDestinations) {
@@ -3,17 +3,43 @@
#pragma once
#include <inttypes.h>
#include <stdbool.h>
#include <sys/types.h>
/** csp0base */
void bus_w(u_int32_t offset, u_int32_t data);
void bus_w_csp1(u_int32_t offset, u_int32_t data);
void bus_w_csp2(u_int32_t offset, u_int32_t data);
u_int32_t bus_r(u_int32_t offset);
/** udp header */
void bus_w_csp1(u_int32_t offset, u_int32_t data);
u_int32_t bus_r_csp1(u_int32_t offset);
void bus_w_csp2(u_int32_t offset, u_int32_t data);
u_int32_t bus_r_csp2(u_int32_t offset);
/**
* Write `size` bytes from `src` to the FPGA as 32-bit words,
* one at a time and in order.
* @param fixedAddress true: every word goes to `offset` (e.g. a FIFO).
* false: words go to consecutive addresses from `offset`.
* @returns OK, or FAIL if `size` is 0 or not a multiple of 4 bytes.
*/
int bus_w_block(u_int32_t offset, const void *src, size_t size,
bool fixedAddress);
int bus_r_block(u_int32_t offset, void *dest, size_t size, bool fixedAddress);
/**
* Force FPGA writes to be aligned and in order
* by writing 32 bit words to the bus (csp1: udp header)
* @returns FAIL if size is not a non-zero multiple of sizeof(uint32_t), else OK
*/
int bus_w_csp1_block(const void *src, size_t size);
uint64_t getU64BitReg(int aLSB, int aMSB);
void setU64BitReg(uint64_t value, int aLSB, int aMSB);
/** literal register address value provided by client */
u_int32_t readRegister(u_int32_t offset);
u_int32_t writeRegister(u_int32_t offset, u_int32_t data);
int mapCSP0(void);
u_int32_t *Arm_getUDPBaseAddress();
@@ -3,6 +3,7 @@
#pragma once
#include <inttypes.h>
#include <stdbool.h>
#include <sys/types.h>
/** enable support for ARDY signal on interface to FPGA
@@ -25,100 +26,36 @@
/** I2C defines */
#define I2C_CLOCK_MHZ (131.25)
/**
* Write into a 16 bit register
* @param offset address offset
* @param data 16 bit data
*/
/* 16 bit register */
void bus_w16(u_int32_t offset, u_int16_t data);
/**
* Read from a 16 bit register
* @param offset address offset
* @retuns 16 bit data read
*/
u_int16_t bus_r16(u_int32_t offset);
/**
* Write into a 32 bit register
* @param offset address offset
* @param data 32 bit data
*/
/** 32 bit register */
void bus_w(u_int32_t offset, u_int32_t data);
/**
* Read from a 32 bit register
* @param offset address offset
* @retuns 32 bit data read
*/
u_int32_t bus_r(u_int32_t offset);
/**
* Read from a 64 bit register
* @param aLSB LSB offset address
* @param aMSB MSB offset address
* @returns 64 bit data read
* Write `size` bytes from `src` to the FPGA as 32-bit words,
* one at a time and in order.
* @param fixedAddress true: every word goes to `offset` (e.g. a FIFO).
* false: words go to consecutive addresses from `offset`.
* @returns OK, or FAIL if `size` is 0 or not a multiple of 4 bytes.
*/
int64_t get64BitReg(int aLSB, int aMSB);
int bus_w_block(u_int32_t offset, const void *src, size_t size,
bool fixedAddress);
int bus_r_block(u_int32_t offset, void *dest, size_t size, bool fixedAddress);
/**
* Write into a 64 bit register
* @param value 64 bit data
* @param aLSB LSB offset address
* @param aMSB MSB offset address
* @returns 64 bit data read
*/
/** legacy: to be replaced at some point (returns int64_t via tcp) */
int64_t get64BitReg(int aLSB, int aMSB);
int64_t set64BitReg(int64_t value, int aLSB, int aMSB);
/**
* Read unsigned 64 bit from a 64 bit register
* @param aLSB LSB offset address
* @param aMSB MSB offset address
* @returns unsigned 64 bit data read
*/
uint64_t getU64BitReg(int aLSB, int aMSB);
/**
* Write unsigned 64 bit into a 64 bit register
* @param value unsigned 64 bit data
* @param aLSB LSB offset address
* @param aMSB MSB offset address
*/
void setU64BitReg(uint64_t value, int aLSB, int aMSB);
/**
* Read from a 32 bit register (literal register value provided by client)
* @param offset address offset
* @retuns 32 bit data read
*/
/** literal register address value provided by client */
u_int32_t readRegister(u_int32_t offset);
/**
* Write into a 32 bit register (literal register value provided by client)
* @param offset address offset
* @param data 32 bit data
*/
void writeRegister(u_int32_t offset, u_int32_t data);
/**
* Read from a 16 bit register (literal register value provided by client)
* @param offset address offset
* @retuns 16 bit data read
*/
u_int32_t readRegister16(u_int32_t offset);
/**
* Write into a 16 bit register (literal register value provided by client)
* @param offset address offset
* @param data 16 bit data
*/
void writeRegister16(u_int32_t offset, u_int32_t data);
/**
* Get base address for memory copy
*/
uint32_t *Blackfin_getBaseAddress();
/**
* Map FPGA
*/
int mapCSP0(void);
@@ -3,89 +3,36 @@
#pragma once
#include <inttypes.h>
#include <stdbool.h>
#include <sys/types.h>
/**
* Write into a 32 bit register for cspbase 1
* @param offset address offset
* @param data 32 bit data
*/
void bus_w_csp1(u_int32_t offset, u_int32_t data);
/** csp0base */
void bus_w(u_int32_t offset, u_int32_t data);
u_int32_t bus_r(u_int32_t offset);
/**
* Read from a 32 bit register for cspbase 1
* @param offset address offset
* @retuns 32 bit data read
*/
void bus_w_csp1(u_int32_t offset, u_int32_t data);
u_int32_t bus_r_csp1(u_int32_t offset);
/**
* Write into a 32 bit register
* @param offset address offset
* @param data 32 bit data
* Write `size` bytes from `src` to the FPGA as 32-bit words,
* one at a time and in order.
* @param fixedAddress true: every word goes to `offset` (e.g. a FIFO).
* false: words go to consecutive addresses from `offset`.
* @returns OK, or FAIL if `size` is 0 or not a multiple of 4 bytes.
*/
void bus_w(u_int32_t offset, u_int32_t data);
int bus_w_block(u_int32_t offset, const void *src, size_t size,
bool fixedAddress);
int bus_r_block(u_int32_t offset, void *dest, size_t size, bool fixedAddress);
/**
* Read from a 32 bit register
* @param offset address offset
* @retuns 32 bit data read
*/
u_int32_t bus_r(u_int32_t offset);
/**
* Read from a 64 bit register
* @param aLSB LSB offset address
* @param aMSB MSB offset address
* @returns 64 bit data read
*/
/** legacy: to be replaced at some point (returns int64_t via tcp) */
int64_t get64BitReg(int aLSB, int aMSB);
/**
* Write into a 64 bit register
* @param value 64 bit data
* @param aLSB LSB offset address
* @param aMSB MSB offset address
* @returns 64 bit data read
*/
int64_t set64BitReg(int64_t value, int aLSB, int aMSB);
/**
* Read unsigned 64 bit from a 64 bit register
* @param aLSB LSB offset address
* @param aMSB MSB offset address
* @returns unsigned 64 bit data read
*/
uint64_t getU64BitReg(int aLSB, int aMSB);
/**
* Write unsigned 64 bit into a 64 bit register
* @param value unsigned 64 bit data
* @param aLSB LSB offset address
* @param aMSB MSB offset address
*/
void setU64BitReg(uint64_t value, int aLSB, int aMSB);
/**
* Read from a 32 bit register (literal register value provided by client)
* @param offset address offset
* @retuns 32 bit data read
*/
/** literal register address value provided by client */
u_int32_t readRegister(u_int32_t offset);
/**
* Write into a 32 bit register (literal register value provided by client)
* @param offset address offset
* @param data 32 bit data
*/
void writeRegister(u_int32_t offset, u_int32_t data);
/**
* Map FPGA
*/
int mapCSP0(void);
/**
* Get Nios base address
*/
u_int32_t *Nios_getBaseAddress();
@@ -497,9 +497,16 @@ void setFirstUDPDestination(int value);
#if defined(JUNGFRAUD) || defined(MOENCHD)
void selectPrimaryInterface(int val);
int getPrimaryInterface();
void setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip,
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
uint32_t sourceip, uint16_t sourceport);
#endif
#if defined(JUNGFRAUD) || defined(MOENCHD)
int setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip,
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
uint32_t sourceip, uint16_t sourceport);
#endif
#ifdef GOTTHARD2D
int setupHeader(int iRxEntry, int vetoInterface, uint32_t destip,
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
uint32_t sourceip, uint16_t sourceport);
#endif
#if defined(JUNGFRAUD) || defined(MOENCHD) || defined(GOTTHARD2D) || \
defined(MYTHEN3D) || defined(CHIPTESTBOARDD) || \
@@ -8,16 +8,20 @@
#include "sls/sls_detector_defs.h"
#include <fcntl.h> // open
#include <string.h> // memcpy
#include <sys/mman.h> // mmap
/* global variables */
#define CSP0 (0xB0080000)
#define CSP1 (0xB0050000) // udp
#define MEM_SIZE_CSP0 (0x10000)
#define CSP2 (0xA0000000)
#define MEM_SIZE_CSP0 (0x20000)
#define MEM_SIZE_CSP1 (0x2000) // smaller size for udp
#define MEM_SIZE_CSP2 (0x4000) // smaller size for udp
u_int32_t *csp0base = 0;
u_int32_t *csp1base = 0;
u_int32_t *csp2base = 0;
void bus_w(u_int32_t offset, u_int32_t data) {
volatile u_int32_t *ptr1;
@@ -25,6 +29,12 @@ void bus_w(u_int32_t offset, u_int32_t data) {
*ptr1 = data;
}
u_int32_t bus_r(u_int32_t offset) {
volatile u_int32_t *ptr1;
ptr1 = (u_int32_t *)(csp0base + offset / (sizeof(u_int32_t)));
return *ptr1;
}
void bus_w_csp1(u_int32_t offset, u_int32_t data) {
volatile u_int32_t *ptr1;
ptr1 = (u_int32_t *)(csp1base + offset / (sizeof(u_int32_t)));
@@ -37,12 +47,67 @@ u_int32_t bus_r_csp1(u_int32_t offset) {
return *ptr1;
}
u_int32_t bus_r(u_int32_t offset) {
void bus_w_csp2(u_int32_t offset, u_int32_t data) {
volatile u_int32_t *ptr1;
ptr1 = (u_int32_t *)(csp0base + offset / (sizeof(u_int32_t)));
ptr1 = (u_int32_t *)(csp2base + offset / (sizeof(u_int32_t)));
*ptr1 = data;
}
u_int32_t bus_r_csp2(u_int32_t offset) {
volatile u_int32_t *ptr1;
ptr1 = (u_int32_t *)(csp2base + offset / (sizeof(u_int32_t)));
return *ptr1;
}
int bus_w_block(u_int32_t offset, const void *src, size_t size,
bool fixedAddress) {
if (size == 0 || size % sizeof(uint32_t) != 0) {
LOG(logERROR, ("Could not write block: size %zu is not a non-zero "
"multiple of %zu\n",
size, sizeof(uint32_t)));
return FAIL;
}
const uint32_t step = fixedAddress ? 0 : sizeof(uint32_t);
uint32_t words[size / sizeof(uint32_t)];
memcpy(words, src, size);
for (size_t i = 0; i != sizeof(words) / sizeof(words[0]); ++i) {
bus_w(offset + i * step, words[i]);
}
return OK;
}
int bus_r_block(u_int32_t offset, void *dst, size_t size, bool fixedAddress) {
if (size == 0 || size % sizeof(uint32_t) != 0) {
LOG(logERROR, ("Could not read block: size %zu is not a non-zero "
"multiple of %zu\n",
size, sizeof(uint32_t)));
return FAIL;
}
const uint32_t step = fixedAddress ? 0 : sizeof(uint32_t);
uint32_t words[size / sizeof(uint32_t)];
for (size_t i = 0; i != sizeof(words) / sizeof(words[0]); ++i) {
words[i] = bus_r(offset + i * step);
}
memcpy(dst, words, size);
return OK;
}
int bus_w_csp1_block(const void *src, size_t size) {
uint32_t step = sizeof(uint32_t);
if (size == 0 || size % sizeof(uint32_t) != 0) {
LOG(logERROR, ("Could not write block: size %zu is not a non-zero "
"multiple of %zu\n",
size, sizeof(uint32_t)));
return FAIL;
}
uint32_t words[size / sizeof(uint32_t)];
memcpy(words, src, size);
for (size_t i = 0; i != sizeof(words) / sizeof(words[0]); ++i) {
bus_w_csp1(i * step, words[i]);
}
return OK;
}
uint64_t getU64BitReg(int aLSB, int aMSB) {
uint64_t retval = bus_r(aMSB);
retval = (retval << 32) | bus_r(aLSB);
@@ -63,12 +128,12 @@ u_int32_t writeRegister(u_int32_t offset, u_int32_t data) {
int mapCSP0(void) {
LOG(logINFO, ("Mapping memory\n"));
u_int32_t csps[2] = {CSP0, CSP1};
u_int32_t **cspbases[2] = {&csp0base, &csp1base};
u_int32_t memsize[2] = {MEM_SIZE_CSP0, MEM_SIZE_CSP1};
char names[2][10] = {"csp0base", "csp1base"};
u_int32_t csps[3] = {CSP0, CSP1, CSP2};
u_int32_t **cspbases[3] = {&csp0base, &csp1base, &csp2base};
u_int32_t memsize[3] = {MEM_SIZE_CSP0, MEM_SIZE_CSP1, MEM_SIZE_CSP2};
char names[3][10] = {"csp0base", "csp1base", "csp2base"};
for (int i = 0; i < 2; ++i) {
for (int i = 0; i < 3; ++i) {
// if not mapped
if (*cspbases[i] == 0) {
LOG(logINFO, ("\tMapping memory for %s\n", names[i]));
@@ -106,5 +171,3 @@ int mapCSP0(void) {
}
return OK;
}
u_int32_t *Arm_getUDPBaseAddress() { return csp1base; }
@@ -8,6 +8,7 @@
#include "sls/sls_detector_defs.h"
#include <fcntl.h> // open
#include <string.h> //memcpy
#include <sys/mman.h> // mmap
/* global variables */
@@ -44,6 +45,41 @@ u_int32_t bus_r(u_int32_t offset) {
return *ptr1;
}
int bus_w_block(u_int32_t offset, const void *src, size_t size,
bool fixedAddress) {
if (size == 0 || size % sizeof(uint32_t) != 0) {
LOG(logERROR, ("Could not write block: size %zu is not a non-zero "
"multiple of %zu\n",
size, sizeof(uint32_t)));
return FAIL;
}
const uint32_t step = fixedAddress ? 0 : (1 << MEM_MAP_SHIFT);
// low memory on blackfin, so avoid array on stack
const char *p = src;
for (size_t i = 0; i != size / sizeof(uint32_t); ++i) {
uint32_t word = 0;
memcpy(&word, p + i * sizeof(word), sizeof(word));
bus_w(offset + i * step, word);
}
return OK;
}
int bus_r_block(u_int32_t offset, void *dst, size_t size, bool fixedAddress) {
if (size == 0 || size % sizeof(uint32_t) != 0) {
LOG(logERROR, ("Could not read block: size %zu is not a non-zero "
"multiple of %zu\n",
size, sizeof(uint32_t)));
return FAIL;
}
const uint32_t step = fixedAddress ? 0 : (1 << MEM_MAP_SHIFT);
char *p = dst;
for (size_t i = 0; i != size / sizeof(uint32_t); ++i) {
uint32_t word = bus_r(offset + i * step);
memcpy(p + i * sizeof(word), &word, sizeof(word));
}
return OK;
}
int64_t get64BitReg(int aLSB, int aMSB) {
int64_t v64;
u_int32_t vLSB, vMSB;
@@ -129,5 +165,3 @@ int mapCSP0(void) {
LOG(logINFO, ("Memory already mapped before\n"));
return OK;
}
uint32_t *Blackfin_getBaseAddress() { return csp0base; }
+43 -11
View File
@@ -8,6 +8,7 @@
#include "sls/sls_detector_defs.h"
#include <fcntl.h> // open
#include <string.h> // memcpy
#include <sys/mman.h> // mmap
/* global variables */
@@ -20,6 +21,18 @@ u_int32_t *csp0base = 0;
u_int32_t *csp1base = 0;
#define CSP1 0x18040000
void bus_w(u_int32_t offset, u_int32_t data) {
volatile u_int32_t *ptr1;
ptr1 = (u_int32_t *)(csp0base + offset / (sizeof(u_int32_t)));
*ptr1 = data;
}
u_int32_t bus_r(u_int32_t offset) {
volatile u_int32_t *ptr1;
ptr1 = (u_int32_t *)(csp0base + offset / (sizeof(u_int32_t)));
return *ptr1;
}
void bus_w_csp1(u_int32_t offset, u_int32_t data) {
volatile u_int32_t *ptr1;
ptr1 = (u_int32_t *)(csp1base + offset / (sizeof(u_int32_t)));
@@ -32,16 +45,37 @@ u_int32_t bus_r_csp1(u_int32_t offset) {
return *ptr1;
}
void bus_w(u_int32_t offset, u_int32_t data) {
volatile u_int32_t *ptr1;
ptr1 = (u_int32_t *)(csp0base + offset / (sizeof(u_int32_t)));
*ptr1 = data;
int bus_w_block(u_int32_t offset, const void *src, size_t size,
bool fixedAddress) {
if (size == 0 || size % sizeof(uint32_t) != 0) {
LOG(logERROR, ("Could not write block: size %zu is not a non-zero "
"multiple of %zu\n",
size, sizeof(uint32_t)));
return FAIL;
}
const uint32_t step = fixedAddress ? 0 : sizeof(uint32_t);
uint32_t words[size / sizeof(uint32_t)];
memcpy(words, src, size);
for (size_t i = 0; i != sizeof(words) / sizeof(words[0]); ++i) {
bus_w(offset + i * step, words[i]);
}
return OK;
}
u_int32_t bus_r(u_int32_t offset) {
volatile u_int32_t *ptr1;
ptr1 = (u_int32_t *)(csp0base + offset / (sizeof(u_int32_t)));
return *ptr1;
int bus_r_block(u_int32_t offset, void *dst, size_t size, bool fixedAddress) {
if (size == 0 || size % sizeof(uint32_t) != 0) {
LOG(logERROR, ("Could not read block: size %zu is not a non-zero "
"multiple of %zu\n",
size, sizeof(uint32_t)));
return FAIL;
}
const uint32_t step = fixedAddress ? 0 : sizeof(uint32_t);
uint32_t words[size / sizeof(uint32_t)];
for (size_t i = 0; i != sizeof(words) / sizeof(words[0]); ++i) {
words[i] = bus_r(offset + i * step);
}
memcpy(dst, words, size);
return OK;
}
int64_t get64BitReg(int aLSB, int aMSB) {
@@ -124,6 +158,4 @@ int mapCSP0(void) {
LOG(logINFO, ("Memory %s already mapped before\n", names[i]));
}
return OK;
}
u_int32_t *Nios_getBaseAddress() { return csp0base; }
}
@@ -1479,10 +1479,9 @@ int configureMAC() {
calcChecksum(udp);
// force FPGA writes to be aligned and in order
uint32_t words[sizeof(udp_header) / sizeof(uint32_t)];
memcpy(words, udp, sizeof(udp_header));
for (size_t i = 0; i != sizeof(words) / sizeof(words[0]); ++i) {
bus_w_csp1(i * sizeof(uint32_t), words[i]);
if (bus_w_csp1_block(udp, sizeof(udp_header)) == FAIL) {
LOG(logERROR, ("Failed to write UDP header\n"));
return FAIL;
}
return OK;
+7 -7
View File
@@ -3,10 +3,10 @@
/** API versions */
#define APILIB "10.1.0 0x260806"
#define APIRECEIVER "10.1.0 0x260806"
#define APICTB "10.1.0 0x261104"
#define APIGOTTHARD2 "10.1.0 0x261104"
#define APIMOENCH "10.1.0 0x261104"
#define APIEIGER "10.1.0 0x261028"
#define APIXILINXCTB "10.1.0 0x261104"
#define APIJUNGFRAU "10.1.0 0x261105"
#define APIMYTHEN3 "10.1.0 0x261104"
#define APICTB "10.1.0 0x261109"
#define APIGOTTHARD2 "10.1.0 0x261106"
#define APIMOENCH "10.1.0 0x261109"
#define APIEIGER "10.1.0 0x261105"
#define APIXILINXCTB "10.1.0 0x261106"
#define APIJUNGFRAU "10.1.0 0x261109"
#define APIMYTHEN3 "10.1.0 0x261106"