def elaborate(self, platform):
m = Module()
# Generate our domain clocks/resets.
m.submodules.car = platform.clock_domain_generator()
# Create our USB device interface...
ulpi = platform.request("target_phy")
m.submodules.usb = usb = USBDevice(bus=ulpi)
# Add our standard control endpoint to the device.
descriptors = self.create_descriptors()
usb.add_standard_control_endpoint(descriptors)
# Connect our device as a high speed device by default.
m.d.comb += [
usb.connect.eq(1),
usb.full_speed_only.eq(1 if os.getenv('LUNA_FULL_ONLY') else 0),
]
# ... and for now, attach our LEDs to our most recent control request.
m.d.comb += [
platform.request('led', 0).eq(usb.tx_activity_led),
platform.request('led', 1).eq(usb.rx_activity_led),
platform.request('led', 2).eq(usb.suspended),
]
return m
def elaborate(self, platform):
m = Module()
m.submodules.soc = self.soc
# Generate our domain clocks/resets.
m.submodules.car = platform.clock_domain_generator(
CLOCK_FREQUENCIES_MHZ)
# Connect up our UART.
uart_io = platform.request("uart", 0)
m.d.comb += [
uart_io.tx.eq(self.uart_pins.tx),
self.uart_pins.rx.eq(uart_io.rx)
]
# Create our USB device.
ulpi = platform.request("target_phy")
m.submodules.usb = usb = USBDevice(bus=ulpi)
# Connect up our device controller.
m.d.comb += self.controller.attach(usb)
# Add our eptri endpoint handlers.
usb.add_endpoint(self.setup)
usb.add_endpoint(self.in_ep)
usb.add_endpoint(self.out_ep)
return m
def elaborate(self, platform):
m = Module()
m.submodules.soc = self.soc
# Check for our prerequisites before building.
if not os.path.exists("eptri_example.bin"):
logging.error(
"Firmware binary not found -- you may want to build this with `make program`."
)
sys.exit(-1)
# Generate our domain clocks/resets.
m.submodules.car = platform.clock_domain_generator(
clock_frequencies=CLOCK_FREQUENCIES_MHZ)
# Connect up our UART.
uart_io = platform.request("uart", 0)
m.d.comb += [
uart_io.tx.eq(self.uart_pins.tx),
self.uart_pins.rx.eq(uart_io.rx)
]
# Create our USB device.
ulpi = platform.request(platform.default_usb_connection)
m.submodules.usb = usb = USBDevice(bus=ulpi)
# Connect up our device controller.
m.d.comb += self.controller.attach(usb)
# Add our eptri endpoint handlers.
usb.add_endpoint(self.setup)
usb.add_endpoint(self.in_ep)
usb.add_endpoint(self.out_ep)
return m
def elaborate(self, platform):
m = Module()
# Generate our domain clocks/resets.
m.submodules.car = platform.clock_domain_generator()
# Create our USB device interface...
ulpi = platform.request("target_phy")
m.submodules.usb = usb = USBDevice(bus=ulpi)
# Add our standard control endpoint to the device.
descriptors = self.create_descriptors()
usb.add_standard_control_endpoint(descriptors)
# Add our endpoint.
test_ep = StressTestEndpoint(endpoint_number=BULK_ENDPOINT_NUMBER,
max_packet_size=MAX_BULK_PACKET_SIZE,
constant=CONSTANT_TO_SEND)
usb.add_endpoint(test_ep)
# Connect our device as a high speed device by default.
m.d.comb += [
usb.connect.eq(1),
usb.full_speed_only.eq(1 if os.getenv('LUNA_FULL_ONLY') else 0),
]
return m
def elaborate(self, platform):
m = Module()
m.submodules.soc = self.soc
# Generate our domain clocks/resets.
m.submodules.car = platform.clock_domain_generator(
clock_frequencies=CLOCK_FREQUENCIES_MHZ)
# Connect up our UART.
uart_io = platform.request("uart", 0)
m.d.comb += [
uart_io.tx.eq(self.uart_pins.tx),
self.uart_pins.rx.eq(uart_io.rx)
]
if hasattr(uart_io.tx, 'oe'):
m.d.comb += uart_io.tx.oe.eq(~self.soc.uart._phy.tx.rdy),
# Create our USB device.
ulpi = platform.request(platform.default_usb_connection)
m.submodules.usb = usb = USBDevice(bus=ulpi)
# Connect up our device controller.
m.d.comb += self.usb_device_controller.attach(usb)
# Add our eptri endpoint handlers.
usb.add_endpoint(self.usb_setup)
usb.add_endpoint(self.usb_in_ep)
usb.add_endpoint(self.usb_out_ep)
return m
def elaborate(self, platform):
m = Module()
# Generate our domain clocks/resets.
m.submodules.car = platform.clock_domain_generator()
# Create our USB device interface...
ulpi = platform.request("target_phy")
m.submodules.usb = usb = USBDevice(bus=ulpi)
# Add our standard control endpoint to the device.
descriptors = self.create_descriptors()
usb.add_standard_control_endpoint(descriptors)
# Add a stream endpoint to our device.
stream_ep = USBStreamInEndpoint(endpoint_number=BULK_ENDPOINT_NUMBER,
max_packet_size=MAX_BULK_PACKET_SIZE)
usb.add_endpoint(stream_ep)
# Send entirely zeroes, as fast as we can.
m.d.comb += [
stream_ep.stream.valid.eq(1),
stream_ep.stream.payload.eq(0)
]
# Connect our device as a high speed device by default.
m.d.comb += [
usb.connect.eq(1),
usb.full_speed_only.eq(1 if os.getenv('LUNA_FULL_ONLY') else 0),
]
return m
def elaborate(self, platform):
m = Module()
# Generate our domain clocks/resets.
m.submodules.car = LunaECP5DomainGenerator()
# Create our USB device interface...
ulpi = platform.request("target_phy")
m.submodules.usb = usb = USBDevice(bus=ulpi)
# Connect our device by default.
m.d.comb += usb.connect.eq(1)
# ... and for now, attach our LEDs to our most recent control request.
leds = Cat(platform.request("led", i) for i in range(6))
m.d.comb += leds.eq(usb.last_request)
return m
def elaborate(self, platform):
m = Module()
# Generate our domain clocks/resets.
m.submodules.car = LunaECP5DomainGenerator()
# Create our USB device interface...
ulpi = platform.request("target_phy")
m.submodules.usb = usb = USBDevice(bus=ulpi)
# Add our standard control endpoint to the device.
descriptors = self.create_descriptors()
usb.add_standard_control_endpoint(descriptors)
# Add a stream endpoint to our device.
stream_ep = USBStreamInEndpoint(
endpoint_number=self.BULK_ENDPOINT_NUMBER,
max_packet_size=self.MAX_BULK_PACKET_SIZE
)
usb.add_endpoint(stream_ep)
# Always generate a monotonic count for our stream, which counts every time our
# stream endpoint accepts a data byte.
counter = Signal(8)
with m.If(stream_ep.stream.ready):
m.d.usb += counter.eq(counter + 1)
m.d.comb += [
stream_ep.stream.valid .eq(1),
stream_ep.stream.payload .eq(counter)
]
# Connect our device as a high speed device by default.
m.d.comb += [
usb.connect .eq(1),
usb.full_speed_only .eq(1 if os.getenv('LUNA_FULL_ONLY') else 0),
]
return m
def elaborate(self, platform):
m = Module()
# Generate our domain clocks/resets.
m.submodules.car = platform.clock_domain_generator()
# Create our USB device interface...
ulpi = platform.request(platform.default_usb_connection)
m.submodules.usb = usb = USBDevice(bus=ulpi)
# Add our standard control endpoint to the device.
descriptors = self.create_descriptors()
control_ep = usb.add_standard_control_endpoint(descriptors)
# Add our custom request handlers.
control_ep.add_request_handler(LEDRequestHandler())
# Connect our device by default.
m.d.comb += usb.connect.eq(1)
return m
