mirror of https://github.com/YosysHQ/icestorm.git
219 lines
8.1 KiB
Python
Executable File
219 lines
8.1 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
from fuzzconfig import *
|
|
import numpy as np
|
|
import os
|
|
|
|
device_class = os.getenv("ICEDEVICE")
|
|
|
|
assert device_class == "5k"
|
|
|
|
working_dir = "work_%s_upip" % (device_class, )
|
|
|
|
os.system("rm -rf " + working_dir)
|
|
os.mkdir(working_dir)
|
|
def randbin(n):
|
|
return "".join([np.random.choice(["0", "1"]) for i in range(n)])
|
|
for idx in range(num):
|
|
with open(working_dir + "/upip_%02d.v" % idx, "w") as f:
|
|
glbs = ["glb[%d]" % i for i in range(np.random.randint(6)+1)]
|
|
|
|
print("""
|
|
module top (
|
|
input [%d:0] glb_pins,
|
|
input [%d:0] in_pins,
|
|
output [15:0] out_pins,
|
|
output [%d:0] led_pins
|
|
);
|
|
wire [%d:0] glb, glb_pins;
|
|
SB_GB gbufs [%d:0] (
|
|
.USER_SIGNAL_TO_GLOBAL_BUFFER(glb_pins),
|
|
.GLOBAL_BUFFER_OUTPUT(glb)
|
|
);
|
|
""" % (len(glbs)-1, len(pins) - len(glbs) - 16 - 1, len(led_pins)-1, len(glbs)-1, len(glbs)-1), file=f)
|
|
bits = ["in_pins[%d]" % (i % (len(pins) - len(glbs) - 16 - 1)) for i in range(60)]
|
|
bits = list(np.random.permutation(bits))
|
|
#Internal oscillators
|
|
tmp = ["in_pins[%d]" % i for i in range(len(pins) - len(glbs) - 16 - 1)]
|
|
tmp = list(np.random.permutation(tmp))
|
|
for osc in ["LF", "HF"]:
|
|
bit_pu = tmp.pop()
|
|
bit_en = tmp.pop()
|
|
bit_clk = "clk_" + osc
|
|
glbs.append(bit_clk)
|
|
param = ""
|
|
if osc == "HF": #only HFOSC has a divider:
|
|
param = "#(.CLKHF_DIV(\"0b%s\"))" % randbin(2)
|
|
|
|
route = np.random.choice(["", "/* synthesis ROUTE_THROUGH_FABRIC = 1 */"])
|
|
|
|
print("""
|
|
SB_%sOSC %s osc_%s (
|
|
.CLK%sPU(%s),
|
|
.CLK%sEN(%s),
|
|
.CLK%s(%s)
|
|
) %s;
|
|
""" % (
|
|
osc, param, osc, osc, bit_pu,
|
|
osc, bit_en, osc, bit_clk, route
|
|
), file=f)
|
|
glbs_orig = list(glbs)
|
|
#256k SPRAM blocks
|
|
for i in range(num_spram256ka):
|
|
tmp = list(np.random.permutation(bits))
|
|
|
|
bits_addr = [tmp.pop() for k in range(14)]
|
|
bits_mask = [tmp.pop() for k in range(4)]
|
|
bits_wdata = [tmp.pop() for k in range(16)]
|
|
bit_wren = tmp.pop()
|
|
bit_cs = tmp.pop()
|
|
bit_clock = tmp.pop()
|
|
bit_standby = tmp.pop()
|
|
bit_sleep = tmp.pop()
|
|
bit_poweroff = tmp.pop()
|
|
|
|
glbs_choice = ["clk", "a", "msk", "wd", "we", "cs", "stb", "slp", "po"]
|
|
|
|
if len(glbs) != 0:
|
|
s = np.random.choice(glbs_choice)
|
|
glbs_choice.remove(s)
|
|
if s == "clk": bit_clock = glbs.pop()
|
|
if s == "a": bits_addr[np.random.randint(len(bits_addr))] = glbs.pop()
|
|
if s == "msk": bits_mask [np.random.randint(len(bits_mask ))] = glbs.pop()
|
|
if s == "wd": bits_wdata[np.random.randint(len(bits_wdata))] = glbs.pop()
|
|
if s == "we": bit_wren = glbs.pop()
|
|
if s == "cs": bit_cs = glbs.pop()
|
|
if s == "stb": bit_standby = glbs.pop()
|
|
if s == "slp": bit_sleep = glbs.pop()
|
|
if s == "po": bit_poweroff = glbs.pop()
|
|
bits_addr = "{%s}" % ", ".join(bits_addr)
|
|
bits_mask = "{%s}" % ", ".join(bits_mask)
|
|
bits_wdata = "{%s}" % ", ".join(bits_wdata)
|
|
|
|
print("""
|
|
wire [15:0] rdata_%d;
|
|
SB_SPRAM256KA spram_%d (
|
|
.ADDRESS(%s),
|
|
.DATAIN(%s),
|
|
.MASKWREN(%s),
|
|
.WREN(%s),
|
|
.CHIPSELECT(%s),
|
|
.CLOCK(%s),
|
|
.STANDBY(%s),
|
|
.SLEEP(%s),
|
|
.POWEROFF(%s),
|
|
.DATAOUT(rdata_%d)
|
|
);
|
|
""" % (
|
|
i, i,
|
|
bits_addr, bits_wdata, bits_mask, bit_wren,
|
|
bit_cs, bit_clock, bit_standby, bit_sleep,
|
|
bit_poweroff, i
|
|
), file=f)
|
|
bits = list(np.random.permutation(bits))
|
|
if np.random.choice(["XOR", "MULT"]) == "MULT":
|
|
#stress routing at sides more with a multiply
|
|
print("""
|
|
wire [31:0] mult_res_%d;
|
|
assign mult_res_%d = rdata_%d * %s;
|
|
""" % (
|
|
i, i, i, ("{%s}" % ", ".join(bits[0:32]))
|
|
), file=f)
|
|
for k in range(32):
|
|
bits[k] = "mult_res_%d[%d]" % (i, k)
|
|
else:
|
|
for k in range(16):
|
|
bits[k] = "rdata_%d[%d] ^ %s" % (i, k, bits[k])
|
|
|
|
# Internal PWM IP
|
|
tmp = list(np.random.permutation(bits))
|
|
glbs = list(glbs_orig)
|
|
bit_cs = tmp.pop()
|
|
bit_clk = np.random.choice([glbs.pop(), tmp.pop()])
|
|
bit_rst = np.random.choice([glbs.pop(), tmp.pop()])
|
|
bit_den = tmp.pop()
|
|
bit_exe = tmp.pop()
|
|
|
|
bits_dat = [tmp.pop() for k in range(8)]
|
|
bits_addr = [tmp.pop() for k in range(4)]
|
|
|
|
print("""
|
|
wire [2:0] pwm_out;
|
|
SB_LEDDA_IP ledda (
|
|
.LEDDCS(%s),
|
|
.LEDDCLK(%s),
|
|
.LEDDDAT7(%s),
|
|
.LEDDDAT6(%s),
|
|
.LEDDDAT5(%s),
|
|
.LEDDDAT4(%s),
|
|
.LEDDDAT3(%s),
|
|
.LEDDDAT2(%s),
|
|
.LEDDDAT1(%s),
|
|
.LEDDDAT0(%s),
|
|
.LEDDADDR3(%s),
|
|
.LEDDADDR2(%s),
|
|
.LEDDADDR1(%s),
|
|
.LEDDADDR0(%s),
|
|
.LEDDDEN(%s),
|
|
.LEDDEXE(%s),
|
|
.LEDDRST(%s),
|
|
.PWMOUT0(pwm_out[0]),
|
|
.PWMOUT1(pwm_out[1]),
|
|
.PWMOUT2(pwm_out[2])
|
|
);
|
|
""" % (
|
|
bit_cs, bit_clk, bits_dat[7], bits_dat[6], bits_dat[5], bits_dat[4],
|
|
bits_dat[3], bits_dat[2], bits_dat[1], bits_dat[0], bits_addr[3],
|
|
bits_addr[2], bits_addr[1], bits_addr[0], bit_den, bit_exe, bit_rst
|
|
), file=f)
|
|
|
|
bits.append("pwm_out[0]")
|
|
bits.append("pwm_out[1]")
|
|
bits.append("pwm_out[2]")
|
|
|
|
# Constant current LED driver
|
|
current_choices = ["0b000000", "0b000001", "0b000011", "0b000111", "0b001111", "0b011111", "0b111111"]
|
|
current_modes = ["0b0", "0b1"]
|
|
|
|
currents = [np.random.choice(current_choices) for i in range(3)]
|
|
|
|
bit_curren = np.random.choice(bits)
|
|
bit_rgbleden = np.random.choice(bits)
|
|
bits_pwm = [np.random.choice([np.random.choice(bits), "pwm_out[%d]" % i]) for i in range(3)]
|
|
|
|
print("""
|
|
SB_RGBA_DRV #(
|
|
.CURRENT_MODE(\"%s\"),
|
|
.RGB0_CURRENT(\"%s\"),
|
|
.RGB1_CURRENT(\"%s\"),
|
|
.RGB2_CURRENT(\"%s\")
|
|
) rgba_drv (
|
|
.CURREN(%s),
|
|
.RGBLEDEN(%s),
|
|
.RGB0PWM(%s),
|
|
.RGB1PWM(%s),
|
|
.RGB2PWM(%s),
|
|
.RGB0(led_pins[0]),
|
|
.RGB1(led_pins[1]),
|
|
.RGB2(led_pins[2])
|
|
);
|
|
""" % (
|
|
np.random.choice(current_modes), currents[0], currents[1], currents[2],
|
|
bit_curren, bit_rgbleden, bits_pwm[0], bits_pwm[1], bits_pwm[2]
|
|
), file = f)
|
|
|
|
# TODO: I2C and SPI
|
|
|
|
print("assign out_pins = rdata_%d;" % i, file=f)
|
|
print("endmodule", file=f)
|
|
with open(working_dir + "/upip_%02d.pcf" % idx, "w") as f:
|
|
p = list(np.random.permutation(pins))
|
|
for i in range(len(pins) - len(glbs) - 16):
|
|
print("set_io in_pins[%d] %s" % (i, p.pop()), file=f)
|
|
for i in range(16):
|
|
print("set_io out_pins[%d] %s" % (i, p.pop()), file=f)
|
|
for i in range(len(led_pins)):
|
|
print("set_io led_pins[%d] %s" % (i, led_pins[i]), file=f)
|
|
|
|
output_makefile(working_dir, "upip")
|