Hardware description

The hardware description is a file containing all addresses and parameters of the hardware. It is used to configure the Dma and all GPIO devices.

Variables

Variables

uint32_t kDataWordSize64Bit = 8: The kDataWordSize64Bit constant represents the data word size for 64-bit DMA transfers in bytes.

uint32_t kDataWordSize16Bit = 2

The kDataWordSize16Bit constant represents the data word size for 16-bit DMA transfers in bytes.

Note: Hardware still transfers 64-bit words, but each word contains 4 x 16-bit values packed together.

uint32_t kDmaRawStartAddress = 0x20000000

The kDmaRawStartAddress constant represents the start address of the raw DMA buffer.

The DMA buffer is reserved in the physical memory. This constant represents the start address of the DMA buffer. It must match the start address in the device tree.

uint32_t kDmaCountStartAddress = 0x1E800000

The kDmaCountStartAddress constant represents the start address of the kDmaCount buffer.

The DMA buffer is reserved in the physical memory. This constant represents the start address of the DMA buffer. It must match the start address in the device tree.

uint32_t kDmaChargeStartAddress = 0x1D000000

The kDmaChargeStartAddress constant represents the start address of the kDmaCharge buffer.

The DMA buffer is reserved in the physical memory. This constant represents the start address of the DMA buffer. It must match the start address in the device tree.

uint32_t kDmaFractionStartAddress = 0x1B800000

The kDmaFractionStartAddress constant represents the start address of the kDmaFraction buffer.

The DMA buffer is reserved in the physical memory. This constant represents the start address of the DMA buffer. It must match the start address in the device tree.

uint32_t kDmaMaxStartAddress = 0x1A000000

The kDmaMaxStartAddress constant represents the start address of the kDmaMax buffer.

The DMA buffer is reserved in the physical memory. This constant represents the start address of the DMA buffer. It must match the start address in the device tree.

uint32_t kDmaRisetimeStartAddress = 0x18800000

The kDmaRisetimeStartAddress constant represents the start address of the kDmaRisetime buffer.

The DMA buffer is reserved in the physical memory. This constant represents the start address of the DMA buffer. It must match the start address in the device tree.

uint32_t kDefaultRawPackageSize = 0x400000

The kDefaultRawPackageSize constant represents the the amount of transfers before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of transfers per package. Calculating kDefaultDataSize * kDefaultRawPackageSize gives the number of bytes per package (see kDefaultRawPackageSizeBytes). It must match the package size set in the hardware design.

uint32_t kDefaultCountPackageSize = 0x80000

The kDefaultCountPackageSize constant represents the the amount of transfers before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of transfers per package. Calculating kDefaultDataSize * kDefaultCountPackageSize gives the number of bytes per package (see kDefaultCountPackageSizeBytes). It must match the package size set in the hardware design.

uint32_t kDefaultChargePackageSize = 0x80000

The kDefaultChargePackageSize constant represents the the amount of transfers before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of transfers per package. Calculating kDefaultDataSize * kDefaultChargePackageSize gives the number of bytes per package (see kDefaultChargePackageSizeBytes). It must match the package size set in the hardware design.

uint32_t kDefaultFractionPackageSize = 0x80000

The kDefaultFractionPackageSize constant represents the the amount of transfers before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of transfers per package. Calculating kDefaultDataSize * kDefaultFractionPackageSize gives the number of bytes per package (see kDefaultFractionPackageSizeBytes). It must match the package size set in the hardware design.

uint32_t kDefaultMaxPackageSize = 0x200000

The kDefaultMaxPackageSize constant represents the the amount of transfers before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of transfers per package. Calculating kDataWordSize16Bit * kDefaultMaxPackageSize gives the number of bytes per package (see kDefaultMaxPackageSizeBytes). It must match the package size set in the hardware design.

uint32_t kDefaultRisetimePackageSize = 0x200000

The kDefaultRisetimePackageSize constant represents the the amount of transfers before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of transfers per package. Calculating kDataWordSize16Bit * kDefaultRisetimePackageSize gives the number of bytes per package (see kDefaultRisetimePackageSizeBytes). It must match the package size set in the hardware design.

uint32_t kDefaultRawPackageSizeBytes = kDataWordSize64Bit * kDefaultRawPackageSize 

The kDefaultRawPackageSizeBytes constant represents the the amount of bytes before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of bytes per package. Calculating kDataWordSize64Bit * kDefaultRawPackageSize gives the number of bytes per package.

uint32_t kDefaultCountPackageSizeBytes = kDataWordSize64Bit * kDefaultCountPackageSize 

The kDefaultCountPackageSizeBytes constant represents the the amount of bytes before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of bytes per package. Calculating kDataWordSize64Bit * kDefaultCountPackageSize gives the number of bytes per package.

uint32_t kDefaultChargePackageSizeBytes = kDataWordSize64Bit * kDefaultChargePackageSize 

The kDefaultChargePackageSizeBytes constant represents the the amount of bytes before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of bytes per package. Calculating kDataWordSize64Bit * kDefaultChargePackageSize gives the number of bytes per package.

uint32_t kDefaultFractionPackageSizeBytes = kDataWordSize64Bit * kDefaultFractionPackageSize 

The kDefaultChargePackageSizeBytes constant represents the the amount of bytes before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of bytes per package. Calculating kDataWordSize64Bit * kDefaultFractionPackageSize gives the number of bytes per package.

uint32_t kDefaultMaxPackageSizeBytes = kDataWordSize16Bit * kDefaultMaxPackageSize 

The kDefaultMaxPackageSizeBytes constant represents the the amount of bytes before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of bytes per package. Calculating kDataWordSize16Bit * kDefaultMaxPackageSize gives the number of bytes per package.

uint32_t kDefaultRisetimePackageSizeBytes = kDataWordSize16Bit * kDefaultRisetimePackageSize 

The kDefaultRisetimePackageSizeBytes constant represents the the amount of bytes before each DMA interrupt.

The hardware packs together transfers into packages. This constant represents the amount of bytes per package. Calculating kDataWordSize16Bit * kDefaultRisetimePackageSize gives the number of bytes per package.

uint8_t kDmaCount = 2

The kDmaCount constant represents the amount of ADC channels.

The used ADC has two DMA channels.

uint32_t kDmaRawReservedSpace = 0x10000000

The kDmaRawReservedSpace constant represents the total reserved space for DMA_RAW buffers.

The DMA buffers are reserved in the physical memory. This constant represents the total reserved space. It must match the reserved space in the device tree.

uint32_t kDmaCountReservedSpace = 0x1800000

The kDmaCountReservedSpace constant represents the total reserved space for kDmaCount buffers.

The DMA buffers are reserved in the physical memory. This constant represents the total reserved space. It must match the reserved space in the device tree.

uint32_t kDmaChargeReservedSpace = 0x1800000

The kDmaChargeReservedSpace constant represents the total reserved space for kDmaCharge buffers.

The DMA buffers are reserved in the physical memory. This constant represents the total reserved space. It must match the reserved space in the device tree.

uint32_t kDmaFractionReservedSpace = 0x1800000

The kDmaFractionReservedSpace constant represents the total reserved space for kDmaFraction buffers.

The DMA buffers are reserved in the physical memory. This constant represents the total reserved space. It must match the reserved space in the device tree.

uint32_t kDmaMaxReservedSpace = 0x1800000

The kDmaMaxReservedSpace constant represents the total reserved space for kDmaMax buffers.

The DMA buffers are reserved in the physical memory. This constant represents the total reserved space. It must match the reserved space in the device tree.

uint32_t kDmaRisetimeReservedSpace = 0x1800000

The kDmaRisetimeReservedSpace constant represents the total reserved space for kDmaRisetime buffers.

The DMA buffers are reserved in the physical memory. This constant represents the total reserved space. It must match the reserved space in the device tree.

uint32_t kDmaDescriptorBase = 0x80000000

The kDmaDescriptorBase constant represents the physical location of the DMA descriptor memory.

The DMA descriptor memory is reserved in the physical memory. Block RAM is used in hardware.

uint32_t kDmaDescriptorSize = 0x40U

The kDmaDescriptorSize constant represents the size of a DMA descriptor.

This is given by documentation of the DMA.

uint32_t kDmaRawDescriptorPerDma = (kDmaRawReservedSpace / kDmaCount) / kDefaultRawPackageSizeBytes 

The kDmaRawDescriptorPerDma constant represents the amount of DMA descriptors per raw DMA device.

The formula calculates the optimal amount of DMA descriptors per DMA device so that the whole reserved memory is used.

uint32_t kDmaCountDescriptorPerDma = (kDmaCountReservedSpace / kDmaCount) / kDefaultCountPackageSizeBytes 

The kDmaCountDescriptorPerDma constant represents the amount of DMA descriptors per kDmaCount device.

The formula calculates the optimal amount of DMA descriptors per DMA device so that the whole reserved memory is used.

uint32_t kDmaChargeDescriptorPerDma = (kDmaChargeReservedSpace / kDmaCount) / kDefaultChargePackageSizeBytes 

The kDmaChargeDescriptorPerDma constant represents the amount of DMA descriptors per charge DMA device.

The formula calculates the optimal amount of DMA descriptors per DMA device so that the whole reserved memory is used.

uint32_t kDmaFractionDescriptorPerDma = (kDmaFractionReservedSpace / kDmaCount) / kDefaultFractionPackageSizeBytes 

The kDmaFractionDescriptorPerDma constant represents the amount of DMA descriptors per integral fraction DMA device.

The formula calculates the optimal amount of DMA descriptors per DMA device so that the whole reserved memory is used.

uint32_t kDmaMaxDescriptorPerDma = (kDmaMaxReservedSpace / kDmaCount) / kDefaultMaxPackageSizeBytes 

The kDmaMaxDescriptorPerDma constant represents the amount of DMA descriptors per max DMA device.

The formula calculates the optimal amount of DMA descriptors per DMA device so that the whole reserved memory is used.

uint32_t kDmaRisetimeDescriptorPerDma = (kDmaRisetimeReservedSpace / kDmaCount) / kDefaultRisetimePackageSizeBytes 

The kDmaRisetimeDescriptorPerDma constant represents the amount of DMA descriptors per risetime DMA device.

The formula calculates the optimal amount of DMA descriptors per DMA device so that the whole reserved memory is used.

std::array<DmaDevice, kDmaCount> kDmasRaw = {{{0x80400000, 0, "/dev/udmabuf0", "/dev/uio8", nexmess::components::dma::DmaPurpose::kRaw}, {0x80410000, kDmaDescriptorSize * kDmaRawDescriptorPerDma, "/dev/udmabuf1", "/dev/uio9", nexmess::components::dma::DmaPurpose::kRaw}}}

The kDmasRaw constant represents the DMA devices used for the ADC.

It is used for the raw data.

The first DMA device is used for ADC channel 0, the second DMA device is used for ADC channel 1.

To check the position of the UIO pin, use “cat

/sys/class/uio/uioX/maps/map0/name”

std::array<DmaDevice, kDmaCount> kDmasCount = {{{0x80420000, 2 * kDmaDescriptorSize * kDmaRawDescriptorPerDma, "/dev/udmabuf2", "/dev/uio2", nexmess::components::dma::DmaPurpose::kCount}, {0x80430000, (2 * kDmaDescriptorSize * kDmaRawDescriptorPerDma) + (kDmaDescriptorSize * kDmaCountDescriptorPerDma), "/dev/udmabuf3", "/dev/uio3", nexmess::components::dma::DmaPurpose::kCount}}}

The kDmasCount constant represents the DMA devices used for the ADC.

It is used for the count data.

The first DMA device is used for ADC channel 0, the second DMA device is used for ADC channel 1.

To check the position of the UIO pin, use “cat

/sys/class/uio/uioX/maps/map0/name”

std::array<DmaDevice, kDmaCount> kDmasCharge = {{{0x80440000, (2 * kDmaDescriptorSize * kDmaRawDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaCountDescriptorPerDma), "/dev/udmabuf4", "/dev/uio0", nexmess::components::dma::DmaPurpose::kCharge}, {0x80450000, (2 * kDmaDescriptorSize * kDmaRawDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaCountDescriptorPerDma) + (kDmaDescriptorSize * kDmaChargeDescriptorPerDma), "/dev/udmabuf5", "/dev/uio1", nexmess::components::dma::DmaPurpose::kCharge}}}

The kDmasCharge constant represents the DMA devices used for the ADC.

It is used for the charge data (stilbene pulse evaluation).

The first DMA device is used for ADC channel 0, the second DMA device is used for ADC channel 1.

To check the position of the UIO pin, use “cat

/sys/class/uio/uioX/maps/map0/name”

std::array<DmaDevice, kDmaCount> kDmasFraction = {{{0x80460000, (2 * kDmaDescriptorSize * kDmaRawDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaCountDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaChargeDescriptorPerDma), "/dev/udmabuf6", "/dev/uio4", nexmess::components::dma::DmaPurpose::kFraction}, {0x80470000, (2 * kDmaDescriptorSize * kDmaRawDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaCountDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaChargeDescriptorPerDma) + (kDmaDescriptorSize * kDmaFractionDescriptorPerDma), "/dev/udmabuf7", "/dev/uio5", nexmess::components::dma::DmaPurpose::kFraction}}}

The kDmasFraction constant represents the DMA devices used for the ADC.

It is used for the integral fraction data (stilbene pulse evaluation).

The first DMA device is used for ADC channel 0, the second DMA device is used for ADC channel 1.

To check the position of the UIO pin, use “cat

/sys/class/uio/uioX/maps/map0/name”

std::array<DmaDevice, kDmaCount> kDmasMax = {{{0x80480000, (2 * kDmaDescriptorSize * kDmaRawDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaCountDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaChargeDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaFractionDescriptorPerDma), "/dev/udmabuf8", "/dev/uio6", nexmess::components::dma::DmaPurpose::kMax}, {0x80490000, (2 * kDmaDescriptorSize * kDmaRawDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaCountDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaChargeDescriptorPerDma) + (2 * kDmaDescriptorSize * kDmaFractionDescriptorPerDma) + (kDmaDescriptorSize * kDmaMaxDescriptorPerDma), "/dev/udmabuf9", "/dev/uio7", nexmess::components::dma::DmaPurpose::kMax}}}

The kDmasMax constant represents the DMA devices used for the ADC.

It is used for the maximum height data (stilbene pulse evaluation).

The first DMA device is used for ADC channel 0, the second DMA device is used for ADC channel 1.

To check the position of the UIO pin, use “cat

/sys/class/uio/uioX/maps/map0/name”

The kDmasRisetime constant represents the DMA devices used for the ADC.

It is used for the risetime data (HPD pulse evaluation).

The first DMA device is used for ADC channel 0, the second DMA device is used for ADC channel 1.

To check the position of the UIO pin, use “cat

/sys/class/uio/uioX/maps/map0/name”

uint32_t kGpioEnabled = 0x81200000

The kGpioEnabled constant represents the address for the register controlling the enabled state of the ADC channels.

There are 2 ADC channels controlled by one register:

bit [0..1]: activate DMA operations of ADC channel 1 and 2
bit [2..3]: activate signal inversion of ADC channel 1 and 2
bin [4..5]: activate FIR filter of ADC channel 1 and 2
bin [6..7]: activate baseline restoration of ADC channel 1 and 2
bin [8..9]: activate CFD triggering for ADC channel 1 and 2
bin [6..7]: activate CFD data output ADC channel 1 and 2

Example: 0b0000000000000101 enables ADC channel 1 for DMA operations and inverts it.

uint32_t kGpioMeasurementInterrupt = 0x81201000

The kGpioMeasurementInterrupt constant represents the address for the registers controlling the measurement interrupt.

This GPIO uses two registers. The first is an input register, the second is an output register.

The first register is used to read the status of the measurement.

bit [0..1]: stopped status of ADC channel 1 and 2
bit [2..3]: DMA raw interrupt status of ADC channel 1 and 2
bit [4..5]: DMA count interrupt status of ADC channel 1 and 2

The second register is used to disable further interrupts.

bit [0..1]: disable interrupt for ADC channel 0 and 1 (0 = no further interrupts, 1 = interrupts work)

uint32_t kGpioMeasurementTime = 0x81202000

The kGpioMeasurementTime constant represents the address for the register controlling the measurement time.

This GPIO uses one register. The register is used to set the measurement time.

The measurement time is given in ms.

uint32_t kGpioOffset = 0x81203000

The kGpioOffset constant represents the address for the register controlling the offsets of the ADC signals.

This GPIO uses one register. The register is used to set the offsets of the ADC channels.

There are 2 ADC channels controlled by one register:

bit [0..15]: offset of ADC channel 1
bit [16..31]: offset of ADC channel 2

The offset sets the number of arbitrary units for shifting the signal of channel 1 and channel 2.

uint32_t kGpioBlrPreGate = 0x81204000

The kGpioBlrPreGate constant represents the address for the register controlling the pre gates of the baseline restorers.

This GPIO uses one register. The register is used to set the pre gates.

There are 2 ADC channels controlled by one register:

bit [0..10]: pre gate of ADC channel 1
bit [11..21]: pre gate of ADC channel 2

The pre gate sets the number of samples to go back for calculating the baseline correction.

uint32_t kGpioPreGate = 0x81205000

The kGpioPreGate constant represents the address for the register controlling the pre gates for the ADC channels.

This GPIO uses one register. The register is used to set the pre gates.

There are 2 ADC channels controlled by one register:

bit [0..15]: pre gate for ADC channel 1
bit [16..31]: pre gate for ADC channel 2

The pre gate sets the number of samples to be measured to be be output before the trigger occurred.

uint32_t kGpioLongGate = 0x81206000

The kGpioLongGate constant represents the address for the register controlling the long gates for the ADC channels.

This GPIO uses one register. The register is used to set the long gates.

There are 2 ADC channels controlled by one register:

bit [0..15]: long gate for ADC channel 1
bit [16..31]: long gate for ADC channel 2

The long gate sets the number of samples to be measured once a trigger occurs.

uint32_t kGpioTriggerValue = 0x81207000

The kGpioTriggerValue constant represents the address for the register controlling the trigger values for the ADC channels.

This GPIO uses one register. The register is used to set the trigger values.

There are 2 ADC channels controlled by one register:

bit [0..15]: trigger value for ADC channel 1
bit [16..31]: trigger value for ADC channel 2

The trigger value is given in a value corresponding to the ADC value.

uint32_t kGpioShortWindow = 0x81208000

The kGpioShortWindow constant represents the address for the register controlling the short integration window for stilbene pulse evaluation.

This GPIO uses one register. The register is used to set the short integration windows.

There are 2 ADC channels controlled by one register:

bit [0..11]: Short integration window for ADC channel 1
bit [16..27]: Short integration window for ADC channel 2

The short integration window sets the number of samples to be used for the size of the short integration window for stilbene pulse evaluation.

uint32_t kGpioLongWindow = 0x81209000

The kGpioLongWindow constant represents the address for the register controlling the long integration window for stilbene pulse evaluation.

This GPIO uses one register. The register is used to set the long integration windows.

There are 2 ADC channels controlled by one register:

bit [0..11]: Long integration window for ADC channel 1
bit [16..27]: Long integration window for ADC channel 2

The long integration window sets the number of samples to be used for the size of the long integration window for stilbene pulse evaluation.

uint32_t kGpioCfdDelay = 0x8120A000

The kGpioCfdDelay constant represents the address for the register controlling the delay used for the CFD filter.

This GPIO uses one register. The register is used to set the CFD delay.

There are 2 ADC channels controlled by one register:

bit [0..11]: CFD delay for ADC channel 1
bit [16..27]: CFD delay for ADC channel 2

The CFD delay sets the number of samples to be used for the delay of one partial signal in the CFD filter.

uint32_t kGpioCfdAmp = 0x8120B000

The kGpioCfdAmp constant represents address for the register for controlling the amplification factors used for the CFD filter.

This GPIO uses one register. As the GPIO is a dual GPIO, it is used for the individual configuration of both channels.

The CFD amplification factor sets the amplification of one partial signal in the CFD filter.

uint32_t kGpioMinHeightFraction = 0x8120C000: The kGpioMinHeightFraction constant represents the address for the register controlling the minimum height for the risetime calculation.

uint32_t kGpioMaxHeightFraction = 0x8120D000: The kGpioMaxHeightFraction constant represents the address for the register controlling the maximum height for the risetime calculation.

uint32_t kGpioEventCountChannel1 = 0x8120E000

The kGpioEventCountChannel1 constant represents the address for the register controlling the event count for ADC channel 1.

The event count is represented using 40 bits.

This GPIO uses two registers. The first register contains the first 32 bits of the event count, the second register uses 8 bits for the rest of the event count.

uint32_t kGpioEventCountChannel2 = 0x8120F000

The kGpioEventCountChannel2 constant represents the address for the register controlling the event count for ADC channel 2.

The event count is represented using 40 bits.

This GPIO uses two registers. The first register contains the first 32 bits of the event count, the second register uses 8 bits for the rest of the event count.

uint32_t kGpioRawPackageSize = 0x81210000: The kGpioRawPackageSize constant represents the address for the Gpio used for the raw data package size.

uint32_t kGpioCountPackageSize = 0x81211000: The kGpioCountPackageSize constant represents the address for the Gpio used for the count data package size.

uint32_t kGpioChargePackageSize = 0x81212000: The kGpioChargePackageSize constant represents the address for the Gpio used for the charge data package size.

uint32_t kGpioFractionPackageSize = 0x81213000: The kGpioFractionPackageSize constant represents the address for the Gpio used for the fraction data package size.

uint32_t kGpioMaxPackageSize = 0x81214000: The kGpioMaxPackageSize constant represents the address for the Gpio used for the maximum value data package size.

uint32_t kGpioRisetimePackageSize = 0x81215000: The kGpioRisetimePackageSize constant represents the address for the Gpio used for the risetime data package size.

struct DmaDevice

#include <hwdevice.h>

The DmaDevice struct represents a DMA device.

This struct is used to configure the DMA devices used for the ADC.

Public Members

uint32_t register_: The register address of the DMA device.

uint32_t descriptor_offset_: The offset of the DMA descriptor memory.

const char *dma_device_: The device name of the DMA device.

const char *uio_device_: The device name of the UIO device.

nexmess::components::dma::DmaPurpose purpose_of_use_: The purpose of use of the DMA device.