RP2040_SVD.SIO

Entities

Array Types

Record Types

Subtypes

Variables

Description

------------- Registers -- -------------

DIV_CSR_Register

type DIV_CSR_Register is record
   READY         : Boolean;
   DIRTY         : Boolean;
   Reserved_2_31 : HAL.UInt30;
end record;
Record fields
READY

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.

DIRTY

unspecified

Reserved_2_31

FIFO_ST_Register

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;
Record fields
VLD

Read-only. Value is 1 if this core's TX FIFO is not full (i.e. if FIFO_WR is ready for more data)

RDY

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.

WOF

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.

ROE

unspecified

Reserved_4_31

GPIO_HI_IN_GPIO_HI_IN_Field

subtype GPIO_HI_IN_GPIO_HI_IN_Field is HAL.UInt6;

GPIO_HI_IN_Register

type GPIO_HI_IN_Register is record
   GPIO_HI_IN    : GPIO_HI_IN_GPIO_HI_IN_Field;
   Reserved_6_31 : HAL.UInt26;
end record;
Record fields
GPIO_HI_IN

unspecified

Reserved_6_31

GPIO_HI_OE_CLR_GPIO_HI_OE_CLR_Field

subtype GPIO_HI_OE_CLR_GPIO_HI_OE_CLR_Field is HAL.UInt6;

GPIO_HI_OE_CLR_Register

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;
Record fields
GPIO_HI_OE_CLR

unspecified

Reserved_6_31

GPIO_HI_OE_GPIO_HI_OE_Field

subtype GPIO_HI_OE_GPIO_HI_OE_Field is HAL.UInt6;

GPIO_HI_OE_Register

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;
Record fields
GPIO_HI_OE

unspecified

Reserved_6_31

GPIO_HI_OE_SET_GPIO_HI_OE_SET_Field

subtype GPIO_HI_OE_SET_GPIO_HI_OE_SET_Field is HAL.UInt6;

GPIO_HI_OE_SET_Register

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;
Record fields
GPIO_HI_OE_SET

unspecified

Reserved_6_31

GPIO_HI_OE_XOR_GPIO_HI_OE_XOR_Field

subtype GPIO_HI_OE_XOR_GPIO_HI_OE_XOR_Field is HAL.UInt6;

GPIO_HI_OE_XOR_Register

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;
Record fields
GPIO_HI_OE_XOR

unspecified

Reserved_6_31

GPIO_HI_OUT_CLR_GPIO_HI_OUT_CLR_Field

subtype GPIO_HI_OUT_CLR_GPIO_HI_OUT_CLR_Field is HAL.UInt6;

GPIO_HI_OUT_CLR_Register

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;
Record fields
GPIO_HI_OUT_CLR

unspecified

Reserved_6_31

GPIO_HI_OUT_GPIO_HI_OUT_Field

subtype GPIO_HI_OUT_GPIO_HI_OUT_Field is HAL.UInt6;

GPIO_HI_OUT_Register

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;
Record fields
GPIO_HI_OUT

unspecified

Reserved_6_31

GPIO_HI_OUT_SET_GPIO_HI_OUT_SET_Field

subtype GPIO_HI_OUT_SET_GPIO_HI_OUT_SET_Field is HAL.UInt6;

GPIO_HI_OUT_SET_Register

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;
Record fields
GPIO_HI_OUT_SET

unspecified

Reserved_6_31

GPIO_HI_OUT_XOR_GPIO_HI_OUT_XOR_Field

subtype GPIO_HI_OUT_XOR_GPIO_HI_OUT_XOR_Field is HAL.UInt6;

GPIO_HI_OUT_XOR_Register

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;
Record fields
GPIO_HI_OUT_XOR

unspecified

Reserved_6_31

GPIO_IN_GPIO_IN_Field

subtype GPIO_IN_GPIO_IN_Field is HAL.UInt30;

GPIO_IN_Register

type GPIO_IN_Register is record
   GPIO_IN        : GPIO_IN_GPIO_IN_Field;
   Reserved_30_31 : HAL.UInt2;
end record;
Record fields
GPIO_IN

unspecified

Reserved_30_31

GPIO_OE_CLR_GPIO_OE_CLR_Field

subtype GPIO_OE_CLR_GPIO_OE_CLR_Field is HAL.UInt30;

GPIO_OE_CLR_Register

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;
Record fields
GPIO_OE_CLR

unspecified

Reserved_30_31

GPIO_OE_GPIO_OE_Field

subtype GPIO_OE_GPIO_OE_Field is HAL.UInt30;

GPIO_OE_Register

type GPIO_OE_Register is record
   GPIO_OE        : GPIO_OE_GPIO_OE_Field := 16#0#;
   Reserved_30_31 : HAL.UInt2 := 16#0#;
end record;
Record fields
GPIO_OE

unspecified

Reserved_30_31

GPIO_OE_SET_GPIO_OE_SET_Field

subtype GPIO_OE_SET_GPIO_OE_SET_Field is HAL.UInt30;

GPIO_OE_SET_Register

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;
Record fields
GPIO_OE_SET

unspecified

Reserved_30_31

GPIO_OE_XOR_GPIO_OE_XOR_Field

subtype GPIO_OE_XOR_GPIO_OE_XOR_Field is HAL.UInt30;

GPIO_OE_XOR_Register

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;
Record fields
GPIO_OE_XOR

unspecified

Reserved_30_31

GPIO_OUT_CLR_GPIO_OUT_CLR_Field

subtype GPIO_OUT_CLR_GPIO_OUT_CLR_Field is HAL.UInt30;

GPIO_OUT_CLR_Register

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;
Record fields
GPIO_OUT_CLR

unspecified

Reserved_30_31

GPIO_OUT_GPIO_OUT_Field

subtype GPIO_OUT_GPIO_OUT_Field is HAL.UInt30;

GPIO_OUT_Register

type GPIO_OUT_Register is record
   GPIO_OUT       : GPIO_OUT_GPIO_OUT_Field := 16#0#;
   Reserved_30_31 : HAL.UInt2 := 16#0#;
end record;
Record fields
GPIO_OUT

unspecified

Reserved_30_31

GPIO_OUT_SET_GPIO_OUT_SET_Field

subtype GPIO_OUT_SET_GPIO_OUT_SET_Field is HAL.UInt30;

GPIO_OUT_SET_Register

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;
Record fields
GPIO_OUT_SET

unspecified

Reserved_30_31

GPIO_OUT_XOR_GPIO_OUT_XOR_Field

subtype GPIO_OUT_XOR_GPIO_OUT_XOR_Field is HAL.UInt30;

GPIO_OUT_XOR_Register

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;
Record fields
GPIO_OUT_XOR

unspecified

Reserved_30_31

INTERP0_ACCUM0_ADD_INTERP0_ACCUM0_ADD_Field

subtype INTERP0_ACCUM0_ADD_INTERP0_ACCUM0_ADD_Field is HAL.UInt24;

INTERP0_ACCUM0_ADD_Register

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;
Record fields
INTERP0_ACCUM0_ADD

unspecified

Reserved_24_31

INTERP0_ACCUM1_ADD_INTERP0_ACCUM1_ADD_Field

subtype INTERP0_ACCUM1_ADD_INTERP0_ACCUM1_ADD_Field is HAL.UInt24;

INTERP0_ACCUM1_ADD_Register

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;
Record fields
INTERP0_ACCUM1_ADD

unspecified

Reserved_24_31

INTERP0_CTRL_LANE0_FORCE_MSB_Field

subtype INTERP0_CTRL_LANE0_FORCE_MSB_Field is HAL.UInt2;

INTERP0_CTRL_LANE0_MASK_LSB_Field

subtype INTERP0_CTRL_LANE0_MASK_LSB_Field is HAL.UInt5;

INTERP0_CTRL_LANE0_MASK_MSB_Field

subtype INTERP0_CTRL_LANE0_MASK_MSB_Field is HAL.UInt5;

INTERP0_CTRL_LANE0_OVERF_Field

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;
Record fields
As_Array
Val
Arr

INTERP0_CTRL_LANE0_OVERF_Field_Array

type INTERP0_CTRL_LANE0_OVERF_Field_Array is array (0 .. 2) of Boolean
  with Component_Size => 1, Size => 3;

INTERP0_CTRL_LANE0_Register

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;
Record fields
SHIFT

The least-significant bit allowed to pass by the mask (inclusive)

MASK_LSB

The most-significant bit allowed to pass by the mask (inclusive)\n Setting MSB < LSB may cause chip to turn inside-out

MASK_MSB

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.

SIGNED

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)

CROSS_INPUT

If 1, feed the opposite lane's result into this lane's accumulator on POP.

CROSS_RESULT

If 1, mask + shift is bypassed for LANE0 result. This does not affect FULL result.

ADD_RAW

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.

FORCE_MSB

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.

BLEND

unspecified

Reserved_22_22

Read-only. Indicates if any masked-off MSBs in ACCUM0 are set.

OVERF

unspecified

Reserved_26_31

INTERP0_CTRL_LANE0_SHIFT_Field

subtype INTERP0_CTRL_LANE0_SHIFT_Field is HAL.UInt5;

INTERP0_CTRL_LANE1_FORCE_MSB_Field

subtype INTERP0_CTRL_LANE1_FORCE_MSB_Field is HAL.UInt2;

INTERP0_CTRL_LANE1_MASK_LSB_Field

subtype INTERP0_CTRL_LANE1_MASK_LSB_Field is HAL.UInt5;

INTERP0_CTRL_LANE1_MASK_MSB_Field

subtype INTERP0_CTRL_LANE1_MASK_MSB_Field is HAL.UInt5;

INTERP0_CTRL_LANE1_Register

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;
Record fields
SHIFT

The least-significant bit allowed to pass by the mask (inclusive)

MASK_LSB

The most-significant bit allowed to pass by the mask (inclusive)\n Setting MSB < LSB may cause chip to turn inside-out

MASK_MSB

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.

SIGNED

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)

CROSS_INPUT

If 1, feed the opposite lane's result into this lane's accumulator on POP.

CROSS_RESULT

If 1, mask + shift is bypassed for LANE1 result. This does not affect FULL result.

ADD_RAW

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.

FORCE_MSB

unspecified

Reserved_21_31

INTERP0_CTRL_LANE1_SHIFT_Field

subtype INTERP0_CTRL_LANE1_SHIFT_Field is HAL.UInt5;

INTERP1_ACCUM0_ADD_INTERP1_ACCUM0_ADD_Field

subtype INTERP1_ACCUM0_ADD_INTERP1_ACCUM0_ADD_Field is HAL.UInt24;

INTERP1_ACCUM0_ADD_Register

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;
Record fields
INTERP1_ACCUM0_ADD

unspecified

Reserved_24_31

INTERP1_ACCUM1_ADD_INTERP1_ACCUM1_ADD_Field

subtype INTERP1_ACCUM1_ADD_INTERP1_ACCUM1_ADD_Field is HAL.UInt24;

INTERP1_ACCUM1_ADD_Register

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;
Record fields
INTERP1_ACCUM1_ADD

unspecified

Reserved_24_31

INTERP1_CTRL_LANE0_FORCE_MSB_Field

subtype INTERP1_CTRL_LANE0_FORCE_MSB_Field is HAL.UInt2;

INTERP1_CTRL_LANE0_MASK_LSB_Field

subtype INTERP1_CTRL_LANE0_MASK_LSB_Field is HAL.UInt5;

INTERP1_CTRL_LANE0_MASK_MSB_Field

subtype INTERP1_CTRL_LANE0_MASK_MSB_Field is HAL.UInt5;

INTERP1_CTRL_LANE0_OVERF_Field

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;
Record fields
As_Array
Val
Arr

INTERP1_CTRL_LANE0_OVERF_Field_Array

type INTERP1_CTRL_LANE0_OVERF_Field_Array is array (0 .. 2) of Boolean
  with Component_Size => 1, Size => 3;

INTERP1_CTRL_LANE0_Register

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;
Record fields
SHIFT

The least-significant bit allowed to pass by the mask (inclusive)

MASK_LSB

The most-significant bit allowed to pass by the mask (inclusive)\n Setting MSB < LSB may cause chip to turn inside-out

MASK_MSB

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.

SIGNED

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)

CROSS_INPUT

If 1, feed the opposite lane's result into this lane's accumulator on POP.

CROSS_RESULT

If 1, mask + shift is bypassed for LANE0 result. This does not affect FULL result.

ADD_RAW

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.

FORCE_MSB

unspecified

Reserved_21_21

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

CLAMP

Read-only. Indicates if any masked-off MSBs in ACCUM0 are set.

OVERF

unspecified

Reserved_26_31

INTERP1_CTRL_LANE0_SHIFT_Field

subtype INTERP1_CTRL_LANE0_SHIFT_Field is HAL.UInt5;

INTERP1_CTRL_LANE1_FORCE_MSB_Field

subtype INTERP1_CTRL_LANE1_FORCE_MSB_Field is HAL.UInt2;

INTERP1_CTRL_LANE1_MASK_LSB_Field

subtype INTERP1_CTRL_LANE1_MASK_LSB_Field is HAL.UInt5;

INTERP1_CTRL_LANE1_MASK_MSB_Field

subtype INTERP1_CTRL_LANE1_MASK_MSB_Field is HAL.UInt5;

INTERP1_CTRL_LANE1_Register

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;
Record fields
SHIFT

The least-significant bit allowed to pass by the mask (inclusive)

MASK_LSB

The most-significant bit allowed to pass by the mask (inclusive)\n Setting MSB < LSB may cause chip to turn inside-out

MASK_MSB

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.

SIGNED

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)

CROSS_INPUT

If 1, feed the opposite lane's result into this lane's accumulator on POP.

CROSS_RESULT

If 1, mask + shift is bypassed for LANE1 result. This does not affect FULL result.

ADD_RAW

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.

FORCE_MSB

unspecified

Reserved_21_31

INTERP1_CTRL_LANE1_SHIFT_Field

subtype INTERP1_CTRL_LANE1_SHIFT_Field is HAL.UInt5;

SIO_Periph

SIO_Periph : aliased SIO_Peripheral
  with Import, Address => SIO_Base;

SIO_Peripheral

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;
Record fields
CPUID

Input value for GPIO pins

GPIO_IN

Input value for QSPI pins

GPIO_HI_IN

GPIO output value

GPIO_OUT

GPIO output value set

GPIO_OUT_SET

GPIO output value clear

GPIO_OUT_CLR

GPIO output value XOR

GPIO_OUT_XOR

GPIO output enable

GPIO_OE

GPIO output enable set

GPIO_OE_SET

GPIO output enable clear

GPIO_OE_CLR

GPIO output enable XOR

GPIO_OE_XOR

QSPI output value

GPIO_HI_OUT

QSPI output value set

GPIO_HI_OUT_SET

QSPI output value clear

GPIO_HI_OUT_CLR

QSPI output value XOR

GPIO_HI_OUT_XOR

QSPI output enable

GPIO_HI_OE

QSPI output enable set

GPIO_HI_OE_SET

QSPI output enable clear

GPIO_HI_OE_CLR

QSPI output enable XOR

GPIO_HI_OE_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.

FIFO_ST

Write access to this core's TX FIFO

FIFO_WR

Read access to this core's RX FIFO

FIFO_RD

Spinlock state\n A bitmap containing the state of all 32 spinlocks (1=locked).\n Mainly intended for debugging.

SPINLOCK_ST

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.

DIV_UDIVIDEND

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.

DIV_UDIVISOR

Divider signed dividend\n The same as UDIVIDEND, but starts a signed calculation, rather than unsigned.

DIV_SDIVIDEND

Divider signed divisor\n The same as UDIVISOR, but starts a signed calculation, rather than unsigned.

DIV_SDIVISOR

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.

DIV_QUOTIENT

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.

DIV_REMAINDER

Control and status register for divider.

DIV_CSR

Read/write access to accumulator 0

INTERP0_ACCUM0

Read/write access to accumulator 1

INTERP0_ACCUM1

Read/write access to BASE0 register.

INTERP0_BASE0

Read/write access to BASE1 register.

INTERP0_BASE1

Read/write access to BASE2 register.

INTERP0_BASE2

Read LANE0 result, and simultaneously write lane results to both accumulators (POP).

INTERP0_POP_LANE0

Read LANE1 result, and simultaneously write lane results to both accumulators (POP).

INTERP0_POP_LANE1

Read FULL result, and simultaneously write lane results to both accumulators (POP).

INTERP0_POP_FULL

Read LANE0 result, without altering any internal state (PEEK).

INTERP0_PEEK_LANE0

Read LANE1 result, without altering any internal state (PEEK).

INTERP0_PEEK_LANE1

Read FULL result, without altering any internal state (PEEK).

INTERP0_PEEK_FULL

Control register for lane 0

INTERP0_CTRL_LANE0

Control register for lane 1

INTERP0_CTRL_LANE1

Values written here are atomically added to ACCUM0\n Reading yields lane 0's raw shift and mask value (BASE0 not added).

INTERP0_ACCUM0_ADD

Values written here are atomically added to ACCUM1\n Reading yields lane 1's raw shift and mask value (BASE1 not added).

INTERP0_ACCUM1_ADD

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.

INTERP0_BASE_1AND0

Read/write access to accumulator 0

INTERP1_ACCUM0

Read/write access to accumulator 1

INTERP1_ACCUM1

Read/write access to BASE0 register.

INTERP1_BASE0

Read/write access to BASE1 register.

INTERP1_BASE1

Read/write access to BASE2 register.

INTERP1_BASE2

Read LANE0 result, and simultaneously write lane results to both accumulators (POP).

INTERP1_POP_LANE0

Read LANE1 result, and simultaneously write lane results to both accumulators (POP).

INTERP1_POP_LANE1

Read FULL result, and simultaneously write lane results to both accumulators (POP).

INTERP1_POP_FULL

Read LANE0 result, without altering any internal state (PEEK).

INTERP1_PEEK_LANE0

Read LANE1 result, without altering any internal state (PEEK).

INTERP1_PEEK_LANE1

Read FULL result, without altering any internal state (PEEK).

INTERP1_PEEK_FULL

Control register for lane 0

INTERP1_CTRL_LANE0

Control register for lane 1

INTERP1_CTRL_LANE1

Values written here are atomically added to ACCUM0\n Reading yields lane 0's raw shift and mask value (BASE0 not added).

INTERP1_ACCUM0_ADD

Values written here are atomically added to ACCUM1\n Reading yields lane 1's raw shift and mask value (BASE1 not added).

INTERP1_ACCUM1_ADD

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.

INTERP1_BASE_1AND0

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.

SPINLOCK0

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.

SPINLOCK1

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.

SPINLOCK2

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.

SPINLOCK3

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.

SPINLOCK4

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.

SPINLOCK5

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.

SPINLOCK6

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.

SPINLOCK7

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.

SPINLOCK8

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.

SPINLOCK9

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.

SPINLOCK10

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.

SPINLOCK11

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.

SPINLOCK12

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.

SPINLOCK13

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.

SPINLOCK14

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.

SPINLOCK15

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.

SPINLOCK16

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.

SPINLOCK17

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.

SPINLOCK18

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.

SPINLOCK19

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.

SPINLOCK20

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.

SPINLOCK21

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.

SPINLOCK22

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.

SPINLOCK23

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.

SPINLOCK24

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.

SPINLOCK25

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.

SPINLOCK26

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.

SPINLOCK27

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.

SPINLOCK28

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.

SPINLOCK29

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.

SPINLOCK30

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.

SPINLOCK31