Commit 40a16639 authored by Mariusz Mroz's avatar Mariusz Mroz

Documentation on new template. Software and gateware corrections.

parent 410ac7fe
......@@ -21,11 +21,16 @@ transcript
doc/*.pdf
*.o
*.so
*.a
*.pyc
*.elf
output
software/rf-test
*.png
*.odt.saved
python/sdbfs/IPMI-FRU
python/gensdbfs
ptsfiles/cp210x/*
!ptsfiles/cp210x/Makefile
!ptsfiles/cp210x/cp210x.c
\ No newline at end of file
......@@ -14,3 +14,6 @@
path = gateware/ip_cores/etherbone-core
url = git://ohwr.org/hdl-core-lib/etherbone-core.git
[submodule "software/fpga-config-space"]
path = software/fpga-config-space
url = git://ohwr.org/hdl-core-lib/fpga-config-space.git
No preview for this file type
#!/bin/bash
rmmod fmc_adc_100m14b 2> /dev/null
rmmod zio 2> /dev/null
rmmod rawrabbit 2> /dev/null
rmmod spec 2> /dev/null
rmmod fmc 2> /dev/null
rmmod cp210x 2>/dev/null
rmmod usbtmc 2>/dev/null
prg=$0
if [ ! -e "$prg" ]; then
case $prg in
(*/*) exit 1;;
(*) prg=$(command -v -- "$prg") || exit;;
esac
fi
dir=$(
cd -P -- "$(dirname -- "$prg")" && pwd -P
) || exit
prg=$dir/$(basename -- "$prg") || exit
top=`echo "$prg" | sed 's/fmcdac600m12b1chadds.*/fmcdac600m12b1chadds\//'`
insmod "$top/software/fmc-bus/kernel/fmc.ko"
insmod "$top/software/spec-sw/kernel/spec.ko" "fw_name=../../$top/gateware/spec-init.bin-2012-12-14"
insmod "$top/software/fmc-adc-100m14b4cha-sw/zio/zio.ko"
insmod "$top/software/fmc-adc-100m14b4cha-sw/kernel/fmc-adc-100m14b.ko" "gateware=../../$top/gateware/spec-fmc-adc-v4.0.bin"
adc=`python -c 'import sys; sys.path.append('\'python\''); import spec_identification; spec_identification.adc_bus()'`
dut=`python -c 'import sys; sys.path.append('\'python\''); import spec_identification; spec_identification.dut_bus()'`
echo "Please verify if both SPEC cards were correctly identified"
echo ""
echo "Files belowe are named with following pattern:"
echo "[arbitrary lenght]-[2 numbers][2 numbers]"
echo "<name>-<bus><slot>"
echo ""
echo "ls /sys/bus/fmc/devices/"
ls /sys/bus/fmc/devices/
echo ""
if [ $adc -ge 0 ]
then
echo "FmcAdc100m14b was found on bus $adc"
else
echo "FmcAdc100m14b was not found"
echo "Make sure that single FmcAdc100m14b board is mounted in PCIe slot and that it contain valid eeprom content"
fi
if [ $dut -ge 0 ]
then
echo "Board under test was found on bus $dut"
else
echo "Board under test was not found"
echo "Make sure that card is mounted in PCIe slot"
fi
#!/bin/bash
echo "WARRNING!!!"
echo "errors indicating that modules are not loaded should be ignored"
echo "i.e: rmmod: \"ERROR: Module fmc_adc_100m14b is not currently loaded\" should be ignored"
rmmod fmc_adc_100m14b > /dev/null
rmmod zio > /dev/null
rmmod rawrabbit > /dev/null
rmmod spec > /dev/null
rmmod fmc > /dev/null
rmmod fmc_adc_100m14b 2> /dev/null
rmmod zio 2> /dev/null
rmmod rawrabbit 2> /dev/null
rmmod spec 2> /dev/null
rmmod fmc 2> /dev/null
modprobe usbserial
rmmod cp210x
rmmod usbtmc
rmmod cp210x 2>/dev/null
rmmod usbtmc 2>/dev/null
prg=$0
......@@ -33,20 +29,18 @@ top=`echo "$prg" | sed 's/pts.*/pts\//'`
insmod "$top/test/fmcdac600m12b1chadds/software/fmc-bus/kernel/fmc.ko"
insmod "$top/test/fmcdac600m12b1chadds/software/spec-sw/kernel/spec.ko"
insmod "$top/test/fmcdac600m12b1chadds/software/spec-sw/kernel/spec.ko" "fw_name=../../$top/test/fmcdac600m12b1chadds/gateware/spec-init.bin-2012-12-14"
insmod "$top/test/fmcdac600m12b1chadds/software/fmc-adc-100m14b4cha-sw/zio/zio.ko"
insmod "$top/test/fmcdac600m12b1chadds/software/fmc-adc-100m14b4cha-sw/kernel/fmc-adc-100m14b.ko"
insmod "$top/test/fmcdac600m12b1chadds/software/fmc-adc-100m14b4cha-sw/kernel/fmc-adc-100m14b.ko" "gateware=../../$top/test/fmcdac600m12b1chadds/gateware/spec-fmc-adc-v4.0.bin"
insmod "$top/cp210x/cp210x.ko"
# "$top/usbdriver/usbtmc_load"
LOGDIR="$top/log_fmcdac600m12b1chadds"
mkdir -p "$LOGDIR"
mkdir -p "$LOGDIR/eeprom"
# sudo rm -fr $LOGDIR/pts*
serial=$1
......
#!/usr/bin/python
import sys
import rr
import time
class CCSR:
def __init__(self, bus, base_addr):
self.base_addr = base_addr;
self.bus = bus;
def wr_reg(self, addr, val):
#print(" wr:%.8X reg:%.8X")%(val,(self.base_addr+addr))
self.bus.iwrite(0, self.base_addr + addr, 4, val)
def rd_reg(self, addr):
reg = self.bus.iread(0, self.base_addr + addr, 4)
#print(" reg:%.8X value:%.8X")%((self.base_addr+addr), reg)
return reg
def wr_bit(self, addr, bit, value):
reg = self.rd_reg(addr)
if(0==value):
reg &= ~(1<<bit)
else:
reg |= (1<<bit)
self.wr_reg(addr, reg)
def rd_bit(self, addr, bit):
if(self.rd_reg(addr) & (1<<bit)):
return 1
else:
return 0
#!/usr/bin/python
import sys
import rr
import time
import onewire
class CDS18B20:
# ROM commands
ROM_SEARCH = 0xF0
ROM_READ = 0x33
ROM_MATCH = 0x55
ROM_SKIP = 0xCC
ROM_ALARM_SEARCH = 0xEC
# DS18B20 fonctions commands
CONVERT_TEMP = 0x44
WRITE_SCRATCHPAD = 0x4E
READ_SCRATCHPAD = 0xBE
COPY_SCRATCHPAD = 0x48
RECALL_EEPROM = 0xB8
READ_POWER_SUPPLY = 0xB4
# Thermometer resolution configuration
RES = {'9-bit':0x0, '10-bit':0x1, '11-bit':0x2, '12-bit':0x3}
def __init__(self, onewire, port):
self.onewire = onewire
self.port = port
def read_serial_number(self):
#print('[DS18B20] Reading serial number')
if(1 != self.onewire.reset(self.port)):
print('[DS18B20] No presence pulse detected')
return -1
else:
#print('[DS18B20] Write ROM command %.2X') % self.ROM_READ
err = self.onewire.write_byte(self.port, self.ROM_READ)
if(err != 0):
print('[DS18B20] Write error')
return -1
family_code = self.onewire.read_byte(self.port)
serial_number = 0
for i in range(6):
serial_number |= self.onewire.read_byte(self.port) << (i*8)
crc = self.onewire.read_byte(self.port)
#print('[DS18B20] Family code : %.2X') % family_code
#print('[DS18B20] Serial number: %.12X') % serial_number
#print('[DS18B20] CRC : %.2X') % crc
return ((crc<<56) | (serial_number<<8) | family_code)
def access(self, serial_number):
#print('[DS18B20] Accessing device')
if(1 != self.onewire.reset(self.port)):
print('[DS18B20] No presence pulse detected')
return -1
else:
#print('[DS18B20] Write ROM command %.2X') % self.ROM_MATCH
err = self.onewire.write_byte(self.port, self.ROM_MATCH)
#print serial_number
block = []
for i in range(8):
block.append(serial_number & 0xFF)
serial_number >>= 8
#print block
self.onewire.write_block(self.port, block)
return 0
def read_temp(self, serial_number):
#print('[DS18B20] Reading temperature')
err = self.access(serial_number)
#print('[DS18B20] Write function command %.2X') % self.CONVERT_TEMP
err = self.onewire.write_byte(self.port, self.CONVERT_TEMP)
time.sleep(0.8)
err = self.access(serial_number)
#print('[DS18B20] Write function command %.2X') % self.READ_SCRATCHPAD
err = self.onewire.write_byte(self.port, self.READ_SCRATCHPAD)
data = self.onewire.read_block(self.port, 9)
#for i in range(9):
# print('Scratchpad data[%1d]: %.2X') % (i, data[i])
temp = (data[1] << 8) | (data[0])
if(temp & 0x1000):
temp = -0x10000 + temp
temp = temp/16.0
return temp
# Set temperature thresholds
# Configure thermometer resolution
#!/usr/bin/python
import sys
import rr
import time
import i2c
class C24AA64:
def __init__(self, i2c, i2c_addr):
self.i2c = i2c
self.i2c_addr = i2c_addr
def wr_data(self, mem_addr, data):
if len(data) > 32:
print "Maximum sequence write size is 32 byte!"
return -1;
self.i2c.start(self.i2c_addr, True)
self.i2c.write((mem_addr >> 8), False)
self.i2c.write((mem_addr & 0xFF), False)
#print('24AA64:write: data lenght=%d')%(len(data))
for i in range(len(data)-1):
#print('24AA64:write: i=%d')%(i)
self.i2c.write(data[i],False)
if len(data) > 1:
i += 1
else:
i = 0
#print('24AA64:write:last i=%d')%(i)
self.i2c.write(data[i],True)
return 0;
def rd_data(self, mem_addr, size):
self.i2c.start(self.i2c_addr, True)
self.i2c.write((mem_addr >> 8), False)
self.i2c.write((mem_addr & 0xFF), False)
self.i2c.start(self.i2c_addr, False)
data = []
#print('24AA64:read: data lenght=%d')%(size)
for i in range(size-1):
data.append(self.i2c.read(False))
#print('24AA64:read: i=%d')%(i)
#print('24AA64:read:last i=%d')%(i)
data.append(self.i2c.read(True))
return data;
#!/usr/bin/python
import sys
import rr
import time
import csr
class CGN4124:
# Host registers (BAR12), for DMA items storage
HOST_BAR = 0xC
HOST_DMA_CARRIER_START_ADDR = 0x00
HOST_DMA_HOST_START_ADDR_L = 0x04
HOST_DMA_HOST_START_ADDR_H = 0x08
HOST_DMA_LENGTH = 0x0C
HOST_DMA_NEXT_ITEM_ADDR_L = 0x10
HOST_DMA_NEXT_ITEM_ADDR_H = 0x14
HOST_DMA_ATTRIB = 0x18
# GN4124 chip registers (BAR4)
GN4124_BAR = 0x4
R_PCI_SYS_CFG = 0x800
R_CLK_CSR = 0x808
R_INT_CFG0 = 0x820
R_GPIO_DIR_MODE = 0xA04
R_GPIO_INT_MASK_CLR = 0xA18
R_GPIO_INT_MASK_SET = 0xA1C
R_GPIO_INT_STATUS = 0xA20
R_GPIO_INT_VALUE = 0xA28
CLK_CSR_DIVOT_MASK = 0x3F0
INT_CFG0_GPIO = 15
GPIO_INT_SRC = 8
# GN4124 core registers (BAR0)
R_DMA_CTL = 0x00
R_DMA_STA = 0x04
R_DMA_CARRIER_START_ADDR = 0x08
R_DMA_HOST_START_ADDR_L = 0x0C
R_DMA_HOST_START_ADDR_H = 0x10
R_DMA_LENGTH = 0x14
R_DMA_NEXT_ITEM_ADDR_L = 0x18
R_DMA_NEXT_ITEM_ADDR_H = 0x1C
R_DMA_ATTRIB = 0x20
DMA_CTL_START = 0
DMA_CTL_ABORT = 1
DMA_CTL_SWAP = 2
DMA_STA = ['Idle','Done','Busy','Error','Aborted']
DMA_ATTRIB_LAST = 0
DMA_ATTRIB_DIR = 1
def rd_reg(self, bar, addr):
return self.bus.iread(bar, addr, 4)
def wr_reg(self, bar, addr, value):
self.bus.iwrite(bar, addr, 4, value)
def __init__(self, bus, csr_addr):
self.bus = bus
self.dma_csr = csr.CCSR(bus, csr_addr)
self.dma_item_cnt = 0
# Get page list
self.pages = self.bus.getplist()
# Shift by 12 to get the 32-bit physical addresses
self.pages = [addr << 12 for addr in self.pages]
self.set_interrupt_config()
# Enable interrupt from gn4124
self.bus.irqena()
# Set local bus frequency
def set_local_bus_freq(self, freq):
# freq in MHz
# LCLK = (25MHz*(DIVFB+1))/(DIVOT+1)
# DIVFB = 31
# DIVOT = (800/LCLK)-1
divot = int(round((800/freq)-1,0))
#print '%d' % divot
data = 0xe001f00c + (divot << 4)
#print '%.8X' % data
#print 'Set local bus freq to %dMHz' % int(round(800/(divot+1),0))
self.wr_reg(self.GN4124_BAR, self.R_CLK_CSR, data)
# Get local bus frequency
# return: frequency in MHz
def get_local_bus_freq(self):
reg = self.rd_reg(self.GN4124_BAR, self.R_CLK_CSR)
divot = ((reg & self.CLK_CSR_DIVOT_MASK)>>4)
return (800/(divot + 1))
# Get physical addresses of the pages allocated to GN4124
def get_physical_addr(self):
return self.pages
# Wait for interrupt
def wait_irq(self):
# Add here reading of the interrupt source (once the irq core will be present)
return self.bus.irqwait()
# GN4124 RSTOUT33 assert/de-assert cycle
def rstout33_cycle(self):
# assert RSTOUT33 pin
self.wr_reg(self.GN4124_BAR, self.R_PCI_SYS_CFG, 0x00021040)
# de-assert RSTOUT33 pin
self.wr_reg(self.GN4124_BAR, self.R_PCI_SYS_CFG, 0x00025000)
# GN4124 interrupt configuration
def set_interrupt_config(self):
# Set interrupt line from FPGA (GPIO8) as input
self.wr_reg(self.GN4124_BAR, self.R_GPIO_DIR_MODE, (1<<self.GPIO_INT_SRC))
# Set interrupt mask for all GPIO except for GPIO8
self.wr_reg(self.GN4124_BAR, self.R_GPIO_INT_MASK_SET, ~(1<<self.GPIO_INT_SRC))
# Make sure the interrupt mask is cleared for GPIO8
self.wr_reg(self.GN4124_BAR, self.R_GPIO_INT_MASK_CLR, (1<<self.GPIO_INT_SRC))
# Interrupt on rising edge of GPIO8
self.wr_reg(self.GN4124_BAR, self.R_GPIO_INT_VALUE, (1<<self.GPIO_INT_SRC))
# GPIO as interrupt 0 source
self.wr_reg(self.GN4124_BAR, self.R_INT_CFG0, (1<<self.INT_CFG0_GPIO))
# Get DMA controller status
def get_dma_status(self):
reg = self.dma_csr.rd_reg(self.R_DMA_STA)
if(reg > len(self.DMA_STA)):
print("DMA status register : %.8X") % reg
raise Exception('Invalid DMA status')
else:
return self.DMA_STA[reg]
# Configure DMA byte swapping
# 0 = A1 B2 C3 D4 (straight)
# 1 = B2 A1 D4 C3 (swap bytes in words)
# 2 = C3 D4 A1 B2 (swap words)
# 3 = D4 C3 B2 A1 (invert bytes)
def set_dma_swap(self, swap):
if(swap > 3):
raise Exception('Invalid swapping configuration : %d') % swap
else:
self.dma_csr.wr_reg(self.R_CTL, (swap << self.DMA_CTL_SWAP))
# Add DMA item (first item is on the board, the following in the host memory)
# carrier_addr, host_addr, length and next_item_addr are in bytes
# dma_dir = 1 -> PCIe to carrier
# dma_dir = 0 -> carrier to PCIe
# dma_last = 0 -> last item in the transfer
# dma_last = 1 -> more item in the transfer
# Only supports 32-bit host address
def add_dma_item(self, carrier_addr, host_addr, length, dma_dir, last_item):
if(0 == self.dma_item_cnt):
# write the first DMA item in the carrier
self.dma_csr.wr_reg(self.R_DMA_CARRIER_START_ADDR, carrier_addr)
self.dma_csr.wr_reg(self.R_DMA_HOST_START_ADDR_L, (host_addr & 0xFFFFFFFF))
self.dma_csr.wr_reg(self.R_DMA_HOST_START_ADDR_H, (host_addr >> 32))
self.dma_csr.wr_reg(self.R_DMA_LENGTH, length)
self.dma_csr.wr_reg(self.R_DMA_NEXT_ITEM_ADDR_L, (self.pages[0] & 0xFFFFFFFF))
self.dma_csr.wr_reg(self.R_DMA_NEXT_ITEM_ADDR_H, 0x0)
attrib = (dma_dir << self.DMA_ATTRIB_DIR) + (last_item << self.DMA_ATTRIB_LAST)
self.dma_csr.wr_reg(self.R_DMA_ATTRIB, attrib)
else:
# write nexy DMA item(s) in host memory
# uses page 0 to store DMA items
# current and next item addresses are automatically set
current_item_addr = (self.dma_item_cnt-1)*0x20
next_item_addr = (self.dma_item_cnt)*0x20
self.wr_reg(self.HOST_BAR, self.HOST_DMA_CARRIER_START_ADDR + current_item_addr, carrier_addr)
self.wr_reg(self.HOST_BAR, self.HOST_DMA_HOST_START_ADDR_L + current_item_addr, host_addr)
self.wr_reg(self.HOST_BAR, self.HOST_DMA_HOST_START_ADDR_H + current_item_addr, 0x0)
self.wr_reg(self.HOST_BAR, self.HOST_DMA_LENGTH + current_item_addr, length)
self.wr_reg(self.HOST_BAR, self.HOST_DMA_NEXT_ITEM_ADDR_L + current_item_addr,
self.pages[0] + next_item_addr)
self.wr_reg(self.HOST_BAR, self.HOST_DMA_NEXT_ITEM_ADDR_H + current_item_addr, 0x0)
attrib = (dma_dir << self.DMA_ATTRIB_DIR) + (last_item << self.DMA_ATTRIB_LAST)
self.wr_reg(self.HOST_BAR, self.HOST_DMA_ATTRIB + current_item_addr, attrib)
self.dma_item_cnt += 1
# Start DMA transfer
def start_dma(self):
self.dma_item_cnt = 0
self.dma_csr.wr_bit(self.R_DMA_CTL, self.DMA_CTL_START, 1)
# The following two lines should be removed
# when the GN4124 vhdl core will implement auto clear of start bit
#while(('Idle' == self.get_dma_status()) or
# ('Busy' == self.get_dma_status())):
# pass
self.dma_csr.wr_bit(self.R_DMA_CTL, self.DMA_CTL_START, 0)
# Abort DMA transfer
def abort_dma(self):
self.dma_item_cnt = 0
self.dma_csr.wr_bit(self.R_DMA_CTL, self.DMA_CTL_ABORT, 1)
# The following two lines should be removed
# when the GN4124 vhdl core will implement auto clear of start bit
while('Aborted' != self.get_dma_status()):
pass
self.dma_csr.wr_bit(self.R_DMA_CTL, self.DMA_CTL_ABORT, 0)
# Get memory page
def get_memory_page(self, page_nb):
data = []
for i in range(2**10):
data.append(self.rd_reg(self.HOST_BAR, (page_nb<<12)+(i<<2)))
return data
# Set memory page
def set_memory_page(self, page_nb, pattern):
for i in range(2**10):
self.wr_reg(self.HOST_BAR, (page_nb<<12)+(i<<2), pattern)
#!/usr/bin/python
import sys
import rr
import time
class COpenCoresI2C:
# OpenCores I2C registers description
R_PREL = 0x0
R_PREH = 0x4
R_CTR = 0x8
R_TXR = 0xC
R_RXR = 0xC
R_CR = 0x10
R_SR = 0x10
CTR_EN = (1<<7)
CR_STA = (1<<7)
CR_STO = (1<<6)
CR_RD = (1<<5)
CR_WR = (1<<4)
CR_ACK = (1<<3)
SR_RXACK = (1<<7)
SR_TIP = (1<<1)
def wr_reg(self, addr, val):
self.bus.iwrite(0, self.base_addr + addr, 4, val)
def rd_reg(self,addr):
return self.bus.iread(0, self.base_addr + addr, 4)
# Function called during object creation
# bus = host bus (PCIe, VME, etc...)
# base_addr = I2C core base address
# prescaler = SCK prescaler, prescaler = (Fsys/(5*Fsck))-1
def __init__(self, bus, base_addr, prescaler):
self.bus = bus
self.base_addr = base_addr
self.wr_reg(self.R_CTR, 0)
#print("prescaler: %.4X") % prescaler
self.wr_reg(self.R_PREL, (prescaler & 0xff))
#print("PREL: %.2X") % self.rd_reg(self.R_PREL)
self.wr_reg(self.R_PREH, (prescaler >> 8))
#print("PREH: %.2X") % self.rd_reg(self.R_PREH)
self.wr_reg(self.R_CTR, self.CTR_EN)
#print("CTR: %.2X") % self.rd_reg(self.R_CTR)
if(not(self.rd_reg(self.R_CTR) & self.CTR_EN)):
print "Warning! I2C core is not enabled!"
def wait_busy(self):
while(self.rd_reg(self.R_SR) & self.SR_TIP):
pass
def start(self, addr, write_mode):
#print('i2c:start: addr=%.2X')%addr
addr = addr << 1
#print('i2c:start: addr=%.2X')%addr
if(write_mode == False):
addr = addr | 1
#print('i2c:start: addr=%.2X')%addr
self.wr_reg(self.R_TXR, addr)
#print("R_TXR: %.2X") % self.rd_reg(self.R_TXR)
self.wr_reg(self.R_CR, self.CR_STA | self.CR_WR)
self.wait_busy()
if(self.rd_reg(self.R_SR) & self.SR_RXACK):
raise Exception('No ACK upon address (device 0x%x not connected?)' % addr)
return "nack"
else:
return "ack"
def write(self, data, last):
self.wr_reg(self.R_TXR, data)
cmd = self.CR_WR
if(last):
cmd = cmd | self.CR_STO
self.wr_reg(self.R_CR, cmd)
self.wait_busy()
if(self.rd_reg(self.R_SR) & self.SR_RXACK):
raise Exception('No ACK upon write')
def read(self, last):
cmd = self.CR_RD
if(last):
cmd = cmd | self.CR_STO | self.CR_ACK
self.wr_reg(self.R_CR, cmd)
self.wait_busy()
return self.rd_reg(self.R_RXR)
def scan(self):
periph_addr = []
for i in range(0,128):
addr = i << 1
addr |= 1
self.wr_reg(self.R_TXR, addr)
self.wr_reg(self.R_CR, self.CR_STA | self.CR_WR)
self.wait_busy()
if(not(self.rd_reg(self.R_SR) & self.SR_RXACK)):
periph_addr.append(i)
print("Device found at address: 0x%.2X") % i
self.wr_reg(self.R_TXR, 0)
self.wr_reg(self.R_CR, self.CR_STO | self.CR_WR)
self.wait_busy()
return periph_addr
##########################################
# Usage example
#gennum = rr.Gennum();
#i2c = COpenCoresI2C(gennum, 0x80000, 500);
#!/usr/bin/python
import sys
import rr
import time
import spi
class CLTC217x:
R_RST = 0x00
R_FMT = 0x01
R_OUTMODE = 0x02
R_TESTPAT_MSB = 0x03
R_TESTPAT_LSB = 0x04
RST = (1<<7)
FMT_DCSOFF = (1<<7)
FMT_RAND = (1<<6)
FMT_TWOSCOMP = (1<<5)
FMT_SLEEP = (1<<4)
FMT_CH4_NAP = (1<<3)
FMT_CH3_NAP = (1<<2)
FMT_CH2_NAP = (1<<1)
FMT_CH1_NAP = (1<<0)
OUTMODE_ILVDS_3M5 = (0<<5)
OUTMODE_ILVDS_4M0 = (1<<5)
OUTMODE_ILVDS_4M5 = (2<<5)
OUTMODE_ILVDS_3M0 = (4<<5)
OUTMODE_ILVDS_2M5 = (5<<5)
OUTMODE_ILVDS_2M1 = (6<<5)
OUTMODE_ILVDS_1M75 = (7<<5)
OUTMODE_TERMON = (1<<4)
OUTMODE_OUTOFF = (1<<3)
OUTMODE_2L_16B = (0<<0)
OUTMODE_2L_14B = (1<<0)
OUTMODE_2L_12B = (2<<0)
OUTMODE_1L_14B = (5<<0)
OUTMODE_1L_12B = (6<<0)
OUTMODE_1L_16B = (7<<0)
TESTPAT_MSB_OUTTEST = (1<<7)
TESTPAT_MSB_MASK = 0x3F
TESTPAT_LSB_MASK = 0xFF
# addr = ltc217x register address (1 byte)
# value = value to write to the register (1 byte)
def wr_reg(self, addr, value):
tx = [value, addr]
self.spi.transaction(self.slave, tx)
def rd_reg(self, addr):
tx = [0xFF, (addr | 0x80)]
rx = self.spi.transaction(self.slave, tx)
return (rx[0] & 0xFF)
def __init__(self, spi, slave):
self.spi = spi
self.slave = slave
self.wr_reg(self.R_RST, self.RST)
#self.wr_reg(self.R_FMT, 0)
self.wr_reg(self.R_FMT, self.FMT_TWOSCOMP)
#self.wr_reg(self.R_OUTMODE, (self.OUTMODE_ILVDS_4M5 | self.OUTMODE_2L_16B | self.OUTMODE_TERMON))
#self.wr_reg(self.R_OUTMODE, (self.OUTMODE_ILVDS_2M5 | self.OUTMODE_2L_16B | self.OUTMODE_TERMON))
self.wr_reg(self.R_OUTMODE, (self.OUTMODE_ILVDS_4M5 | self.OUTMODE_2L_16B))
def get_fmt(self):
return self.rd_reg(self.R_FMT)
def get_outmode(self):
return self.rd_reg(self.R_OUTMODE)
def get_testpat(self):
return (((self.rd_reg(self.R_TESTPAT_MSB) & self.TESTPAT_MSB_MASK)<<8)
+ (self.rd_reg(self.R_TESTPAT_LSB) & self.TESTPAT_LSB_MASK))
def get_testpat_stat(self):
return ((self.rd_reg(self.R_TESTPAT_MSB))>>7)
def set_testpat(self, pattern):
self.wr_reg(self.R_TESTPAT_MSB, ((pattern>>8) & self.TESTPAT_MSB_MASK))
self.wr_reg(self.R_TESTPAT_LSB, (pattern & self.TESTPAT_LSB_MASK))
def en_testpat(self):
reg = self.rd_reg(self.R_TESTPAT_MSB)
reg |= self.TESTPAT_MSB_OUTTEST
self.wr_reg(self.R_TESTPAT_MSB, reg)
def dis_testpat(self):
reg = self.rd_reg(self.R_TESTPAT_MSB)
reg &= ~self.TESTPAT_MSB_OUTTEST
self.wr_reg(self.R_TESTPAT_MSB, reg)
def print_regs(self):
print '\nLTC217x registers:'
for i in range(0,5):
print("reg %d: %.2X") % (i, self.rd_reg(i))
#!/usr/bin/python
import sys
import rr
import time
import spi
import csr
class CMAX5442:
def __init__(self, spi, slave):
self.spi = spi
self.slave = slave
# offset = value to write to the DAC (2 bytes)
def set_offset(self, offset):
tx = [(offset & 0xFF), ((offset & 0xFF00)>>8)]
#print('[max5442] Set offset: %.4X') % offset
#for i in range(len(tx)):
# print('[max5442] tx[%d]: %.2X') %(i, tx[i])
self.spi.transaction(self.slave, tx)
#!/usr/bin/python
import sys
import rr
import time
class COpenCoresOneWire:
# OpenCores 1-wire registers description
R_CSR = 0x0
R_CDR = 0x4
CSR_DAT_MSK = (1<<0)
CSR_RST_MSK = (1<<1)
CSR_OVD_MSK = (1<<2)
CSR_CYC_MSK = (1<<3)
CSR_PWR_MSK = (1<<4)
CSR_IRQ_MSK = (1<<6)
CSR_IEN_MSK = (1<<7)
CSR_SEL_OFS = 8
CSR_SEL_MSK = (0xF<<8)
CSR_POWER_OFS = 16
CSR_POWER_MSK = (0xFFFF<<16)
CDR_NOR_MSK = (0xFFFF<<0)
CDR_OVD_OFS = 16
CDR_OVD_MSK = (0XFFFF<<16)
def wr_reg(self, addr, val):
self.bus.iwrite(0, self.base_addr + addr, 4, val)
def rd_reg(self,addr):
return self.bus.iread(0, self.base_addr + addr, 4)
# Function called during object creation
# bus = host bus (PCIe, VME, etc...)
# base_addr = 1-wire core base address
# clk_div_nor = clock divider normal operation, clk_div_nor = Fclk * 5E-6 - 1
# clk_div_ovd = clock divider overdrive operation, clk_div_ovd = Fclk * 1E-6 - 1
def __init__(self, bus, base_addr, clk_div_nor, clk_div_ovd):
self.bus = bus
self.base_addr = base_addr
#print('\n### Onewire class init ###')
#print("Clock divider (normal operation): %.4X") % clk_div_nor
#print("Clock divider (overdrive operation): %.4X") % clk_div_ovd
data = ((clk_div_nor & self.CDR_NOR_MSK) | ((clk_div_ovd<<self.CDR_OVD_OFS) & self.CDR_OVD_MSK))
#print('CRD register wr: %.8X') % data
self.wr_reg(self.R_CDR, data)
#print('CRD register rd: %.8X') % self.rd_reg(self.R_CDR)
# return: 1 -> presence pulse detected
# 0 -> no presence pulse detected
def reset(self, port):
data = ((port<<self.CSR_SEL_OFS) & self.CSR_SEL_MSK) | self.CSR_CYC_MSK | self.CSR_RST_MSK
#print('[onewire] Sending reset command, CSR: %.8X') % data
self.wr_reg(self.R_CSR, data)
while(self.rd_reg(self.R_CSR) & self.CSR_CYC_MSK):
pass
reg = self.rd_reg(self.R_CSR)
#print('[onewire] Reading CSR: %.8X') % reg
return ~reg & self.CSR_DAT_MSK
def slot(self, port, bit):
data = ((port<<self.CSR_SEL_OFS) & self.CSR_SEL_MSK) | self.CSR_CYC_MSK | (bit & self.CSR_DAT_MSK)
self.wr_reg(self.R_CSR, data)
while(self.rd_reg(self.R_CSR) & self.CSR_CYC_MSK):
pass
reg = self.rd_reg(self.R_CSR)
return reg & self.CSR_DAT_MSK
def read_bit(self, port):
return self.slot(port, 0x1)
def write_bit(self, port, bit):
return self.slot(port, bit)
def read_byte(self, port):
data = 0
for i in range(8):
data |= self.read_bit(port) << i
return data
def write_byte(self, port, byte):
data = 0
byte_old = byte
for i in range(8):
data |= self.write_bit(port, (byte & 0x1)) << i
byte >>= 1
if(byte_old == data):
return 0
else:
return -1
def write_block(self, port, block):
if(160 < len(block)):
return -1
data = []
for i in range(len(block)):
data.append(self.write_byte(port, block[i]))
return data
def read_block(self, port, length):
if(160 < length):
return -1
data = []
for i in range(length):
data.append(self.read_byte(port))
return data
#!/usr/bin/python
import sys
import rr
import time
import i2c
class CSi57x:
R_HS = 0x07
R_RFREQ4 = 0x08
R_RFREQ3 = 0x09
R_RFREQ2 = 0x0A
R_RFREQ1 = 0x0B
R_RFREQ0 = 0x0C
R_RFMC = 0x87
R_FDCO = 0x89
HS_DIV_MASK = 0xE0
N1_H_MASK = 0x1F
N1_L_MASK = 0xC0
RFREQ4_MASK = 0x3F
RFMC_RST = (1<<7)
RFMC_NEW_FREQ = (1<<6)
RFMC_FREEZE_M = (1<<5)
RFMC_FREEZE_VCADC = (1<<4)
RFMC_RECALL = (1<<0)
FDCO_FREEZE_DCO = (1<<4)
HS_DIV = [4, 5, 6, 7, 0, 9, 0, 11]
def __init__(self, i2c, addr):
self.i2c = i2c
self.addr = addr
def rd_reg(self, addr):
self.i2c.start(self.addr, True)
self.i2c.write(addr, False)
self.i2c.start(self.addr, False)
reg = self.i2c.read(True)
#print("raw data from Si570: %.2X")%reg
return reg
def wr_reg(self, addr, data):
self.i2c.start(self.addr, True)
self.i2c.write(addr, False)
self.i2c.write(data, True)
def get_rfreq(self):
rfreq = self.rd_reg(self.R_RFREQ0)
rfreq += (self.rd_reg(self.R_RFREQ1)<<8)
rfreq += (self.rd_reg(self.R_RFREQ2)<<16)
rfreq += (self.rd_reg(self.R_RFREQ3)<<24)
rfreq += ((self.rd_reg(self.R_RFREQ4) & self.RFREQ4_MASK)<<32)
return (rfreq>>28)+((rfreq & 0x0FFFFFFF)/2.0**28)
def get_n1_div(self):
n1 = ((self.rd_reg(self.R_RFREQ4) & self.N1_L_MASK)>>6)
n1 += ((self.rd_reg(self.R_HS) & self.N1_H_MASK)<<2)
return n1+1
def get_hs_div(self):
return self.HS_DIV[((self.rd_reg(self.R_HS))>>5)]
def set_rfreq(self, freq):
self.wr_reg(self.R_RFERQ0, (freq & 0xFF))
self.wr_reg(self.R_RFERQ1, ((freq>>8) & 0xFF))
self.wr_reg(self.R_RFERQ2, ((freq>>16) & 0xFF))
self.wr_reg(self.R_RFERQ3, ((freq>>24) & 0xFF))
reg = self.rd_reg(self.R_RFERQ4)
self.wr_reg(self.R_RFERQ4, (((freq>>32) & self.RFREQ4_MASK) | (reg & self.N1_L_MASK)))
def set_hs_div(self, div):
reg = self.rd_reg(self.R_HS)
self.wr_reg(self.R_HS, ((div<<5) | (reg & self.N1_H_MASK)))
def set_n1_div(self, div):
reg = self.rd_reg(self.R_HS)
self.wr_reg(self.R_HS, ((div>>2) | (reg & self.HS_DIV_MASK)))
reg = self.rd_reg(self.R_RFREQ4)
self.wr_reg(self.R_RFREQ4, (((div & self.N1_L_MASK)<<6) | (reg & self.RFREQ4_MASK)))
def freeze_m(self):
reg = self.rd_reg(self.R_RFMC) | self.RFMC_FREEZE_M
self.wr_reg(self.R_RFMC, reg)
def unfreeze_m(self):
reg = self.rd_reg(self.R_RFMC) & ~(self.RFMC_FREEZE_M)
self.wr_reg(self.R_RFMC, reg)
def freeze_dco(self):
self.wr_reg(self.R_RDCO, self.FDCO_FREEZE_DCO)
def unfreeze_dco(self):
self.wr_reg(self.R_RDCO, 0)
def reset_reg(self):
reg = self.rd_reg(self.R_RFMC) | self.RFMC_RST
self.wr_reg(self.R_RFMC, reg)
def recall_nvm(self):
reg = self.rd_reg(self.R_RFMC) | self.RFMC_RECALL
self.wr_reg(self.R_RFMC, reg)
def get_raw_config(self):
config = []
config.append(self.rd_reg(self.R_HS))
config.append(self.rd_reg(self.R_RFREQ4))
config.append(self.rd_reg(self.R_RFREQ3))
config.append(self.rd_reg(self.R_RFREQ2))
config.append(self.rd_reg(self.R_RFREQ1))
config.append(self.rd_reg(self.R_RFREQ0))
return config
# For Si571 only !
def freeze_vcadc(self):
reg = self.rd_reg(self.R_RFMC) | self.RFMC_FREEZE_VCADC
self.wr_reg(self.R_RFMC, reg)
def unfreeze_vcadc(self):
reg = self.rd_reg(self.R_RFMC) & ~(self.RFMC_FREEZE_VCADC)
self.wr_reg(self.R_RFMC, reg)
#!/usr/bin/python
import sys
import rr
import time
class COpenCoresSPI:
R_RX = [0x00, 0x04, 0x08, 0x0C]
R_TX = [0x00, 0x04, 0x08, 0x0C]
R_CTRL = 0x10
R_DIV = 0x14
R_SS = 0x18
LGH_MASK = (0x7F)
CTRL_GO = (1<<8)
CTRL_BSY = (1<<8)
CTRL_RXNEG = (1<<9)
CTRL_TXNEG = (1<<10)
CTRL_LSB = (1<<11)
CTRL_IE = (1<<12)
CTRL_ASS = (1<<13)
DIV_MASK = (0xFFFF)
SS_SEL = [0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40]
conf = 0x0
def wr_reg(self, addr, val):
self.bus.iwrite(0, self.base_addr + addr, 4, val)
def rd_reg(self, addr):
return self.bus.iread(0, self.base_addr + addr, 4)
def __init__(self, bus, base_addr, divider):
self.bus = bus;
self.base_addr = base_addr;
self.wr_reg(self.R_DIV, (divider & self.DIV_MASK));
# default configuration
self.conf = self.CTRL_ASS | self.CTRL_TXNEG
def wait_busy(self):
while(self.rd_reg(self.R_CTRL) & self.CTRL_BSY):
pass
def config(self, ass, rx_neg, tx_neg, lsb, ie):
self.conf = 0
if(ass):
self.conf |= self.CTRL_ASS
if(tx_neg):
self.conf |= self.CTRL_TXNEG
if(rx_neg):
self.conf |= self.CTRL_RXNEG
if(lsb):
self.conf |= self.CTRL_LSB
if(ie):
self.conf |= self.CTRL_IE
# slave = slave number (0 to 7)
# data = byte data array to send, in case if read fill with dummy data of the right size
def transaction(self, slave, data):
txrx = [0x00000000, 0x00000000, 0x00000000, 0x00000000]
for i in range(0,len(data)):
txrx[i/4] += (data[i]<<((i%4)*8))
#print("tx[%d]=%.8X data[%d]=%.2X") %(i/4,txrx[i/4],i,data[i])
for i in range(0, len(txrx)):
self.wr_reg(self.R_TX[i], txrx[i])
#print('data length: 0x%X')%len(data)
self.wr_reg(self.R_SS, self.SS_SEL[slave])
self.wr_reg(self.R_CTRL, (self.LGH_MASK & (len(data)<<3)) | self.CTRL_GO | self.conf)
self.wait_busy()
for i in range(0, len(txrx)):
txrx[i] = self.rd_reg(self.R_RX[i])
#print("rx[%d]=%.8X") %(i,txrx[i])
return txrx
#gennum = rr.Gennum();
#spi = COpenCoresSPI(gennum, 0x80000, 500);
obj-m = cp210x.o
KVERSION = $(shell uname -r)
all:
make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules
clean:
make -C /lib/modules/$(KVERSION)/build M=$(PWD) clean
install:
cp cp210x.ko /lib/modules/$(KVERSION)/kernel/drivers/usb/serial/
This diff is collapsed.
#! /usr/bin/env python
# coding: utf8
class PtsException(Exception):
pass
class PtsCritical(PtsException):
"""critical error, abort the whole test suite"""
pass
class PtsError(PtsException):
"""error, continue remaining tests in test suite"""
pass
class PtsUser(PtsException):
"""error, user intervention required"""
pass
class PtsWarning(PtsException):
"""warning, a cautionary message should be displayed"""
pass
class PtsInvalid(PtsException):
"""reserved: invalid parameters"""
class PtsNoBatch(PtsInvalid):
"""reserved: a suite was created without batch of tests to run"""
pass
class PtsBadTestNo(PtsInvalid):
"""reserved: a bad test number was given"""
pass
if __name__ == '__main__':
pass
......@@ -24,15 +24,19 @@ $PATH"
rm /tmp/data.bin
# echo "1"
echo 1 > /sys/bus/zio/devices/adc-100m14b-0200/cset0/trigger/sw-trg-enable
tmp=`printf "%02x00" $3`
adcpath="/sys/bus/zio/devices/adc-100m14b-$tmp/"
echo 1 > "${adcpath}/cset0/trigger/sw-trg-enable"
# echo 1 > /sys/bus/zio/devices/adc-100m14b-0200/cset0/trigger/sw-trg-enable
# echo "2"
sleep 1
# echo "3"
fald-acq -b 0 -a $1 -r $2 -B /tmp/data.bin 0x0200 &
fald-acq -b 0 -a $1 -r $2 -B /tmp/data.bin "0x${tmp}" &
# echo "4"
sleep 2
# echo "5"
echo 1 > /sys/bus/zio/devices/adc-100m14b-0200/cset0/trigger/sw-trg-fire
echo 1 > "${adcpath}/cset0/trigger/sw-trg-fire"
# echo 1 > /sys/bus/zio/devices/adc-100m14b-0200/cset0/trigger/sw-trg-fire
# echo "6"
wait
# echo "7"
......
import commands
def spec_identification():
dutnr = commands.getoutput("ls /sys/bus/fmc/devices/ | grep -iv adc | grep -v 100. | grep -e '.*-[0-9][0-9][0-9][0-9]$' | wc -w ")
if int( dutnr ) == 1:
dutbus_string=commands.getoutput("ls /sys/bus/fmc/devices/ | grep -iv adc | grep -v 100. | grep -e '.*-[0-9][0-9][0-9][0-9]$' | sed 's/.*-//'")
dutbus = int(dutbus_string[1:2],16)
else:
dutbus = -1;
adcnr=commands.getoutput("ls /sys/bus/fmc/devices/ | grep -i adc | grep 100. | grep -e '.*-[0-9][0-9][0-9][0-9]$' | wc -w")
if int( adcnr ) == 1:
adcbus_string=commands.getoutput("ls /sys/bus/fmc/devices/ | grep -i adc | grep 100. | grep -e '.*-[0-9][0-9][0-9][0-9]$' | sed 's/.*-//'")
adcbus = int(adcbus_string[1:2],16)
else:
adcbus = -1;
return [ dutbus, adcbus ]
def dut_bus():
print spec_identification()[0]
def adc_bus():
print spec_identification()[1]
\ No newline at end of file
......@@ -17,6 +17,15 @@ from ptsexcept import *
from utilFunctions import *
import calibr_box
import find_usb_tty
import calibration_box_connections
from spec_identification import *
# Quick test designed to ensure that communication with carrier is possible
"""
......@@ -31,7 +40,7 @@ test00:
UIDEL = 1;
FIRMWARE_PATH = '/../gateware/syn/spec_top.bin'
INPUT_TIMEOUT = 20;
AUTOMATION = True
def test_sdbid(dut):
......@@ -89,8 +98,31 @@ def verify_fmc_present(dut):
def main (card=None, default_directory='.',suite=None):
specid = spec_identification()[0];
if specid < 0 :
raise PtsCritical("Bus number of FmcDac600m12b1chadds was not found")
if AUTOMATION:
BOX_USB_VENDOR_ID = 0x10c4 # Cygnal Integrated Products, Inc.
BOX_USB_DEVICE_ID = 0xea60 # CP210x Composite Device
print("Looking for calibration box")
box_tty = find_usb_tty.CttyUSB().find_usb_tty(BOX_USB_VENDOR_ID, BOX_USB_DEVICE_ID)
if len( box_tty ) < 1:
raise PtsCritical( "Can't find calibration box. Make sure that it is connected, and that CP210x driver was correctly mounted");
# print("Calibration Box device: %s" % box_tty[0])
box = calibr_box.CCalibr_box(box_tty[0])
box.select_trigger_loopback(0)
box.select_output(calibration_box_connections.connections['ref_clk'])
else:
box = 0;
carrier=spec( FIRMWARE_PATH, 1, True );
carrier=spec( FIRMWARE_PATH, specid, True );
# Verification whether communication with SPEC is possible and if firmware is correct
# SDB magic number verification
......
......@@ -15,10 +15,15 @@ import time
from fmcdds import *
from spec import *
from ad9516 import *
from ptsexcept import PtsCritical
from ptsexcept import *
from utilFunctions import *
import calibr_box
import find_usb_tty
import calibration_box_connections
from spec_identification import *
"""
test01:
......@@ -36,6 +41,8 @@ test01:
LATER: check DAC CLK
"""
AUTOMATION = True
OSC_TUNNING_THD = 1e-6
FIRMWARE_PATH = '/../gateware/syn/spec_top.bin'
INPUT_TIMEOUT = 5;
......@@ -120,15 +127,15 @@ def ad9516_test_ld(carrier ):
device.write_reg( 0x232, 1);
time.sleep(0.5)
if( device.gpio_get(device.LD) == 0 ):
raise PtsCritical("FPGA did not didn\'t read correct value of AD9516 LD pin. This might be caused by interrupted trace.")
raise PtsError("FPGA did not didn\'t read correct value of AD9516 LD pin. This might be caused by interrupted trace.")
# redirector.InOut()
print >> sys.__stdout__, "Please check if PLL LED on FmcDac600m12b1chaDDS is ON."
print >> sys.__stdout__, "Please check if PLL LED on FmcDac600m12b1chaDDS is ON and type [y/n]."
# redirector.InOut()
tmp = yesnoquestion( "Please check if PLL LED on FmcDac600m12b1chaDDS is ON.", INPUT_TIMEOUT )
tmp = yesnoquestion( "Please check if PLL LED on FmcDac600m12b1chaDDS is ON and type [y/n].", INPUT_TIMEOUT )
if ( tmp == 0 ):
raise PtsError("User verification of PLL LED on FmcDac600m12b1chaDDS failed. LED didn\'t turn on.")
......@@ -142,12 +149,12 @@ def ad9516_test_ld(carrier ):
device.write_reg( 0x232, 1);
time.sleep(0.5)
if( device.gpio_get(device.LD) != 0 ):
raise PtsCritical("FPGA did not correct value of AD9516 LD pin. This might be caused by interrupted trace.")
raise PtsError("FPGA did not correct value of AD9516 LD pin. This might be caused by interrupted trace.")
# redirector.InOut()
print >> sys.__stdout__, "Please check if PLL LED on FmcDac600m12b1chaDDS is OFF."
print >> sys.__stdout__, "Please check if PLL LED on FmcDac600m12b1chaDDS is OFF and type [y/n]."
# redirector.InOut()
tmp = yesnoquestion( "Please check if PLL LED on FmcDac600m12b1chaDDS is OFF.", INPUT_TIMEOUT )
tmp = yesnoquestion( "Please check if PLL LED on FmcDac600m12b1chaDDS is OFF and type [y/n].", INPUT_TIMEOUT )
if ( tmp == 0 ):
raise PtsError("User verification of PLL LED on FmcDac600m12b1chaDDS failed. LED didn\'t turn off.")
......@@ -167,14 +174,38 @@ def ad9516_test_reset(carrier):
dev.gpio_set( dev.RESET_N, 0 )
if( (carrier.readl( DDS_REG_FPGACTRL ) & DDS_FPGACTRL_MAINPLL() ) != 0 ):
raise PtsCritical("AD9516 didn\'t reset after receive reset signal. This line might be corrupted.")
raise PtsError("AD9516 didn\'t reset after receive reset signal. This line might be corrupted.")
print "AD9516 reset line tests succeeded"
def main (card=None, default_directory='.',suite=None):
carrier=spec( FIRMWARE_PATH, 1, True );
if AUTOMATION:
BOX_USB_VENDOR_ID = 0x10c4 # Cygnal Integrated Products, Inc.
BOX_USB_DEVICE_ID = 0xea60 # CP210x Composite Device
print("Looking for calibration box")
box_tty = find_usb_tty.CttyUSB().find_usb_tty(BOX_USB_VENDOR_ID, BOX_USB_DEVICE_ID)
if len( box_tty ) < 1:
raise PtsCritical( "Can't find calibration box. Make sure that it is connected, and that CP210x driver was correctly mounted");
# print("Calibration Box device: %s" % box_tty[0])
box = calibr_box.CCalibr_box(box_tty[0])
box.select_trigger_loopback(0)
box.select_output(calibration_box_connections.connections['ref_clk'])
else:
box = 0;
specid = spec_identification()[0];
if specid < 0 :
raise PtsCritical("Bus number of FmcDac600m12b1chadds was not found")
carrier=spec( FIRMWARE_PATH, specid, True );
# verifies
# SPI communication with the device
......
......@@ -33,27 +33,71 @@ from pylab import *
from spec import *
from ad9516 import *
from dac import *
from ptsexcept import PtsCritical
from ptsexcept import *
import calibr_box
import find_usb_tty
import calibration_box_connections
from spec_identification import *
"""
test01:
DAC tests
"""
AUTOMATION = True
FIRMWARE_PATH = '/../gateware/syn/spec_top.bin'
WORK_PATH='/test/fmcdac600m12b1chadds/python/'
# WORK_PATH='/./'
LOG_PATH = 'log_fmcdac600m12b1chadds/tmp'
DEBUG = False
card=None
default_directory='.'
suite=None
delay = 0;
carrier=spec( FIRMWARE_PATH, 1, True );
if AUTOMATION:
BOX_USB_VENDOR_ID = 0x10c4 # Cygnal Integrated Products, Inc.
BOX_USB_DEVICE_ID = 0xea60 # CP210x Composite Device
print("Looking for calibration box")
box_tty = find_usb_tty.CttyUSB().find_usb_tty(BOX_USB_VENDOR_ID, BOX_USB_DEVICE_ID)
if len( box_tty ) < 1:
raise PtsCritical( "Can't find calibration box. Make sure that it is connected, and that CP210x driver was correctly mounted");
# print("Calibration Box device: %s" % box_tty[0])
box = calibr_box.CCalibr_box(box_tty[0])
box.select_trigger_loopback(0)
box.select_output(calibration_box_connections.connections['ref_clk'])
else:
box = 0;
specid = spec_identification()[0];
if specid < 0 :
raise PtsCritical("Bus number of FmcDac600m12b1chadds was not found")
adcid = spec_identification()[1];
if adcid < 0 :
raise PtsCritical("Bus number of FmcAdc100m14b was not found")
carrier=spec( FIRMWARE_PATH, specid, True );
sys_pll = ad9516(carrier);
......@@ -74,8 +118,10 @@ def measure_spectrum(bit_amp,urange,f, logname):
time.sleep(2.0)
curr = os.getcwd()
os.system(curr+WORK_PATH+"acq.sh "+str(n_samples*n_repeat)+" "+urange + " 2>>" + logname + " 1>/dev/null")
# os.system(curr+WORK_PATH+"acq.sh "+str(n_samples*n_repeat)+" "+urange + "")
if DEBUG:
os.system(curr+WORK_PATH+"acq.sh "+str(n_samples*n_repeat)+" "+urange + " " + str( adcid ) +"")
else:
os.system(curr+WORK_PATH+"acq.sh "+str(n_samples*n_repeat)+" "+urange + " " + str( adcid ) +" 2>>" + logname + " 1>/dev/null")
#
......@@ -119,6 +165,12 @@ def test_proc(fm, logname ):
w_sig_bk=measure_spectrum(i, urange,fm, logname)
w_sig=w_sig_bk-w_bkgr
if gen_figs:
plot(w_bkgr)
title("background: bit value=%d frequency=%g" % (i, fm))
grid()
savefig("spectrum_bg_u%i_f_%g.png" % (i, fm))
show()
clf()
plot(w_sig_bk)
title("s+b: bit value=%d frequency=%g" % (i, fm))
grid()
......@@ -139,16 +191,15 @@ def test_proc(fm, logname ):
s_pow=sum(w_sig[(n_pos-2):(n_pos+3)])/5
#Check if the signal is visible
if s_pow/m_pow < 5:
raise PtsCritical("DAC: bit nr %d does not generate output signal, P/Pt=%g", (b, s_pow/m_pow))
# print "DAC: bit nr %d does not generate output signal, P/Pt=%g" % (b, s_pow/m_pow)
raise PtsError("DAC: bit nr %d does not generate output signal, P/Pt=%g", (b, s_pow/m_pow))
# print "DAC: bit nr %d does not generate output signal, P/Pt=%g" % (b, s_pow/m_pow)
#If this is not bit number 0, check if power increased ba ca.4 (in fact between 2 and 8)
#comparing to the signal generated by the previous bit
if b > 0:
r_pow = s_pow / old_s_pow
if (r_pow < 2) or (r_pow > 8):
raise PtsCritical("DAC: incorrect increase of power when switching from bit nr %d to bit nr %d : %g (expected between 2 and 8)" %
(b-1, b, r_pow))
# print "DAC: incorrect increase of power when switching from bit nr %d to bit nr %d : %g (expected between 2 and 8)" % (b-1, b, r_pow)
raise PtsError("DAC: incorrect increase of power when switching from bit nr %d to bit nr %d : %g (expected between 2 and 8)" % (b-1, b, r_pow))
# print "DAC: incorrect increase of power when switching from bit nr %d to bit nr %d : %g (expected between 2 and 8)" % (b-1, b, r_pow)
old_s_pow = s_pow
results.append([i,s_pow, m_pow])
......@@ -168,6 +219,8 @@ def main (card=None, logname=None, default_directory='.',suite=None):
# print >> __stdout__, "Connect direct DAC output to ADC input 0 and confirm with enter key"
# raw_input("")
if logname == None :
# os.system( default_directory + "log_fmcdac600m")
logname = '../../../log_fmcdac600m12b1chadds/tmp'
......
......@@ -12,19 +12,21 @@ import os
import csr
import time
import calibr_box
import find_usb_tty
from spec import *
from ad9516 import *
from ad9510 import *
from dac import *
from ptsexcept import PtsCritical
from ptsexcept import *
from sys import __stdout__
import calibr_box
import find_usb_tty
import calibration_box_connections
from spec_identification import *
"""
test03:
AD9510 tests
......@@ -36,14 +38,7 @@ test03:
REF OUT (connector output of DAC)
STATUS
REF_IN
TODO:
CLK_PD - output same clk to PD and FPGA
- in FPGA output received clk do dac
- this should give the same clk freq
- it should be able to phase shift one of clocks in ext pll
- phase shift should be readable in adc
CLK
CLK_PD
"""
......@@ -53,7 +48,7 @@ test03:
FIRMWARE_PATH = '/../gateware/syn/spec_top.bin'
AUTOMATION = True
TEST_RAW_DAC = False
TEST_RAW_DAC = True
def spi_test(dut):
......@@ -66,7 +61,7 @@ def spi_test(dut):
read = dut.read_reg(0x49);
if written != read:
raise PtsCritical("AD9510: SPI communication FAILED on 0xFF")
raise PtsError("AD9510: SPI communication FAILED on 0xFF")
time.sleep(0.001)
......@@ -75,7 +70,7 @@ def spi_test(dut):
read = dut.read_reg(0x49);
if written != read:
raise PtsCritical("AD9510: SPI communication FAILED on 0x00")
raise PtsError("AD9510: SPI communication FAILED on 0x00")
time.sleep(0.001)
......@@ -84,7 +79,7 @@ def spi_test(dut):
read = dut.read_reg(0x49);
if written != read:
raise PtsCritical("AD9510: SPI communication FAILED on 0xAA")
raise PtsError("AD9510: SPI communication FAILED on 0xAA")
time.sleep(0.001)
......@@ -93,7 +88,7 @@ def spi_test(dut):
read = dut.read_reg(0x49);
if written != read:
raise PtsCritical("AD9510: SPI communication FAILED on 0x55")
raise PtsError("AD9510: SPI communication FAILED on 0x55")
print "AD9510: SPI test succeeded"
......@@ -108,7 +103,7 @@ def test_function_line( dut ):
# SPI should fail if Function line (reset_n) is connected
try:
spi_test(dut);
except PtsCritical:
except PtsError:
print "AD9510: Function line was verified"
# disable reset
......@@ -165,7 +160,7 @@ def test_ld_line(dut):
# It only matters if reference doesn't show up or fade in meantime
# DAC output is REF input for PLL and it didn't change
if low == high:
raise PtsCritical("AD9510: STATUS line test failed. This line might be corrupted")
raise PtsError("AD9510: STATUS line test failed. This line might be corrupted")
else:
print "AD9510: STATUS line verification succeeded"
......@@ -193,7 +188,7 @@ def test_refclk_presense(dut):
if result == 0:
raise PtsCritical("AD9510: REFIN not detected. Connection between DAC and VXCO_PLL might be corrupted.")
raise PtsError("AD9510: REFIN not detected. Connection between DAC and VXCO_PLL might be corrupted.")
else:
print "AD9510: REFIN line verification succeeded"
......@@ -273,7 +268,7 @@ def test_rf_in(carrier, pll,dacinst, box):
# measure frequency in fpga
if test_clk2(carrier, 10e6, 1e6) > 0:
raise PtsCritical("RF IN input might be corrupted")
raise PtsError("RF IN input might be corrupted")
def test_ref_out(carrier, pll,dacinst, box):
......@@ -328,7 +323,7 @@ def test_ref_out(carrier, pll,dacinst, box):
# measure frequency in FPGA
if test_clk2(carrier, 10e6, 1e6) > 0:
raise PtsCritical("RF IN input might be corrupted")
raise PtsError("RF IN input might be corrupted")
def test_beam_out(carrier, pll,dacinst, box):
......@@ -376,14 +371,37 @@ def test_beam_out(carrier, pll,dacinst, box):
# measure frequency in FPGA
# BEAM should be 500MHz
if test_clk2(carrier, 50e6, 10e6) > 0:
raise PtsCritical("RF IN input might be corrupted")
raise PtsError("RF IN input might be corrupted")
def main (card=None, default_directory='.',suite=None):
if AUTOMATION:
BOX_USB_VENDOR_ID = 0x10c4 # Cygnal Integrated Products, Inc.
BOX_USB_DEVICE_ID = 0xea60 # CP210x Composite Device
print("Looking for calibration box")
box_tty = find_usb_tty.CttyUSB().find_usb_tty(BOX_USB_VENDOR_ID, BOX_USB_DEVICE_ID)
if len( box_tty ) < 1:
raise PtsCritical( "Can't find calibration box. Make sure that it is connected, and that CP210x driver was correctly mounted");
# print("Calibration Box device: %s" % box_tty[0])
box = calibr_box.CCalibr_box(box_tty[0])
box.select_trigger_loopback(0)
box.select_output(calibration_box_connections.connections['ref_clk'])
else:
box = 0;
carrier=spec( FIRMWARE_PATH, 1, True );
specid = spec_identification()[0];
if specid < 0 :
raise PtsCritical("Bus number of FmcDac600m12b1chadds was not found")
carrier=spec( FIRMWARE_PATH, specid, True );
sys_pll = ad9516(carrier);
# default configuration
......@@ -401,17 +419,6 @@ def main (card=None, default_directory='.',suite=None):
vcxo_pll = ad9510(carrier, 1);
if AUTOMATION:
BOX_USB_VENDOR_ID = 0x10c4 # Cygnal Integrated Products, Inc.
BOX_USB_DEVICE_ID = 0xea60 # CP210x Composite Device
box_tty = find_usb_tty.CttyUSB().find_usb_tty(BOX_USB_VENDOR_ID, BOX_USB_DEVICE_ID)
# print("Calibration Box device: %s" % box_tty[0])
box = calibr_box.CCalibr_box(box_tty[0])
box.select_trigger_loopback(0)
else:
box = 0;
# check status line
test_ld_line(vcxo_pll);
......@@ -425,7 +432,7 @@ def main (card=None, default_directory='.',suite=None):
print "Testing CLK2 line with 50 MHz frequency clock"
# validate CLK2 lines to FPGA
if test_clk2(carrier, 50e6, 5e6) > 0:
raise PtsCritical("ad9510: CLK2 clock lines might be corrupted")
raise PtsError("ad9510: CLK2 clock lines might be corrupted")
if TEST_RAW_DAC:
# validate RF IN input connector
......
......@@ -17,11 +17,20 @@ from ad9516 import *
from ad9510 import *
from adf4002 import *
from dac import *
from ptsexcept import PtsCritical
from ptsexcept import *
import matplotlib.pyplot as plt
import pylab
import numpy
import calibr_box
import find_usb_tty
import calibration_box_connections
from spec_identification import *
"""
test04:
communication + LockDetect lines
......@@ -30,7 +39,7 @@ test04:
"""
AUTOMATION = True
FIRMWARE_PATH = '/../gateware/syn/spec_top.bin'
......@@ -47,7 +56,7 @@ def test_muxout_spi(dev, carrier):
# verify
if tmp == 0:
raise PtsCritical("ADF4002: Lock Detect line didn't go high. Communication lines or LD line might be corrupted.")
raise PtsError("ADF4002: Lock Detect line didn't go high. Communication lines or LD line might be corrupted.")
# force GND on muxout
......@@ -59,7 +68,7 @@ def test_muxout_spi(dev, carrier):
# verify
if tmp > 0:
raise PtsCritical("ADF4002: Lock Detect line didn't go low. Communication lines or LD line might be corrupted.")
raise PtsError("ADF4002: Lock Detect line didn't go low. Communication lines or LD line might be corrupted.")
def test_pd_inputs(dev,carrier, vcxo_pll, input):
......@@ -89,7 +98,7 @@ def test_pd_inputs(dev,carrier, vcxo_pll, input):
if( vcxo_pll.gpio_get(vcxo_pll.PIN_STATUS) ):
print "VCXO PLL locked on ref (DAC) clock"
else:
print "VCXO PLL is not locked on ref clock. Can't continue test PD input tests"
raise PtsError("VCXO PLL is not locked on ref clock. Can't continue test PD input tests")
return 1
mean = 0
......@@ -99,9 +108,9 @@ def test_pd_inputs(dev,carrier, vcxo_pll, input):
mean /= 10
# print "mean: %d" % mean
print "Measured signal frequency: %d" % mean
if abs( mean - CENTER ) > MAXDIFF :
raise PtsCritical("ADF4002: %s signal not detected. This line might be corrupted." % input_str )
raise PtsError("ADF4002: %s signal not detected. This line might be corrupted." % input_str )
else:
print "ADF4002: %s signal detected." % input_str
......@@ -115,7 +124,7 @@ def resync(vcxo_pll):
def test_cp(dev,carrier, vcxo_pll ):
VAR_OF_MEAN_THD = 1e3;
MEAN_OF_VAR_THD = 300;
MEAN_OF_VAR_THD = 400;
nsamples = 1e4;
nr = 10;
......@@ -128,7 +137,7 @@ def test_cp(dev,carrier, vcxo_pll ):
if( vcxo_pll.gpio_get(vcxo_pll.PIN_STATUS) ):
print "VCXO PLL locked on ref (DAC) clock"
else:
print "VCXO PLL is not locked on ref clock. Can't continue Charge Pump and ADC test"
raise PtsError("VCXO PLL is not locked on ref clock. Can't continue Charge Pump and ADC test")
return
......@@ -146,7 +155,7 @@ def test_cp(dev,carrier, vcxo_pll ):
if ( numpy.mean(std_arr) > MEAN_OF_VAR_THD ):
print "Big variance on Phase Detector output was measured. This might be caused by corrupted PD or ADC"
raise PtsError("Measured variance ( %s ) on Phase Detector output was bigger then threshold ( %s ). This might be caused by corrupted PD or ADC" % ( str( numpy.mean(std_arr) ), str( MEAN_OF_VAR_THD ) ))
# to ensure that ADC doesn't measure noise i will change phase shift
......@@ -156,7 +165,7 @@ def test_cp(dev,carrier, vcxo_pll ):
if( vcxo_pll.gpio_get(vcxo_pll.PIN_STATUS) ):
print "VCXO PLL locked on ref (DAC) clock"
else:
print "VCXO PLL is not locked on ref clock. Can't continue Charge Pump and ADC test"
raise PtsError("VCXO PLL is not locked on ref clock. Can't continue Charge Pump and ADC test")
mean_arr=[];
std_arr=[];
......@@ -170,14 +179,14 @@ def test_cp(dev,carrier, vcxo_pll ):
# change phase shift
resync(vcxo_pll)
# print "variancja srednich " + str( numpy.std(mean_arr) )
# print "srednia variancji " + str( numpy.mean(std_arr) )
print "Variance of mean values " + str( numpy.std(mean_arr) ) + " threshold is set to: " + str( VAR_OF_MEAN_THD )
print "Mean variance: " + str( numpy.mean(std_arr) ) + " threshold is set to: " + str( MEAN_OF_VAR_THD )
if ( numpy.std(mean_arr) < VAR_OF_MEAN_THD ):
print "Resynchronization of VCXO PLL didn't cause significant Phase Detector output change. This might be caused by corrupted PD or ADC"
raise PtsError("Resynchronization of VCXO PLL didn't cause significant Phase Detector output change. This might be caused by corrupted PD or ADC")
if ( numpy.mean(std_arr) > MEAN_OF_VAR_THD ):
print "Big variance on Phase Detector output was measured during resynchronizations. This might be caused by corrupted PD or ADC"
raise PtsError("Measured variance ( %s ) on Phase Detector output was bigger then threshold ( %s ). This might be caused by corrupted PD or ADC" % [ str( numpy.mean(std_arr) ), str( MEAN_OF_VAR_THD ) ])
def get_adc(carrier, nr = 1e4):
......@@ -209,8 +218,32 @@ def get_adc(carrier, nr = 1e4):
def main (card=None, default_directory='.',suite=None):
if AUTOMATION:
BOX_USB_VENDOR_ID = 0x10c4 # Cygnal Integrated Products, Inc.
BOX_USB_DEVICE_ID = 0xea60 # CP210x Composite Device
print("Looking for calibration box")
box_tty = find_usb_tty.CttyUSB().find_usb_tty(BOX_USB_VENDOR_ID, BOX_USB_DEVICE_ID)
if len( box_tty ) < 1:
raise PtsCritical( "Can't find calibration box. Make sure that it is connected, and that CP210x driver was correctly mounted");
# print("Calibration Box device: %s" % box_tty[0])
box = calibr_box.CCalibr_box(box_tty[0])
box.select_trigger_loopback(0)
box.select_output(calibration_box_connections.connections['ref_clk'])
else:
box = 0;
specid = spec_identification()[0];
if specid < 0 :
raise PtsCritical("Bus number of FmcDac600m12b1chadds was not found")
# init spec
carrier=spec( FIRMWARE_PATH, 1, True );
carrier=spec( FIRMWARE_PATH, specid, True );
#configure main clock source
sys_pll = ad9516(carrier);
......
......@@ -20,31 +20,34 @@ from spec import *
from ad9516 import *
from ad9510 import *
from dac import *
from ptsexcept import PtsCritical
from ptsexcept import *
from sys import __stdout__
import calibration_box_connections
from Canvas import Line
import calibr_box
import find_usb_tty
import calibration_box_connections
from spec_identification import *
"""
test03:
AD9510 tests
SPI check
Function (SYNCB) line
CLK2OUT
CLK_VCXO (Beam out)
RF_IN
REF OUT (connector output of DAC)
STATUS
REF_IN
TODO:
CLK_PD - output same clk to PD and FPGA
- in FPGA output received clk do dac
- this should give the same clk freq
- it should be able to phase shift one of clocks in ext pll
- phase shift should be readable in adc
CLK
test05:
Delay line test
125 Mhz (8ns) clock (CLK1) is outputed from FPGA through Delay line
Delay line is connected with Pulse Output (set to input mode) with lemo-lemo cable
Delayed clock (CLK2) is probed with CLK1
Since both clocks have the same frequency, probed signal should be constant '0' or '1'
For some delay values both clocks edges will be nearly aligned resulting in variable output
Dedicated logic was developed in order to detect such cases
During the test delay value is modified from min to max with constant step
Probed signal value are assigned to each delay value (with indication if signal was stable)
Delay is possible in 10 ns range (bigger then clock period)
Test is supposed to find probed signal edges, and evaluate tunning range
Evaluated value will be significantly smaller then real value, since jitter will be added to measured period
"""
......@@ -103,7 +106,7 @@ def test_delay_line( carrier, dacinst ):
print "Trigger input frequency: %d Hz" % tmp
if ( abs( tmp - default_freq ) > freq_thd ):
PtsCritical( "Input frequency measured on Trigger input differ from correct value. This input might be corrupted" )
PtsError( "Input frequency measured on Trigger input differ from correct value. This input might be corrupted" )
else:
print "Trigger input and pulse output verified successfully"
......@@ -191,8 +194,31 @@ def write_delay(carrier, value ):
def main (card=None, default_directory='.',suite=None):
if AUTOMATION:
BOX_USB_VENDOR_ID = 0x10c4 # Cygnal Integrated Products, Inc.
BOX_USB_DEVICE_ID = 0xea60 # CP210x Composite Device
print("Looking for calibration box")
box_tty = find_usb_tty.CttyUSB().find_usb_tty(BOX_USB_VENDOR_ID, BOX_USB_DEVICE_ID)
if len( box_tty ) < 1:
raise PtsError( "Can't find calibration box. Make sure that it is connected, and that CP210x driver was correctly mounted");
# print("Calibration Box device: %s" % box_tty[0])
box = calibr_box.CCalibr_box(box_tty[0])
box.select_trigger_loopback(0)
box.select_output(calibration_box_connections.connections['ref_clk'])
else:
box = 0;
specid = spec_identification()[0];
if specid < 0 :
raise PtsError("Bus number of FmcDac600m12b1chadds was not found")
carrier=spec( FIRMWARE_PATH, 1, True );
carrier=spec( FIRMWARE_PATH, specid, True );
sys_pll = ad9516(carrier);
# default configuration
......@@ -248,7 +274,7 @@ def main (card=None, default_directory='.',suite=None):
# clock period in ns
REF_PERIOD = 8.0
# measurement tolerance in ns
TOLERANCE = 1
TOLERANCE = 2
# configure number of same value consecutive samples
# that are considered as stable signal
......@@ -308,13 +334,13 @@ def main (card=None, default_directory='.',suite=None):
# calculate clock period based on sampled edges
# 2 edges are required to measure half of period
if len(edges) < 2:
print "Not enough edges to calculate half period"
PtsError( "Not enough edges to calculate half period")
return
elif len( edges ) == 2:
period = 2 * ( edges[1] - edges[0] )
if abs( period - (REF_PERIOD*100.0) ) > 2*TOLERANCE*100 :
print "Delay line test failed"
PtsError("Delay line test failed")
else:
print "Delay line test succeeded"
......@@ -322,7 +348,7 @@ def main (card=None, default_directory='.',suite=None):
period = edges[2] - edges[0]
if abs( period - (REF_PERIOD*100.0) ) > TOLERANCE*100 :
print "Delay line test failed"
PtsError("Delay line test failed")
else:
print "Delay line test succeeded"
......
......@@ -21,6 +21,10 @@ from adf4002 import *
from dac import *
from sys import __stdout__
from spec_identification import *
"""
test06: Writes and validates the card's EEPROM.
"""
......@@ -29,8 +33,13 @@ FIRMWARE_PATH = '/../gateware/syn/spec_top.bin'
def main (card=None, default_directory='.',suite=None):
specid = spec_identification()[0];
if specid < 0 :
raise PtsCritical("Bus number of FmcDac600m12b1chadds was not found")
# init spec
carrier=spec( FIRMWARE_PATH, 1, True );
carrier=spec( FIRMWARE_PATH, specid, True );
#configure main clock source
# sys_pll = ad9516(carrier);
......@@ -54,9 +63,9 @@ def main (card=None, default_directory='.',suite=None):
print("eeprom file written to eeprom")
eeprom = "/home/gumas/pts/log_fmcdac600m12b1chadds/eeprom/fd-eeprom_%s.bin" % datetime.datetime.now()
eeprom = "log_fmcdac600m12b1chadds/eeprom/fd-eeprom_%s.bin" % datetime.datetime.now()
print "%s/fd-eeprom.bin" % default_directory, "%s" % eeprom
os.rename("%s/fd-eeprom.bin" % default_directory, "%s" % eeprom)
os.rename("%s/fd-eeprom.bin" % default_directory, "%s" % eeprom )
print("eeprom file moved to %s" % eeprom)
#os.remove("%s/fd-eeprom.bin" % (default_directory))
......
......@@ -3,12 +3,23 @@
# Whole software was tested under Ubuntu 14.04 LTS with kernel 3.13.
# clone repository to ~/pts/test/fmcdac600m12b1chadds
# in order to run fmcdac600m12b1chadds tests you need
# cp210x and common directories from pts repository
# you may either copy whole pts repository or use a coppy attached in fmcdac600m12b1chadds repository
# if you do not want to clone pts repository:
# mv ptsfiles/* ../../
######################################
######################################
##### Getting all submodules ##########
######################################
######################################
git submodule init
git submodule update
......@@ -34,7 +45,7 @@ mv pts_fmcdac600m12b1chadds ~/pts/test/fmcdac600m12b1chadds
# setting up main scripts in pts directory
cp ~/pts/test/fmcdac600m12b1chadds/fmcdac600m12b1chadds.sh ~/pts/fmcdac600m12b1chadds.sh
cp ~/pts/test/fmcdds.sh ~/pts/fmcdds.sh
cp ~/pts/test/fmcdac600m12b1chadds/fmcdac600m12b1chadds.sh ~/pts/fmcdds.sh
cp ~/pts/test/fmcdac600m12b1chadds/ptsDacDDS.py ~/pts/ptsDacDDS.py
......
......@@ -9,7 +9,9 @@ OBJ2 = spec-sw/tools/speclib.o spec-sw/kernel/loader-ll.o
CFLAGS = -I../include -g -Imini_bone -Ispec-sw/tools/ -I. -Ispec-sw/kernel/ -fPIC
DIRS = fmc-bus spec-sw fmc-adc-100m14b4cha-sw
DIRS = fmc-bus spec-sw fmc-adc-100m14b4cha-sw ../python/libipmi fpga-config-space/sdbfs/lib fpga-config-space/sdbfs/userspace
# rf-test: $(OBJS)
......@@ -21,11 +23,13 @@ DIRS = fmc-bus spec-sw fmc-adc-100m14b4cha-sw
# ar rc libfinedelay.a $(OBJS)
all modules install modules_install: $(OBJS)
for d in $(DIRS); do $(MAKE) -C $$d $@ || exit 1; done
for d in $(DIRS); do $(MAKE) -C $$d $@ ; done
gcc -o rf-test $(OBJS) $(SPECLIB) -lm
gcc -shared -o rf-lib.so -Wl,--whole-archive spec-sw/tools/libspec.a -Wl,--no-whole-archive $(OBJS)
gcc -o rf-test $(OBJS) $(SPECLIB) -lm
ln -fs ../software/fpga-config-space/sdbfs/userspace/gensdbfs ../python/gensdbfs
clean:
for d in $(DIRS); do $(MAKE) -C $$d $@ || exit 1; done
for d in $(DIRS); do $(MAKE) -C $$d $@; done
rm -f $(OBJS) rf-test
rm -f ../python/gensdbfs
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment