------------- Registers -- -------------
subtype CTRL_CLKDIV_RESTART_Field is HAL.UInt4;
type CTRL_Register is record
SM_ENABLE : CTRL_SM_ENABLE_Field := 16#0#;
SM_RESTART : CTRL_SM_RESTART_Field := 16#0#;
CLKDIV_RESTART : CTRL_CLKDIV_RESTART_Field := 16#0#;
Reserved_12_31 : HAL.UInt20 := 16#0#;
end record;
After a write operation all bits in the field are cleared (set to zero). Write 1 to instantly clear internal SM state which may be otherwise difficult to access and will affect future execution.\n\n Specifically, the following are cleared: input and output shift counters; the contents of the input shift register; the delay counter; the waiting-on-IRQ state; any stalled instruction written to SMx_INSTR or run by OUT/MOV EXEC; any pin write left asserted due to OUT_STICKY.
After a write operation all bits in the field are cleared (set to zero). Restart a state machine's clock divider from an initial phase of 0. Clock dividers are free-running, so once started, their output (including fractional jitter) is completely determined by the integer/fractional divisor configured in SMx_CLKDIV. This means that, if multiple clock dividers with the same divisor are restarted simultaneously, by writing multiple 1 bits to this field, the execution clocks of those state machines will run in precise lockstep.\n\n Note that setting/clearing SM_ENABLE does not stop the clock divider from running, so once multiple state machines' clocks are synchronised, it is safe to disable/reenable a state machine, whilst keeping the clock dividers in sync.\n\n Note also that CLKDIV_RESTART can be written to whilst the state machine is running, and this is useful to resynchronise clock dividers after the divisors (SMx_CLKDIV) have been changed on-the-fly.
unspecified
subtype CTRL_SM_ENABLE_Field is HAL.UInt4;
subtype CTRL_SM_RESTART_Field is HAL.UInt4;
subtype DBG_CFGINFO_FIFO_DEPTH_Field is HAL.UInt6;
subtype DBG_CFGINFO_IMEM_SIZE_Field is HAL.UInt6;
type DBG_CFGINFO_Register is record
FIFO_DEPTH : DBG_CFGINFO_FIFO_DEPTH_Field;
Reserved_6_7 : HAL.UInt2;
SM_COUNT : DBG_CFGINFO_SM_COUNT_Field;
Reserved_12_15 : HAL.UInt4;
IMEM_SIZE : DBG_CFGINFO_IMEM_SIZE_Field;
Reserved_22_31 : HAL.UInt10;
end record;
unspecified
Read-only. The number of state machines this PIO instance is equipped with.
unspecified
Read-only. The size of the instruction memory, measured in units of one instruction
unspecified
subtype DBG_CFGINFO_SM_COUNT_Field is HAL.UInt4;
type FDEBUG_Register is record
RXSTALL : FDEBUG_RXSTALL_Field := 16#0#;
Reserved_4_7 : HAL.UInt4 := 16#0#;
RXUNDER : FDEBUG_RXUNDER_Field := 16#0#;
Reserved_12_15 : HAL.UInt4 := 16#0#;
TXOVER : FDEBUG_TXOVER_Field := 16#0#;
Reserved_20_23 : HAL.UInt4 := 16#0#;
TXSTALL : FDEBUG_TXSTALL_Field := 16#0#;
Reserved_28_31 : HAL.UInt4 := 16#0#;
end record;
unspecified
Write data bit of one shall clear (set to zero) the corresponding bit in the field. RX FIFO underflow (i.e. read-on-empty by the system) has occurred. Write 1 to clear. Note that read-on-empty does not perturb the state of the FIFO in any way, but the data returned by reading from an empty FIFO is undefined, so this flag generally only becomes set due to some kind of software error.
unspecified
Write data bit of one shall clear (set to zero) the corresponding bit in the field. TX FIFO overflow (i.e. write-on-full by the system) has occurred. Write 1 to clear. Note that write-on-full does not alter the state or contents of the FIFO in any way, but the data that the system attempted to write is dropped, so if this flag is set, your software has quite likely dropped some data on the floor.
unspecified
Write data bit of one shall clear (set to zero) the corresponding bit in the field. State machine has stalled on empty TX FIFO during a blocking PULL, or an OUT with autopull enabled. Write 1 to clear.
unspecified
subtype FDEBUG_RXSTALL_Field is HAL.UInt4;
subtype FDEBUG_RXUNDER_Field is HAL.UInt4;
subtype FDEBUG_TXOVER_Field is HAL.UInt4;
subtype FDEBUG_TXSTALL_Field is HAL.UInt4;
type FLEVEL_Register is record
TX0 : FLEVEL_TX0_Field;
RX0 : FLEVEL_RX0_Field;
TX1 : FLEVEL_TX1_Field;
RX1 : FLEVEL_RX1_Field;
TX2 : FLEVEL_TX2_Field;
RX2 : FLEVEL_RX2_Field;
TX3 : FLEVEL_TX3_Field;
RX3 : FLEVEL_RX3_Field;
end record;
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
subtype FLEVEL_RX0_Field is HAL.UInt4;
subtype FLEVEL_RX1_Field is HAL.UInt4;
subtype FLEVEL_RX2_Field is HAL.UInt4;
subtype FLEVEL_RX3_Field is HAL.UInt4;
subtype FLEVEL_TX0_Field is HAL.UInt4;
subtype FLEVEL_TX1_Field is HAL.UInt4;
subtype FLEVEL_TX2_Field is HAL.UInt4;
subtype FLEVEL_TX3_Field is HAL.UInt4;
type FSTAT_Register is record
RXFULL : FSTAT_RXFULL_Field;
Reserved_4_7 : HAL.UInt4;
RXEMPTY : FSTAT_RXEMPTY_Field;
Reserved_12_15 : HAL.UInt4;
TXFULL : FSTAT_TXFULL_Field;
Reserved_20_23 : HAL.UInt4;
TXEMPTY : FSTAT_TXEMPTY_Field;
Reserved_28_31 : HAL.UInt4;
end record;
unspecified
Read-only. State machine RX FIFO is empty
unspecified
Read-only. State machine TX FIFO is full
unspecified
Read-only. State machine TX FIFO is empty
unspecified
subtype FSTAT_RXEMPTY_Field is HAL.UInt4;
subtype FSTAT_RXFULL_Field is HAL.UInt4;
subtype FSTAT_TXEMPTY_Field is HAL.UInt4;
subtype FSTAT_TXFULL_Field is HAL.UInt4;
subtype INSTR_MEM0_INSTR_MEM0_Field is HAL.UInt16;
type INSTR_MEM0_Register is record
INSTR_MEM0 : INSTR_MEM0_INSTR_MEM0_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM10_INSTR_MEM10_Field is HAL.UInt16;
type INSTR_MEM10_Register is record
INSTR_MEM10 : INSTR_MEM10_INSTR_MEM10_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM11_INSTR_MEM11_Field is HAL.UInt16;
type INSTR_MEM11_Register is record
INSTR_MEM11 : INSTR_MEM11_INSTR_MEM11_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM12_INSTR_MEM12_Field is HAL.UInt16;
type INSTR_MEM12_Register is record
INSTR_MEM12 : INSTR_MEM12_INSTR_MEM12_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM13_INSTR_MEM13_Field is HAL.UInt16;
type INSTR_MEM13_Register is record
INSTR_MEM13 : INSTR_MEM13_INSTR_MEM13_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM14_INSTR_MEM14_Field is HAL.UInt16;
type INSTR_MEM14_Register is record
INSTR_MEM14 : INSTR_MEM14_INSTR_MEM14_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM15_INSTR_MEM15_Field is HAL.UInt16;
type INSTR_MEM15_Register is record
INSTR_MEM15 : INSTR_MEM15_INSTR_MEM15_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM16_INSTR_MEM16_Field is HAL.UInt16;
type INSTR_MEM16_Register is record
INSTR_MEM16 : INSTR_MEM16_INSTR_MEM16_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM17_INSTR_MEM17_Field is HAL.UInt16;
type INSTR_MEM17_Register is record
INSTR_MEM17 : INSTR_MEM17_INSTR_MEM17_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM18_INSTR_MEM18_Field is HAL.UInt16;
type INSTR_MEM18_Register is record
INSTR_MEM18 : INSTR_MEM18_INSTR_MEM18_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM19_INSTR_MEM19_Field is HAL.UInt16;
type INSTR_MEM19_Register is record
INSTR_MEM19 : INSTR_MEM19_INSTR_MEM19_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM1_INSTR_MEM1_Field is HAL.UInt16;
type INSTR_MEM1_Register is record
INSTR_MEM1 : INSTR_MEM1_INSTR_MEM1_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM20_INSTR_MEM20_Field is HAL.UInt16;
type INSTR_MEM20_Register is record
INSTR_MEM20 : INSTR_MEM20_INSTR_MEM20_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM21_INSTR_MEM21_Field is HAL.UInt16;
type INSTR_MEM21_Register is record
INSTR_MEM21 : INSTR_MEM21_INSTR_MEM21_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM22_INSTR_MEM22_Field is HAL.UInt16;
type INSTR_MEM22_Register is record
INSTR_MEM22 : INSTR_MEM22_INSTR_MEM22_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM23_INSTR_MEM23_Field is HAL.UInt16;
type INSTR_MEM23_Register is record
INSTR_MEM23 : INSTR_MEM23_INSTR_MEM23_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM24_INSTR_MEM24_Field is HAL.UInt16;
type INSTR_MEM24_Register is record
INSTR_MEM24 : INSTR_MEM24_INSTR_MEM24_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM25_INSTR_MEM25_Field is HAL.UInt16;
type INSTR_MEM25_Register is record
INSTR_MEM25 : INSTR_MEM25_INSTR_MEM25_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM26_INSTR_MEM26_Field is HAL.UInt16;
type INSTR_MEM26_Register is record
INSTR_MEM26 : INSTR_MEM26_INSTR_MEM26_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM27_INSTR_MEM27_Field is HAL.UInt16;
type INSTR_MEM27_Register is record
INSTR_MEM27 : INSTR_MEM27_INSTR_MEM27_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM28_INSTR_MEM28_Field is HAL.UInt16;
type INSTR_MEM28_Register is record
INSTR_MEM28 : INSTR_MEM28_INSTR_MEM28_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM29_INSTR_MEM29_Field is HAL.UInt16;
type INSTR_MEM29_Register is record
INSTR_MEM29 : INSTR_MEM29_INSTR_MEM29_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM2_INSTR_MEM2_Field is HAL.UInt16;
type INSTR_MEM2_Register is record
INSTR_MEM2 : INSTR_MEM2_INSTR_MEM2_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM30_INSTR_MEM30_Field is HAL.UInt16;
type INSTR_MEM30_Register is record
INSTR_MEM30 : INSTR_MEM30_INSTR_MEM30_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM31_INSTR_MEM31_Field is HAL.UInt16;
type INSTR_MEM31_Register is record
INSTR_MEM31 : INSTR_MEM31_INSTR_MEM31_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM3_INSTR_MEM3_Field is HAL.UInt16;
type INSTR_MEM3_Register is record
INSTR_MEM3 : INSTR_MEM3_INSTR_MEM3_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM4_INSTR_MEM4_Field is HAL.UInt16;
type INSTR_MEM4_Register is record
INSTR_MEM4 : INSTR_MEM4_INSTR_MEM4_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM5_INSTR_MEM5_Field is HAL.UInt16;
type INSTR_MEM5_Register is record
INSTR_MEM5 : INSTR_MEM5_INSTR_MEM5_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM6_INSTR_MEM6_Field is HAL.UInt16;
type INSTR_MEM6_Register is record
INSTR_MEM6 : INSTR_MEM6_INSTR_MEM6_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM7_INSTR_MEM7_Field is HAL.UInt16;
type INSTR_MEM7_Register is record
INSTR_MEM7 : INSTR_MEM7_INSTR_MEM7_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM8_INSTR_MEM8_Field is HAL.UInt16;
type INSTR_MEM8_Register is record
INSTR_MEM8 : INSTR_MEM8_INSTR_MEM8_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INSTR_MEM9_INSTR_MEM9_Field is HAL.UInt16;
type INSTR_MEM9_Register is record
INSTR_MEM9 : INSTR_MEM9_INSTR_MEM9_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
type INTR_Register is record
SM0_RXNEMPTY : Boolean;
SM1_RXNEMPTY : Boolean;
SM2_RXNEMPTY : Boolean;
SM3_RXNEMPTY : Boolean;
SM0_TXNFULL : Boolean;
SM1_TXNFULL : Boolean;
SM2_TXNFULL : Boolean;
SM3_TXNFULL : Boolean;
SM : INTR_SM_Field;
Reserved_12_31 : HAL.UInt20;
end record;
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
unspecified
type INTR_SM_Field
(As_Array : Boolean := False)
is record
case As_Array is
when False =>
Val : HAL.UInt4;
when True =>
Arr : INTR_SM_Field_Array;
end case;
end record;
type INTR_SM_Field_Array is array (0 .. 3) of Boolean
with Component_Size => 1, Size => 4;
type IRQ0_INTE_Register is record
SM0_RXNEMPTY : Boolean := False;
SM1_RXNEMPTY : Boolean := False;
SM2_RXNEMPTY : Boolean := False;
SM3_RXNEMPTY : Boolean := False;
SM0_TXNFULL : Boolean := False;
SM1_TXNFULL : Boolean := False;
SM2_TXNFULL : Boolean := False;
SM3_TXNFULL : Boolean := False;
SM : IRQ0_INTE_SM_Field :=
(As_Array => False, Val => 16#0#);
Reserved_12_31 : HAL.UInt20 := 16#0#;
end record;
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
type IRQ0_INTE_SM_Field
(As_Array : Boolean := False)
is record
case As_Array is
when False =>
Val : HAL.UInt4;
when True =>
Arr : IRQ0_INTE_SM_Field_Array;
end case;
end record;
type IRQ0_INTE_SM_Field_Array is array (0 .. 3) of Boolean
with Component_Size => 1, Size => 4;
type IRQ0_INTF_Register is record
SM0_RXNEMPTY : Boolean := False;
SM1_RXNEMPTY : Boolean := False;
SM2_RXNEMPTY : Boolean := False;
SM3_RXNEMPTY : Boolean := False;
SM0_TXNFULL : Boolean := False;
SM1_TXNFULL : Boolean := False;
SM2_TXNFULL : Boolean := False;
SM3_TXNFULL : Boolean := False;
SM : IRQ0_INTF_SM_Field :=
(As_Array => False, Val => 16#0#);
Reserved_12_31 : HAL.UInt20 := 16#0#;
end record;
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
type IRQ0_INTF_SM_Field
(As_Array : Boolean := False)
is record
case As_Array is
when False =>
Val : HAL.UInt4;
when True =>
Arr : IRQ0_INTF_SM_Field_Array;
end case;
end record;
type IRQ0_INTF_SM_Field_Array is array (0 .. 3) of Boolean
with Component_Size => 1, Size => 4;
type IRQ0_INTS_Register is record
SM0_RXNEMPTY : Boolean;
SM1_RXNEMPTY : Boolean;
SM2_RXNEMPTY : Boolean;
SM3_RXNEMPTY : Boolean;
SM0_TXNFULL : Boolean;
SM1_TXNFULL : Boolean;
SM2_TXNFULL : Boolean;
SM3_TXNFULL : Boolean;
SM : IRQ0_INTS_SM_Field;
Reserved_12_31 : HAL.UInt20;
end record;
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
unspecified
type IRQ0_INTS_SM_Field
(As_Array : Boolean := False)
is record
case As_Array is
when False =>
Val : HAL.UInt4;
when True =>
Arr : IRQ0_INTS_SM_Field_Array;
end case;
end record;
type IRQ0_INTS_SM_Field_Array is array (0 .. 3) of Boolean
with Component_Size => 1, Size => 4;
type IRQ1_INTE_Register is record
SM0_RXNEMPTY : Boolean := False;
SM1_RXNEMPTY : Boolean := False;
SM2_RXNEMPTY : Boolean := False;
SM3_RXNEMPTY : Boolean := False;
SM0_TXNFULL : Boolean := False;
SM1_TXNFULL : Boolean := False;
SM2_TXNFULL : Boolean := False;
SM3_TXNFULL : Boolean := False;
SM : IRQ1_INTE_SM_Field :=
(As_Array => False, Val => 16#0#);
Reserved_12_31 : HAL.UInt20 := 16#0#;
end record;
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
type IRQ1_INTE_SM_Field
(As_Array : Boolean := False)
is record
case As_Array is
when False =>
Val : HAL.UInt4;
when True =>
Arr : IRQ1_INTE_SM_Field_Array;
end case;
end record;
type IRQ1_INTE_SM_Field_Array is array (0 .. 3) of Boolean
with Component_Size => 1, Size => 4;
type IRQ1_INTF_Register is record
SM0_RXNEMPTY : Boolean := False;
SM1_RXNEMPTY : Boolean := False;
SM2_RXNEMPTY : Boolean := False;
SM3_RXNEMPTY : Boolean := False;
SM0_TXNFULL : Boolean := False;
SM1_TXNFULL : Boolean := False;
SM2_TXNFULL : Boolean := False;
SM3_TXNFULL : Boolean := False;
SM : IRQ1_INTF_SM_Field :=
(As_Array => False, Val => 16#0#);
Reserved_12_31 : HAL.UInt20 := 16#0#;
end record;
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
unspecified
type IRQ1_INTF_SM_Field
(As_Array : Boolean := False)
is record
case As_Array is
when False =>
Val : HAL.UInt4;
when True =>
Arr : IRQ1_INTF_SM_Field_Array;
end case;
end record;
type IRQ1_INTF_SM_Field_Array is array (0 .. 3) of Boolean
with Component_Size => 1, Size => 4;
type IRQ1_INTS_Register is record
SM0_RXNEMPTY : Boolean;
SM1_RXNEMPTY : Boolean;
SM2_RXNEMPTY : Boolean;
SM3_RXNEMPTY : Boolean;
SM0_TXNFULL : Boolean;
SM1_TXNFULL : Boolean;
SM2_TXNFULL : Boolean;
SM3_TXNFULL : Boolean;
SM : IRQ1_INTS_SM_Field;
Reserved_12_31 : HAL.UInt20;
end record;
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
Read-only.
unspecified
type IRQ1_INTS_SM_Field
(As_Array : Boolean := False)
is record
case As_Array is
when False =>
Val : HAL.UInt4;
when True =>
Arr : IRQ1_INTS_SM_Field_Array;
end case;
end record;
type IRQ1_INTS_SM_Field_Array is array (0 .. 3) of Boolean
with Component_Size => 1, Size => 4;
subtype IRQ_FORCE_IRQ_FORCE_Field is HAL.UInt8;
type IRQ_FORCE_Register is record
IRQ_FORCE : IRQ_FORCE_IRQ_FORCE_Field := 16#0#;
Reserved_8_31 : HAL.UInt24 := 16#0#;
end record;
unspecified
subtype IRQ_IRQ_Field is HAL.UInt8;
type IRQ_Register is record
IRQ : IRQ_IRQ_Field := 16#0#;
Reserved_8_31 : HAL.UInt24 := 16#0#;
end record;
unspecified
PIO0_Periph : aliased PIO_Peripheral
with Import, Address => PIO0_Base;
PIO1_Periph : aliased PIO_Peripheral
with Import, Address => PIO1_Base;
type PIO_Peripheral is record
CTRL : aliased CTRL_Register;
FSTAT : aliased FSTAT_Register;
FDEBUG : aliased FDEBUG_Register;
FLEVEL : aliased FLEVEL_Register;
TXF0 : aliased HAL.UInt32;
TXF1 : aliased HAL.UInt32;
TXF2 : aliased HAL.UInt32;
TXF3 : aliased HAL.UInt32;
RXF0 : aliased HAL.UInt32;
RXF1 : aliased HAL.UInt32;
RXF2 : aliased HAL.UInt32;
RXF3 : aliased HAL.UInt32;
IRQ : aliased IRQ_Register;
IRQ_FORCE : aliased IRQ_FORCE_Register;
INPUT_SYNC_BYPASS : aliased HAL.UInt32;
DBG_PADOUT : aliased HAL.UInt32;
DBG_PADOE : aliased HAL.UInt32;
DBG_CFGINFO : aliased DBG_CFGINFO_Register;
INSTR_MEM0 : aliased INSTR_MEM0_Register;
INSTR_MEM1 : aliased INSTR_MEM1_Register;
INSTR_MEM2 : aliased INSTR_MEM2_Register;
INSTR_MEM3 : aliased INSTR_MEM3_Register;
INSTR_MEM4 : aliased INSTR_MEM4_Register;
INSTR_MEM5 : aliased INSTR_MEM5_Register;
INSTR_MEM6 : aliased INSTR_MEM6_Register;
INSTR_MEM7 : aliased INSTR_MEM7_Register;
INSTR_MEM8 : aliased INSTR_MEM8_Register;
INSTR_MEM9 : aliased INSTR_MEM9_Register;
INSTR_MEM10 : aliased INSTR_MEM10_Register;
INSTR_MEM11 : aliased INSTR_MEM11_Register;
INSTR_MEM12 : aliased INSTR_MEM12_Register;
INSTR_MEM13 : aliased INSTR_MEM13_Register;
INSTR_MEM14 : aliased INSTR_MEM14_Register;
INSTR_MEM15 : aliased INSTR_MEM15_Register;
INSTR_MEM16 : aliased INSTR_MEM16_Register;
INSTR_MEM17 : aliased INSTR_MEM17_Register;
INSTR_MEM18 : aliased INSTR_MEM18_Register;
INSTR_MEM19 : aliased INSTR_MEM19_Register;
INSTR_MEM20 : aliased INSTR_MEM20_Register;
INSTR_MEM21 : aliased INSTR_MEM21_Register;
INSTR_MEM22 : aliased INSTR_MEM22_Register;
INSTR_MEM23 : aliased INSTR_MEM23_Register;
INSTR_MEM24 : aliased INSTR_MEM24_Register;
INSTR_MEM25 : aliased INSTR_MEM25_Register;
INSTR_MEM26 : aliased INSTR_MEM26_Register;
INSTR_MEM27 : aliased INSTR_MEM27_Register;
INSTR_MEM28 : aliased INSTR_MEM28_Register;
INSTR_MEM29 : aliased INSTR_MEM29_Register;
INSTR_MEM30 : aliased INSTR_MEM30_Register;
INSTR_MEM31 : aliased INSTR_MEM31_Register;
SM0_CLKDIV : aliased SM0_CLKDIV_Register;
SM0_EXECCTRL : aliased SM0_EXECCTRL_Register;
SM0_SHIFTCTRL : aliased SM0_SHIFTCTRL_Register;
SM0_ADDR : aliased SM0_ADDR_Register;
SM0_INSTR : aliased SM0_INSTR_Register;
SM0_PINCTRL : aliased SM0_PINCTRL_Register;
SM1_CLKDIV : aliased SM1_CLKDIV_Register;
SM1_EXECCTRL : aliased SM1_EXECCTRL_Register;
SM1_SHIFTCTRL : aliased SM1_SHIFTCTRL_Register;
SM1_ADDR : aliased SM1_ADDR_Register;
SM1_INSTR : aliased SM1_INSTR_Register;
SM1_PINCTRL : aliased SM1_PINCTRL_Register;
SM2_CLKDIV : aliased SM2_CLKDIV_Register;
SM2_EXECCTRL : aliased SM2_EXECCTRL_Register;
SM2_SHIFTCTRL : aliased SM2_SHIFTCTRL_Register;
SM2_ADDR : aliased SM2_ADDR_Register;
SM2_INSTR : aliased SM2_INSTR_Register;
SM2_PINCTRL : aliased SM2_PINCTRL_Register;
SM3_CLKDIV : aliased SM3_CLKDIV_Register;
SM3_EXECCTRL : aliased SM3_EXECCTRL_Register;
SM3_SHIFTCTRL : aliased SM3_SHIFTCTRL_Register;
SM3_ADDR : aliased SM3_ADDR_Register;
SM3_INSTR : aliased SM3_INSTR_Register;
SM3_PINCTRL : aliased SM3_PINCTRL_Register;
INTR : aliased INTR_Register;
IRQ0_INTE : aliased IRQ0_INTE_Register;
IRQ0_INTF : aliased IRQ0_INTF_Register;
IRQ0_INTS : aliased IRQ0_INTS_Register;
IRQ1_INTE : aliased IRQ1_INTE_Register;
IRQ1_INTF : aliased IRQ1_INTF_Register;
IRQ1_INTS : aliased IRQ1_INTS_Register;
end record;
FIFO status register
FIFO debug register
FIFO levels
Direct write access to the TX FIFO for this state machine. Each write pushes one word to the FIFO. Attempting to write to a full FIFO has no effect on the FIFO state or contents, and sets the sticky FDEBUG_TXOVER error flag for this FIFO.
Direct write access to the TX FIFO for this state machine. Each write pushes one word to the FIFO. Attempting to write to a full FIFO has no effect on the FIFO state or contents, and sets the sticky FDEBUG_TXOVER error flag for this FIFO.
Direct write access to the TX FIFO for this state machine. Each write pushes one word to the FIFO. Attempting to write to a full FIFO has no effect on the FIFO state or contents, and sets the sticky FDEBUG_TXOVER error flag for this FIFO.
Direct write access to the TX FIFO for this state machine. Each write pushes one word to the FIFO. Attempting to write to a full FIFO has no effect on the FIFO state or contents, and sets the sticky FDEBUG_TXOVER error flag for this FIFO.
Direct read access to the RX FIFO for this state machine. Each read pops one word from the FIFO. Attempting to read from an empty FIFO has no effect on the FIFO state, and sets the sticky FDEBUG_RXUNDER error flag for this FIFO. The data returned to the system on a read from an empty FIFO is undefined.
Direct read access to the RX FIFO for this state machine. Each read pops one word from the FIFO. Attempting to read from an empty FIFO has no effect on the FIFO state, and sets the sticky FDEBUG_RXUNDER error flag for this FIFO. The data returned to the system on a read from an empty FIFO is undefined.
Direct read access to the RX FIFO for this state machine. Each read pops one word from the FIFO. Attempting to read from an empty FIFO has no effect on the FIFO state, and sets the sticky FDEBUG_RXUNDER error flag for this FIFO. The data returned to the system on a read from an empty FIFO is undefined.
Direct read access to the RX FIFO for this state machine. Each read pops one word from the FIFO. Attempting to read from an empty FIFO has no effect on the FIFO state, and sets the sticky FDEBUG_RXUNDER error flag for this FIFO. The data returned to the system on a read from an empty FIFO is undefined.
State machine IRQ flags register. Write 1 to clear. There are 8 state machine IRQ flags, which can be set, cleared, and waited on by the state machines. There's no fixed association between flags and state machines -- any state machine can use any flag.\n\n Any of the 8 flags can be used for timing synchronisation between state machines, using IRQ and WAIT instructions. The lower four of these flags are also routed out to system-level interrupt requests, alongside FIFO status interrupts -- see e.g. IRQ0_INTE.
Writing a 1 to each of these bits will forcibly assert the corresponding IRQ. Note this is different to the INTF register: writing here affects PIO internal state. INTF just asserts the processor-facing IRQ signal for testing ISRs, and is not visible to the state machines.
There is a 2-flipflop synchronizer on each GPIO input, which protects PIO logic from metastabilities. This increases input delay, and for fast synchronous IO (e.g. SPI) these synchronizers may need to be bypassed. Each bit in this register corresponds to one GPIO.\n 0 -> input is synchronized (default)\n 1 -> synchronizer is bypassed\n If in doubt, leave this register as all zeroes.
Read to sample the pad output values PIO is currently driving to the GPIOs. On RP2040 there are 30 GPIOs, so the two most significant bits are hardwired to 0.
Read to sample the pad output enables (direction) PIO is currently driving to the GPIOs. On RP2040 there are 30 GPIOs, so the two most significant bits are hardwired to 0.
The PIO hardware has some free parameters that may vary between chip products.\n These should be provided in the chip datasheet, but are also exposed here.
Write-only access to instruction memory location 0
Write-only access to instruction memory location 1
Write-only access to instruction memory location 2
Write-only access to instruction memory location 3
Write-only access to instruction memory location 4
Write-only access to instruction memory location 5
Write-only access to instruction memory location 6
Write-only access to instruction memory location 7
Write-only access to instruction memory location 8
Write-only access to instruction memory location 9
Write-only access to instruction memory location 10
Write-only access to instruction memory location 11
Write-only access to instruction memory location 12
Write-only access to instruction memory location 13
Write-only access to instruction memory location 14
Write-only access to instruction memory location 15
Write-only access to instruction memory location 16
Write-only access to instruction memory location 17
Write-only access to instruction memory location 18
Write-only access to instruction memory location 19
Write-only access to instruction memory location 20
Write-only access to instruction memory location 21
Write-only access to instruction memory location 22
Write-only access to instruction memory location 23
Write-only access to instruction memory location 24
Write-only access to instruction memory location 25
Write-only access to instruction memory location 26
Write-only access to instruction memory location 27
Write-only access to instruction memory location 28
Write-only access to instruction memory location 29
Write-only access to instruction memory location 30
Write-only access to instruction memory location 31
Clock divisor register for state machine 0\n Frequency = clock freq / (CLKDIV_INT + CLKDIV_FRAC / 256)
Execution/behavioural settings for state machine 0
Control behaviour of the input/output shift registers for state machine 0
Current instruction address of state machine 0
Read to see the instruction currently addressed by state machine 0's program counter\n Write to execute an instruction immediately (including jumps) and then resume execution.
State machine pin control
Clock divisor register for state machine 1\n Frequency = clock freq / (CLKDIV_INT + CLKDIV_FRAC / 256)
Execution/behavioural settings for state machine 1
Control behaviour of the input/output shift registers for state machine 1
Current instruction address of state machine 1
Read to see the instruction currently addressed by state machine 1's program counter\n Write to execute an instruction immediately (including jumps) and then resume execution.
State machine pin control
Clock divisor register for state machine 2\n Frequency = clock freq / (CLKDIV_INT + CLKDIV_FRAC / 256)
Execution/behavioural settings for state machine 2
Control behaviour of the input/output shift registers for state machine 2
Current instruction address of state machine 2
Read to see the instruction currently addressed by state machine 2's program counter\n Write to execute an instruction immediately (including jumps) and then resume execution.
State machine pin control
Clock divisor register for state machine 3\n Frequency = clock freq / (CLKDIV_INT + CLKDIV_FRAC / 256)
Execution/behavioural settings for state machine 3
Control behaviour of the input/output shift registers for state machine 3
Current instruction address of state machine 3
Read to see the instruction currently addressed by state machine 3's program counter\n Write to execute an instruction immediately (including jumps) and then resume execution.
State machine pin control
Raw Interrupts
Interrupt Enable for irq0
Interrupt Force for irq0
Interrupt status after masking & forcing for irq0
Interrupt Enable for irq1
Interrupt Force for irq1
Interrupt status after masking & forcing for irq1
type SM0_ADDR_Register is record
SM0_ADDR : SM0_ADDR_SM0_ADDR_Field;
Reserved_5_31 : HAL.UInt27;
end record;
unspecified
subtype SM0_ADDR_SM0_ADDR_Field is HAL.UInt5;
subtype SM0_CLKDIV_FRAC_Field is HAL.UInt8;
subtype SM0_CLKDIV_INT_Field is HAL.UInt16;
type SM0_CLKDIV_Register is record
Reserved_0_7 : HAL.UInt8 := 16#0#;
FRAC : SM0_CLKDIV_FRAC_Field := 16#0#;
INT : SM0_CLKDIV_INT_Field := 16#1#;
end record;
Fractional part of clock divisor
Effective frequency is sysclk/(int + frac/256).\n Value of 0 is interpreted as 65536. If INT is 0, FRAC must also be 0.
subtype SM0_EXECCTRL_JMP_PIN_Field is HAL.UInt5;
subtype SM0_EXECCTRL_OUT_EN_SEL_Field is HAL.UInt5;
type SM0_EXECCTRL_Register is record
STATUS_N : SM0_EXECCTRL_STATUS_N_Field := 16#0#;
STATUS_SEL : SM0_EXECCTRL_STATUS_SEL_Field :=
RP2040_SVD.PIO.TXLEVEL;
Reserved_5_6 : HAL.UInt2 := 16#0#;
WRAP_BOTTOM : SM0_EXECCTRL_WRAP_BOTTOM_Field := 16#0#;
WRAP_TOP : SM0_EXECCTRL_WRAP_TOP_Field := 16#1F#;
OUT_STICKY : Boolean := False;
INLINE_OUT_EN : Boolean := False;
OUT_EN_SEL : SM0_EXECCTRL_OUT_EN_SEL_Field := 16#0#;
JMP_PIN : SM0_EXECCTRL_JMP_PIN_Field := 16#0#;
SIDE_PINDIR : Boolean := False;
SIDE_EN : Boolean := False;
EXEC_STALLED : Boolean := False;
end record;
Comparison used for the MOV x, STATUS instruction.
unspecified
After reaching wrap_top, execution is wrapped to this address.
After reaching this address, execution is wrapped to wrap_bottom.\n If the instruction is a jump, and the jump condition is true, the jump takes priority.
Continuously assert the most recent OUT/SET to the pins
If 1, use a bit of OUT data as an auxiliary write enable\n When used in conjunction with OUT_STICKY, writes with an enable of 0 will\n deassert the latest pin write. This can create useful masking/override behaviour\n due to the priority ordering of state machine pin writes (SM0 < SM1 < ...)
Which data bit to use for inline OUT enable
The GPIO number to use as condition for JMP PIN. Unaffected by input mapping.
If 1, side-set data is asserted to pin directions, instead of pin values
If 1, the MSB of the Delay/Side-set instruction field is used as side-set enable, rather than a side-set data bit. This allows instructions to perform side-set optionally, rather than on every instruction, but the maximum possible side-set width is reduced from 5 to 4. Note that the value of PINCTRL_SIDESET_COUNT is inclusive of this enable bit.
Read-only. If 1, an instruction written to SMx_INSTR is stalled, and latched by the state machine. Will clear to 0 once this instruction completes.
subtype SM0_EXECCTRL_STATUS_N_Field is HAL.UInt4;
type SM0_EXECCTRL_STATUS_SEL_Field is
TXLEVEL,
RXLEVEL)
with Size => 1;
All-ones if RX FIFO level < N, otherwise all-zeroes
subtype SM0_EXECCTRL_WRAP_BOTTOM_Field is HAL.UInt5;
subtype SM0_EXECCTRL_WRAP_TOP_Field is HAL.UInt5;
type SM0_INSTR_Register is record
SM0_INSTR : SM0_INSTR_SM0_INSTR_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype SM0_INSTR_SM0_INSTR_Field is HAL.UInt16;
subtype SM0_PINCTRL_IN_BASE_Field is HAL.UInt5;
subtype SM0_PINCTRL_OUT_BASE_Field is HAL.UInt5;
subtype SM0_PINCTRL_OUT_COUNT_Field is HAL.UInt6;
type SM0_PINCTRL_Register is record
OUT_BASE : SM0_PINCTRL_OUT_BASE_Field := 16#0#;
SET_BASE : SM0_PINCTRL_SET_BASE_Field := 16#0#;
SIDESET_BASE : SM0_PINCTRL_SIDESET_BASE_Field := 16#0#;
IN_BASE : SM0_PINCTRL_IN_BASE_Field := 16#0#;
OUT_COUNT : SM0_PINCTRL_OUT_COUNT_Field := 16#0#;
SET_COUNT : SM0_PINCTRL_SET_COUNT_Field := 16#5#;
SIDESET_COUNT : SM0_PINCTRL_SIDESET_COUNT_Field := 16#0#;
end record;
The lowest-numbered pin that will be affected by a SET PINS or SET PINDIRS instruction. The data written to this pin is the least-significant bit of the SET data.
The lowest-numbered pin that will be affected by a side-set operation. The MSBs of an instruction's side-set/delay field (up to 5, determined by SIDESET_COUNT) are used for side-set data, with the remaining LSBs used for delay. The least-significant bit of the side-set portion is the bit written to this pin, with more-significant bits written to higher-numbered pins.
The pin which is mapped to the least-significant bit of a state machine's IN data bus. Higher-numbered pins are mapped to consecutively more-significant data bits, with a modulo of 32 applied to pin number.
The number of pins asserted by an OUT PINS, OUT PINDIRS or MOV PINS instruction. In the range 0 to 32 inclusive.
The number of pins asserted by a SET. In the range 0 to 5 inclusive.
The number of MSBs of the Delay/Side-set instruction field which are used for side-set. Inclusive of the enable bit, if present. Minimum of 0 (all delay bits, no side-set) and maximum of 5 (all side-set, no delay).
subtype SM0_PINCTRL_SET_BASE_Field is HAL.UInt5;
subtype SM0_PINCTRL_SET_COUNT_Field is HAL.UInt3;
subtype SM0_PINCTRL_SIDESET_BASE_Field is HAL.UInt5;
subtype SM0_PINCTRL_SIDESET_COUNT_Field is HAL.UInt3;
subtype SM0_SHIFTCTRL_PULL_THRESH_Field is HAL.UInt5;
subtype SM0_SHIFTCTRL_PUSH_THRESH_Field is HAL.UInt5;
type SM0_SHIFTCTRL_Register is record
Reserved_0_15 : HAL.UInt16 := 16#0#;
AUTOPUSH : Boolean := False;
AUTOPULL : Boolean := False;
IN_SHIFTDIR : Boolean := True;
OUT_SHIFTDIR : Boolean := True;
PUSH_THRESH : SM0_SHIFTCTRL_PUSH_THRESH_Field := 16#0#;
PULL_THRESH : SM0_SHIFTCTRL_PULL_THRESH_Field := 16#0#;
FJOIN_TX : Boolean := False;
FJOIN_RX : Boolean := False;
end record;
Push automatically when the input shift register is filled, i.e. on an IN instruction which causes the input shift counter to reach or exceed PUSH_THRESH.
Pull automatically when the output shift register is emptied, i.e. on or following an OUT instruction which causes the output shift counter to reach or exceed PULL_THRESH.
1 = shift input shift register to right (data enters from left). 0 = to left.
1 = shift out of output shift register to right. 0 = to left.
Number of bits shifted into ISR before autopush, or conditional push (PUSH IFFULL), will take place.\n Write 0 for value of 32.
Number of bits shifted out of OSR before autopull, or conditional pull (PULL IFEMPTY), will take place.\n Write 0 for value of 32.
When 1, TX FIFO steals the RX FIFO's storage, and becomes twice as deep.\n RX FIFO is disabled as a result (always reads as both full and empty).\n FIFOs are flushed when this bit is changed.
When 1, RX FIFO steals the TX FIFO's storage, and becomes twice as deep.\n TX FIFO is disabled as a result (always reads as both full and empty).\n FIFOs are flushed when this bit is changed.
type SM1_ADDR_Register is record
SM1_ADDR : SM1_ADDR_SM1_ADDR_Field;
Reserved_5_31 : HAL.UInt27;
end record;
unspecified
subtype SM1_ADDR_SM1_ADDR_Field is HAL.UInt5;
subtype SM1_CLKDIV_FRAC_Field is HAL.UInt8;
subtype SM1_CLKDIV_INT_Field is HAL.UInt16;
type SM1_CLKDIV_Register is record
Reserved_0_7 : HAL.UInt8 := 16#0#;
FRAC : SM1_CLKDIV_FRAC_Field := 16#0#;
INT : SM1_CLKDIV_INT_Field := 16#1#;
end record;
Fractional part of clock divisor
Effective frequency is sysclk/(int + frac/256).\n Value of 0 is interpreted as 65536. If INT is 0, FRAC must also be 0.
subtype SM1_EXECCTRL_JMP_PIN_Field is HAL.UInt5;
subtype SM1_EXECCTRL_OUT_EN_SEL_Field is HAL.UInt5;
type SM1_EXECCTRL_Register is record
STATUS_N : SM1_EXECCTRL_STATUS_N_Field := 16#0#;
STATUS_SEL : SM1_EXECCTRL_STATUS_SEL_Field :=
RP2040_SVD.PIO.TXLEVEL;
Reserved_5_6 : HAL.UInt2 := 16#0#;
WRAP_BOTTOM : SM1_EXECCTRL_WRAP_BOTTOM_Field := 16#0#;
WRAP_TOP : SM1_EXECCTRL_WRAP_TOP_Field := 16#1F#;
OUT_STICKY : Boolean := False;
INLINE_OUT_EN : Boolean := False;
OUT_EN_SEL : SM1_EXECCTRL_OUT_EN_SEL_Field := 16#0#;
JMP_PIN : SM1_EXECCTRL_JMP_PIN_Field := 16#0#;
SIDE_PINDIR : Boolean := False;
SIDE_EN : Boolean := False;
EXEC_STALLED : Boolean := False;
end record;
Comparison used for the MOV x, STATUS instruction.
unspecified
After reaching wrap_top, execution is wrapped to this address.
After reaching this address, execution is wrapped to wrap_bottom.\n If the instruction is a jump, and the jump condition is true, the jump takes priority.
Continuously assert the most recent OUT/SET to the pins
If 1, use a bit of OUT data as an auxiliary write enable\n When used in conjunction with OUT_STICKY, writes with an enable of 0 will\n deassert the latest pin write. This can create useful masking/override behaviour\n due to the priority ordering of state machine pin writes (SM0 < SM1 < ...)
Which data bit to use for inline OUT enable
The GPIO number to use as condition for JMP PIN. Unaffected by input mapping.
If 1, side-set data is asserted to pin directions, instead of pin values
If 1, the MSB of the Delay/Side-set instruction field is used as side-set enable, rather than a side-set data bit. This allows instructions to perform side-set optionally, rather than on every instruction, but the maximum possible side-set width is reduced from 5 to 4. Note that the value of PINCTRL_SIDESET_COUNT is inclusive of this enable bit.
Read-only. If 1, an instruction written to SMx_INSTR is stalled, and latched by the state machine. Will clear to 0 once this instruction completes.
subtype SM1_EXECCTRL_STATUS_N_Field is HAL.UInt4;
type SM1_EXECCTRL_STATUS_SEL_Field is
TXLEVEL,
RXLEVEL)
with Size => 1;
All-ones if RX FIFO level < N, otherwise all-zeroes
subtype SM1_EXECCTRL_WRAP_BOTTOM_Field is HAL.UInt5;
subtype SM1_EXECCTRL_WRAP_TOP_Field is HAL.UInt5;
type SM1_INSTR_Register is record
SM1_INSTR : SM1_INSTR_SM1_INSTR_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype SM1_INSTR_SM1_INSTR_Field is HAL.UInt16;
subtype SM1_PINCTRL_IN_BASE_Field is HAL.UInt5;
subtype SM1_PINCTRL_OUT_BASE_Field is HAL.UInt5;
subtype SM1_PINCTRL_OUT_COUNT_Field is HAL.UInt6;
type SM1_PINCTRL_Register is record
OUT_BASE : SM1_PINCTRL_OUT_BASE_Field := 16#0#;
SET_BASE : SM1_PINCTRL_SET_BASE_Field := 16#0#;
SIDESET_BASE : SM1_PINCTRL_SIDESET_BASE_Field := 16#0#;
IN_BASE : SM1_PINCTRL_IN_BASE_Field := 16#0#;
OUT_COUNT : SM1_PINCTRL_OUT_COUNT_Field := 16#0#;
SET_COUNT : SM1_PINCTRL_SET_COUNT_Field := 16#5#;
SIDESET_COUNT : SM1_PINCTRL_SIDESET_COUNT_Field := 16#0#;
end record;
The lowest-numbered pin that will be affected by a SET PINS or SET PINDIRS instruction. The data written to this pin is the least-significant bit of the SET data.
The lowest-numbered pin that will be affected by a side-set operation. The MSBs of an instruction's side-set/delay field (up to 5, determined by SIDESET_COUNT) are used for side-set data, with the remaining LSBs used for delay. The least-significant bit of the side-set portion is the bit written to this pin, with more-significant bits written to higher-numbered pins.
The pin which is mapped to the least-significant bit of a state machine's IN data bus. Higher-numbered pins are mapped to consecutively more-significant data bits, with a modulo of 32 applied to pin number.
The number of pins asserted by an OUT PINS, OUT PINDIRS or MOV PINS instruction. In the range 0 to 32 inclusive.
The number of pins asserted by a SET. In the range 0 to 5 inclusive.
The number of MSBs of the Delay/Side-set instruction field which are used for side-set. Inclusive of the enable bit, if present. Minimum of 0 (all delay bits, no side-set) and maximum of 5 (all side-set, no delay).
subtype SM1_PINCTRL_SET_BASE_Field is HAL.UInt5;
subtype SM1_PINCTRL_SET_COUNT_Field is HAL.UInt3;
subtype SM1_PINCTRL_SIDESET_BASE_Field is HAL.UInt5;
subtype SM1_PINCTRL_SIDESET_COUNT_Field is HAL.UInt3;
subtype SM1_SHIFTCTRL_PULL_THRESH_Field is HAL.UInt5;
subtype SM1_SHIFTCTRL_PUSH_THRESH_Field is HAL.UInt5;
type SM1_SHIFTCTRL_Register is record
Reserved_0_15 : HAL.UInt16 := 16#0#;
AUTOPUSH : Boolean := False;
AUTOPULL : Boolean := False;
IN_SHIFTDIR : Boolean := True;
OUT_SHIFTDIR : Boolean := True;
PUSH_THRESH : SM1_SHIFTCTRL_PUSH_THRESH_Field := 16#0#;
PULL_THRESH : SM1_SHIFTCTRL_PULL_THRESH_Field := 16#0#;
FJOIN_TX : Boolean := False;
FJOIN_RX : Boolean := False;
end record;
Push automatically when the input shift register is filled, i.e. on an IN instruction which causes the input shift counter to reach or exceed PUSH_THRESH.
Pull automatically when the output shift register is emptied, i.e. on or following an OUT instruction which causes the output shift counter to reach or exceed PULL_THRESH.
1 = shift input shift register to right (data enters from left). 0 = to left.
1 = shift out of output shift register to right. 0 = to left.
Number of bits shifted into ISR before autopush, or conditional push (PUSH IFFULL), will take place.\n Write 0 for value of 32.
Number of bits shifted out of OSR before autopull, or conditional pull (PULL IFEMPTY), will take place.\n Write 0 for value of 32.
When 1, TX FIFO steals the RX FIFO's storage, and becomes twice as deep.\n RX FIFO is disabled as a result (always reads as both full and empty).\n FIFOs are flushed when this bit is changed.
When 1, RX FIFO steals the TX FIFO's storage, and becomes twice as deep.\n TX FIFO is disabled as a result (always reads as both full and empty).\n FIFOs are flushed when this bit is changed.
type SM2_ADDR_Register is record
SM2_ADDR : SM2_ADDR_SM2_ADDR_Field;
Reserved_5_31 : HAL.UInt27;
end record;
unspecified
subtype SM2_ADDR_SM2_ADDR_Field is HAL.UInt5;
subtype SM2_CLKDIV_FRAC_Field is HAL.UInt8;
subtype SM2_CLKDIV_INT_Field is HAL.UInt16;
type SM2_CLKDIV_Register is record
Reserved_0_7 : HAL.UInt8 := 16#0#;
FRAC : SM2_CLKDIV_FRAC_Field := 16#0#;
INT : SM2_CLKDIV_INT_Field := 16#1#;
end record;
Fractional part of clock divisor
Effective frequency is sysclk/(int + frac/256).\n Value of 0 is interpreted as 65536. If INT is 0, FRAC must also be 0.
subtype SM2_EXECCTRL_JMP_PIN_Field is HAL.UInt5;
subtype SM2_EXECCTRL_OUT_EN_SEL_Field is HAL.UInt5;
type SM2_EXECCTRL_Register is record
STATUS_N : SM2_EXECCTRL_STATUS_N_Field := 16#0#;
STATUS_SEL : SM2_EXECCTRL_STATUS_SEL_Field :=
RP2040_SVD.PIO.TXLEVEL;
Reserved_5_6 : HAL.UInt2 := 16#0#;
WRAP_BOTTOM : SM2_EXECCTRL_WRAP_BOTTOM_Field := 16#0#;
WRAP_TOP : SM2_EXECCTRL_WRAP_TOP_Field := 16#1F#;
OUT_STICKY : Boolean := False;
INLINE_OUT_EN : Boolean := False;
OUT_EN_SEL : SM2_EXECCTRL_OUT_EN_SEL_Field := 16#0#;
JMP_PIN : SM2_EXECCTRL_JMP_PIN_Field := 16#0#;
SIDE_PINDIR : Boolean := False;
SIDE_EN : Boolean := False;
EXEC_STALLED : Boolean := False;
end record;
Comparison used for the MOV x, STATUS instruction.
unspecified
After reaching wrap_top, execution is wrapped to this address.
After reaching this address, execution is wrapped to wrap_bottom.\n If the instruction is a jump, and the jump condition is true, the jump takes priority.
Continuously assert the most recent OUT/SET to the pins
If 1, use a bit of OUT data as an auxiliary write enable\n When used in conjunction with OUT_STICKY, writes with an enable of 0 will\n deassert the latest pin write. This can create useful masking/override behaviour\n due to the priority ordering of state machine pin writes (SM0 < SM1 < ...)
Which data bit to use for inline OUT enable
The GPIO number to use as condition for JMP PIN. Unaffected by input mapping.
If 1, side-set data is asserted to pin directions, instead of pin values
If 1, the MSB of the Delay/Side-set instruction field is used as side-set enable, rather than a side-set data bit. This allows instructions to perform side-set optionally, rather than on every instruction, but the maximum possible side-set width is reduced from 5 to 4. Note that the value of PINCTRL_SIDESET_COUNT is inclusive of this enable bit.
Read-only. If 1, an instruction written to SMx_INSTR is stalled, and latched by the state machine. Will clear to 0 once this instruction completes.
subtype SM2_EXECCTRL_STATUS_N_Field is HAL.UInt4;
type SM2_EXECCTRL_STATUS_SEL_Field is
TXLEVEL,
RXLEVEL)
with Size => 1;
All-ones if RX FIFO level < N, otherwise all-zeroes
subtype SM2_EXECCTRL_WRAP_BOTTOM_Field is HAL.UInt5;
subtype SM2_EXECCTRL_WRAP_TOP_Field is HAL.UInt5;
type SM2_INSTR_Register is record
SM2_INSTR : SM2_INSTR_SM2_INSTR_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype SM2_INSTR_SM2_INSTR_Field is HAL.UInt16;
subtype SM2_PINCTRL_IN_BASE_Field is HAL.UInt5;
subtype SM2_PINCTRL_OUT_BASE_Field is HAL.UInt5;
subtype SM2_PINCTRL_OUT_COUNT_Field is HAL.UInt6;
type SM2_PINCTRL_Register is record
OUT_BASE : SM2_PINCTRL_OUT_BASE_Field := 16#0#;
SET_BASE : SM2_PINCTRL_SET_BASE_Field := 16#0#;
SIDESET_BASE : SM2_PINCTRL_SIDESET_BASE_Field := 16#0#;
IN_BASE : SM2_PINCTRL_IN_BASE_Field := 16#0#;
OUT_COUNT : SM2_PINCTRL_OUT_COUNT_Field := 16#0#;
SET_COUNT : SM2_PINCTRL_SET_COUNT_Field := 16#5#;
SIDESET_COUNT : SM2_PINCTRL_SIDESET_COUNT_Field := 16#0#;
end record;
The lowest-numbered pin that will be affected by a SET PINS or SET PINDIRS instruction. The data written to this pin is the least-significant bit of the SET data.
The lowest-numbered pin that will be affected by a side-set operation. The MSBs of an instruction's side-set/delay field (up to 5, determined by SIDESET_COUNT) are used for side-set data, with the remaining LSBs used for delay. The least-significant bit of the side-set portion is the bit written to this pin, with more-significant bits written to higher-numbered pins.
The pin which is mapped to the least-significant bit of a state machine's IN data bus. Higher-numbered pins are mapped to consecutively more-significant data bits, with a modulo of 32 applied to pin number.
The number of pins asserted by an OUT PINS, OUT PINDIRS or MOV PINS instruction. In the range 0 to 32 inclusive.
The number of pins asserted by a SET. In the range 0 to 5 inclusive.
The number of MSBs of the Delay/Side-set instruction field which are used for side-set. Inclusive of the enable bit, if present. Minimum of 0 (all delay bits, no side-set) and maximum of 5 (all side-set, no delay).
subtype SM2_PINCTRL_SET_BASE_Field is HAL.UInt5;
subtype SM2_PINCTRL_SET_COUNT_Field is HAL.UInt3;
subtype SM2_PINCTRL_SIDESET_BASE_Field is HAL.UInt5;
subtype SM2_PINCTRL_SIDESET_COUNT_Field is HAL.UInt3;
subtype SM2_SHIFTCTRL_PULL_THRESH_Field is HAL.UInt5;
subtype SM2_SHIFTCTRL_PUSH_THRESH_Field is HAL.UInt5;
type SM2_SHIFTCTRL_Register is record
Reserved_0_15 : HAL.UInt16 := 16#0#;
AUTOPUSH : Boolean := False;
AUTOPULL : Boolean := False;
IN_SHIFTDIR : Boolean := True;
OUT_SHIFTDIR : Boolean := True;
PUSH_THRESH : SM2_SHIFTCTRL_PUSH_THRESH_Field := 16#0#;
PULL_THRESH : SM2_SHIFTCTRL_PULL_THRESH_Field := 16#0#;
FJOIN_TX : Boolean := False;
FJOIN_RX : Boolean := False;
end record;
Push automatically when the input shift register is filled, i.e. on an IN instruction which causes the input shift counter to reach or exceed PUSH_THRESH.
Pull automatically when the output shift register is emptied, i.e. on or following an OUT instruction which causes the output shift counter to reach or exceed PULL_THRESH.
1 = shift input shift register to right (data enters from left). 0 = to left.
1 = shift out of output shift register to right. 0 = to left.
Number of bits shifted into ISR before autopush, or conditional push (PUSH IFFULL), will take place.\n Write 0 for value of 32.
Number of bits shifted out of OSR before autopull, or conditional pull (PULL IFEMPTY), will take place.\n Write 0 for value of 32.
When 1, TX FIFO steals the RX FIFO's storage, and becomes twice as deep.\n RX FIFO is disabled as a result (always reads as both full and empty).\n FIFOs are flushed when this bit is changed.
When 1, RX FIFO steals the TX FIFO's storage, and becomes twice as deep.\n TX FIFO is disabled as a result (always reads as both full and empty).\n FIFOs are flushed when this bit is changed.
type SM3_ADDR_Register is record
SM3_ADDR : SM3_ADDR_SM3_ADDR_Field;
Reserved_5_31 : HAL.UInt27;
end record;
unspecified
subtype SM3_ADDR_SM3_ADDR_Field is HAL.UInt5;
subtype SM3_CLKDIV_FRAC_Field is HAL.UInt8;
subtype SM3_CLKDIV_INT_Field is HAL.UInt16;
type SM3_CLKDIV_Register is record
Reserved_0_7 : HAL.UInt8 := 16#0#;
FRAC : SM3_CLKDIV_FRAC_Field := 16#0#;
INT : SM3_CLKDIV_INT_Field := 16#1#;
end record;
Fractional part of clock divisor
Effective frequency is sysclk/(int + frac/256).\n Value of 0 is interpreted as 65536. If INT is 0, FRAC must also be 0.
subtype SM3_EXECCTRL_JMP_PIN_Field is HAL.UInt5;
subtype SM3_EXECCTRL_OUT_EN_SEL_Field is HAL.UInt5;
type SM3_EXECCTRL_Register is record
STATUS_N : SM3_EXECCTRL_STATUS_N_Field := 16#0#;
STATUS_SEL : SM3_EXECCTRL_STATUS_SEL_Field :=
RP2040_SVD.PIO.TXLEVEL;
Reserved_5_6 : HAL.UInt2 := 16#0#;
WRAP_BOTTOM : SM3_EXECCTRL_WRAP_BOTTOM_Field := 16#0#;
WRAP_TOP : SM3_EXECCTRL_WRAP_TOP_Field := 16#1F#;
OUT_STICKY : Boolean := False;
INLINE_OUT_EN : Boolean := False;
OUT_EN_SEL : SM3_EXECCTRL_OUT_EN_SEL_Field := 16#0#;
JMP_PIN : SM3_EXECCTRL_JMP_PIN_Field := 16#0#;
SIDE_PINDIR : Boolean := False;
SIDE_EN : Boolean := False;
EXEC_STALLED : Boolean := False;
end record;
Comparison used for the MOV x, STATUS instruction.
unspecified
After reaching wrap_top, execution is wrapped to this address.
After reaching this address, execution is wrapped to wrap_bottom.\n If the instruction is a jump, and the jump condition is true, the jump takes priority.
Continuously assert the most recent OUT/SET to the pins
If 1, use a bit of OUT data as an auxiliary write enable\n When used in conjunction with OUT_STICKY, writes with an enable of 0 will\n deassert the latest pin write. This can create useful masking/override behaviour\n due to the priority ordering of state machine pin writes (SM0 < SM1 < ...)
Which data bit to use for inline OUT enable
The GPIO number to use as condition for JMP PIN. Unaffected by input mapping.
If 1, side-set data is asserted to pin directions, instead of pin values
If 1, the MSB of the Delay/Side-set instruction field is used as side-set enable, rather than a side-set data bit. This allows instructions to perform side-set optionally, rather than on every instruction, but the maximum possible side-set width is reduced from 5 to 4. Note that the value of PINCTRL_SIDESET_COUNT is inclusive of this enable bit.
Read-only. If 1, an instruction written to SMx_INSTR is stalled, and latched by the state machine. Will clear to 0 once this instruction completes.
subtype SM3_EXECCTRL_STATUS_N_Field is HAL.UInt4;
type SM3_EXECCTRL_STATUS_SEL_Field is
TXLEVEL,
RXLEVEL)
with Size => 1;
All-ones if RX FIFO level < N, otherwise all-zeroes
subtype SM3_EXECCTRL_WRAP_BOTTOM_Field is HAL.UInt5;
subtype SM3_EXECCTRL_WRAP_TOP_Field is HAL.UInt5;
type SM3_INSTR_Register is record
SM3_INSTR : SM3_INSTR_SM3_INSTR_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype SM3_INSTR_SM3_INSTR_Field is HAL.UInt16;
subtype SM3_PINCTRL_IN_BASE_Field is HAL.UInt5;
subtype SM3_PINCTRL_OUT_BASE_Field is HAL.UInt5;
subtype SM3_PINCTRL_OUT_COUNT_Field is HAL.UInt6;
type SM3_PINCTRL_Register is record
OUT_BASE : SM3_PINCTRL_OUT_BASE_Field := 16#0#;
SET_BASE : SM3_PINCTRL_SET_BASE_Field := 16#0#;
SIDESET_BASE : SM3_PINCTRL_SIDESET_BASE_Field := 16#0#;
IN_BASE : SM3_PINCTRL_IN_BASE_Field := 16#0#;
OUT_COUNT : SM3_PINCTRL_OUT_COUNT_Field := 16#0#;
SET_COUNT : SM3_PINCTRL_SET_COUNT_Field := 16#5#;
SIDESET_COUNT : SM3_PINCTRL_SIDESET_COUNT_Field := 16#0#;
end record;
The lowest-numbered pin that will be affected by a SET PINS or SET PINDIRS instruction. The data written to this pin is the least-significant bit of the SET data.
The lowest-numbered pin that will be affected by a side-set operation. The MSBs of an instruction's side-set/delay field (up to 5, determined by SIDESET_COUNT) are used for side-set data, with the remaining LSBs used for delay. The least-significant bit of the side-set portion is the bit written to this pin, with more-significant bits written to higher-numbered pins.
The pin which is mapped to the least-significant bit of a state machine's IN data bus. Higher-numbered pins are mapped to consecutively more-significant data bits, with a modulo of 32 applied to pin number.
The number of pins asserted by an OUT PINS, OUT PINDIRS or MOV PINS instruction. In the range 0 to 32 inclusive.
The number of pins asserted by a SET. In the range 0 to 5 inclusive.
The number of MSBs of the Delay/Side-set instruction field which are used for side-set. Inclusive of the enable bit, if present. Minimum of 0 (all delay bits, no side-set) and maximum of 5 (all side-set, no delay).
subtype SM3_PINCTRL_SET_BASE_Field is HAL.UInt5;
subtype SM3_PINCTRL_SET_COUNT_Field is HAL.UInt3;
subtype SM3_PINCTRL_SIDESET_BASE_Field is HAL.UInt5;
subtype SM3_PINCTRL_SIDESET_COUNT_Field is HAL.UInt3;
subtype SM3_SHIFTCTRL_PULL_THRESH_Field is HAL.UInt5;
subtype SM3_SHIFTCTRL_PUSH_THRESH_Field is HAL.UInt5;
type SM3_SHIFTCTRL_Register is record
Reserved_0_15 : HAL.UInt16 := 16#0#;
AUTOPUSH : Boolean := False;
AUTOPULL : Boolean := False;
IN_SHIFTDIR : Boolean := True;
OUT_SHIFTDIR : Boolean := True;
PUSH_THRESH : SM3_SHIFTCTRL_PUSH_THRESH_Field := 16#0#;
PULL_THRESH : SM3_SHIFTCTRL_PULL_THRESH_Field := 16#0#;
FJOIN_TX : Boolean := False;
FJOIN_RX : Boolean := False;
end record;
Push automatically when the input shift register is filled, i.e. on an IN instruction which causes the input shift counter to reach or exceed PUSH_THRESH.
Pull automatically when the output shift register is emptied, i.e. on or following an OUT instruction which causes the output shift counter to reach or exceed PULL_THRESH.
1 = shift input shift register to right (data enters from left). 0 = to left.
1 = shift out of output shift register to right. 0 = to left.
Number of bits shifted into ISR before autopush, or conditional push (PUSH IFFULL), will take place.\n Write 0 for value of 32.
Number of bits shifted out of OSR before autopull, or conditional pull (PULL IFEMPTY), will take place.\n Write 0 for value of 32.
When 1, TX FIFO steals the RX FIFO's storage, and becomes twice as deep.\n RX FIFO is disabled as a result (always reads as both full and empty).\n FIFOs are flushed when this bit is changed.
When 1, RX FIFO steals the TX FIFO's storage, and becomes twice as deep.\n TX FIFO is disabled as a result (always reads as both full and empty).\n FIFOs are flushed when this bit is changed.