I3C 8-bit Address Memory Target¶

The PxI3C8BitAddressMemoryTarget class emulates a byte-addressable memory device on an I3C bus. A controller writes an 8-bit memory index, then reads or writes data bytes with auto-increment.

Features¶

256-byte memory map with 8-bit indexing and auto-increment.
CCC handling including address assignment, MRL/MWL, GETCAPS, GETSTATUS, GETMXDS, and group addresses.
IBI and Hot-Join support when enabled through CCCs.
Memory events via memory_target_read_event and memory_target_write_event.

PxI3C8BitAddressMemoryTarget ¶

PxI3C8BitAddressMemoryTarget(
    exerciser: AqProtocolExerciser,
    *args,
    pid: int | None = None,
    bcr: int = 0,
    dcr: int = 0,
    config: I3C8BitAddressMemoryTargetConfig | None = None,
    static_addr: int = 0,
    minimum_mrl: int | None = None,
    minimum_mwl: int | None = None,
    getcaps_std_value: bytes | None = None,
    getcaps_usr_value: list[tuple[int, bytes]] | None = None,
    getstatus_std_value: bytes | None = None,
    getstatus_usr_value: list[tuple[int, bytes]] | None = None,
    getmxds_std_value: bytes | None = None,
    getmxds_usr_value: list[tuple[int, bytes]] | None = None,
    supported_group_address_count: int = 3,
    **kwargs
)

Bases: PxAbstractTarget

I3C byte-addressable memory target.

Emulates a 256-byte memory device on an I3C bus. Controllers access memory using a 7-bit device address plus an 8-bit sub-address (memory offset), then read or write data bytes with auto-increment.

Use read_mem and write_mem to access backing store from Python. Bus reads and writes from a controller emit memory_target_read_event and memory_target_write_event notifications. The target also supports standard I3C CCC handling, IBI, and Hot-Join like other I3C targets.

CLASS	DESCRIPTION
`IbiType`	IBI type enumeration.
`HotJoinType`	Hot-Join type enumeration.

METHOD	DESCRIPTION
`add_event_handler`	Add an event handler to the current device instance.
`remove_event_handler`	Remove an event handler.
`get_event_handlers`	Retreive handlers registerd on this device.
`on_event`	Add an event handler to the instance by decorator.
`set_config`	Set the config of the target.
`detach_from_bus`	Detach the device from the bus.
`perform_operation`	Send an operation.
`attach_to_bus`	Attach the target to a bus.
`ibi_request`	Initiate an IBI request from the current target.
`send_hotjoin`	Initiate a Hot-Join request from the current target.
`read_mem`	Read bytes from backing store via the Protocol Exerciser API.
`write_mem`	Write bytes to backing store via the Protocol Exerciser API.

ATTRIBUTE	DESCRIPTION
`available_events_map`	A reverse mapping of `field_name_by_number`, which uses field name as key. TYPE: `dict[str, str]`
`is_attached`	Check if the device is attached to a bus. TYPE: `bool`
`state`	Get the state of the device. TYPE: `Message \| None`
`name`	Get the name of the device. TYPE: `str`
`additional_data`	Get the opaque additional data blob associated with this device. TYPE: `bytes`
`config`	Get the config of the device. TYPE: `Message \| None`
`cts_op_name`	Get the name of CTS operation. Currently not available now. TYPE: `str \| None`
`static_address`	Static address of the I3C memory target. TYPE: `int`
`assigned_address`	Get the assigned address of the target. TYPE: `int`
`event_state`	Get the event state of the target. TYPE: `int`
`group_addresses`	Get the group addresses assigned to the target. TYPE: `list[int]`
`mrl`	Get the maximum read length of the target. TYPE: `int`
`mwl`	Get the maximum write length of the target. TYPE: `int`

available_events_map ¶

available_events_map: dict[str, str]

A reverse mapping of field_name_by_number, which uses field name as key.

is_attached ¶

is_attached: bool

Check if the device is attached to a bus.

state ¶

state: Message | None

Get the state of the device.

name ¶

name: str

Get the name of the device.

additional_data ¶

additional_data: bytes

Get the opaque additional data blob associated with this device.

config ¶

config: Message | None

Get the config of the device.

cts_op_name ¶

cts_op_name: str | None

Get the name of CTS operation. Currently not available now.

static_address ¶

static_address: int

Static address of the I3C memory target.

assigned_address ¶

assigned_address: int

Get the assigned address of the target.

event_state ¶

event_state: int

Get the event state of the target.

group_addresses ¶

group_addresses: list[int]

Get the group addresses assigned to the target.

mrl ¶

mrl: int

Get the maximum read length of the target.

mwl ¶

mwl: int

Get the maximum write length of the target.

IbiType ¶

Bases: IntEnum

IBI type enumeration.

HotJoinType ¶

Bases: IntEnum

Hot-Join type enumeration.

add_event_handler ¶

add_event_handler(event: str, handler: Callable[[Any], Any]) -> None

Add an event handler to the current device instance.

remove_event_handler ¶

remove_event_handler(event: str) -> None

Remove an event handler.

get_event_handlers ¶

get_event_handlers() -> dict[str, Callable]

Retreive handlers registerd on this device.

on_event ¶

on_event(event_type: str) -> Callable[[Callable[..., Any]], Callable[..., Any]]

Add an event handler to the instance by decorator.

set_config ¶

set_config(config: Message) -> None

Set the config of the target.

detach_from_bus ¶

detach_from_bus() -> None

Detach the device from the bus.

The opposite of the attach_to_bus method.

perform_operation ¶

perform_operation(operation: PxDeviceOperation) -> PxDeviceOperation

Send an operation.

attach_to_bus ¶

attach_to_bus(bus: PxAbstractBus) -> None

Attach the target to a bus.

This method is used to make the device aware of the bus it is connected to. It is used to set the bus attribute of the device.

Note

This method will not automatically create an actual instance on the Protocol Exerciser until user call the attach_to_bus method.

PARAMETER	DESCRIPTION
`bus` ¶	The bus to attach the device to TYPE: `PxAbstractBus`

RAISES	DESCRIPTION
`ValueError`	If the device is already attached to a bus

ibi_request ¶

ibi_request(
    ibi_type: IbiType = IMMEDIATE,
    mdb_value: bytes = b"",
    additional_data: bytes = b"",
    skip_bcr_check: bool = False,
) -> None

Initiate an IBI request from the current target.

send_hotjoin ¶

send_hotjoin(hotjoin_type: HotJoinType = IMMEDIATE) -> None

Initiate a Hot-Join request from the current target.

read_mem ¶

read_mem(addr: int, count: int) -> list[int]

Read bytes from backing store via the Protocol Exerciser API.

write_mem ¶

write_mem(addr: int, data: list[int]) -> None

Write bytes to backing store via the Protocol Exerciser API.