------------- Registers -- -------------
type DIV_CSR_Register is record
READY : Boolean;
DIRTY : Boolean;
Reserved_2_31 : HAL.UInt30;
end record;
Read-only. Changes to 1 when any register is written, and back to 0 when QUOTIENT is read.\n Software can use this flag to make save/restore more efficient (skip if not DIRTY).\n If the flag is used in this way, it's recommended to either read QUOTIENT only,\n or REMAINDER and then QUOTIENT, to prevent data loss on context switch.
unspecified
type FIFO_ST_Register is record
VLD : Boolean := False;
RDY : Boolean := True;
WOF : Boolean := False;
ROE : Boolean := False;
Reserved_4_31 : HAL.UInt28 := 16#0#;
end record;
Read-only. Value is 1 if this core's TX FIFO is not full (i.e. if FIFO_WR is ready for more data)
Write data bit of one shall clear (set to zero) the corresponding bit in the field. Sticky flag indicating the TX FIFO was written when full. This write was ignored by the FIFO.
Write data bit of one shall clear (set to zero) the corresponding bit in the field. Sticky flag indicating the RX FIFO was read when empty. This read was ignored by the FIFO.
unspecified
subtype GPIO_HI_IN_GPIO_HI_IN_Field is HAL.UInt6;
type GPIO_HI_IN_Register is record
GPIO_HI_IN : GPIO_HI_IN_GPIO_HI_IN_Field;
Reserved_6_31 : HAL.UInt26;
end record;
unspecified
subtype GPIO_HI_OE_CLR_GPIO_HI_OE_CLR_Field is HAL.UInt6;
type GPIO_HI_OE_CLR_Register is record
GPIO_HI_OE_CLR : GPIO_HI_OE_CLR_GPIO_HI_OE_CLR_Field := 16#0#;
Reserved_6_31 : HAL.UInt26 := 16#0#;
end record;
unspecified
subtype GPIO_HI_OE_GPIO_HI_OE_Field is HAL.UInt6;
type GPIO_HI_OE_Register is record
GPIO_HI_OE : GPIO_HI_OE_GPIO_HI_OE_Field := 16#0#;
Reserved_6_31 : HAL.UInt26 := 16#0#;
end record;
unspecified
subtype GPIO_HI_OE_SET_GPIO_HI_OE_SET_Field is HAL.UInt6;
type GPIO_HI_OE_SET_Register is record
GPIO_HI_OE_SET : GPIO_HI_OE_SET_GPIO_HI_OE_SET_Field := 16#0#;
Reserved_6_31 : HAL.UInt26 := 16#0#;
end record;
unspecified
subtype GPIO_HI_OE_XOR_GPIO_HI_OE_XOR_Field is HAL.UInt6;
type GPIO_HI_OE_XOR_Register is record
GPIO_HI_OE_XOR : GPIO_HI_OE_XOR_GPIO_HI_OE_XOR_Field := 16#0#;
Reserved_6_31 : HAL.UInt26 := 16#0#;
end record;
unspecified
subtype GPIO_HI_OUT_CLR_GPIO_HI_OUT_CLR_Field is HAL.UInt6;
type GPIO_HI_OUT_CLR_Register is record
GPIO_HI_OUT_CLR : GPIO_HI_OUT_CLR_GPIO_HI_OUT_CLR_Field := 16#0#;
Reserved_6_31 : HAL.UInt26 := 16#0#;
end record;
unspecified
subtype GPIO_HI_OUT_GPIO_HI_OUT_Field is HAL.UInt6;
type GPIO_HI_OUT_Register is record
GPIO_HI_OUT : GPIO_HI_OUT_GPIO_HI_OUT_Field := 16#0#;
Reserved_6_31 : HAL.UInt26 := 16#0#;
end record;
unspecified
subtype GPIO_HI_OUT_SET_GPIO_HI_OUT_SET_Field is HAL.UInt6;
type GPIO_HI_OUT_SET_Register is record
GPIO_HI_OUT_SET : GPIO_HI_OUT_SET_GPIO_HI_OUT_SET_Field := 16#0#;
Reserved_6_31 : HAL.UInt26 := 16#0#;
end record;
unspecified
subtype GPIO_HI_OUT_XOR_GPIO_HI_OUT_XOR_Field is HAL.UInt6;
type GPIO_HI_OUT_XOR_Register is record
GPIO_HI_OUT_XOR : GPIO_HI_OUT_XOR_GPIO_HI_OUT_XOR_Field := 16#0#;
Reserved_6_31 : HAL.UInt26 := 16#0#;
end record;
unspecified
subtype GPIO_IN_GPIO_IN_Field is HAL.UInt30;
type GPIO_IN_Register is record
GPIO_IN : GPIO_IN_GPIO_IN_Field;
Reserved_30_31 : HAL.UInt2;
end record;
unspecified
subtype GPIO_OE_CLR_GPIO_OE_CLR_Field is HAL.UInt30;
type GPIO_OE_CLR_Register is record
GPIO_OE_CLR : GPIO_OE_CLR_GPIO_OE_CLR_Field := 16#0#;
Reserved_30_31 : HAL.UInt2 := 16#0#;
end record;
unspecified
subtype GPIO_OE_GPIO_OE_Field is HAL.UInt30;
type GPIO_OE_Register is record
GPIO_OE : GPIO_OE_GPIO_OE_Field := 16#0#;
Reserved_30_31 : HAL.UInt2 := 16#0#;
end record;
unspecified
subtype GPIO_OE_SET_GPIO_OE_SET_Field is HAL.UInt30;
type GPIO_OE_SET_Register is record
GPIO_OE_SET : GPIO_OE_SET_GPIO_OE_SET_Field := 16#0#;
Reserved_30_31 : HAL.UInt2 := 16#0#;
end record;
unspecified
subtype GPIO_OE_XOR_GPIO_OE_XOR_Field is HAL.UInt30;
type GPIO_OE_XOR_Register is record
GPIO_OE_XOR : GPIO_OE_XOR_GPIO_OE_XOR_Field := 16#0#;
Reserved_30_31 : HAL.UInt2 := 16#0#;
end record;
unspecified
subtype GPIO_OUT_CLR_GPIO_OUT_CLR_Field is HAL.UInt30;
type GPIO_OUT_CLR_Register is record
GPIO_OUT_CLR : GPIO_OUT_CLR_GPIO_OUT_CLR_Field := 16#0#;
Reserved_30_31 : HAL.UInt2 := 16#0#;
end record;
unspecified
subtype GPIO_OUT_GPIO_OUT_Field is HAL.UInt30;
type GPIO_OUT_Register is record
GPIO_OUT : GPIO_OUT_GPIO_OUT_Field := 16#0#;
Reserved_30_31 : HAL.UInt2 := 16#0#;
end record;
unspecified
subtype GPIO_OUT_SET_GPIO_OUT_SET_Field is HAL.UInt30;
type GPIO_OUT_SET_Register is record
GPIO_OUT_SET : GPIO_OUT_SET_GPIO_OUT_SET_Field := 16#0#;
Reserved_30_31 : HAL.UInt2 := 16#0#;
end record;
unspecified
subtype GPIO_OUT_XOR_GPIO_OUT_XOR_Field is HAL.UInt30;
type GPIO_OUT_XOR_Register is record
GPIO_OUT_XOR : GPIO_OUT_XOR_GPIO_OUT_XOR_Field := 16#0#;
Reserved_30_31 : HAL.UInt2 := 16#0#;
end record;
unspecified
subtype INTERP0_ACCUM0_ADD_INTERP0_ACCUM0_ADD_Field is HAL.UInt24;
type INTERP0_ACCUM0_ADD_Register is record
INTERP0_ACCUM0_ADD : INTERP0_ACCUM0_ADD_INTERP0_ACCUM0_ADD_Field :=
16#0#;
Reserved_24_31 : HAL.UInt8 := 16#0#;
end record;
unspecified
subtype INTERP0_ACCUM1_ADD_INTERP0_ACCUM1_ADD_Field is HAL.UInt24;
type INTERP0_ACCUM1_ADD_Register is record
INTERP0_ACCUM1_ADD : INTERP0_ACCUM1_ADD_INTERP0_ACCUM1_ADD_Field :=
16#0#;
Reserved_24_31 : HAL.UInt8 := 16#0#;
end record;
unspecified
subtype INTERP0_CTRL_LANE0_FORCE_MSB_Field is HAL.UInt2;
subtype INTERP0_CTRL_LANE0_MASK_LSB_Field is HAL.UInt5;
subtype INTERP0_CTRL_LANE0_MASK_MSB_Field is HAL.UInt5;
type INTERP0_CTRL_LANE0_OVERF_Field
(As_Array : Boolean := False)
is record
case As_Array is
when False =>
Val : HAL.UInt3;
when True =>
Arr : INTERP0_CTRL_LANE0_OVERF_Field_Array;
end case;
end record;
type INTERP0_CTRL_LANE0_OVERF_Field_Array is array (0 .. 2) of Boolean
with Component_Size => 1, Size => 3;
type INTERP0_CTRL_LANE0_Register is record
SHIFT : INTERP0_CTRL_LANE0_SHIFT_Field := 16#0#;
MASK_LSB : INTERP0_CTRL_LANE0_MASK_LSB_Field := 16#0#;
MASK_MSB : INTERP0_CTRL_LANE0_MASK_MSB_Field := 16#0#;
SIGNED : Boolean := False;
CROSS_INPUT : Boolean := False;
CROSS_RESULT : Boolean := False;
ADD_RAW : Boolean := False;
FORCE_MSB : INTERP0_CTRL_LANE0_FORCE_MSB_Field := 16#0#;
BLEND : Boolean := False;
Reserved_22_22 : HAL.Bit := 16#0#;
OVERF : INTERP0_CTRL_LANE0_OVERF_Field :=
(As_Array => False, Val => 16#0#);
Reserved_26_31 : HAL.UInt6 := 16#0#;
end record;
The least-significant bit allowed to pass by the mask (inclusive)
The most-significant bit allowed to pass by the mask (inclusive)\n Setting MSB < LSB may cause chip to turn inside-out
If SIGNED is set, the shifted and masked accumulator value is sign-extended to 32 bits\n before adding to BASE0, and LANE0 PEEK/POP appear extended to 32 bits when read by processor.
If 1, feed the opposite lane's accumulator into this lane's shift + mask hardware.\n Takes effect even if ADD_RAW is set (the CROSS_INPUT mux is before the shift+mask bypass)
If 1, feed the opposite lane's result into this lane's accumulator on POP.
If 1, mask + shift is bypassed for LANE0 result. This does not affect FULL result.
ORed into bits 29:28 of the lane result presented to the processor on the bus.\n No effect on the internal 32-bit datapath. Handy for using a lane to generate sequence\n of pointers into flash or SRAM.
Only present on INTERP0 on each core. If BLEND mode is enabled:\n - LANE1 result is a linear interpolation between BASE0 and BASE1, controlled\n by the 8 LSBs of lane 1 shift and mask value (a fractional number between\n 0 and 255/256ths)\n - LANE0 result does not have BASE0 added (yields only the 8 LSBs of lane 1 shift+mask value)\n - FULL result does not have lane 1 shift+mask value added (BASE2 + lane 0 shift+mask)\n LANE1 SIGNED flag controls whether the interpolation is signed or unsigned.
unspecified
Read-only. Indicates if any masked-off MSBs in ACCUM0 are set.
unspecified
subtype INTERP0_CTRL_LANE0_SHIFT_Field is HAL.UInt5;
subtype INTERP0_CTRL_LANE1_FORCE_MSB_Field is HAL.UInt2;
subtype INTERP0_CTRL_LANE1_MASK_LSB_Field is HAL.UInt5;
subtype INTERP0_CTRL_LANE1_MASK_MSB_Field is HAL.UInt5;
type INTERP0_CTRL_LANE1_Register is record
SHIFT : INTERP0_CTRL_LANE1_SHIFT_Field := 16#0#;
MASK_LSB : INTERP0_CTRL_LANE1_MASK_LSB_Field := 16#0#;
MASK_MSB : INTERP0_CTRL_LANE1_MASK_MSB_Field := 16#0#;
SIGNED : Boolean := False;
CROSS_INPUT : Boolean := False;
CROSS_RESULT : Boolean := False;
ADD_RAW : Boolean := False;
FORCE_MSB : INTERP0_CTRL_LANE1_FORCE_MSB_Field := 16#0#;
Reserved_21_31 : HAL.UInt11 := 16#0#;
end record;
The least-significant bit allowed to pass by the mask (inclusive)
The most-significant bit allowed to pass by the mask (inclusive)\n Setting MSB < LSB may cause chip to turn inside-out
If SIGNED is set, the shifted and masked accumulator value is sign-extended to 32 bits\n before adding to BASE1, and LANE1 PEEK/POP appear extended to 32 bits when read by processor.
If 1, feed the opposite lane's accumulator into this lane's shift + mask hardware.\n Takes effect even if ADD_RAW is set (the CROSS_INPUT mux is before the shift+mask bypass)
If 1, feed the opposite lane's result into this lane's accumulator on POP.
If 1, mask + shift is bypassed for LANE1 result. This does not affect FULL result.
ORed into bits 29:28 of the lane result presented to the processor on the bus.\n No effect on the internal 32-bit datapath. Handy for using a lane to generate sequence\n of pointers into flash or SRAM.
unspecified
subtype INTERP0_CTRL_LANE1_SHIFT_Field is HAL.UInt5;
subtype INTERP1_ACCUM0_ADD_INTERP1_ACCUM0_ADD_Field is HAL.UInt24;
type INTERP1_ACCUM0_ADD_Register is record
INTERP1_ACCUM0_ADD : INTERP1_ACCUM0_ADD_INTERP1_ACCUM0_ADD_Field :=
16#0#;
Reserved_24_31 : HAL.UInt8 := 16#0#;
end record;
unspecified
subtype INTERP1_ACCUM1_ADD_INTERP1_ACCUM1_ADD_Field is HAL.UInt24;
type INTERP1_ACCUM1_ADD_Register is record
INTERP1_ACCUM1_ADD : INTERP1_ACCUM1_ADD_INTERP1_ACCUM1_ADD_Field :=
16#0#;
Reserved_24_31 : HAL.UInt8 := 16#0#;
end record;
unspecified
subtype INTERP1_CTRL_LANE0_FORCE_MSB_Field is HAL.UInt2;
subtype INTERP1_CTRL_LANE0_MASK_LSB_Field is HAL.UInt5;
subtype INTERP1_CTRL_LANE0_MASK_MSB_Field is HAL.UInt5;
type INTERP1_CTRL_LANE0_OVERF_Field
(As_Array : Boolean := False)
is record
case As_Array is
when False =>
Val : HAL.UInt3;
when True =>
Arr : INTERP1_CTRL_LANE0_OVERF_Field_Array;
end case;
end record;
type INTERP1_CTRL_LANE0_OVERF_Field_Array is array (0 .. 2) of Boolean
with Component_Size => 1, Size => 3;
type INTERP1_CTRL_LANE0_Register is record
SHIFT : INTERP1_CTRL_LANE0_SHIFT_Field := 16#0#;
MASK_LSB : INTERP1_CTRL_LANE0_MASK_LSB_Field := 16#0#;
MASK_MSB : INTERP1_CTRL_LANE0_MASK_MSB_Field := 16#0#;
SIGNED : Boolean := False;
CROSS_INPUT : Boolean := False;
CROSS_RESULT : Boolean := False;
ADD_RAW : Boolean := False;
FORCE_MSB : INTERP1_CTRL_LANE0_FORCE_MSB_Field := 16#0#;
Reserved_21_21 : HAL.Bit := 16#0#;
CLAMP : Boolean := False;
OVERF : INTERP1_CTRL_LANE0_OVERF_Field :=
(As_Array => False, Val => 16#0#);
Reserved_26_31 : HAL.UInt6 := 16#0#;
end record;
The least-significant bit allowed to pass by the mask (inclusive)
The most-significant bit allowed to pass by the mask (inclusive)\n Setting MSB < LSB may cause chip to turn inside-out
If SIGNED is set, the shifted and masked accumulator value is sign-extended to 32 bits\n before adding to BASE0, and LANE0 PEEK/POP appear extended to 32 bits when read by processor.
If 1, feed the opposite lane's accumulator into this lane's shift + mask hardware.\n Takes effect even if ADD_RAW is set (the CROSS_INPUT mux is before the shift+mask bypass)
If 1, feed the opposite lane's result into this lane's accumulator on POP.
If 1, mask + shift is bypassed for LANE0 result. This does not affect FULL result.
ORed into bits 29:28 of the lane result presented to the processor on the bus.\n No effect on the internal 32-bit datapath. Handy for using a lane to generate sequence\n of pointers into flash or SRAM.
unspecified
Only present on INTERP1 on each core. If CLAMP mode is enabled:\n - LANE0 result is shifted and masked ACCUM0, clamped by a lower bound of\n BASE0 and an upper bound of BASE1.\n - Signedness of these comparisons is determined by LANE0_CTRL_SIGNED
Read-only. Indicates if any masked-off MSBs in ACCUM0 are set.
unspecified
subtype INTERP1_CTRL_LANE0_SHIFT_Field is HAL.UInt5;
subtype INTERP1_CTRL_LANE1_FORCE_MSB_Field is HAL.UInt2;
subtype INTERP1_CTRL_LANE1_MASK_LSB_Field is HAL.UInt5;
subtype INTERP1_CTRL_LANE1_MASK_MSB_Field is HAL.UInt5;
type INTERP1_CTRL_LANE1_Register is record
SHIFT : INTERP1_CTRL_LANE1_SHIFT_Field := 16#0#;
MASK_LSB : INTERP1_CTRL_LANE1_MASK_LSB_Field := 16#0#;
MASK_MSB : INTERP1_CTRL_LANE1_MASK_MSB_Field := 16#0#;
SIGNED : Boolean := False;
CROSS_INPUT : Boolean := False;
CROSS_RESULT : Boolean := False;
ADD_RAW : Boolean := False;
FORCE_MSB : INTERP1_CTRL_LANE1_FORCE_MSB_Field := 16#0#;
Reserved_21_31 : HAL.UInt11 := 16#0#;
end record;
The least-significant bit allowed to pass by the mask (inclusive)
The most-significant bit allowed to pass by the mask (inclusive)\n Setting MSB < LSB may cause chip to turn inside-out
If SIGNED is set, the shifted and masked accumulator value is sign-extended to 32 bits\n before adding to BASE1, and LANE1 PEEK/POP appear extended to 32 bits when read by processor.
If 1, feed the opposite lane's accumulator into this lane's shift + mask hardware.\n Takes effect even if ADD_RAW is set (the CROSS_INPUT mux is before the shift+mask bypass)
If 1, feed the opposite lane's result into this lane's accumulator on POP.
If 1, mask + shift is bypassed for LANE1 result. This does not affect FULL result.
ORed into bits 29:28 of the lane result presented to the processor on the bus.\n No effect on the internal 32-bit datapath. Handy for using a lane to generate sequence\n of pointers into flash or SRAM.
unspecified
subtype INTERP1_CTRL_LANE1_SHIFT_Field is HAL.UInt5;
SIO_Periph : aliased SIO_Peripheral
with Import, Address => SIO_Base;
type SIO_Peripheral is record
CPUID : aliased HAL.UInt32;
GPIO_IN : aliased GPIO_IN_Register;
GPIO_HI_IN : aliased GPIO_HI_IN_Register;
GPIO_OUT : aliased GPIO_OUT_Register;
GPIO_OUT_SET : aliased GPIO_OUT_SET_Register;
GPIO_OUT_CLR : aliased GPIO_OUT_CLR_Register;
GPIO_OUT_XOR : aliased GPIO_OUT_XOR_Register;
GPIO_OE : aliased GPIO_OE_Register;
GPIO_OE_SET : aliased GPIO_OE_SET_Register;
GPIO_OE_CLR : aliased GPIO_OE_CLR_Register;
GPIO_OE_XOR : aliased GPIO_OE_XOR_Register;
GPIO_HI_OUT : aliased GPIO_HI_OUT_Register;
GPIO_HI_OUT_SET : aliased GPIO_HI_OUT_SET_Register;
GPIO_HI_OUT_CLR : aliased GPIO_HI_OUT_CLR_Register;
GPIO_HI_OUT_XOR : aliased GPIO_HI_OUT_XOR_Register;
GPIO_HI_OE : aliased GPIO_HI_OE_Register;
GPIO_HI_OE_SET : aliased GPIO_HI_OE_SET_Register;
GPIO_HI_OE_CLR : aliased GPIO_HI_OE_CLR_Register;
GPIO_HI_OE_XOR : aliased GPIO_HI_OE_XOR_Register;
FIFO_ST : aliased FIFO_ST_Register;
FIFO_WR : aliased HAL.UInt32;
FIFO_RD : aliased HAL.UInt32;
SPINLOCK_ST : aliased HAL.UInt32;
DIV_UDIVIDEND : aliased HAL.UInt32;
DIV_UDIVISOR : aliased HAL.UInt32;
DIV_SDIVIDEND : aliased HAL.UInt32;
DIV_SDIVISOR : aliased HAL.UInt32;
DIV_QUOTIENT : aliased HAL.UInt32;
DIV_REMAINDER : aliased HAL.UInt32;
DIV_CSR : aliased DIV_CSR_Register;
INTERP0_ACCUM0 : aliased HAL.UInt32;
INTERP0_ACCUM1 : aliased HAL.UInt32;
INTERP0_BASE0 : aliased HAL.UInt32;
INTERP0_BASE1 : aliased HAL.UInt32;
INTERP0_BASE2 : aliased HAL.UInt32;
INTERP0_POP_LANE0 : aliased HAL.UInt32;
INTERP0_POP_LANE1 : aliased HAL.UInt32;
INTERP0_POP_FULL : aliased HAL.UInt32;
INTERP0_PEEK_LANE0 : aliased HAL.UInt32;
INTERP0_PEEK_LANE1 : aliased HAL.UInt32;
INTERP0_PEEK_FULL : aliased HAL.UInt32;
INTERP0_CTRL_LANE0 : aliased INTERP0_CTRL_LANE0_Register;
INTERP0_CTRL_LANE1 : aliased INTERP0_CTRL_LANE1_Register;
INTERP0_ACCUM0_ADD : aliased INTERP0_ACCUM0_ADD_Register;
INTERP0_ACCUM1_ADD : aliased INTERP0_ACCUM1_ADD_Register;
INTERP0_BASE_1AND0 : aliased HAL.UInt32;
INTERP1_ACCUM0 : aliased HAL.UInt32;
INTERP1_ACCUM1 : aliased HAL.UInt32;
INTERP1_BASE0 : aliased HAL.UInt32;
INTERP1_BASE1 : aliased HAL.UInt32;
INTERP1_BASE2 : aliased HAL.UInt32;
INTERP1_POP_LANE0 : aliased HAL.UInt32;
INTERP1_POP_LANE1 : aliased HAL.UInt32;
INTERP1_POP_FULL : aliased HAL.UInt32;
INTERP1_PEEK_LANE0 : aliased HAL.UInt32;
INTERP1_PEEK_LANE1 : aliased HAL.UInt32;
INTERP1_PEEK_FULL : aliased HAL.UInt32;
INTERP1_CTRL_LANE0 : aliased INTERP1_CTRL_LANE0_Register;
INTERP1_CTRL_LANE1 : aliased INTERP1_CTRL_LANE1_Register;
INTERP1_ACCUM0_ADD : aliased INTERP1_ACCUM0_ADD_Register;
INTERP1_ACCUM1_ADD : aliased INTERP1_ACCUM1_ADD_Register;
INTERP1_BASE_1AND0 : aliased HAL.UInt32;
SPINLOCK0 : aliased HAL.UInt32;
SPINLOCK1 : aliased HAL.UInt32;
SPINLOCK2 : aliased HAL.UInt32;
SPINLOCK3 : aliased HAL.UInt32;
SPINLOCK4 : aliased HAL.UInt32;
SPINLOCK5 : aliased HAL.UInt32;
SPINLOCK6 : aliased HAL.UInt32;
SPINLOCK7 : aliased HAL.UInt32;
SPINLOCK8 : aliased HAL.UInt32;
SPINLOCK9 : aliased HAL.UInt32;
SPINLOCK10 : aliased HAL.UInt32;
SPINLOCK11 : aliased HAL.UInt32;
SPINLOCK12 : aliased HAL.UInt32;
SPINLOCK13 : aliased HAL.UInt32;
SPINLOCK14 : aliased HAL.UInt32;
SPINLOCK15 : aliased HAL.UInt32;
SPINLOCK16 : aliased HAL.UInt32;
SPINLOCK17 : aliased HAL.UInt32;
SPINLOCK18 : aliased HAL.UInt32;
SPINLOCK19 : aliased HAL.UInt32;
SPINLOCK20 : aliased HAL.UInt32;
SPINLOCK21 : aliased HAL.UInt32;
SPINLOCK22 : aliased HAL.UInt32;
SPINLOCK23 : aliased HAL.UInt32;
SPINLOCK24 : aliased HAL.UInt32;
SPINLOCK25 : aliased HAL.UInt32;
SPINLOCK26 : aliased HAL.UInt32;
SPINLOCK27 : aliased HAL.UInt32;
SPINLOCK28 : aliased HAL.UInt32;
SPINLOCK29 : aliased HAL.UInt32;
SPINLOCK30 : aliased HAL.UInt32;
SPINLOCK31 : aliased HAL.UInt32;
end record;
Input value for GPIO pins
Input value for QSPI pins
GPIO output value
GPIO output value set
GPIO output value clear
GPIO output value XOR
GPIO output enable
GPIO output enable set
GPIO output enable clear
GPIO output enable XOR
QSPI output value
QSPI output value set
QSPI output value clear
QSPI output value XOR
QSPI output enable
QSPI output enable set
QSPI output enable clear
QSPI output enable XOR
Status register for inter-core FIFOs (mailboxes).\n There is one FIFO in the core 0 -> core 1 direction, and one core 1 -> core 0. Both are 32 bits wide and 8 words deep.\n Core 0 can see the read side of the 1->0 FIFO (RX), and the write side of 0->1 FIFO (TX).\n Core 1 can see the read side of the 0->1 FIFO (RX), and the write side of 1->0 FIFO (TX).\n The SIO IRQ for each core is the logical OR of the VLD, WOF and ROE fields of its FIFO_ST register.
Write access to this core's TX FIFO
Read access to this core's RX FIFO
Spinlock state\n A bitmap containing the state of all 32 spinlocks (1=locked).\n Mainly intended for debugging.
Divider unsigned dividend\n Write to the DIVIDEND operand of the divider, i.e. the p in p / q.\n Any operand write starts a new calculation. The results appear in QUOTIENT, REMAINDER.\n UDIVIDEND/SDIVIDEND are aliases of the same internal register. The U alias starts an\n unsigned calculation, and the S alias starts a signed calculation.
Divider unsigned divisor\n Write to the DIVISOR operand of the divider, i.e. the q in p / q.\n Any operand write starts a new calculation. The results appear in QUOTIENT, REMAINDER.\n UDIVIDEND/SDIVIDEND are aliases of the same internal register. The U alias starts an\n unsigned calculation, and the S alias starts a signed calculation.
Divider signed dividend\n The same as UDIVIDEND, but starts a signed calculation, rather than unsigned.
Divider signed divisor\n The same as UDIVISOR, but starts a signed calculation, rather than unsigned.
Divider result quotient\n The result of DIVIDEND / DIVISOR (division). Contents undefined while CSR_READY is low.\n For signed calculations, QUOTIENT is negative when the signs of DIVIDEND and DIVISOR differ.\n This register can be written to directly, for context save/restore purposes. This halts any\n in-progress calculation and sets the CSR_READY and CSR_DIRTY flags.\n Reading from QUOTIENT clears the CSR_DIRTY flag, so should read results in the order\n REMAINDER, QUOTIENT if CSR_DIRTY is used.
Divider result remainder\n The result of DIVIDEND % DIVISOR (modulo). Contents undefined while CSR_READY is low.\n For signed calculations, REMAINDER is negative only when DIVIDEND is negative.\n This register can be written to directly, for context save/restore purposes. This halts any\n in-progress calculation and sets the CSR_READY and CSR_DIRTY flags.
Control and status register for divider.
Read/write access to accumulator 0
Read/write access to accumulator 1
Read/write access to BASE0 register.
Read/write access to BASE1 register.
Read/write access to BASE2 register.
Read LANE0 result, and simultaneously write lane results to both accumulators (POP).
Read LANE1 result, and simultaneously write lane results to both accumulators (POP).
Read FULL result, and simultaneously write lane results to both accumulators (POP).
Read LANE0 result, without altering any internal state (PEEK).
Read LANE1 result, without altering any internal state (PEEK).
Read FULL result, without altering any internal state (PEEK).
Control register for lane 0
Control register for lane 1
Values written here are atomically added to ACCUM0\n Reading yields lane 0's raw shift and mask value (BASE0 not added).
Values written here are atomically added to ACCUM1\n Reading yields lane 1's raw shift and mask value (BASE1 not added).
On write, the lower 16 bits go to BASE0, upper bits to BASE1 simultaneously.\n Each half is sign-extended to 32 bits if that lane's SIGNED flag is set.
Read/write access to accumulator 0
Read/write access to accumulator 1
Read/write access to BASE0 register.
Read/write access to BASE1 register.
Read/write access to BASE2 register.
Read LANE0 result, and simultaneously write lane results to both accumulators (POP).
Read LANE1 result, and simultaneously write lane results to both accumulators (POP).
Read FULL result, and simultaneously write lane results to both accumulators (POP).
Read LANE0 result, without altering any internal state (PEEK).
Read LANE1 result, without altering any internal state (PEEK).
Read FULL result, without altering any internal state (PEEK).
Control register for lane 0
Control register for lane 1
Values written here are atomically added to ACCUM0\n Reading yields lane 0's raw shift and mask value (BASE0 not added).
Values written here are atomically added to ACCUM1\n Reading yields lane 1's raw shift and mask value (BASE1 not added).
On write, the lower 16 bits go to BASE0, upper bits to BASE1 simultaneously.\n Each half is sign-extended to 32 bits if that lane's SIGNED flag is set.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.
Reading from a spinlock address will:\n - Return 0 if lock is already locked\n - Otherwise return nonzero, and simultaneously claim the lock\n\n Writing (any value) releases the lock.\n If core 0 and core 1 attempt to claim the same lock simultaneously, core 0 wins.\n The value returned on success is 0x1 << lock number.