def extend(self):
print("EXTEND")
# FTDI link back to pc
self.add_resources([
Resource(
"serial",
0,
Subsignal("tx", Pins("B8", dir="o")),
Subsignal("rx", Pins("A8", dir="i")),
),
Resource(
"serial",
1,
Subsignal("tx", Pins("J1", dir="o")),
Subsignal("rx", Pins("H2", dir="i")),
),
Resource("user_led",
1,
Pins("J1", dir="o"),
extras=["IO_STANDARD=SB_LVCMOS33"]),
Resource("user_led",
2,
Pins("H1", dir="o"),
extras=["IO_STANDARD=SB_LVCMOS33"]),
Resource("user_led",
3,
Pins("H9", dir="o"),
extras=["IO_STANDARD=SB_LVCMOS33"]),
Resource("user_led",
4,
Pins("D9", dir="o"),
extras=["IO_STANDARD=SB_LVCMOS33"]),
])
class BB(TinyFPGABXPlatform):
resources = TinyFPGABXPlatform.resources + [
# FTDI link back to pc
Resource(
"serial",
0,
Subsignal("tx", Pins("19", conn=("gpio", 0), dir="o")),
Subsignal("rx", Pins("20", conn=("gpio", 0), dir="i")),
),
Resource("user_led", 1, Pins("12", conn=("gpio", 0), dir="o")),
Resource("user_led", 2, Pins("13", conn=("gpio", 0), dir="o")),
Resource("user_led", 3, Pins("14", conn=("gpio", 0), dir="o")),
Resource("user_led", 4, Pins("15", conn=("gpio", 0), dir="o")),
]
def blinky(self):
leds = []
for n in itertools.count():
try:
l = self.request("user_led", n)
print(l)
leds.append(l)
except ResourceError:
break
leds_cat = Cat(led.o for led in leds)
return leds_cat
def LaserscannerResource(*args,
laser0,
laser1,
photodiode,
pwm,
enable,
number=None,
conn=None,
attrs=None):
""" Resource for laser scanner
The enable pin is currently activated via the Linux host
I/O signals:
O: laser0 -- laser channel 0
O: laser1 -- laser channel 1
I: photodiode -- photodiode used to measure position of laser
O: pwm -- polygon is rotated with pwm
O: en -- on low polygon motor is enabled (depends on type)
"""
io = []
io.append(
Subsignal("laser0", Pins(laser0, dir="o", conn=conn, assert_width=1)))
io.append(
Subsignal("laser1", Pins(laser1, dir="o", conn=conn, assert_width=1)))
io.append(
Subsignal("photodiode",
Pins(photodiode, dir="i", conn=conn, assert_width=1)))
io.append(Subsignal("pwm", Pins(pwm, dir="o", conn=conn, assert_width=1)))
io.append(
Subsignal("en", PinsN(enable, dir="o", conn=conn, assert_width=1)))
if attrs is not None:
io.append(attrs)
return Resource.family(*args, number, default_name="laserscanner", ios=io)
def assemble_platform():
platform = ICEBreakerPlatform()
seg7_conn = ('pmod', 1)
seg7 = Resource(
'seg7', 0,
Subsignal('segs', Pins('1 2 3 4 7 8 9', conn=seg7_conn, dir='o')),
Subsignal('digit', Pins('10', conn=seg7_conn, dir='o')))
midi = UARTResource(1,
rx='39',
tx='40',
attrs=Attrs(IO_STANDARD='SB_LVCMOS'))
platform.add_resources((seg7, midi))
return platform
class SensorPlatform(LatticeICE40Platform):
device = "iCE40HX8K"
package = "BG121"
resources = [
Resource("clk25", 0, Pins("B6", dir="i"), Clock(25e6)),
Resource("user_led", 0, Pins("A10", dir="o")),
Resource("user_led", 1, Pins("A11", dir="o")),
Resource("user_sw", 0, Pins("L1", dir="i")),
Resource("user_sw", 1, Pins("L7", dir="i")),
Resource(
"adc",
0,
Subsignal("cs", Pins("L2", dir="o")),
Subsignal("dout", Pins("L3", dir="o")),
Subsignal("sclk", Pins("L4", dir="o")),
),
Resource(
"daqnet",
0,
Subsignal("led1", Pins("A3", dir="o")),
Subsignal("led2", Pins("A4", dir="o")),
Subsignal("txp", Pins("C2", dir="o")),
Subsignal("txn", Pins("C1", dir="o")),
Subsignal("rx", Pins("B2", dir="i")),
),
]
connectors = []
class TinyBoneless(TinyFPGABXPlatform):
resources = TinyFPGABXPlatform.resources + [
# FTDI link for now
Resource(
"uart",
0,
Subsignal("tx", Pins("19", conn=("gpio", 0), dir="o")),
Subsignal("rx", Pins("20", conn=("gpio", 0), dir="i")),
Subsignal("dtr", Pins("21", conn=("gpio", 0), dir="i")),
),
*LEDResources("blinky",
pins="J1 H2 H9 D9",
attrs=Attrs(IO_STANDARD="SB_LVCMOS")),
]
user_flash = (0x50000, 0xFBFFF)
class STEVE(TinyFPGABXPlatform):
resources = TinyFPGABXPlatform.resources + [
# FTDI link back to pc
Resource(
"serial",
0,
Subsignal("tx", Pins("19", conn=("gpio", 0), dir="o")),
Subsignal("rx", Pins("20", conn=("gpio", 0), dir="i")),
),
# Serial to AVR
Resource(
"serial",
1,
Subsignal("tx", Pins("14", conn=("gpio", 0), dir="o")),
Subsignal("rx", Pins("15", conn=("gpio", 0), dir="i")),
),
]
def assemble_platform():
platform = ICEBreakerPlatform()
i2s_conn = ('pmod', 0)
seg7_conn = ('pmod', 1)
i2s = Resource(
'i2s',
0,
Subsignal('mclk', Pins('1', conn=i2s_conn, dir='o')),
Subsignal('lrck', Pins('2', conn=i2s_conn, dir='o')),
Subsignal('sck', Pins('3', conn=i2s_conn, dir='o')),
Subsignal('sd', Pins('4', conn=i2s_conn, dir='o')),
)
seg7 = Resource(
'seg7', 0,
Subsignal('segs', Pins('1 2 3 4 7 8 9', conn=seg7_conn, dir='o')),
Subsignal('digit', Pins('10', conn=seg7_conn, dir='o')))
midi = UARTResource(1,
rx='39',
tx='40',
attrs=Attrs(IO_STANDARD='SB_LVCMOS'))
dbg = Resource(
'dbg',
0,
Subsignal('dbg', Pins('7 8 9 10', conn=i2s_conn, dir='o')),
)
platform.add_resources((i2s, seg7, midi, dbg))
return platform
def __init__(self):
super().__init__()
self.add_resources([
Resource("sensor", 0,
Subsignal("shutter", Pins("25", dir='o', conn=("expansion", 0)), Attrs(IOSTANDARD="LVCMOS18")),
Subsignal("trigger", Pins("27", dir='o', conn=("expansion", 0)), Attrs(IOSTANDARD="LVCMOS18")),
Subsignal("reset", PinsN("31", dir='o', conn=("expansion", 0)), Attrs(IOSTANDARD="LVCMOS18")),
Subsignal("clk", Pins("33", dir='o', conn=("expansion", 0)), Attrs(IOSTANDARD="LVCMOS18")),
Subsignal("lvds_clk", DiffPairs("51", "53", dir='i', conn=("expansion", 0)), Attrs(IOSTANDARD="DIFF_SSTL18_I", IN_TERM="UNTUNED_SPLIT_50")),
Subsignal("lvds", DiffPairsN("41 45 55 65", "43 47 57 67", dir='i', conn=("expansion", 0)), Attrs(IOSTANDARD="DIFF_SSTL18_I", IN_TERM="UNTUNED_SPLIT_50")),
),
Resource("i2c", 0,
Subsignal("scl", Pins("35", dir='io', conn=("expansion", 0)), Attrs(IOSTANDARD="LVCMOS18")),
Subsignal("sda", Pins("37", dir='io', conn=("expansion", 0)), Attrs(IOSTANDARD="LVCMOS18")),
),
Resource("ws2812", 0, Pins("56", dir='o', conn=("expansion", 0)), Attrs(IOSTANDARD="LVCMOS18")),
Resource("encoder", 0,
Subsignal("quadrature", Pins("58 68", dir='i', conn=("expansion", 0))),
Subsignal("push", Pins("66", dir='i', conn=("expansion", 0)))
),
])
self.add_connectors([
Connector("plugin", "south",
gen_plugin_connector(
lvds=["21 23", "3 5", "9 11", "13 15", "4 6", "10 12"],
gpio=[71, 73, 63, 61, 64, 62, 75, 77],
i2c=[46, 48]),
conn=("expansion", 0),
),
Connector("plugin", "north",
gen_plugin_connector(
lvds=["14 16", "22 24", "26 28", "32 34", "36 38", "42 44"],
gpio=[76, 78, 80, 84, 86, 88, 90, 74],
i2c=[52, 54]),
conn=("expansion", 0),
),
Connector("pmod", "north", "110 106 100 96 - - 108 104 98 94 - -", conn=("expansion", 0), ),
Connector("pmod", "south", "97 95 89 85 - - 99 93 87 83 - -", conn=("expansion", 0), ),
Connector("pmod", "east", "103 105 107 109 - -", conn=("expansion", 0), ),
])
class BB(TinyFPGABXPlatform):
resources = TinyFPGABXPlatform.resources + [
# FTDI link back to pc
Resource(
"serial",
0,
Subsignal("tx", Pins("19", conn=("gpio", 0), dir="o")),
Subsignal("rx", Pins("20", conn=("gpio", 0), dir="i")),
),
Resource("user_led", 1, Pins("12", conn=("gpio", 0), dir="o")),
Resource("user_led", 2, Pins("13", conn=("gpio", 0), dir="o")),
Resource("user_led", 3, Pins("14", conn=("gpio", 0), dir="o")),
Resource("user_led", 4, Pins("15", conn=("gpio", 0), dir="o")),
Resource("pwm", 0, Pins("5", conn=("gpio", 0), dir="o")),
]
clock = "clk16"
def freq(self):
clk = self.lookup(self.clock)
return clk.clock.frequency
class TinyFPGABxPlatform(LatticeICE40Platform, LUNAPlatform):
device = "iCE40LP8K"
package = "CM81"
default_clk = "clk16"
name = "TinyFPGA Bx"
# Provide the type that'll be used to create our clock domains.
clock_domain_generator = TinyFPGABxDomainGenerator
# We only have a direct connection on our USB lines, so use that for USB comms.
default_usb_connection = "usb"
resources = [
Resource("clk16", 0, Pins("B2", dir="i"), Clock(16e6),
Attrs(IO_STANDARD="SB_LVCMOS")),
Resource("led", 0, Pins("B3"), Attrs(IO_STANDARD="SB_LVCMOS")),
Resource("usb", 0, Subsignal("d_p", Pins("B4", dir="io")),
Subsignal("d_n", Pins("A4", dir="io")),
Subsignal("pullup", Pins("A3", dir="o")),
Attrs(IO_STANDARD="SB_LVCMOS")),
]
connectors = [
Connector(
"gpio",
0,
# Left side of the board
# 1 2 3 4 5 6 7 8 9 10 11 12 13
" A2 A1 B1 C2 C1 D2 D1 E2 E1 G2 H1 J1 H2 "
# Right side of the board
# 14 15 16 17 18 19 20 21 22 23 24
" H9 D9 D8 C9 A9 B8 A8 B7 A7 B6 A6 "
# Bottom of the board
# 25 26 27 28 29 30 31
"G1 J3 J4 G9 J9 E8 J2"),
]
def toolchain_program(self, products, name):
tinyprog = os.environ.get("TINYPROG", "tinyprog")
with products.extract("{}.bin".format(name)) as bitstream_filename:
subprocess.check_call([tinyprog, "-p", bitstream_filename])
def generate(top):
from nmigen_boards.icestick import ICEStickPlatform
platform = ICEStickPlatform()
platform.add_resources([
Resource(
'sound_out',
0,
Subsignal('pin', Pins('3', conn=('j', 1), dir='o')),
)
])
platform.build(top, do_program=args.program or args.interactive)
def build(top):
from nmigen_boards.icestick import ICEStickPlatform
platform = ICEStickPlatform()
platform.add_resources([
Resource("spi", 0,
Subsignal("mosi", Pins('3', conn=('j', 1), dir='i')),
Subsignal("sclk", Pins('4', conn=('j', 1), dir='i')),
Subsignal("ssel", Pins('5', conn=('j', 1), dir='i')),
)
])
conn = platform.request('spi')
spi = top.submodules.spi
top.d.comb += [
spi.i_mosi.eq(conn.mosi),
spi.i_sclk.eq(conn.sclk),
spi.i_ssel.eq(conn.ssel),
platform.request('led', 4).eq(spi.o_done),
platform.request('led', 0).eq(spi.o_data[0]),
]
platform.build(top, do_program = False)
def StepperResource(*args,
step,
direction,
limit,
number=None,
conn=None,
attrs=None):
""" The enable pin is currently activated via the Linux host
I/O signals:
O: step -- pin for step pulse
O: dir -- rotating direction of motor
I: limit -- limit switch to detect end movement
"""
io = []
io.append(Subsignal("step", Pins(step, dir="o", conn=conn,
assert_width=1)))
io.append(
Subsignal("dir", Pins(direction, dir="o", conn=conn, assert_width=1)))
io.append(
Subsignal("limit", Pins(limit, dir="i", conn=conn, assert_width=1)))
if attrs is not None:
io.append(attrs)
return Resource.family(*args, number, default_name="stepper", ios=io)
class FomuEVTPlatform(LatticeICE40Platform, LUNAPlatform):
""" Platform for the Fomu EVT platforms. """
default_clk = "clk48"
name = "Fomu EVT"
# Provide the type that'll be used to create our clock domains.
clock_domain_generator = FomuDomainGenerator
# We only have a direct connection on our USB lines, so use that for USB comms.
default_usb_connection = "usb"
device = "iCE40UP5K"
package = "SG48"
default_clk = "clk48"
resources = [
Resource("clk48", 0, Pins("44", dir="i"), Clock(48e6),
Attrs(GLOBAL=True, IO_STANDARD="SB_LVCMOS")),
Resource("led", 0, PinsN("41"), Attrs(IO_STANDARD="SB_LVCMOS")),
Resource(
"rgb_led",
0,
Subsignal("r", PinsN("40"), Attrs(IO_STANDARD="SB_LVCMOS")),
Subsignal("g", PinsN("39"), Attrs(IO_STANDARD="SB_LVCMOS")),
Subsignal("b", PinsN("41"), Attrs(IO_STANDARD="SB_LVCMOS")),
),
Resource(
"usb",
0,
Subsignal("d_p", Pins("34")),
Subsignal("d_n", Pins("37")),
Subsignal("pullup", Pins("35", dir="o")),
Attrs(IO_STANDARD="SB_LVCMOS"),
),
# PMOD
Resource("user_io", 0, PinsN("25"), Attrs(IO_STANDARD="SB_LVCMOS")),
Resource("user_io", 1, PinsN("26"), Attrs(IO_STANDARD="SB_LVCMOS")),
Resource("user_io", 2, PinsN("27"), Attrs(IO_STANDARD="SB_LVCMOS")),
Resource("user_io", 3, PinsN("28"), Attrs(IO_STANDARD="SB_LVCMOS")),
]
connectors = []
def toolchain_program(self, products, name):
""" Program the FPGA of an Fomu EVT board. """
with products.extract("{}.bin".format(name)) as bitstream_filename:
subprocess.check_call(["fomu-flash", "-f", bitstream_filename])
def toolchain_flash(self, products, name="top"):
""" Flash the SPI flash of an Fomu EVT board. """
with products.extract("{}.bin".format(name)) as bitstream_filename:
subprocess.check_call(["fomu-flash", "-w", bitstream_filename])
def elaborate(self, platform):
m = Module()
resources = [
Resource("wishbone", 0,
Subsignal("adr", Pins("ADDR0 ADDR1 ADDR2 ADDR3 ADDR4 ADDR5 ADDR6 ADDR7"
" ADDR8 ADDR9 ADDR10 ADDR11 ADDR12 ADDR13 ADDR14 ADDR15"
" ADDR16 ADDR17 ADDR18 ADDR19 ADDR20 ADDR21 ADDR22 ADDR23"
" ADDR24 ADDR25 ADDR26 ADDR27 ADDR28 ADDR29 ADDR30 ADDR31", dir="i")),
Subsignal("dat_r", Pins("DATR0 DATR1 DATR2 DATR3 DATR4 DATR5 DATR6 DATR7"
" DATR8 DATR9 DATR10 DATR11 DATR12 DATR13 DATR14 DATR15"
" DATR16 DATR17 DATR18 DATR19 DATR20 DATR21 DATR22 DATR23"
" DATR24 DATR25 DATR26 DATR27 DATR28 DATR29 DATR30 DATR31", dir="o")),
Subsignal("dat_w", Pins("DATW0 DATW1 DATW2 DATW3 DATW4 DATW5 DATW6 DATW7"
" DATW8 DATW9 DATW10 DATW11 DATW12 DATW13 DATW14 DATW15"
" DATW16 DATW17 DATW18 DATW19 DATW20 DATW21 DATW22 DATW23"
" DATW24 DATW25 DATW26 DATW27 DATW28 DATW29 DATW30 DATW31", dir="i")),
Subsignal("cyc", Pins("CYC", dir="i")),
Subsignal("stb", Pins("STB", dir="i")),
Subsignal("sel", Pins("SEL0 SEL1 SEL2 SEL3", dir="i")),
Subsignal("ack", Pins("ACK", dir="o")),
Subsignal("we", Pins("WE", dir="i"))),
]
platform.add_resources(resources)
m.submodules.sysclk = self.crg
m.submodules.decoder = self._decoder
m.submodules.ddrphy = self.ddrphy
m.submodules.dramcore = self.dramcore
m.submodules.drambone = self.drambone
ext_bus = platform.request("wishbone", 0)
m.d.comb += [
self._decoder.bus.adr.eq(ext_bus.adr.i),
self._decoder.bus.dat_w.eq(ext_bus.dat_w.i),
ext_bus.dat_r.o.eq(self._decoder.bus.dat_r),
self._decoder.bus.cyc.eq(ext_bus.cyc.i),
self._decoder.bus.stb.eq(ext_bus.stb.i),
self._decoder.bus.sel.eq(ext_bus.sel.i),
ext_bus.ack.o.eq(self._decoder.bus.ack),
self._decoder.bus.we.eq(ext_bus.we.i),
]
return m
def ULPIResource(name, data_sites, clk_site, dir_site, nxt_site, stp_site,
reset_site):
""" Generates a set of resources for a ULPI-connected USB PHY. """
return Resource(name, 0, Subsignal("data", Pins(data_sites, dir="io")),
Subsignal("clk", Pins(clk_site, dir="o")),
Subsignal("dir", Pins(dir_site, dir="i")),
Subsignal("nxt", Pins(nxt_site, dir="i")),
Subsignal("stp", Pins(stp_site, dir="o")),
Subsignal("rst", PinsN(reset_site, dir="o")),
Attrs(IO_TYPE="LVCMOS33", SLEWRATE="FAST"))
class BetaRFWPlatform(LatticeMachXO2Platform):
device = "LCMXO2-2000HC"
package = "TG100"
speed = "6"
resources = [
Resource(
"pic_io",
0,
Subsignal("ss", Pins("27", dir="io"),
Attrs(IO_TYPE="LVCMOS33", PULLMODE="UP", DRIVE="4")),
Subsignal("sck", Pins("31", dir="io"),
Attrs(IO_TYPE="LVCMOS33", PULLMODE="UP", DRIVE="4")),
Subsignal("sdo", Pins("32", dir="io"),
Attrs(IO_TYPE="LVCMOS33", PULLMODE="UP", DRIVE="4")),
Subsignal("pb22b", Pins("47", dir="io"),
Attrs(IO_TYPE="LVCMOS33", PULLMODE="UP", DRIVE="4")),
Subsignal("sn", Pins("48", dir="io"),
Attrs(IO_TYPE="LVCMOS33", PULLMODE="UP", DRIVE="4")),
Subsignal("sdi", Pins("49", dir="io"),
Attrs(IO_TYPE="LVCMOS33", PULLMODE="UP", DRIVE="4")),
Subsignal("done", Pins("76", dir="io"),
Attrs(IO_TYPE="LVCMOS33", PULLMODE="UP", DRIVE="4")),
Subsignal("initn", Pins("77", dir="io"),
Attrs(IO_TYPE="LVCMOS33", PULLMODE="UP", DRIVE="4")),
)
]
connectors = []
def __init__(self):
super().__init__()
add_plugin_connector(
self,
"north",
gpio=["83", "78", "74", "75", "71", "70", "69", "68"])
add_plugin_connector(
self, "south", gpio=["1", "2", "98", "99", "96", "97", "84", "87"])
def ULPIResource(name,
data_sites,
clk_site,
dir_site,
nxt_site,
stp_site,
reset_site,
extras=()):
""" Generates a set of resources for a ULPI-connected USB PHY. """
return Resource(
name, 0, Subsignal("data", Pins(data_sites, dir="io")),
Subsignal("clk", Pins(clk_site, dir="i"), Attrs(PULLDOWN="TRUE"),
Clock(60e6)), Subsignal("dir", Pins(dir_site, dir="i")),
Subsignal("nxt", Pins(nxt_site, dir="i")),
Subsignal("stp", Pins(stp_site, dir="o")),
Subsignal("rst", PinsN(reset_site, dir="o")), Attrs(SLEW="FAST"))
class FomuHackerPlatform(LatticeICE40Platform, LUNAPlatform):
""" Base class for Fomu platforms. """
default_clk = "clk48"
name = "Fomu Hacker"
# Provide the type that'll be used to create our clock domains.
clock_domain_generator = FomuDomainGenerator
# We only have a direct connection on our USB lines, so use that for USB comms.
default_usb_connection = "usb"
device = "iCE40UP5K"
package = "UWG30"
default_clk = "clk48"
resources = [
Resource("clk48", 0, Pins("F5", dir="i"), Clock(48e6),
Attrs(GLOBAL=True, IO_STANDARD="SB_LVCMOS")),
Resource("led", 0, PinsN("C5"), Attrs(IO_STANDARD="SB_LVCMOS")),
Resource(
"rgb_led",
0,
Subsignal("r", PinsN("C5"), Attrs(IO_STANDARD="SB_LVCMOS")),
Subsignal("g", PinsN("B5"), Attrs(IO_STANDARD="SB_LVCMOS")),
Subsignal("b", PinsN("A5"), Attrs(IO_STANDARD="SB_LVCMOS")),
),
Resource(
"usb",
0,
Subsignal("d_p", Pins("A4")),
Subsignal("d_n", Pins("A2")),
Subsignal("pullup", Pins("D5", dir="o")),
Attrs(IO_STANDARD="SB_LVCMOS"),
),
]
connectors = []
def toolchain_program(self, products, name):
""" Program the flash of a FomuHacker board. """
# Use the DFU bootloader to program the ECP5 bitstream.
dfu_util = os.environ.get("DFU_UTIL", "dfu-util")
with products.extract("{}.bin".format(name)) as bitstream_filename:
subprocess.check_call(
[dfu_util, "-d", "1209:5bf0", "-D", bitstream_filename])
def ULPIResource(name,
data_sites,
clk_site,
dir_site,
nxt_site,
stp_site,
reset_site,
extras=(),
attrs=None):
""" Generates a set of resources for a ULPI-connected USB PHY. """
attrs = Attrs() if attrs is None else attrs
return Resource(name, 0, Subsignal("data", Pins(data_sites, dir="io")),
Subsignal("clk", Pins(clk_site, dir="i"), Clock(60e6)),
Subsignal("dir", Pins(dir_site, dir="i")),
Subsignal("nxt", Pins(nxt_site, dir="i")),
Subsignal("stp", Pins(stp_site, dir="o")),
Subsignal("rst", Pins(reset_site, dir="o")), attrs)
def __init__(self):
lvcmos = self.lvcmos
# Create resources for each LED header
for jidx, pins in enumerate(self.leds):
self.resources += [
Resource("led_rgb", jidx,
Subsignal("r0", Pins(pins[0], dir="o"), lvcmos),
Subsignal("g0", Pins(pins[1], dir="o"), lvcmos),
Subsignal("b0", Pins(pins[2], dir="o"), lvcmos),
Subsignal("r1", Pins(pins[3], dir="o"), lvcmos),
Subsignal("g1", Pins(pins[4], dir="o"), lvcmos),
Subsignal("b1", Pins(pins[5], dir="o"), lvcmos))
]
# Create resources for each unknown pin
for pin in self.outputs:
self.resources += [Resource(pin, 0, Pins(pin, dir="o"), lvcmos)]
for pin in self.inputs:
self.resources += [Resource(pin, 0, Pins(pin, dir="i"), lvcmos)]
for pin in self.bidis:
self.resources += [Resource(pin, 0, Pins(pin, dir="io"), lvcmos)]
super().__init__()
class USB2SnifferPlatform(Xilinx7SeriesPlatform, LUNAPlatform):
""" Board description for OpenVizsla USB analyzer. """
name = "LambdaConcept USB2Sniffer"
device = "xc7a35t"
package = "fgg484"
speed = "1"
default_clk = "clk100"
# Provide the type that'll be used to create our clock domains.
clock_domain_generator = StubClockDomainGenerator
# We only have a single PHY; so use it directly.
default_usb_connection = "target_phy"
#
# I/O resources.
#
resources = [
Resource("clk100", 0, Pins("J19"), Attrs(IOStandard="LVCMOS33")),
Resource("led", 0, PinsN("W1"), Attrs(IOStandard="LVCMOS33")),
Resource("led", 1, PinsN("Y2"), Attrs(IOStandard="LVCMOS33")),
Resource(
"rgb_led",
0,
Subsignal("r", PinsN("W2")),
Subsignal("g", PinsN("Y1")),
Subsignal("b", PinsN("W1")),
Attrs(IOStandard="LVCMOS33"),
),
Resource(
"rgb_led",
1,
Subsignal("r", PinsN("AA1")),
Subsignal("g", PinsN("AB1")),
Subsignal("b", PinsN("Y2")),
Attrs(IOStandard="LVCMOS33"),
),
Resource(
"serial",
0,
Subsignal("tx", Pins("U21")), # FPGA_GPIO0
Subsignal("rx", Pins("T21")), # FPGA_GPIO1
Attrs(IOStandard="LVCMOS33"),
),
Resource(
"ddram",
0,
Subsignal("a",
Pins("M2 M5 M3 M1 L6 P1 N3 N2"
"M6 R1 L5 N5 N4 P2 P6"),
Attrs(IOStandard="SSTL15")),
Subsignal("ba", Pins("L3 K6 L4"), Attrs(IOStandard="SSTL15")),
Subsignal("ras_n", Pins("J4"), Attrs(IOStandard="SSTL15")),
Subsignal("cas_n", Pins("K3"), Attrs(IOStandard="SSTL15")),
Subsignal("we_n", Pins("L1"), Attrs(IOStandard="SSTL15")),
Subsignal("dm", Pins("G3 F1"), Attrs(IOStandard="SSTL15")),
Subsignal(
"dq", Pins("G2 H4 H5 J1 K1 H3 H2 J5"
"E3 B2 F3 D2 C2 A1 E2 B1"),
Attrs(IOStandard="SSTL15", IN_TERM="UNTUNED_SPLIT_50")),
Subsignal("dqs_p", Pins("K2 E1"), Attrs(IOStandard="DIFF_SSTL15")),
Subsignal("dqs_n", Pins("J2 D1"), Attrs(IOStandard="DIFF_SSTL15")),
Subsignal("clk_p", Pins("P5"), Attrs(IOStandard="DIFF_SSTL15")),
Subsignal("clk_n", Pins("P4"), Attrs(IOStandard="DIFF_SSTL15")),
Subsignal("cke", Pins("J6"), Attrs(IOStandard="SSTL15")),
Subsignal("odt", Pins("K4"), Attrs(IOStandard="SSTL15")),
Subsignal("reset_n", Pins("G1"), Attrs(IOStandard="SSTL15")),
Attrs(SLEW="FAST"),
),
Resource("flash", 0, Subsignal("cs_n", Pins("T19")),
Subsignal("mosi", Pins("P22")),
Subsignal("miso", Pins("R22")), Subsignal("vpp", Pins("P21")),
Subsignal("hold", Pins("R21")), Attrs(IOStandard="LVCMOS33")),
Resource("usb_fifo_clock", 0, Pins("D17"),
Attrs(IOStandard="LVCMOS33")),
Resource(
"usb_fifo", 0, Subsignal("rst", Pins("K22")),
Subsignal(
"data",
Pins(
"A16 F14 A15 F13 A14 E14 A13 E13 B13 C15 C13 C14 B16 E17 B15 F16"
"A20 E18 B20 F18 D19 D21 E19 E21 A21 B21 A19 A18 F20 F19 B18 B17"
)), Subsignal("be", Pins("K16 L16 G20 H20")),
Subsignal("rxf_n", Pins("M13")), Subsignal("txe_n", Pins("L13")),
Subsignal("rd_n", Pins("K19")), Subsignal("wr_n", Pins("M15")),
Subsignal("oe_n", Pins("L21")), Subsignal("siwua", Pins("M16")),
Attrs(IOStandard="LVCMOS33", SLEW="FAST")),
Resource(
"ulpi_sw",
0,
Subsignal("s", Pins("Y8", dir="o")),
Subsignal("oe", PinsN("Y9", dir="o")),
Attrs(IOStandard="LVCMOS33"),
),
# Host PHY -- connects directly to the host port.
ULPIResource("target_phy",
data_sites="AB18 AA18 AA19 AB20 AA20 AB21 AA21 AB22",
clk_site="W19",
dir_site="W21",
stp_site="Y22",
nxt_site="W22",
reset_site="V20",
attrs=Attrs(IOStandard="LVCMOS33", SLEW="FAST")),
# Target PHY -- connects via a switch to the target port.
ULPIResource("sideband_phy",
data_sites="AB2 AA3 AB3 Y4 AA4 AB5 AA5 AB6",
clk_site="V4",
dir_site="AB7",
stp_site="AA6",
nxt_site="AB8",
reset_site="AA8",
attrs=Attrs(IOStandard="LVCMOS33", SLEW="FAST"))
]
connectors = []
def toolchain_program(self, products, name):
xc3sprog = os.environ.get("XC3SPROG", "xc3sprog")
with products.extract("{}.bit".format(name)) as bitstream_file:
subprocess.check_call([xc3sprog, "-c", "ft4232h", bitstream_file])
class ECPIX5PlatformRev02(LatticeECP5Platform, LUNAPlatform):
name = "ECPIX-5 R02"
device = "LFE5UM5G-85F"
package = "BG554"
speed = "8"
default_clk = "clk100"
default_rst = "rst"
# Provide the type that'll be used to create our clock domains.
clock_domain_generator = StubClockDomainGenerator
# We only have a single PHY; so use it directly.
default_usb_connection = "ulpi"
resources = [
Resource("rst", 0, PinsN("AB1", dir="i"), Attrs(IO_TYPE="LVCMOS33")),
Resource("clk100", 0, Pins("K23", dir="i"), Clock(100e6),
Attrs(IO_TYPE="LVCMOS33")),
# LEDs
Resource(
"rgb_led",
0,
Subsignal("r", Pins("U21")),
Subsignal("g", Pins("W21")),
Subsignal("b", Pins("T24")),
Attrs(IO_TYPE="LVCMOS33"),
),
Resource(
"rgb_led",
1,
Subsignal("r", Pins("T23")),
Subsignal("g", Pins("R21")),
Subsignal("b", Pins("T22")),
Attrs(IO_TYPE="LVCMOS33"),
),
Resource(
"rgb_led",
2,
Subsignal("r", Pins("P21")),
Subsignal("g", Pins("R23")),
Subsignal("b", Pins("P22")),
Attrs(IO_TYPE="LVCMOS33"),
),
Resource(
"rgb_led",
3,
Subsignal("r", Pins("K21")),
Subsignal("g", Pins("K24")),
Subsignal("b", Pins("M21")),
Attrs(IO_TYPE="LVCMOS33"),
),
Resource("uart", 0, Subsignal("rx", Pins("R26", dir="i")),
Subsignal("tx", Pins("R24", dir="o")),
Attrs(IO_TYPE="LVCMOS33", PULLMODE="UP")),
Resource("eth_rgmii", 0, Subsignal("rst", PinsN("C13", dir="o")),
Subsignal("mdio", Pins("A13", dir="io")),
Subsignal("mdc", Pins("C11", dir="o")),
Subsignal("tx_clk", Pins("A12", dir="o")),
Subsignal("tx_ctrl", Pins("C9", dir="o")),
Subsignal("tx_data", Pins("D8 C8 B8 A8", dir="o")),
Subsignal("rx_clk", Pins("E11", dir="i")),
Subsignal("rx_ctrl", Pins("A11", dir="i")),
Subsignal("rx_data", Pins("B11 A10 B10 A9", dir="i")),
Attrs(IO_TYPE="LVCMOS33")),
Resource("eth_int", 0, PinsN("B13", dir="i"),
Attrs(IO_TYPE="LVCMOS33")),
Resource(
"ddr3", 0,
Subsignal("clk", DiffPairs("H3", "J3", dir="o"),
Attrs(IO_TYPE="SSTL135D_I")),
Subsignal("clk_en", Pins("P1", dir="o")),
Subsignal("we", PinsN("R3", dir="o")),
Subsignal("ras", PinsN("T3", dir="o")),
Subsignal("cas", PinsN("P2", dir="o")),
Subsignal(
"a",
Pins("T5 M3 L3 V6 K2 W6 K3 L1 H2 L2 N1 J1 M1 K1", dir="o")),
Subsignal("ba", Pins("U6 N3 N4", dir="o")),
Subsignal("dqs", DiffPairs("V4 V1", "U5 U2", dir="io"),
Attrs(IO_TYPE="SSTL135D_I")),
Subsignal(
"dq",
Pins("T4 W4 R4 W5 R6 P6 P5 P4 R1 W3 T2 V3 U3 W1 T1 W2",
dir="io")), Subsignal("dm", Pins("J4 H5", dir="o")),
Subsignal("odt", Pins("L2", dir="o")), Attrs(IO_TYPE="SSTL135_I")),
Resource(
"hdmi", 0, Subsignal("rst", PinsN("N6", dir="o")),
Subsignal("scl", Pins("C17", dir="io")),
Subsignal("sda", Pins("E17", dir="io")),
Subsignal("pclk", Pins("C1", dir="o")),
Subsignal("vsync", Pins("A4", dir="o")),
Subsignal("hsync", Pins("B4", dir="o")),
Subsignal("de", Pins("A3", dir="o")),
Subsignal(
"d",
Subsignal(
"b",
Pins("AD25 AC26 AB24 AB25 B3 C3 D3 B1 C2 D2 D1 E3",
dir="o")),
Subsignal(
"g",
Pins("AA23 AA22 AA24 AA25 E1 F2 F1 D17 D16 E16 J6 H6",
dir="o")),
Subsignal(
"r",
Pins("AD26 AE25 AF25 AE26 E10 D11 D10 C10 D9 E8 H5 J4",
dir="o")),
), Subsignal("mclk", Pins("E19", dir="o")),
Subsignal("sck", Pins("D6", dir="o")),
Subsignal("ws", Pins("C6", dir="o")),
Subsignal("i2s", Pins("A6 B6 A5 C5", dir="o")),
Subsignal("int", PinsN("C4", dir="i")), Attrs(IO_TYPE="LVTTL33")),
Resource("sata", 0, Subsignal("tx", DiffPairs("AD16", "AD17",
dir="o")),
Subsignal("rx", DiffPairs("AF15", "AF16", dir="i")),
Attrs(IO_TYPE="LVDS")),
ULPIResource("ulpi",
data_sites="M26 L25 L26 K25 K26 J23 P25 H25",
clk_site="H24",
dir_site="F22",
stp_site="H23",
nxt_site="F23",
reset_site="E23",
attrs=Attrs(IO_TYPE="LVCMOS33")),
Resource("usbc_cfg", 0, Subsignal("scl", Pins("D24", dir="io")),
Subsignal("sda", Pins("C24", dir="io")),
Subsignal("dir", Pins("B23", dir="i")),
Subsignal("id", Pins("D23", dir="i")),
Subsignal("int", PinsN("B24", dir="i")),
Attrs(IO_TYPE="LVCMOS33")),
Resource(
"usbc_mux",
0,
Subsignal("en", Pins("C23", dir="oe")),
Subsignal("amsel", Pins("B26", dir="oe")),
Subsignal("pol", Pins("D26", dir="o")),
#Subsignal("lna", DiffPairs( "AF9", "AF10", dir="i"), Attrs(IO_TYPE="LVCMOS18D")),
#Subsignal("lnb", DiffPairs("AD10", "AD11", dir="o"), Attrs(IO_TYPE="LVCMOS18D")),
#Subsignal("lnc", DiffPairs( "AD7", "AD8", dir="o"), Attrs(IO_TYPE="LVCMOS18D")),
#Subsignal("lnd", DiffPairs( "AF6", "AF7", dir="i"), Attrs(IO_TYPE="LVCMOS18D")),
Attrs(IO_TYPE="LVCMOS33")),
# Compatibility aliases.
Resource("led", 0, Pins("W21", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("led", 1, Pins("R21", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("led", 2, Pins("R23", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("led", 3, Pins("K24", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("user_io", 0, Pins("T25")),
Resource("user_io", 1, Pins("U25")),
Resource("user_io", 2, Pins("U24")),
Resource("user_io", 3, Pins("V24")),
]
connectors = [
Connector("pmod", 0, "T25 U25 U24 V24 - - T26 U26 V26 W26 - -"),
Connector("pmod", 1, "U23 V23 U22 V21 - - W25 W24 W23 W22 - -"),
Connector("pmod", 2, "J24 H22 E21 D18 - - K22 J21 H21 D22 - -"),
Connector("pmod", 3, " E4 F4 E6 H4 - - F3 D4 D5 F5 - -"),
Connector("pmod", 4, "E26 D25 F26 F25 - - A25 A24 C26 C25 - -"),
Connector("pmod", 5, "D19 C21 B21 C22 - - D21 A21 A22 A23 - -"),
Connector("pmod", 6, "C16 B17 C18 B19 - - A17 A18 A19 C19 - -"),
Connector("pmod", 7, "D14 B14 E14 B16 - - C14 A14 A15 A16 - -"),
]
@property
def file_templates(self):
return {
**super().file_templates, "{{name}}-openocd.cfg":
r"""
interface ftdi
ftdi_vid_pid 0x0403 0x6010
ftdi_channel 0
ftdi_layout_init 0xfff8 0xfffb
reset_config none
adapter_khz 25000
jtag newtap ecp5 tap -irlen 8 -expected-id 0x81113043
"""
}
def toolchain_program(self, products, name):
openocd = os.environ.get("OPENOCD", "openocd")
with products.extract("{}-openocd.cfg".format(name), "{}.svf".format(name)) \
as (config_filename, vector_filename):
subprocess.check_call([
openocd, "-f", config_filename, "-c",
"transport select jtag; init; svf -quiet {}; exit".format(
vector_filename)
])
def hdmi_plugin_connect(platform, plugin_number):
if "plugin_{}:gpio0".format(plugin_number) in platform._conn_pins:
lowspeed_signals = [
# i2c to read edid data from the monitor
Subsignal("sda", Pins("lvds5_n", dir='io', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="LVCMOS18")),
Subsignal("scl", Pins("lvds5_p", dir='io', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="LVCMOS18")),
# hdmi plugin-module specific signals
Subsignal("output_enable", PinsN("gpio6", dir='o', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="LVCMOS33")),
Subsignal("equalizer", Pins("gpio1 gpio4", dir='o', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="LVCMOS33")),
Subsignal("dcc_enable", Pins("gpio5", dir='o', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="LVCMOS33")),
Subsignal("vcc_enable", Pins("gpio7", dir='o', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="LVCMOS33")),
Subsignal("ddet", Pins("gpio3", dir='o', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="LVCMOS33")),
Subsignal("ihp", Pins("gpio2", dir='i', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="LVCMOS33")),
]
else:
lowspeed_signals = []
platform.add_resources([
Resource("hdmi", plugin_number,
Subsignal("clock", DiffPairs("lvds3_p", "lvds3_n", dir='o', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="DIFF_SSTL18_I")),
Subsignal("data_b", DiffPairs("lvds2_p", "lvds2_n", dir='o', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="DIFF_SSTL18_I")),
Subsignal("data_g", DiffPairs("lvds1_p", "lvds1_n", dir='o', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="DIFF_SSTL18_I")),
Subsignal("data_r", DiffPairs("lvds0_p", "lvds0_n", dir='o', conn=("plugin", plugin_number)), Attrs(IOSTANDARD="DIFF_SSTL18_I")),
*lowspeed_signals
)
])
# uart Rx -> ext Tx
# ext Rx -> uart Tx
m.d.comb += [
ext_pins.tx.eq(uart_pins.rx),
uart_pins.tx.eq(ext_pins.rx),
]
return m
if __name__ == '__main__':
plat = ICEBreakerPlatform()
plat.add_resources(plat.break_off_pmod)
# The external IO pins to use
ext_io = [
Resource(
'ext_io',
0,
# External Input
Subsignal('rx', Pins('4', dir='i', conn=('pmod', 0)),
Attrs(IO_STANDARD="LVCMOS33", PULLUP=1)),
# External Output
Subsignal('tx', Pins('3', dir='o', conn=('pmod', 0)),
Attrs(IO_STANDARD="LVCMOS33", PULLUP=1)),
),
]
plat.add_resources(ext_io)
plat.build(Top(pins='ext_io'), do_program=True)
def connect_mainboard(self):
add_plugin_connector(
platform=self,
number="south",
conn=("JX2", 0),
lvds=["94 96", "93 95", "97 99", "87 89", "81 83", "73 75"],
)
add_plugin_connector(
platform=self,
number="north",
conn=("JX1", 0),
lvds=["68 70", "74 76", "82 84", "92 94", "93 91", "89 87"])
lvds_lanes = []
for lane, pins in CMV_LVDS_LANES.items():
lvds_lanes.append(
Subsignal(
f"lvds_{lane}",
DiffPairs(*pins, dir='i', invert=(
lane == 37)), # lane 37 inverted to simplify routing
Attrs(IOSTANDARD="LVDS_25",
DIFF_TERM="TRUE",
IBUF_LOW_PWR="TRUE")))
self.add_resources([
Resource(
"sensor",
0,
Subsignal("clk", Pins("19", dir='o', conn=("JX1", 0)),
Attrs(IOSTANDARD="LVCMOS25")),
Subsignal("reset", PinsN("17", dir='o', conn=("JX1", 0)),
Attrs(IOSTANDARD="LVCMOS25")),
Subsignal("frame_req", Pins("9", dir='o', conn=("JX1", 0)),
Attrs(IOSTANDARD="LVCMOS25")),
Subsignal("t_exp1", Pins("10", dir='o', conn=("JX1", 0)),
Attrs(IOSTANDARD="LVCMOS25")),
Subsignal("t_exp2", Pins("100", dir='o', conn=("JX2", 0)),
Attrs(IOSTANDARD="LVCMOS25")),
Subsignal("lvds_clk",
DiffPairs("81", "83", dir='o', conn=("JX1", 0)),
Attrs(IOSTANDARD="LVDS_25")),
*lvds_lanes,
Subsignal(
"lvds_ctrl", DiffPairs("82",
"84",
dir='i',
conn=("JX2", 0)),
Attrs(IOSTANDARD="LVDS_25",
DIFF_TERM="TRUE",
IBUF_LOW_PWR="TRUE")),
Subsignal(
"lvds_outclk",
DiffPairsN("48", "50", dir='i', conn=("JX1", 0)),
Attrs(IOSTANDARD="LVDS_25",
DIFF_TERM="TRUE",
IBUF_LOW_PWR="TRUE")),
),
Resource(
"sensor_spi",
0,
Subsignal("cs", Pins("24", dir='o', conn=("JX1", 0)),
Attrs(IOSTANDARD="LVCMOS25")),
Subsignal("clk", Pins("26", dir='o', conn=("JX1", 0)),
Attrs(IOSTANDARD="LVCMOS25")),
Subsignal("copi", Pins("29", dir='o', conn=("JX2", 0)),
Attrs(IOSTANDARD="LVCMOS25")),
Subsignal("cipo", Pins("31", dir='i', conn=("JX2", 0)),
Attrs(IOSTANDARD="LVCMOS25")),
),
])
# TODO: add ext & shield connectors (but how?)
# best would be a way to (transpranetly) handle the routing fabrics
self.add_resources([
Resource("routing", 'east',
DiffPairs('29', '31', dir='io', conn=("JX2", 0)),
Attrs(IOSTANDARD="LVCMOS33")),
Resource("routing", 'west', Pins("56", dir='o', conn=("JX1", 0)),
Attrs(IOSTANDARD="LVCMOS33")),
])
class OrangeCrabR0D1(OrangeCrabPlatform, LUNAPlatform):
""" Board description for OrangeCrab r0.1. """
name = "OrangeCrab r0.1"
#
# I/O resources.
#
resources = [
Resource("clk_48MHz", 0, Pins("A9"), Attrs(IO_TYPE="LVCMOS33"),
Clock(48e6)),
Resource(
"rgb_led",
0,
Subsignal("r", Pins("V17"), Attrs(IO_TYPE="LVCMOS33")),
Subsignal("g", Pins("T17"), Attrs(IO_TYPE="LVCMOS33")),
Subsignal("b", Pins("J3"), Attrs(IO_TYPE="LVCMOS33")),
),
Resource(
"ddram", 0,
Subsignal("a", Pins("A4 D2 C3 C7 D3 D4 D1 B2 C1 A2 A7 C2 C4"),
Attrs(IO_TYPE="SSTL135_I")),
Subsignal("ba", Pins("B6 B7 A6"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("ras_n", Pins("C12"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("cas_n", Pins("D13"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("we_n", Pins("B12"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("cs_n", Pins("A12"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("dm", Pins("D16 G16"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal(
"dq",
Pins(
"C17 D15 B17 C16 A15 B13 A17 A13 F17 F16 G15 F15 J16 C18 H16 F18"
), Attrs(IO_TYPE="SSTL135_I", TERMINATION="75")),
Subsignal(
"dqs_p", Pins("B15 G18"),
Attrs(IO_TYPE="SSTL135D_I",
TERMINATION="OFF",
DIFFRESISTOR="100")),
Subsignal("clk_p", Pins("J18"), Attrs(IO_TYPE="SSTL135D_I")),
Subsignal("cke", Pins("D6"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("odt", Pins("C13"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("reset_n", Pins("B1"), Attrs(IO_TYPE="SSTL135_I")),
Attrs(SLEWRATE="FAST")),
Resource("spiflash4x", 0, Subsignal("cs_n", Pins("U17")),
Subsignal("clk", Pins("U16")),
Subsignal("dq", Pins("U18 T18 R18 N18")),
Attrs(IO_TYPE="LVCMOS33")),
Resource("spi-internal", 0,
Subsignal("cs_n", Pins("B11"), Attrs(PULLMODE="UP")),
Subsignal("clk", Pins("C11")),
Subsignal("miso", Pins("A11"), Attrs(PULLMODE="UP")),
Subsignal("mosi", Pins("A10"), Attrs(PULLMODE="UP")),
Attrs(IO_TYPE="LVCMOS33", SLEWRATE="SLOW")),
Resource(
"spisdcard",
0,
Subsignal("clk", Pins("K1")),
Subsignal("mosi", Pins("K2"), Attrs(PULLMODE="UP")),
Subsignal("cs_n", Pins("M1"), Attrs(PULLMODE="UP")),
Subsignal("miso", Pins("J1"), Attrs(PULLMODE="UP")),
Attrs(IO_TYPE="LVCMOS33", SLEWRATE="FAST"),
),
# USB Connector.
Resource("usb", 0, Subsignal("d_p", Pins("N1", dir="io")),
Subsignal("d_n", Pins("M2", dir="io")),
Subsignal("pullup", Pins("N2", dir="o")),
Attrs(IO_TYPE="LVCMOS33")),
]
connectors = [
Connector(
"GPIO", 0,
"N17 M18 C10 C9 - B10 B9 - - C8 B8 A8 H2 J2 N15 R17 N16 - - - - - - - -"
)
]
class DaishoPlatform(IntelPlatform):
""" Board description for Daisho boards."""
name = "Daisho"
device = "EEP4CE30F29C8"
default_clk = "clk_60MHz"
#
# Default clock frequencies for each of our clock domains.
#
# Different revisions have different FPGA speed grades, and thus the
# default frequencies will vary.
#
DEFAULT_CLOCK_FREQUENCIES_MHZ = {
"fast": 120,
"sync": 60,
"ulpi": 60
}
#
# Preferred DRAM bus I/O (de)-skewing constants.
#
ram_timings = dict(
clock_skew = 64
)
# Provides any platform-specific ULPI registers necessary.
# This is the spot to put any platform-specific vendor registers that need
# to be written.
ulpi_extra_registers = {
0x39: 0b000110 # USB3343: swap D+ and D- to match the LUNA boards
}
#
# I/O resources.
#
resources = [
# Primary, discrete 60MHz oscillator.
Resource("clk_60MHz", 0, Pins("A8", dir="i"),
Clock(60e6), Attrs(IO_TYPE="LVCMOS33")),
# Connection to our SPI flash; can be used to work with the flash
# from e.g. a bootloader.
Resource("spi_flash", 0,
# SCK is on pin 9; but doesn't have a traditional I/O buffer.
# Instead, we'll need to drive a clock into a USRMCLK instance.
# See interfaces/flash.py for more information.
Subsignal("sdi", Pins("T8", dir="o")),
Subsignal("sdo", Pins("T7", dir="i")),
# In r0.1, the chip select line can either be driven by the FPGA
# or by the Debug Controller. Accordingly, we'll mark the line as
# bidirectional, and let the user decide.
Subsignal("cs", PinsN("N8", dir="io")),
Attrs(IO_TYPE="LVCMOS33")
),
#
# Note: r0.1 has a DFM issue that makes it difficult to solder a BGA with
# reliable connections on the intended SCK pin (P12), and lacks a CS pin on the
# debug SPI; which seems like a silly omission.
#
# Accordingly, we're mapping the debug SPI and UART over the same pins, as the
# microcontroller can use either.
#
# UART connected to the debug controller; can be routed to a host via CDC-ACM.
Resource("uart", 0,
Subsignal("rx", Pins("R14", dir="i")),
Subsignal("tx", Pins("T14", dir="o")),
Attrs(IO_TYPE="LVCMOS33")
),
# SPI bus connected to the debug controller, for simple register exchanges.
# Note that the Debug Controller is the master on this bus.
Resource("debug_spi", 0,
Subsignal("sck", Pins( "R14", dir="i")),
Subsignal("sdi", Pins( "P13", dir="i")),
Subsignal("sdo", Pins( "P11", dir="o")),
Subsignal("cs", PinsN("T14", dir="i")),
Attrs(IO_TYPE="LVCMOS33")
),
# FPGA-connected LEDs.
Resource("led", 5, PinsN("P15", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("led", 4, PinsN("N16", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("led", 3, PinsN("M15", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("led", 2, PinsN("M16", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("led", 1, PinsN("L15", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("led", 0, PinsN("L16", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
# USB PHYs
ULPIResource("sideband_phy",
data_sites="R2 R1 P2 P1 N1 M2 M1 L2", clk_site="R4",
dir_site="T3", nxt_site="T2", stp_site="T4", reset_site="R3"),
ULPIResource("host_phy",
data_sites="G2 G1 F2 F1 E1 D1 C1 B1", clk_site="K2",
dir_site="J1", nxt_site="H2", stp_site="J2", reset_site="K1"),
ULPIResource("target_phy",
data_sites="D16 E15 E16 F15 F16 G15 J16 K16", clk_site="B15",
dir_site="C15", nxt_site="C16", stp_site="B16", reset_site="G16"),
# Target port power switching
# Note: the r0.1 boards that have been produced incorrectly use the AP22814B
# instead of the AP22814A. This inverts the load-switch enables.
#
Resource("power_a_port", 0, PinsN("C14", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("pass_through_vbus", 0, PinsN("D14", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("target_vbus_fault", 0, Pins("K15", dir="i"), Attrs(IO_TYPE="LVCMOS33")),
# HyperRAM (1V8 domain).
Resource("ram", 0,
# Note: our clock uses the pseudo-differential I/O present on the top tiles.
# This requires a recent version of trellis+nextpnr. If your build complains
# that LVCMOS18D is an invalid I/O type, you'll need to upgrade.
Subsignal("clk", DiffPairs("B14", "A15", dir="o"), Attrs(IO_TYPE="LVCMOS18D")),
Subsignal("dq", Pins("A11 B10 B12 A12 B11 A10 B9 A9", dir="io")),
Subsignal("rwds", Pins( "A13", dir="io")),
Subsignal("cs", PinsN("A14", dir="o")),
Subsignal("reset", PinsN("B13", dir="o")),
Attrs(IO_TYPE="LVCMOS18", SLEWRATE="FAST")
),
# User I/O connections.
Resource("user_io", 0, Pins("A5", dir="io"), Attrs(IO_TYPE="LVCMOS33", SLEWRATE="FAST")),
Resource("user_io", 1, Pins("A4", dir="io"), Attrs(IO_TYPE="LVCMOS33", SLEWRATE="FAST")),
Resource("user_io", 2, Pins("A3", dir="io"), Attrs(IO_TYPE="LVCMOS33", SLEWRATE="FAST")),
Resource("user_io", 3, Pins("A2", dir="io"), Attrs(IO_TYPE="LVCMOS33", SLEWRATE="FAST")),
]
connectors = [
# User I/O connector.
Connector("user_io", 0, """
A5 - A2
A4 - A3
""")
]
def toolchain_prepare(self, fragment, name, **kwargs):
overrides = {
'ecppack_opts': '--compress --idcode {} --freq 38.8'.format(0x21111043)
}
return super().toolchain_prepare(fragment, name, **overrides, **kwargs)
def toolchain_program(self, products, name):
""" Programs the relevant LUNA board via its sideband connection. """
from luna.apollo import ApolloDebugger
from luna.apollo.ecp5 import ECP5_JTAGProgrammer
# Create our connection to the debug module.
debugger = ApolloDebugger()
# Grab our generated bitstream, and upload it to the FPGA.
bitstream = products.get("{}.bit".format(name))
with debugger.jtag as jtag:
programmer = ECP5_JTAGProgrammer(jtag)
programmer.configure(bitstream)
def toolchain_flash(self, products, name="top"):
""" Programs the LUNA board's flash via its sideband connection. """
from luna.apollo import ApolloDebugger
from luna.apollo.flash import ensure_flash_gateware_loaded
# Create our connection to the debug module.
debugger = ApolloDebugger()
ensure_flash_gateware_loaded(debugger, platform=self.__class__())
# Grab our generated bitstream, and upload it to the .
bitstream = products.get("{}.bit".format(name))
with debugger.flash as flash:
flash.program(bitstream)
debugger.soft_reset()
def toolchain_erase(self):
""" Erases the LUNA board's flash. """
from luna.apollo import ApolloDebugger
from luna.apollo.flash import ensure_flash_gateware_loaded
# Create our connection to the debug module.
debugger = ApolloDebugger()
ensure_flash_gateware_loaded(debugger, platform=self.__class__())
with debugger.flash as flash:
flash.erase()
debugger.soft_reset()
class OrangeCrabR0D2(OrangeCrabPlatform, LUNAPlatform):
""" Board description for OrangeCrab r0.2. """
name = "OrangeCrab r0.2"
#
# I/O resources.
#
resources = [
# System clock.
Resource("clk_48MHz", 0, Pins("A9"), Attrs(IO_TYPE="LVCMOS33"),
Clock(48e6)),
# Self-reset.
Resource("rst_n", 0, Pins("V17"), Attrs(IO_TYPE="LVCMOS33")),
# Buttons.
Resource("user_button", 0, Pins("J17"), Attrs(IO_TYPE="SSTL135_I")),
# LEDs.
Resource(
"rgb_led",
0,
Subsignal("r", Pins("K4", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Subsignal("g", Pins("M3", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Subsignal("b", Pins("J3", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
),
# Create aliases for our LEDs with standard naming.
Resource("led", 0, Pins("K4", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("led", 1, Pins("M3", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
Resource("led", 2, Pins("J3", dir="o"), Attrs(IO_TYPE="LVCMOS33")),
# RAM.
Resource(
"ddram", 0,
Subsignal(
"a", Pins("C4 D2 D3 A3 A4 D4 C3 B2"
"B1 D1 A7 C2 B6 C1 A2 C7"),
Attrs(IO_TYPE="SSTL135_I")),
Subsignal(
"ba",
Pins("D6 B7 A6"),
Attrs(IO_TYPE="SSTL135_I"),
), Subsignal("ras_n", Pins("C12"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("cas_n", Pins("D13"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("we_n", Pins("B12"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("cs_n", Pins("A12"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("dm", Pins("D16 G16"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal(
"dq",
Pins("C17 D15 B17 C16 A15 B13 A17 A13"
"F17 F16 G15 F15 J16 C18 H16 F18"),
Attrs(IO_TYPE="SSTL135_I"), Attrs(TERMINATION="75")),
Subsignal("dqs_p", Pins("B15 G18"), Attrs(IO_TYPE="SSTL135D_I"),
Attrs(TERMINATION="OFF"), Attrs(DIFFRESISTOR="100")),
Subsignal("clk_p", Pins("J18"), Attrs(IO_TYPE="SSTL135D_I")),
Subsignal("cke", Pins("D18"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("odt", Pins("C13"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("reset_n", Pins("L18"), Attrs(IO_TYPE="SSTL135_I")),
Subsignal("vccio", Pins("K16 D17 K15 K17 B18 C6"),
Attrs(IO_TYPE="SSTL135_II")),
Subsignal("gnd", Pins("L15 L16"), Attrs(IO_TYPE="SSTL135_II")),
Attrs(SLEWRATE="FAST")),
# USB Connector.
Resource("usb", 0, Subsignal("d_p", Pins("N1", dir="io")),
Subsignal("d_n", Pins("M2", dir="io")),
Subsignal("pullup", Pins("N2", dir="o")),
Attrs(IO_TYPE="LVCMOS33")),
# Onboard flash.
Resource(
"spiflash4x",
0,
Subsignal("cs_n", Pins("U17"), Attrs(IO_TYPE="LVCMOS33")),
#Subsignal("clk", Pins("U16"), Attrs(IO_TYPE="LVCMOS33")),
Subsignal("dq", Pins("U18 T18 R18 N18"),
Attrs(IO_TYPE="LVCMOS33")),
),
Resource(
"spiflash",
0,
Subsignal("cs_n", Pins("U17"), Attrs(IO_TYPE="LVCMOS33")),
#Subsignal("clk", Pins("U16"), Attrs(IO_TYPE="LVCMOS33")), # Note: CLK is bound using USRMCLK block
Subsignal("miso", Pins("T18"), Attrs(IO_TYPE="LVCMOS33")),
Subsignal("mosi", Pins("U18"), Attrs(IO_TYPE="LVCMOS33")),
Subsignal("wp", Pins("R18"), Attrs(IO_TYPE="LVCMOS33")),
Subsignal("hold", Pins("N18"), Attrs(IO_TYPE="LVCMOS33")),
),
# SD Card.
Resource(
"spisdcard",
0,
Subsignal("clk", Pins("K1")),
Subsignal("mosi", Pins("K2"), Attrs(PULLMODE="UP")),
Subsignal("cs_n", Pins("M1"), Attrs(PULLMODE="UP")),
Subsignal("miso", Pins("J1"), Attrs(PULLMODE="UP")),
Attrs(SLEW="FAST"),
Attrs(IO_TYPE="LVCMOS33"),
),
# User I/O
Resource("user_io", 0, Pins("N17")),
Resource("user_io", 1, Pins("M18")),
Resource("user_io", 2, Pins("C10")),
Resource("user_io", 3, Pins("C9")),
# 4
Resource("user_io", 5, Pins("B10")),
Resource("user_io", 6, Pins("B9")),
# 7
# 8
Resource("user_io", 9, Pins("C8")),
Resource("user_io", 10, Pins("B8")),
Resource("user_io", 11, Pins("A8")),
Resource("user_io", 12, Pins("H2")),
Resource("user_io", 13, Pins("J2")),
Resource("user_io", 14, Pins("N15")),
Resource("user_io", 15, Pins("R17")),
Resource("user_io", 16, Pins("N16")),
# 17
Resource("user_io", 18, Pins("L4")),
Resource("user_io", 19, Pins("N3")),
Resource("user_io", 20, Pins("N4")),
Resource("user_io", 21, Pins("H4")),
Resource("user_io", 22, Pins("G4")),
Resource("user_io", 23, Pins("T17")),
]
connectors = [
Connector(
"GPIO", 0,
"N17 M18 C10 C9 - B10 B9 - - C8 B8 A8 H2 J2 N15 R17 N16 - L4 N3 N4 H4 G4 T17"
)
]