def do_test(arch, tx_clk, tx_phy, seed):
rand = random.Random()
rand.seed(seed)
dev_address = get_dut_address()
ep = 0
# The inter-frame gap is to give the DUT time to print its output
packets = []
AppendSetupToken(packets, ep)
packets.append(TxDataPacket(rand, length=3, pid=3, bad_crc=True))
#packets.append(RxHandshakePacket())
AppendSetupToken(packets, ep)
packets.append(TxDataPacket(rand, length=8, pid=3, bad_crc=False))
packets.append(RxHandshakePacket(timeout=11))
# Note, quite big gap to allow checking.
packets.append(
TokenPacket(
inter_pkt_gap=2000,
pid=0xe1, #OUT
address=dev_address,
endpoint=ep))
packets.append(TxDataPacket(rand, length=10, pid=0xb))
packets.append(RxHandshakePacket())
packets.append(
TokenPacket(
inter_pkt_gap=2000,
pid=0x69, #OUT
address=dev_address,
endpoint=ep))
#Expect 0-length
packets.append(RxDataPacket(rand, length=0, pid=0x4b))
# Send ACK
packets.append(TxHandshakePacket())
do_rx_test(arch,
tx_clk,
tx_phy,
packets,
__file__,
seed,
level='smoke',
extra_tasks=[])
def do_test(arch, tx_clk, tx_phy, seed):
rand = random.Random()
rand.seed(seed)
ep = 0
# The inter-frame gap is to give the DUT time to print its output
packets = []
# SETUP transaction
AppendSetupToken(packets, ep)
packets.append(TxDataPacket(rand, length=8, pid=3))
packets.append(RxHandshakePacket(timeout=11))
# IN transaction
# Note, quite big gap to allow checking.
packets.append(TokenPacket(
inter_pkt_gap=2000,
pid=0x69, #IN
endpoint=ep))
packets.append(RxDataPacket(rand, length=10, pid=0x4b))
packets.append(TxHandshakePacket())
# Send 0 length OUT transaction
packets.append(TokenPacket(
inter_pkt_gap=2000,
pid=0xe1, #OUT
endpoint=ep))
packets.append(TxDataPacket(rand, length=0, pid=0xb))
packets.append(RxHandshakePacket())
# Send ACK
packets.append(TxHandshakePacket())
do_rx_test(arch,
tx_clk,
tx_phy,
packets,
__file__,
seed,
level='smoke',
extra_tasks=[])
def test_session(ep, address, bus_speed):
pktLength = 10
ied = 500
session = UsbSession(bus_speed=bus_speed,
run_enumeration=False,
device_address=address)
session.add_event(
UsbTransaction(
session,
deviceAddress=address,
endpointNumber=ep,
endpointType="BULK",
transType="OUT",
dataLength=pktLength,
))
# Expect NAK's from DUT
session.add_event(
TokenPacket(
pid=USB_PID["IN"],
address=address,
endpoint=ep,
))
session.add_event(RxHandshakePacket(pid=USB_PID["NAK"]))
session.add_event(
TokenPacket(
pid=USB_PID["OUT"],
address=address,
endpoint=ep,
interEventDelay=ied,
))
session.add_event(
TxDataPacket(
dataPayload=session.getPayload_out(ep, pktLength),
pid=USB_PID["DATA0"],
))
session.add_event(RxHandshakePacket(pid=USB_PID["NAK"]))
return session
def test_session(ep, address, bus_speed):
ied = 500
trafficAddress1 = (address + 1) % 128
trafficAddress2 = (address + 127) % 128
start_length = 0
end_length = start_length + 10
session = UsbSession(
bus_speed=bus_speed, run_enumeration=False, device_address=address
)
for pktLength in range(start_length, end_length):
# SETUP to another address (Note, DUT would not see ACK)
session.add_event(
TokenPacket(
pid=USB_PID["SETUP"],
address=trafficAddress1,
endpoint=ep,
)
)
session.add_event(
TxDataPacket(
dataPayload=[1, 2, 3, 4, 5, 6, 7, 8],
pid=USB_PID["DATA0"],
)
)
session.add_event(
UsbTransaction(
session,
deviceAddress=address,
endpointNumber=ep,
endpointType="CONTROL",
transType="SETUP",
dataLength=8,
)
)
session.add_event(
UsbTransaction(
session,
deviceAddress=address,
endpointNumber=ep,
endpointType="CONTROL",
transType="IN",
dataLength=pktLength,
)
)
# SETUP to another address (Note, DUT would not see ACK)
session.add_event(
TokenPacket(
pid=USB_PID["SETUP"],
address=trafficAddress2,
endpoint=ep,
)
)
session.add_event(
TxDataPacket(
dataPayload=[1, 2, 3, 4, 5, 6, 7, 8],
pid=USB_PID["DATA0"],
)
)
session.add_event(
TokenPacket(
pid=USB_PID["IN"],
address=trafficAddress2,
endpoint=ep,
interEventDelay=1000,
)
)
# Send 0 length OUT transaction
session.add_event(
UsbTransaction(
session,
deviceAddress=address,
endpointNumber=ep,
endpointType="CONTROL",
transType="OUT",
dataLength=0,
)
)
return session
def __init__(
self,
session,
deviceAddress=0,
endpointNumber=0,
endpointType="BULK",
transType="OUT",
bus_speed="HS",
eventTime=0,
dataLength=0,
interEventDelay=INTER_TRANSACTION_DELAY,
badDataCrc=False,
resend=False,
rxeAssertDelay_data=0,
halted=False,
resetDataPid=False,
):
self._deviceAddress = deviceAddress
self._endpointNumber = endpointNumber
self._endpointType = endpointType
self._transType = transType
self._datalength = dataLength
self._bus_speed = bus_speed
self._badDataCrc = badDataCrc
self._rxeAssertDelay_data = rxeAssertDelay_data
self._halted = halted
assert endpointType in USB_EP_TYPES
assert transType in USB_TRANS_TYPES
# Populate packet list for a (valid) transaction
self._packets = []
# TODO would it be better to generate packets on the fly in drive()
# rather than create a packet list?
if transType in ["OUT", "SETUP"]:
packets = []
packets.append(
TokenPacket(
interEventDelay=interEventDelay,
pid=USB_PID[transType],
address=self._deviceAddress,
endpoint=self._endpointNumber,
data_valid_count=self.data_valid_count,
))
# Don't toggle data pid if we had a bad data crc
if (self._badDataCrc or self._rxeAssertDelay_data
or endpointType == "ISO" or halted):
togglePid = False
else:
togglePid = True
if halted:
resetDataPid = True
expectHandshake = ((not self._badDataCrc)
and (not self._rxeAssertDelay_data)
and (deviceAddress == session.deviceAddress)
and (self._endpointType != "ISO"))
if expectHandshake or self._endpointType == "ISO":
resend = False
else:
resend = True
# Generate packet data payload
packetPayload = session.getPayload_out(endpointNumber,
dataLength,
resend=resend)
# Reset data PID's on SETUP transaction
if transType == "SETUP":
pid = session.data_pid_out(endpointNumber,
togglePid=True,
resetDataPid=True)
# If SETUP trans then we need to reset and toggle the corresponding IN EP's PID also
in_pid = session.data_pid_in(endpointNumber,
togglePid=True,
resetDataPid=True)
else:
pid = session.data_pid_out(endpointNumber,
togglePid=togglePid,
resetDataPid=resetDataPid)
# Add data packet to packets list
packets.append(
TxDataPacket(
pid=pid,
dataPayload=packetPayload,
bad_crc=self._badDataCrc,
rxe_assert_time=self._rxeAssertDelay_data,
))
if expectHandshake:
if halted:
packets.append(RxHandshakePacket(pid=USB_PID["STALL"]))
else:
packets.append(RxHandshakePacket())
self._packets.extend(packets)
else:
self._packets.append(
TokenPacket(
interEventDelay=interEventDelay,
pid=USB_PID["IN"],
address=self._deviceAddress,
endpoint=self._endpointNumber,
data_valid_count=self.data_valid_count,
))
if (self._badDataCrc or self._rxeAssertDelay_data
or self._endpointType == "ISO" or halted):
togglePid = False
else:
togglePid = True
if halted:
resetDataPid = True
pid = session.data_pid_in(endpointNumber,
togglePid=togglePid,
resetDataPid=resetDataPid)
# Add data packet to packets list
if not halted:
# Generate packet data payload
packetPayload = session.getPayload_in(endpointNumber,
dataLength)
self._packets.append(
RxDataPacket(pid=pid, dataPayload=packetPayload))
if self._endpointType != "ISO" and not halted:
self._packets.append(TxHandshakePacket())
if halted:
self._packets.append(RxHandshakePacket(pid=USB_PID["STALL"]))
super().__init__(time=eventTime)
def test_session(ep, address, bus_speed):
session = UsbSession(bus_speed=bus_speed,
run_enumeration=False,
device_address=address)
# The large inter-frame gap is to give the DUT time to print its output
interEventDelay = 500
# Valid OUT transaction
session.add_event(
UsbTransaction(
session,
deviceAddress=address,
endpointNumber=ep,
endpointType="BULK",
transType="OUT",
dataLength=10,
interEventDelay=interEventDelay,
))
# OUT Transaction with invalid DATA PID. XCORE should ignore packet - no ACK
session.add_event(
TokenPacket(
pid=USB_PID["OUT"],
address=address,
endpoint=ep,
interEventDelay=interEventDelay,
))
session.add_event(
TxDataPacket(
dataPayload=session.getPayload_out(ep, 11, resend=True),
pid=USB_PID["DATA1"] & 0xF,
))
# Send some valid OUT transactions
session.add_event(
UsbTransaction(
session,
deviceAddress=address,
endpointNumber=ep,
endpointType="BULK",
transType="OUT",
dataLength=11,
interEventDelay=interEventDelay,
))
session.add_event(
UsbTransaction(
session,
deviceAddress=address,
endpointNumber=ep,
endpointType="BULK",
transType="OUT",
dataLength=12,
interEventDelay=interEventDelay,
))
session.add_event(
UsbTransaction(
session,
deviceAddress=address,
endpointNumber=ep,
endpointType="BULK",
transType="OUT",
dataLength=13,
interEventDelay=interEventDelay,
))
return session