RP2040_SVD.DMA

Entities

Simple Types

Record Types

Subtypes

Variables

Description

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

CH0_CTRL_TRIG_CHAIN_TO_Field

subtype CH0_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH0_CTRL_TRIG_DATA_SIZE_Field

type CH0_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH0_CTRL_TRIG_Register

type CH0_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH0_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH0_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH0_CTRL_TRIG_CHAIN_TO_Field := 16#0#;
   TREQ_SEL       : CH0_CTRL_TRIG_TREQ_SEL_Field :=
                     CH0_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (0).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH0_CTRL_TRIG_RING_SIZE_Field

type CH0_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH0_CTRL_TRIG_TREQ_SEL_Field

type CH0_CTRL_TRIG_TREQ_SEL_Field is
   CH0_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH0_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH0_DBG_CTDREQ_CH0_DBG_CTDREQ_Field

subtype CH0_DBG_CTDREQ_CH0_DBG_CTDREQ_Field is HAL.UInt6;

CH0_DBG_CTDREQ_Register

type CH0_DBG_CTDREQ_Register is record
   CH0_DBG_CTDREQ : CH0_DBG_CTDREQ_CH0_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31  : HAL.UInt26 := 16#0#;
end record;
Record fields
CH0_DBG_CTDREQ

unspecified

Reserved_6_31

CH10_CTRL_TRIG_CHAIN_TO_Field

subtype CH10_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH10_CTRL_TRIG_DATA_SIZE_Field

type CH10_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH10_CTRL_TRIG_Register

type CH10_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH10_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH10_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH10_CTRL_TRIG_CHAIN_TO_Field := 16#A#;
   TREQ_SEL       : CH10_CTRL_TRIG_TREQ_SEL_Field :=
                     CH10_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (10).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH10_CTRL_TRIG_RING_SIZE_Field

type CH10_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH10_CTRL_TRIG_TREQ_SEL_Field

type CH10_CTRL_TRIG_TREQ_SEL_Field is
   CH10_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH10_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH10_DBG_CTDREQ_CH10_DBG_CTDREQ_Field

subtype CH10_DBG_CTDREQ_CH10_DBG_CTDREQ_Field is HAL.UInt6;

CH10_DBG_CTDREQ_Register

type CH10_DBG_CTDREQ_Register is record
   CH10_DBG_CTDREQ : CH10_DBG_CTDREQ_CH10_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31   : HAL.UInt26 := 16#0#;
end record;
Record fields
CH10_DBG_CTDREQ

unspecified

Reserved_6_31

CH11_CTRL_TRIG_CHAIN_TO_Field

subtype CH11_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH11_CTRL_TRIG_DATA_SIZE_Field

type CH11_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH11_CTRL_TRIG_Register

type CH11_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH11_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH11_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH11_CTRL_TRIG_CHAIN_TO_Field := 16#B#;
   TREQ_SEL       : CH11_CTRL_TRIG_TREQ_SEL_Field :=
                     CH11_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (11).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH11_CTRL_TRIG_RING_SIZE_Field

type CH11_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH11_CTRL_TRIG_TREQ_SEL_Field

type CH11_CTRL_TRIG_TREQ_SEL_Field is
   CH11_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH11_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH11_DBG_CTDREQ_CH11_DBG_CTDREQ_Field

subtype CH11_DBG_CTDREQ_CH11_DBG_CTDREQ_Field is HAL.UInt6;

CH11_DBG_CTDREQ_Register

type CH11_DBG_CTDREQ_Register is record
   CH11_DBG_CTDREQ : CH11_DBG_CTDREQ_CH11_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31   : HAL.UInt26 := 16#0#;
end record;
Record fields
CH11_DBG_CTDREQ

unspecified

Reserved_6_31

CH1_CTRL_TRIG_CHAIN_TO_Field

subtype CH1_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH1_CTRL_TRIG_DATA_SIZE_Field

type CH1_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH1_CTRL_TRIG_Register

type CH1_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH1_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH1_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH1_CTRL_TRIG_CHAIN_TO_Field := 16#1#;
   TREQ_SEL       : CH1_CTRL_TRIG_TREQ_SEL_Field :=
                     CH1_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (1).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH1_CTRL_TRIG_RING_SIZE_Field

type CH1_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH1_CTRL_TRIG_TREQ_SEL_Field

type CH1_CTRL_TRIG_TREQ_SEL_Field is
   CH1_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH1_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH1_DBG_CTDREQ_CH1_DBG_CTDREQ_Field

subtype CH1_DBG_CTDREQ_CH1_DBG_CTDREQ_Field is HAL.UInt6;

CH1_DBG_CTDREQ_Register

type CH1_DBG_CTDREQ_Register is record
   CH1_DBG_CTDREQ : CH1_DBG_CTDREQ_CH1_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31  : HAL.UInt26 := 16#0#;
end record;
Record fields
CH1_DBG_CTDREQ

unspecified

Reserved_6_31

CH2_CTRL_TRIG_CHAIN_TO_Field

subtype CH2_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH2_CTRL_TRIG_DATA_SIZE_Field

type CH2_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH2_CTRL_TRIG_Register

type CH2_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH2_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH2_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH2_CTRL_TRIG_CHAIN_TO_Field := 16#2#;
   TREQ_SEL       : CH2_CTRL_TRIG_TREQ_SEL_Field :=
                     CH2_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (2).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH2_CTRL_TRIG_RING_SIZE_Field

type CH2_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH2_CTRL_TRIG_TREQ_SEL_Field

type CH2_CTRL_TRIG_TREQ_SEL_Field is
   CH2_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH2_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH2_DBG_CTDREQ_CH2_DBG_CTDREQ_Field

subtype CH2_DBG_CTDREQ_CH2_DBG_CTDREQ_Field is HAL.UInt6;

CH2_DBG_CTDREQ_Register

type CH2_DBG_CTDREQ_Register is record
   CH2_DBG_CTDREQ : CH2_DBG_CTDREQ_CH2_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31  : HAL.UInt26 := 16#0#;
end record;
Record fields
CH2_DBG_CTDREQ

unspecified

Reserved_6_31

CH3_CTRL_TRIG_CHAIN_TO_Field

subtype CH3_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH3_CTRL_TRIG_DATA_SIZE_Field

type CH3_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH3_CTRL_TRIG_Register

type CH3_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH3_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH3_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH3_CTRL_TRIG_CHAIN_TO_Field := 16#3#;
   TREQ_SEL       : CH3_CTRL_TRIG_TREQ_SEL_Field :=
                     CH3_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (3).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH3_CTRL_TRIG_RING_SIZE_Field

type CH3_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH3_CTRL_TRIG_TREQ_SEL_Field

type CH3_CTRL_TRIG_TREQ_SEL_Field is
   CH3_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH3_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH3_DBG_CTDREQ_CH3_DBG_CTDREQ_Field

subtype CH3_DBG_CTDREQ_CH3_DBG_CTDREQ_Field is HAL.UInt6;

CH3_DBG_CTDREQ_Register

type CH3_DBG_CTDREQ_Register is record
   CH3_DBG_CTDREQ : CH3_DBG_CTDREQ_CH3_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31  : HAL.UInt26 := 16#0#;
end record;
Record fields
CH3_DBG_CTDREQ

unspecified

Reserved_6_31

CH4_CTRL_TRIG_CHAIN_TO_Field

subtype CH4_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH4_CTRL_TRIG_DATA_SIZE_Field

type CH4_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH4_CTRL_TRIG_Register

type CH4_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH4_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH4_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH4_CTRL_TRIG_CHAIN_TO_Field := 16#4#;
   TREQ_SEL       : CH4_CTRL_TRIG_TREQ_SEL_Field :=
                     CH4_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (4).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH4_CTRL_TRIG_RING_SIZE_Field

type CH4_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH4_CTRL_TRIG_TREQ_SEL_Field

type CH4_CTRL_TRIG_TREQ_SEL_Field is
   CH4_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH4_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH4_DBG_CTDREQ_CH4_DBG_CTDREQ_Field

subtype CH4_DBG_CTDREQ_CH4_DBG_CTDREQ_Field is HAL.UInt6;

CH4_DBG_CTDREQ_Register

type CH4_DBG_CTDREQ_Register is record
   CH4_DBG_CTDREQ : CH4_DBG_CTDREQ_CH4_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31  : HAL.UInt26 := 16#0#;
end record;
Record fields
CH4_DBG_CTDREQ

unspecified

Reserved_6_31

CH5_CTRL_TRIG_CHAIN_TO_Field

subtype CH5_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH5_CTRL_TRIG_DATA_SIZE_Field

type CH5_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH5_CTRL_TRIG_Register

type CH5_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH5_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH5_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH5_CTRL_TRIG_CHAIN_TO_Field := 16#5#;
   TREQ_SEL       : CH5_CTRL_TRIG_TREQ_SEL_Field :=
                     CH5_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (5).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH5_CTRL_TRIG_RING_SIZE_Field

type CH5_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH5_CTRL_TRIG_TREQ_SEL_Field

type CH5_CTRL_TRIG_TREQ_SEL_Field is
   CH5_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH5_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH5_DBG_CTDREQ_CH5_DBG_CTDREQ_Field

subtype CH5_DBG_CTDREQ_CH5_DBG_CTDREQ_Field is HAL.UInt6;

CH5_DBG_CTDREQ_Register

type CH5_DBG_CTDREQ_Register is record
   CH5_DBG_CTDREQ : CH5_DBG_CTDREQ_CH5_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31  : HAL.UInt26 := 16#0#;
end record;
Record fields
CH5_DBG_CTDREQ

unspecified

Reserved_6_31

CH6_CTRL_TRIG_CHAIN_TO_Field

subtype CH6_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH6_CTRL_TRIG_DATA_SIZE_Field

type CH6_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH6_CTRL_TRIG_Register

type CH6_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH6_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH6_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH6_CTRL_TRIG_CHAIN_TO_Field := 16#6#;
   TREQ_SEL       : CH6_CTRL_TRIG_TREQ_SEL_Field :=
                     CH6_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (6).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH6_CTRL_TRIG_RING_SIZE_Field

type CH6_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH6_CTRL_TRIG_TREQ_SEL_Field

type CH6_CTRL_TRIG_TREQ_SEL_Field is
   CH6_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH6_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH6_DBG_CTDREQ_CH6_DBG_CTDREQ_Field

subtype CH6_DBG_CTDREQ_CH6_DBG_CTDREQ_Field is HAL.UInt6;

CH6_DBG_CTDREQ_Register

type CH6_DBG_CTDREQ_Register is record
   CH6_DBG_CTDREQ : CH6_DBG_CTDREQ_CH6_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31  : HAL.UInt26 := 16#0#;
end record;
Record fields
CH6_DBG_CTDREQ

unspecified

Reserved_6_31

CH7_CTRL_TRIG_CHAIN_TO_Field

subtype CH7_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH7_CTRL_TRIG_DATA_SIZE_Field

type CH7_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH7_CTRL_TRIG_Register

type CH7_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH7_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH7_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH7_CTRL_TRIG_CHAIN_TO_Field := 16#7#;
   TREQ_SEL       : CH7_CTRL_TRIG_TREQ_SEL_Field :=
                     CH7_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (7).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH7_CTRL_TRIG_RING_SIZE_Field

type CH7_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH7_CTRL_TRIG_TREQ_SEL_Field

type CH7_CTRL_TRIG_TREQ_SEL_Field is
   CH7_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH7_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH7_DBG_CTDREQ_CH7_DBG_CTDREQ_Field

subtype CH7_DBG_CTDREQ_CH7_DBG_CTDREQ_Field is HAL.UInt6;

CH7_DBG_CTDREQ_Register

type CH7_DBG_CTDREQ_Register is record
   CH7_DBG_CTDREQ : CH7_DBG_CTDREQ_CH7_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31  : HAL.UInt26 := 16#0#;
end record;
Record fields
CH7_DBG_CTDREQ

unspecified

Reserved_6_31

CH8_CTRL_TRIG_CHAIN_TO_Field

subtype CH8_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH8_CTRL_TRIG_DATA_SIZE_Field

type CH8_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH8_CTRL_TRIG_Register

type CH8_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH8_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH8_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH8_CTRL_TRIG_CHAIN_TO_Field := 16#8#;
   TREQ_SEL       : CH8_CTRL_TRIG_TREQ_SEL_Field :=
                     CH8_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (8).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH8_CTRL_TRIG_RING_SIZE_Field

type CH8_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH8_CTRL_TRIG_TREQ_SEL_Field

type CH8_CTRL_TRIG_TREQ_SEL_Field is
   CH8_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH8_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH8_DBG_CTDREQ_CH8_DBG_CTDREQ_Field

subtype CH8_DBG_CTDREQ_CH8_DBG_CTDREQ_Field is HAL.UInt6;

CH8_DBG_CTDREQ_Register

type CH8_DBG_CTDREQ_Register is record
   CH8_DBG_CTDREQ : CH8_DBG_CTDREQ_CH8_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31  : HAL.UInt26 := 16#0#;
end record;
Record fields
CH8_DBG_CTDREQ

unspecified

Reserved_6_31

CH9_CTRL_TRIG_CHAIN_TO_Field

subtype CH9_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;

CH9_CTRL_TRIG_DATA_SIZE_Field

type CH9_CTRL_TRIG_DATA_SIZE_Field is
  (SIZE_BYTE,
   SIZE_HALFWORD,
   SIZE_WORD)
  with Size => 2;
Enumeration Literal
SIZE_BYTE
SIZE_HALFWORD
SIZE_WORD

CH9_CTRL_TRIG_Register

type CH9_CTRL_TRIG_Register is record
   EN             : Boolean := False;
   HIGH_PRIORITY  : Boolean := False;
   DATA_SIZE      : CH9_CTRL_TRIG_DATA_SIZE_Field :=
                     RP2040_SVD.DMA.SIZE_BYTE;
   INCR_READ      : Boolean := False;
   INCR_WRITE     : Boolean := False;
   RING_SIZE      : CH9_CTRL_TRIG_RING_SIZE_Field :=
                     RP2040_SVD.DMA.RING_NONE;
   RING_SEL       : Boolean := False;
   CHAIN_TO       : CH9_CTRL_TRIG_CHAIN_TO_Field := 16#9#;
   TREQ_SEL       : CH9_CTRL_TRIG_TREQ_SEL_Field :=
                     CH9_CTRL_TRIG_TREQ_SEL_Field_Reset;
   IRQ_QUIET      : Boolean := False;
   BSWAP          : Boolean := False;
   SNIFF_EN       : Boolean := False;
   BUSY           : Boolean := False;
   Reserved_25_28 : HAL.UInt4 := 16#0#;
   WRITE_ERROR    : Boolean := False;
   READ_ERROR     : Boolean := False;
   AHB_ERROR      : Boolean := False;
end record;
Record fields
EN

HIGH_PRIORITY gives a channel preferential treatment in issue scheduling: in each scheduling round, all high priority channels are considered first, and then only a single low priority channel, before returning to the high priority channels.\n\n This only affects the order in which the DMA schedules channels. The DMA's bus priority is not changed. If the DMA is not saturated then a low priority channel will see no loss of throughput.

HIGH_PRIORITY

Set the size of each bus transfer (byte/halfword/word). READ_ADDR and WRITE_ADDR advance by this amount (1/2/4 bytes) with each transfer.

DATA_SIZE

If 1, the read address increments with each transfer. If 0, each read is directed to the same, initial address.\n\n Generally this should be disabled for peripheral-to-memory transfers.

INCR_READ

If 1, the write address increments with each transfer. If 0, each write is directed to the same, initial address.\n\n Generally this should be disabled for memory-to-peripheral transfers.

INCR_WRITE

Size of address wrap region. If 0, don't wrap. For values n > 0, only the lower n bits of the address will change. This wraps the address on a (1 << n) byte boundary, facilitating access to naturally-aligned ring buffers.\n\n Ring sizes between 2 and 32768 bytes are possible. This can apply to either read or write addresses, based on value of RING_SEL.

RING_SIZE

Select whether RING_SIZE applies to read or write addresses.\n If 0, read addresses are wrapped on a (1 << RING_SIZE) boundary. If 1, write addresses are wrapped.

RING_SEL

When this channel completes, it will trigger the channel indicated by CHAIN_TO. Disable by setting CHAIN_TO = (this channel).\n Reset value is equal to channel number (9).

CHAIN_TO

Select a Transfer Request signal.\n The channel uses the transfer request signal to pace its data transfer rate. Sources for TREQ signals are internal (TIMERS) or external (DREQ, a Data Request from the system).\n 0x0 to 0x3a -> select DREQ n as TREQ

TREQ_SEL

In QUIET mode, the channel does not generate IRQs at the end of every transfer block. Instead, an IRQ is raised when NULL is written to a trigger register, indicating the end of a control block chain.\n\n This reduces the number of interrupts to be serviced by the CPU when transferring a DMA chain of many small control blocks.

IRQ_QUIET

Apply byte-swap transformation to DMA data.\n For byte data, this has no effect. For halfword data, the two bytes of each halfword are swapped. For word data, the four bytes of each word are swapped to reverse order.

BSWAP

If 1, this channel's data transfers are visible to the sniff hardware, and each transfer will advance the state of the checksum. This only applies if the sniff hardware is enabled, and has this channel selected.\n\n This allows checksum to be enabled or disabled on a per-control- block basis.

SNIFF_EN

Read-only. This flag goes high when the channel starts a new transfer sequence, and low when the last transfer of that sequence completes. Clearing EN while BUSY is high pauses the channel, and BUSY will stay high while paused.\n\n To terminate a sequence early (and clear the BUSY flag), see CHAN_ABORT.

BUSY

unspecified

Reserved_25_28

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a write bus error. Write one to clear.\n WRITE_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 5 transfers later)

WRITE_ERROR

Write data bit of one shall clear (set to zero) the corresponding bit in the field. If 1, the channel received a read bus error. Write one to clear.\n READ_ADDR shows the approximate address where the bus error was encountered (will not to be earlier, or more than 3 transfers later)

READ_ERROR

Read-only. Logical OR of the READ_ERROR and WRITE_ERROR flags. The channel halts when it encounters any bus error, and always raises its channel IRQ flag.

AHB_ERROR

CH9_CTRL_TRIG_RING_SIZE_Field

type CH9_CTRL_TRIG_RING_SIZE_Field is
  (RING_NONE)
  with Size => 4;
Enumeration Literal
RING_NONE

CH9_CTRL_TRIG_TREQ_SEL_Field

type CH9_CTRL_TRIG_TREQ_SEL_Field is
   CH9_CTRL_TRIG_TREQ_SEL_Field_Reset,
   TIMER0,
   TIMER1,
   TIMER2,
   TIMER3,
   PERMANENT)
  with Size => 6;
Enumeration Literal
CH9_CTRL_TRIG_TREQ_SEL_Field_Reset

Select Timer 0 as TREQ

TIMER0

Select Timer 1 as TREQ

TIMER1

Select Timer 2 as TREQ (Optional)

TIMER2

Select Timer 3 as TREQ (Optional)

TIMER3

Permanent request, for unpaced transfers.

PERMANENT

CH9_DBG_CTDREQ_CH9_DBG_CTDREQ_Field

subtype CH9_DBG_CTDREQ_CH9_DBG_CTDREQ_Field is HAL.UInt6;

CH9_DBG_CTDREQ_Register

type CH9_DBG_CTDREQ_Register is record
   CH9_DBG_CTDREQ : CH9_DBG_CTDREQ_CH9_DBG_CTDREQ_Field := 16#0#;
   Reserved_6_31  : HAL.UInt26 := 16#0#;
end record;
Record fields
CH9_DBG_CTDREQ

unspecified

Reserved_6_31

CHAN_ABORT_CHAN_ABORT_Field

subtype CHAN_ABORT_CHAN_ABORT_Field is HAL.UInt16;

CHAN_ABORT_Register

type CHAN_ABORT_Register is record
   CHAN_ABORT     : CHAN_ABORT_CHAN_ABORT_Field := 16#0#;
   Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
Record fields
CHAN_ABORT

unspecified

Reserved_16_31

DMA_Periph

DMA_Periph : aliased DMA_Peripheral
  with Import, Address => DMA_Base;

DMA_Peripheral

type DMA_Peripheral is record
   CH0_READ_ADDR             : aliased HAL.UInt32;
   CH0_WRITE_ADDR            : aliased HAL.UInt32;
   CH0_TRANS_COUNT           : aliased HAL.UInt32;
   CH0_CTRL_TRIG             : aliased CH0_CTRL_TRIG_Register;
   CH0_AL1_CTRL              : aliased HAL.UInt32;
   CH0_AL1_READ_ADDR         : aliased HAL.UInt32;
   CH0_AL1_WRITE_ADDR        : aliased HAL.UInt32;
   CH0_AL1_TRANS_COUNT_TRIG  : aliased HAL.UInt32;
   CH0_AL2_CTRL              : aliased HAL.UInt32;
   CH0_AL2_TRANS_COUNT       : aliased HAL.UInt32;
   CH0_AL2_READ_ADDR         : aliased HAL.UInt32;
   CH0_AL2_WRITE_ADDR_TRIG   : aliased HAL.UInt32;
   CH0_AL3_CTRL              : aliased HAL.UInt32;
   CH0_AL3_WRITE_ADDR        : aliased HAL.UInt32;
   CH0_AL3_TRANS_COUNT       : aliased HAL.UInt32;
   CH0_AL3_READ_ADDR_TRIG    : aliased HAL.UInt32;
   CH1_READ_ADDR             : aliased HAL.UInt32;
   CH1_WRITE_ADDR            : aliased HAL.UInt32;
   CH1_TRANS_COUNT           : aliased HAL.UInt32;
   CH1_CTRL_TRIG             : aliased CH1_CTRL_TRIG_Register;
   CH1_AL1_CTRL              : aliased HAL.UInt32;
   CH1_AL1_READ_ADDR         : aliased HAL.UInt32;
   CH1_AL1_WRITE_ADDR        : aliased HAL.UInt32;
   CH1_AL1_TRANS_COUNT_TRIG  : aliased HAL.UInt32;
   CH1_AL2_CTRL              : aliased HAL.UInt32;
   CH1_AL2_TRANS_COUNT       : aliased HAL.UInt32;
   CH1_AL2_READ_ADDR         : aliased HAL.UInt32;
   CH1_AL2_WRITE_ADDR_TRIG   : aliased HAL.UInt32;
   CH1_AL3_CTRL              : aliased HAL.UInt32;
   CH1_AL3_WRITE_ADDR        : aliased HAL.UInt32;
   CH1_AL3_TRANS_COUNT       : aliased HAL.UInt32;
   CH1_AL3_READ_ADDR_TRIG    : aliased HAL.UInt32;
   CH2_READ_ADDR             : aliased HAL.UInt32;
   CH2_WRITE_ADDR            : aliased HAL.UInt32;
   CH2_TRANS_COUNT           : aliased HAL.UInt32;
   CH2_CTRL_TRIG             : aliased CH2_CTRL_TRIG_Register;
   CH2_AL1_CTRL              : aliased HAL.UInt32;
   CH2_AL1_READ_ADDR         : aliased HAL.UInt32;
   CH2_AL1_WRITE_ADDR        : aliased HAL.UInt32;
   CH2_AL1_TRANS_COUNT_TRIG  : aliased HAL.UInt32;
   CH2_AL2_CTRL              : aliased HAL.UInt32;
   CH2_AL2_TRANS_COUNT       : aliased HAL.UInt32;
   CH2_AL2_READ_ADDR         : aliased HAL.UInt32;
   CH2_AL2_WRITE_ADDR_TRIG   : aliased HAL.UInt32;
   CH2_AL3_CTRL              : aliased HAL.UInt32;
   CH2_AL3_WRITE_ADDR        : aliased HAL.UInt32;
   CH2_AL3_TRANS_COUNT       : aliased HAL.UInt32;
   CH2_AL3_READ_ADDR_TRIG    : aliased HAL.UInt32;
   CH3_READ_ADDR             : aliased HAL.UInt32;
   CH3_WRITE_ADDR            : aliased HAL.UInt32;
   CH3_TRANS_COUNT           : aliased HAL.UInt32;
   CH3_CTRL_TRIG             : aliased CH3_CTRL_TRIG_Register;
   CH3_AL1_CTRL              : aliased HAL.UInt32;
   CH3_AL1_READ_ADDR         : aliased HAL.UInt32;
   CH3_AL1_WRITE_ADDR        : aliased HAL.UInt32;
   CH3_AL1_TRANS_COUNT_TRIG  : aliased HAL.UInt32;
   CH3_AL2_CTRL              : aliased HAL.UInt32;
   CH3_AL2_TRANS_COUNT       : aliased HAL.UInt32;
   CH3_AL2_READ_ADDR         : aliased HAL.UInt32;
   CH3_AL2_WRITE_ADDR_TRIG   : aliased HAL.UInt32;
   CH3_AL3_CTRL              : aliased HAL.UInt32;
   CH3_AL3_WRITE_ADDR        : aliased HAL.UInt32;
   CH3_AL3_TRANS_COUNT       : aliased HAL.UInt32;
   CH3_AL3_READ_ADDR_TRIG    : aliased HAL.UInt32;
   CH4_READ_ADDR             : aliased HAL.UInt32;
   CH4_WRITE_ADDR            : aliased HAL.UInt32;
   CH4_TRANS_COUNT           : aliased HAL.UInt32;
   CH4_CTRL_TRIG             : aliased CH4_CTRL_TRIG_Register;
   CH4_AL1_CTRL              : aliased HAL.UInt32;
   CH4_AL1_READ_ADDR         : aliased HAL.UInt32;
   CH4_AL1_WRITE_ADDR        : aliased HAL.UInt32;
   CH4_AL1_TRANS_COUNT_TRIG  : aliased HAL.UInt32;
   CH4_AL2_CTRL              : aliased HAL.UInt32;
   CH4_AL2_TRANS_COUNT       : aliased HAL.UInt32;
   CH4_AL2_READ_ADDR         : aliased HAL.UInt32;
   CH4_AL2_WRITE_ADDR_TRIG   : aliased HAL.UInt32;
   CH4_AL3_CTRL              : aliased HAL.UInt32;
   CH4_AL3_WRITE_ADDR        : aliased HAL.UInt32;
   CH4_AL3_TRANS_COUNT       : aliased HAL.UInt32;
   CH4_AL3_READ_ADDR_TRIG    : aliased HAL.UInt32;
   CH5_READ_ADDR             : aliased HAL.UInt32;
   CH5_WRITE_ADDR            : aliased HAL.UInt32;
   CH5_TRANS_COUNT           : aliased HAL.UInt32;
   CH5_CTRL_TRIG             : aliased CH5_CTRL_TRIG_Register;
   CH5_AL1_CTRL              : aliased HAL.UInt32;
   CH5_AL1_READ_ADDR         : aliased HAL.UInt32;
   CH5_AL1_WRITE_ADDR        : aliased HAL.UInt32;
   CH5_AL1_TRANS_COUNT_TRIG  : aliased HAL.UInt32;
   CH5_AL2_CTRL              : aliased HAL.UInt32;
   CH5_AL2_TRANS_COUNT       : aliased HAL.UInt32;
   CH5_AL2_READ_ADDR         : aliased HAL.UInt32;
   CH5_AL2_WRITE_ADDR_TRIG   : aliased HAL.UInt32;
   CH5_AL3_CTRL              : aliased HAL.UInt32;
   CH5_AL3_WRITE_ADDR        : aliased HAL.UInt32;
   CH5_AL3_TRANS_COUNT       : aliased HAL.UInt32;
   CH5_AL3_READ_ADDR_TRIG    : aliased HAL.UInt32;
   CH6_READ_ADDR             : aliased HAL.UInt32;
   CH6_WRITE_ADDR            : aliased HAL.UInt32;
   CH6_TRANS_COUNT           : aliased HAL.UInt32;
   CH6_CTRL_TRIG             : aliased CH6_CTRL_TRIG_Register;
   CH6_AL1_CTRL              : aliased HAL.UInt32;
   CH6_AL1_READ_ADDR         : aliased HAL.UInt32;
   CH6_AL1_WRITE_ADDR        : aliased HAL.UInt32;
   CH6_AL1_TRANS_COUNT_TRIG  : aliased HAL.UInt32;
   CH6_AL2_CTRL              : aliased HAL.UInt32;
   CH6_AL2_TRANS_COUNT       : aliased HAL.UInt32;
   CH6_AL2_READ_ADDR         : aliased HAL.UInt32;
   CH6_AL2_WRITE_ADDR_TRIG   : aliased HAL.UInt32;
   CH6_AL3_CTRL              : aliased HAL.UInt32;
   CH6_AL3_WRITE_ADDR        : aliased HAL.UInt32;
   CH6_AL3_TRANS_COUNT       : aliased HAL.UInt32;
   CH6_AL3_READ_ADDR_TRIG    : aliased HAL.UInt32;
   CH7_READ_ADDR             : aliased HAL.UInt32;
   CH7_WRITE_ADDR            : aliased HAL.UInt32;
   CH7_TRANS_COUNT           : aliased HAL.UInt32;
   CH7_CTRL_TRIG             : aliased CH7_CTRL_TRIG_Register;
   CH7_AL1_CTRL              : aliased HAL.UInt32;
   CH7_AL1_READ_ADDR         : aliased HAL.UInt32;
   CH7_AL1_WRITE_ADDR        : aliased HAL.UInt32;
   CH7_AL1_TRANS_COUNT_TRIG  : aliased HAL.UInt32;
   CH7_AL2_CTRL              : aliased HAL.UInt32;
   CH7_AL2_TRANS_COUNT       : aliased HAL.UInt32;
   CH7_AL2_READ_ADDR         : aliased HAL.UInt32;
   CH7_AL2_WRITE_ADDR_TRIG   : aliased HAL.UInt32;
   CH7_AL3_CTRL              : aliased HAL.UInt32;
   CH7_AL3_WRITE_ADDR        : aliased HAL.UInt32;
   CH7_AL3_TRANS_COUNT       : aliased HAL.UInt32;
   CH7_AL3_READ_ADDR_TRIG    : aliased HAL.UInt32;
   CH8_READ_ADDR             : aliased HAL.UInt32;
   CH8_WRITE_ADDR            : aliased HAL.UInt32;
   CH8_TRANS_COUNT           : aliased HAL.UInt32;
   CH8_CTRL_TRIG             : aliased CH8_CTRL_TRIG_Register;
   CH8_AL1_CTRL              : aliased HAL.UInt32;
   CH8_AL1_READ_ADDR         : aliased HAL.UInt32;
   CH8_AL1_WRITE_ADDR        : aliased HAL.UInt32;
   CH8_AL1_TRANS_COUNT_TRIG  : aliased HAL.UInt32;
   CH8_AL2_CTRL              : aliased HAL.UInt32;
   CH8_AL2_TRANS_COUNT       : aliased HAL.UInt32;
   CH8_AL2_READ_ADDR         : aliased HAL.UInt32;
   CH8_AL2_WRITE_ADDR_TRIG   : aliased HAL.UInt32;
   CH8_AL3_CTRL              : aliased HAL.UInt32;
   CH8_AL3_WRITE_ADDR        : aliased HAL.UInt32;
   CH8_AL3_TRANS_COUNT       : aliased HAL.UInt32;
   CH8_AL3_READ_ADDR_TRIG    : aliased HAL.UInt32;
   CH9_READ_ADDR             : aliased HAL.UInt32;
   CH9_WRITE_ADDR            : aliased HAL.UInt32;
   CH9_TRANS_COUNT           : aliased HAL.UInt32;
   CH9_CTRL_TRIG             : aliased CH9_CTRL_TRIG_Register;
   CH9_AL1_CTRL              : aliased HAL.UInt32;
   CH9_AL1_READ_ADDR         : aliased HAL.UInt32;
   CH9_AL1_WRITE_ADDR        : aliased HAL.UInt32;
   CH9_AL1_TRANS_COUNT_TRIG  : aliased HAL.UInt32;
   CH9_AL2_CTRL              : aliased HAL.UInt32;
   CH9_AL2_TRANS_COUNT       : aliased HAL.UInt32;
   CH9_AL2_READ_ADDR         : aliased HAL.UInt32;
   CH9_AL2_WRITE_ADDR_TRIG   : aliased HAL.UInt32;
   CH9_AL3_CTRL              : aliased HAL.UInt32;
   CH9_AL3_WRITE_ADDR        : aliased HAL.UInt32;
   CH9_AL3_TRANS_COUNT       : aliased HAL.UInt32;
   CH9_AL3_READ_ADDR_TRIG    : aliased HAL.UInt32;
   CH10_READ_ADDR            : aliased HAL.UInt32;
   CH10_WRITE_ADDR           : aliased HAL.UInt32;
   CH10_TRANS_COUNT          : aliased HAL.UInt32;
   CH10_CTRL_TRIG            : aliased CH10_CTRL_TRIG_Register;
   CH10_AL1_CTRL             : aliased HAL.UInt32;
   CH10_AL1_READ_ADDR        : aliased HAL.UInt32;
   CH10_AL1_WRITE_ADDR       : aliased HAL.UInt32;
   CH10_AL1_TRANS_COUNT_TRIG : aliased HAL.UInt32;
   CH10_AL2_CTRL             : aliased HAL.UInt32;
   CH10_AL2_TRANS_COUNT      : aliased HAL.UInt32;
   CH10_AL2_READ_ADDR        : aliased HAL.UInt32;
   CH10_AL2_WRITE_ADDR_TRIG  : aliased HAL.UInt32;
   CH10_AL3_CTRL             : aliased HAL.UInt32;
   CH10_AL3_WRITE_ADDR       : aliased HAL.UInt32;
   CH10_AL3_TRANS_COUNT      : aliased HAL.UInt32;
   CH10_AL3_READ_ADDR_TRIG   : aliased HAL.UInt32;
   CH11_READ_ADDR            : aliased HAL.UInt32;
   CH11_WRITE_ADDR           : aliased HAL.UInt32;
   CH11_TRANS_COUNT          : aliased HAL.UInt32;
   CH11_CTRL_TRIG            : aliased CH11_CTRL_TRIG_Register;
   CH11_AL1_CTRL             : aliased HAL.UInt32;
   CH11_AL1_READ_ADDR        : aliased HAL.UInt32;
   CH11_AL1_WRITE_ADDR       : aliased HAL.UInt32;
   CH11_AL1_TRANS_COUNT_TRIG : aliased HAL.UInt32;
   CH11_AL2_CTRL             : aliased HAL.UInt32;
   CH11_AL2_TRANS_COUNT      : aliased HAL.UInt32;
   CH11_AL2_READ_ADDR        : aliased HAL.UInt32;
   CH11_AL2_WRITE_ADDR_TRIG  : aliased HAL.UInt32;
   CH11_AL3_CTRL             : aliased HAL.UInt32;
   CH11_AL3_WRITE_ADDR       : aliased HAL.UInt32;
   CH11_AL3_TRANS_COUNT      : aliased HAL.UInt32;
   CH11_AL3_READ_ADDR_TRIG   : aliased HAL.UInt32;
   INTR                      : aliased INTR_Register;
   INTE0                     : aliased INTE0_Register;
   INTF0                     : aliased INTF0_Register;
   INTS0                     : aliased INTS0_Register;
   INTE1                     : aliased INTE1_Register;
   INTF1                     : aliased INTF1_Register;
   INTS1                     : aliased INTS1_Register;
   TIMER0                    : aliased TIMER_Register;
   TIMER1                    : aliased TIMER_Register;
   TIMER2                    : aliased TIMER_Register;
   TIMER3                    : aliased TIMER_Register;
   MULTI_CHAN_TRIGGER        : aliased MULTI_CHAN_TRIGGER_Register;
   SNIFF_CTRL                : aliased SNIFF_CTRL_Register;
   SNIFF_DATA                : aliased HAL.UInt32;
   FIFO_LEVELS               : aliased FIFO_LEVELS_Register;
   CHAN_ABORT                : aliased CHAN_ABORT_Register;
   N_CHANNELS                : aliased N_CHANNELS_Register;
   CH0_DBG_CTDREQ            : aliased CH0_DBG_CTDREQ_Register;
   CH0_DBG_TCR               : aliased HAL.UInt32;
   CH1_DBG_CTDREQ            : aliased CH1_DBG_CTDREQ_Register;
   CH1_DBG_TCR               : aliased HAL.UInt32;
   CH2_DBG_CTDREQ            : aliased CH2_DBG_CTDREQ_Register;
   CH2_DBG_TCR               : aliased HAL.UInt32;
   CH3_DBG_CTDREQ            : aliased CH3_DBG_CTDREQ_Register;
   CH3_DBG_TCR               : aliased HAL.UInt32;
   CH4_DBG_CTDREQ            : aliased CH4_DBG_CTDREQ_Register;
   CH4_DBG_TCR               : aliased HAL.UInt32;
   CH5_DBG_CTDREQ            : aliased CH5_DBG_CTDREQ_Register;
   CH5_DBG_TCR               : aliased HAL.UInt32;
   CH6_DBG_CTDREQ            : aliased CH6_DBG_CTDREQ_Register;
   CH6_DBG_TCR               : aliased HAL.UInt32;
   CH7_DBG_CTDREQ            : aliased CH7_DBG_CTDREQ_Register;
   CH7_DBG_TCR               : aliased HAL.UInt32;
   CH8_DBG_CTDREQ            : aliased CH8_DBG_CTDREQ_Register;
   CH8_DBG_TCR               : aliased HAL.UInt32;
   CH9_DBG_CTDREQ            : aliased CH9_DBG_CTDREQ_Register;
   CH9_DBG_TCR               : aliased HAL.UInt32;
   CH10_DBG_CTDREQ           : aliased CH10_DBG_CTDREQ_Register;
   CH10_DBG_TCR              : aliased HAL.UInt32;
   CH11_DBG_CTDREQ           : aliased CH11_DBG_CTDREQ_Register;
   CH11_DBG_TCR              : aliased HAL.UInt32;
end record;
Record fields
CH0_READ_ADDR

DMA Channel 0 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH0_WRITE_ADDR

DMA Channel 0 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH0_TRANS_COUNT

DMA Channel 0 Control and Status

CH0_CTRL_TRIG

Alias for channel 0 CTRL register

CH0_AL1_CTRL

Alias for channel 0 READ_ADDR register

CH0_AL1_READ_ADDR

Alias for channel 0 WRITE_ADDR register

CH0_AL1_WRITE_ADDR

Alias for channel 0 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH0_AL1_TRANS_COUNT_TRIG

Alias for channel 0 CTRL register

CH0_AL2_CTRL

Alias for channel 0 TRANS_COUNT register

CH0_AL2_TRANS_COUNT

Alias for channel 0 READ_ADDR register

CH0_AL2_READ_ADDR

Alias for channel 0 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH0_AL2_WRITE_ADDR_TRIG

Alias for channel 0 CTRL register

CH0_AL3_CTRL

Alias for channel 0 WRITE_ADDR register

CH0_AL3_WRITE_ADDR

Alias for channel 0 TRANS_COUNT register

CH0_AL3_TRANS_COUNT

Alias for channel 0 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH0_AL3_READ_ADDR_TRIG

DMA Channel 1 Read Address pointer\n This register updates automatically each time a read completes. The current value is the next address to be read by this channel.

CH1_READ_ADDR

DMA Channel 1 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH1_WRITE_ADDR

DMA Channel 1 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH1_TRANS_COUNT

DMA Channel 1 Control and Status

CH1_CTRL_TRIG

Alias for channel 1 CTRL register

CH1_AL1_CTRL

Alias for channel 1 READ_ADDR register

CH1_AL1_READ_ADDR

Alias for channel 1 WRITE_ADDR register

CH1_AL1_WRITE_ADDR

Alias for channel 1 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH1_AL1_TRANS_COUNT_TRIG

Alias for channel 1 CTRL register

CH1_AL2_CTRL

Alias for channel 1 TRANS_COUNT register

CH1_AL2_TRANS_COUNT

Alias for channel 1 READ_ADDR register

CH1_AL2_READ_ADDR

Alias for channel 1 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH1_AL2_WRITE_ADDR_TRIG

Alias for channel 1 CTRL register

CH1_AL3_CTRL

Alias for channel 1 WRITE_ADDR register

CH1_AL3_WRITE_ADDR

Alias for channel 1 TRANS_COUNT register

CH1_AL3_TRANS_COUNT

Alias for channel 1 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH1_AL3_READ_ADDR_TRIG

DMA Channel 2 Read Address pointer\n This register updates automatically each time a read completes. The current value is the next address to be read by this channel.

CH2_READ_ADDR

DMA Channel 2 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH2_WRITE_ADDR

DMA Channel 2 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH2_TRANS_COUNT

DMA Channel 2 Control and Status

CH2_CTRL_TRIG

Alias for channel 2 CTRL register

CH2_AL1_CTRL

Alias for channel 2 READ_ADDR register

CH2_AL1_READ_ADDR

Alias for channel 2 WRITE_ADDR register

CH2_AL1_WRITE_ADDR

Alias for channel 2 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH2_AL1_TRANS_COUNT_TRIG

Alias for channel 2 CTRL register

CH2_AL2_CTRL

Alias for channel 2 TRANS_COUNT register

CH2_AL2_TRANS_COUNT

Alias for channel 2 READ_ADDR register

CH2_AL2_READ_ADDR

Alias for channel 2 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH2_AL2_WRITE_ADDR_TRIG

Alias for channel 2 CTRL register

CH2_AL3_CTRL

Alias for channel 2 WRITE_ADDR register

CH2_AL3_WRITE_ADDR

Alias for channel 2 TRANS_COUNT register

CH2_AL3_TRANS_COUNT

Alias for channel 2 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH2_AL3_READ_ADDR_TRIG

DMA Channel 3 Read Address pointer\n This register updates automatically each time a read completes. The current value is the next address to be read by this channel.

CH3_READ_ADDR

DMA Channel 3 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH3_WRITE_ADDR

DMA Channel 3 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH3_TRANS_COUNT

DMA Channel 3 Control and Status

CH3_CTRL_TRIG

Alias for channel 3 CTRL register

CH3_AL1_CTRL

Alias for channel 3 READ_ADDR register

CH3_AL1_READ_ADDR

Alias for channel 3 WRITE_ADDR register

CH3_AL1_WRITE_ADDR

Alias for channel 3 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH3_AL1_TRANS_COUNT_TRIG

Alias for channel 3 CTRL register

CH3_AL2_CTRL

Alias for channel 3 TRANS_COUNT register

CH3_AL2_TRANS_COUNT

Alias for channel 3 READ_ADDR register

CH3_AL2_READ_ADDR

Alias for channel 3 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH3_AL2_WRITE_ADDR_TRIG

Alias for channel 3 CTRL register

CH3_AL3_CTRL

Alias for channel 3 WRITE_ADDR register

CH3_AL3_WRITE_ADDR

Alias for channel 3 TRANS_COUNT register

CH3_AL3_TRANS_COUNT

Alias for channel 3 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH3_AL3_READ_ADDR_TRIG

DMA Channel 4 Read Address pointer\n This register updates automatically each time a read completes. The current value is the next address to be read by this channel.

CH4_READ_ADDR

DMA Channel 4 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH4_WRITE_ADDR

DMA Channel 4 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH4_TRANS_COUNT

DMA Channel 4 Control and Status

CH4_CTRL_TRIG

Alias for channel 4 CTRL register

CH4_AL1_CTRL

Alias for channel 4 READ_ADDR register

CH4_AL1_READ_ADDR

Alias for channel 4 WRITE_ADDR register

CH4_AL1_WRITE_ADDR

Alias for channel 4 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH4_AL1_TRANS_COUNT_TRIG

Alias for channel 4 CTRL register

CH4_AL2_CTRL

Alias for channel 4 TRANS_COUNT register

CH4_AL2_TRANS_COUNT

Alias for channel 4 READ_ADDR register

CH4_AL2_READ_ADDR

Alias for channel 4 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH4_AL2_WRITE_ADDR_TRIG

Alias for channel 4 CTRL register

CH4_AL3_CTRL

Alias for channel 4 WRITE_ADDR register

CH4_AL3_WRITE_ADDR

Alias for channel 4 TRANS_COUNT register

CH4_AL3_TRANS_COUNT

Alias for channel 4 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH4_AL3_READ_ADDR_TRIG

DMA Channel 5 Read Address pointer\n This register updates automatically each time a read completes. The current value is the next address to be read by this channel.

CH5_READ_ADDR

DMA Channel 5 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH5_WRITE_ADDR

DMA Channel 5 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH5_TRANS_COUNT

DMA Channel 5 Control and Status

CH5_CTRL_TRIG

Alias for channel 5 CTRL register

CH5_AL1_CTRL

Alias for channel 5 READ_ADDR register

CH5_AL1_READ_ADDR

Alias for channel 5 WRITE_ADDR register

CH5_AL1_WRITE_ADDR

Alias for channel 5 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH5_AL1_TRANS_COUNT_TRIG

Alias for channel 5 CTRL register

CH5_AL2_CTRL

Alias for channel 5 TRANS_COUNT register

CH5_AL2_TRANS_COUNT

Alias for channel 5 READ_ADDR register

CH5_AL2_READ_ADDR

Alias for channel 5 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH5_AL2_WRITE_ADDR_TRIG

Alias for channel 5 CTRL register

CH5_AL3_CTRL

Alias for channel 5 WRITE_ADDR register

CH5_AL3_WRITE_ADDR

Alias for channel 5 TRANS_COUNT register

CH5_AL3_TRANS_COUNT

Alias for channel 5 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH5_AL3_READ_ADDR_TRIG

DMA Channel 6 Read Address pointer\n This register updates automatically each time a read completes. The current value is the next address to be read by this channel.

CH6_READ_ADDR

DMA Channel 6 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH6_WRITE_ADDR

DMA Channel 6 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH6_TRANS_COUNT

DMA Channel 6 Control and Status

CH6_CTRL_TRIG

Alias for channel 6 CTRL register

CH6_AL1_CTRL

Alias for channel 6 READ_ADDR register

CH6_AL1_READ_ADDR

Alias for channel 6 WRITE_ADDR register

CH6_AL1_WRITE_ADDR

Alias for channel 6 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH6_AL1_TRANS_COUNT_TRIG

Alias for channel 6 CTRL register

CH6_AL2_CTRL

Alias for channel 6 TRANS_COUNT register

CH6_AL2_TRANS_COUNT

Alias for channel 6 READ_ADDR register

CH6_AL2_READ_ADDR

Alias for channel 6 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH6_AL2_WRITE_ADDR_TRIG

Alias for channel 6 CTRL register

CH6_AL3_CTRL

Alias for channel 6 WRITE_ADDR register

CH6_AL3_WRITE_ADDR

Alias for channel 6 TRANS_COUNT register

CH6_AL3_TRANS_COUNT

Alias for channel 6 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH6_AL3_READ_ADDR_TRIG

DMA Channel 7 Read Address pointer\n This register updates automatically each time a read completes. The current value is the next address to be read by this channel.

CH7_READ_ADDR

DMA Channel 7 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH7_WRITE_ADDR

DMA Channel 7 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH7_TRANS_COUNT

DMA Channel 7 Control and Status

CH7_CTRL_TRIG

Alias for channel 7 CTRL register

CH7_AL1_CTRL

Alias for channel 7 READ_ADDR register

CH7_AL1_READ_ADDR

Alias for channel 7 WRITE_ADDR register

CH7_AL1_WRITE_ADDR

Alias for channel 7 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH7_AL1_TRANS_COUNT_TRIG

Alias for channel 7 CTRL register

CH7_AL2_CTRL

Alias for channel 7 TRANS_COUNT register

CH7_AL2_TRANS_COUNT

Alias for channel 7 READ_ADDR register

CH7_AL2_READ_ADDR

Alias for channel 7 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH7_AL2_WRITE_ADDR_TRIG

Alias for channel 7 CTRL register

CH7_AL3_CTRL

Alias for channel 7 WRITE_ADDR register

CH7_AL3_WRITE_ADDR

Alias for channel 7 TRANS_COUNT register

CH7_AL3_TRANS_COUNT

Alias for channel 7 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH7_AL3_READ_ADDR_TRIG

DMA Channel 8 Read Address pointer\n This register updates automatically each time a read completes. The current value is the next address to be read by this channel.

CH8_READ_ADDR

DMA Channel 8 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH8_WRITE_ADDR

DMA Channel 8 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH8_TRANS_COUNT

DMA Channel 8 Control and Status

CH8_CTRL_TRIG

Alias for channel 8 CTRL register

CH8_AL1_CTRL

Alias for channel 8 READ_ADDR register

CH8_AL1_READ_ADDR

Alias for channel 8 WRITE_ADDR register

CH8_AL1_WRITE_ADDR

Alias for channel 8 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH8_AL1_TRANS_COUNT_TRIG

Alias for channel 8 CTRL register

CH8_AL2_CTRL

Alias for channel 8 TRANS_COUNT register

CH8_AL2_TRANS_COUNT

Alias for channel 8 READ_ADDR register

CH8_AL2_READ_ADDR

Alias for channel 8 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH8_AL2_WRITE_ADDR_TRIG

Alias for channel 8 CTRL register

CH8_AL3_CTRL

Alias for channel 8 WRITE_ADDR register

CH8_AL3_WRITE_ADDR

Alias for channel 8 TRANS_COUNT register

CH8_AL3_TRANS_COUNT

Alias for channel 8 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH8_AL3_READ_ADDR_TRIG

DMA Channel 9 Read Address pointer\n This register updates automatically each time a read completes. The current value is the next address to be read by this channel.

CH9_READ_ADDR

DMA Channel 9 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH9_WRITE_ADDR

DMA Channel 9 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH9_TRANS_COUNT

DMA Channel 9 Control and Status

CH9_CTRL_TRIG

Alias for channel 9 CTRL register

CH9_AL1_CTRL

Alias for channel 9 READ_ADDR register

CH9_AL1_READ_ADDR

Alias for channel 9 WRITE_ADDR register

CH9_AL1_WRITE_ADDR

Alias for channel 9 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH9_AL1_TRANS_COUNT_TRIG

Alias for channel 9 CTRL register

CH9_AL2_CTRL

Alias for channel 9 TRANS_COUNT register

CH9_AL2_TRANS_COUNT

Alias for channel 9 READ_ADDR register

CH9_AL2_READ_ADDR

Alias for channel 9 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH9_AL2_WRITE_ADDR_TRIG

Alias for channel 9 CTRL register

CH9_AL3_CTRL

Alias for channel 9 WRITE_ADDR register

CH9_AL3_WRITE_ADDR

Alias for channel 9 TRANS_COUNT register

CH9_AL3_TRANS_COUNT

Alias for channel 9 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH9_AL3_READ_ADDR_TRIG

DMA Channel 10 Read Address pointer\n This register updates automatically each time a read completes. The current value is the next address to be read by this channel.

CH10_READ_ADDR

DMA Channel 10 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH10_WRITE_ADDR

DMA Channel 10 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH10_TRANS_COUNT

DMA Channel 10 Control and Status

CH10_CTRL_TRIG

Alias for channel 10 CTRL register

CH10_AL1_CTRL

Alias for channel 10 READ_ADDR register

CH10_AL1_READ_ADDR

Alias for channel 10 WRITE_ADDR register

CH10_AL1_WRITE_ADDR

Alias for channel 10 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH10_AL1_TRANS_COUNT_TRIG

Alias for channel 10 CTRL register

CH10_AL2_CTRL

Alias for channel 10 TRANS_COUNT register

CH10_AL2_TRANS_COUNT

Alias for channel 10 READ_ADDR register

CH10_AL2_READ_ADDR

Alias for channel 10 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH10_AL2_WRITE_ADDR_TRIG

Alias for channel 10 CTRL register

CH10_AL3_CTRL

Alias for channel 10 WRITE_ADDR register

CH10_AL3_WRITE_ADDR

Alias for channel 10 TRANS_COUNT register

CH10_AL3_TRANS_COUNT

Alias for channel 10 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH10_AL3_READ_ADDR_TRIG

DMA Channel 11 Read Address pointer\n This register updates automatically each time a read completes. The current value is the next address to be read by this channel.

CH11_READ_ADDR

DMA Channel 11 Write Address pointer\n This register updates automatically each time a write completes. The current value is the next address to be written by this channel.

CH11_WRITE_ADDR

DMA Channel 11 Transfer Count\n Program the number of bus transfers a channel will perform before halting. Note that, if transfers are larger than one byte in size, this is not equal to the number of bytes transferred (see CTRL_DATA_SIZE).\n\n When the channel is active, reading this register shows the number of transfers remaining, updating automatically each time a write transfer completes.\n\n Writing this register sets the RELOAD value for the transfer counter. Each time this channel is triggered, the RELOAD value is copied into the live transfer counter. The channel can be started multiple times, and will perform the same number of transfers each time, as programmed by most recent write.\n\n The RELOAD value can be observed at CHx_DBG_TCR. If TRANS_COUNT is used as a trigger, the written value is used immediately as the length of the new transfer sequence, as well as being written to RELOAD.

CH11_TRANS_COUNT

DMA Channel 11 Control and Status

CH11_CTRL_TRIG

Alias for channel 11 CTRL register

CH11_AL1_CTRL

Alias for channel 11 READ_ADDR register

CH11_AL1_READ_ADDR

Alias for channel 11 WRITE_ADDR register

CH11_AL1_WRITE_ADDR

Alias for channel 11 TRANS_COUNT register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH11_AL1_TRANS_COUNT_TRIG

Alias for channel 11 CTRL register

CH11_AL2_CTRL

Alias for channel 11 TRANS_COUNT register

CH11_AL2_TRANS_COUNT

Alias for channel 11 READ_ADDR register

CH11_AL2_READ_ADDR

Alias for channel 11 WRITE_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH11_AL2_WRITE_ADDR_TRIG

Alias for channel 11 CTRL register

CH11_AL3_CTRL

Alias for channel 11 WRITE_ADDR register

CH11_AL3_WRITE_ADDR

Alias for channel 11 TRANS_COUNT register

CH11_AL3_TRANS_COUNT

Alias for channel 11 READ_ADDR register\n This is a trigger register (0xc). Writing a nonzero value will\n reload the channel counter and start the channel.

CH11_AL3_READ_ADDR_TRIG

Interrupt Status (raw)

INTR

Interrupt Enables for IRQ 0

INTE0

Force Interrupts

INTF0

Interrupt Status for IRQ 0

INTS0

Interrupt Enables for IRQ 1

INTE1

Force Interrupts for IRQ 1

INTF1

Interrupt Status (masked) for IRQ 1

INTS1

Pacing (X/Y) Fractional Timer\n The pacing timer produces TREQ assertions at a rate set by ((X/Y) * sys_clk). This equation is evaluated every sys_clk cycles and therefore can only generate TREQs at a rate of 1 per sys_clk (i.e. permanent TREQ) or less.

TIMER0

Pacing (X/Y) Fractional Timer\n The pacing timer produces TREQ assertions at a rate set by ((X/Y) * sys_clk). This equation is evaluated every sys_clk cycles and therefore can only generate TREQs at a rate of 1 per sys_clk (i.e. permanent TREQ) or less.

TIMER1

Pacing (X/Y) Fractional Timer\n The pacing timer produces TREQ assertions at a rate set by ((X/Y) * sys_clk). This equation is evaluated every sys_clk cycles and therefore can only generate TREQs at a rate of 1 per sys_clk (i.e. permanent TREQ) or less.

TIMER2

Pacing (X/Y) Fractional Timer\n The pacing timer produces TREQ assertions at a rate set by ((X/Y) * sys_clk). This equation is evaluated every sys_clk cycles and therefore can only generate TREQs at a rate of 1 per sys_clk (i.e. permanent TREQ) or less.

TIMER3

Trigger one or more channels simultaneously

MULTI_CHAN_TRIGGER

Sniffer Control

SNIFF_CTRL

Data accumulator for sniff hardware\n Write an initial seed value here before starting a DMA transfer on the channel indicated by SNIFF_CTRL_DMACH. The hardware will update this register each time it observes a read from the indicated channel. Once the channel completes, the final result can be read from this register.

SNIFF_DATA

Debug RAF, WAF, TDF levels

FIFO_LEVELS

Abort an in-progress transfer sequence on one or more channels

CHAN_ABORT

The number of channels this DMA instance is equipped with. This DMA supports up to 16 hardware channels, but can be configured with as few as one, to minimise silicon area.

N_CHANNELS

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH0_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH0_DBG_TCR

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH1_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH1_DBG_TCR

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH2_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH2_DBG_TCR

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH3_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH3_DBG_TCR

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH4_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH4_DBG_TCR

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH5_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH5_DBG_TCR

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH6_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH6_DBG_TCR

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH7_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH7_DBG_TCR

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH8_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH8_DBG_TCR

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH9_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH9_DBG_TCR

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH10_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH10_DBG_TCR

Read: get channel DREQ counter (i.e. how many accesses the DMA expects it can perform on the peripheral without overflow/underflow. Write any value: clears the counter, and cause channel to re-initiate DREQ handshake.

CH11_DBG_CTDREQ

Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer

CH11_DBG_TCR

FIFO_LEVELS_RAF_LVL_Field

subtype FIFO_LEVELS_RAF_LVL_Field is HAL.UInt8;

FIFO_LEVELS_Register

type FIFO_LEVELS_Register is record
   TDF_LVL        : FIFO_LEVELS_TDF_LVL_Field;
   WAF_LVL        : FIFO_LEVELS_WAF_LVL_Field;
   RAF_LVL        : FIFO_LEVELS_RAF_LVL_Field;
   Reserved_24_31 : HAL.UInt8;
end record;
Record fields
TDF_LVL

Read-only. Current Write-Address-FIFO fill level

WAF_LVL

Read-only. Current Read-Address-FIFO fill level

RAF_LVL

unspecified

Reserved_24_31

FIFO_LEVELS_TDF_LVL_Field

subtype FIFO_LEVELS_TDF_LVL_Field is HAL.UInt8;

FIFO_LEVELS_WAF_LVL_Field

subtype FIFO_LEVELS_WAF_LVL_Field is HAL.UInt8;

INTE0_INTE0_Field

subtype INTE0_INTE0_Field is HAL.UInt16;

INTE0_Register

type INTE0_Register is record
   INTE0          : INTE0_INTE0_Field := 16#0#;
   Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
Record fields
INTE0

unspecified

Reserved_16_31

INTE1_INTE1_Field

subtype INTE1_INTE1_Field is HAL.UInt16;

INTE1_Register

type INTE1_Register is record
   INTE1          : INTE1_INTE1_Field := 16#0#;
   Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
Record fields
INTE1

unspecified

Reserved_16_31

INTF0_INTF0_Field

subtype INTF0_INTF0_Field is HAL.UInt16;

INTF0_Register

type INTF0_Register is record
   INTF0          : INTF0_INTF0_Field := 16#0#;
   Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
Record fields
INTF0

unspecified

Reserved_16_31

INTF1_INTF1_Field

subtype INTF1_INTF1_Field is HAL.UInt16;

INTF1_Register

type INTF1_Register is record
   INTF1          : INTF1_INTF1_Field := 16#0#;
   Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
Record fields
INTF1

unspecified

Reserved_16_31

INTR_INTR_Field

subtype INTR_INTR_Field is HAL.UInt16;

INTR_Register

type INTR_Register is record
   INTR           : INTR_INTR_Field;
   Reserved_16_31 : HAL.UInt16;
end record;
Record fields
INTR

unspecified

Reserved_16_31

INTS0_INTS0_Field

subtype INTS0_INTS0_Field is HAL.UInt16;

INTS0_Register

type INTS0_Register is record
   INTS0          : INTS0_INTS0_Field := 16#0#;
   Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
Record fields
INTS0

unspecified

Reserved_16_31

INTS1_INTS1_Field

subtype INTS1_INTS1_Field is HAL.UInt16;

INTS1_Register

type INTS1_Register is record
   INTS1          : INTS1_INTS1_Field := 16#0#;
   Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
Record fields
INTS1

unspecified

Reserved_16_31

MULTI_CHAN_TRIGGER_MULTI_CHAN_TRIGGER_Field

subtype MULTI_CHAN_TRIGGER_MULTI_CHAN_TRIGGER_Field is HAL.UInt16;

MULTI_CHAN_TRIGGER_Register

type MULTI_CHAN_TRIGGER_Register is record
   MULTI_CHAN_TRIGGER : MULTI_CHAN_TRIGGER_MULTI_CHAN_TRIGGER_Field :=
                         16#0#;
   Reserved_16_31     : HAL.UInt16 := 16#0#;
end record;
Record fields
MULTI_CHAN_TRIGGER

unspecified

Reserved_16_31

N_CHANNELS_N_CHANNELS_Field

subtype N_CHANNELS_N_CHANNELS_Field is HAL.UInt5;

N_CHANNELS_Register

type N_CHANNELS_Register is record
   N_CHANNELS    : N_CHANNELS_N_CHANNELS_Field;
   Reserved_5_31 : HAL.UInt27;
end record;
Record fields
N_CHANNELS

unspecified

Reserved_5_31

SNIFF_CTRL_CALC_Field

type SNIFF_CTRL_CALC_Field is
   CRC32,
   CRC32R,
   CRC16,
   CRC16R,
   EVEN,
   SUM)
  with Size => 4;
Enumeration Literal
CRC32

Calculate a CRC-32 (IEEE802.3 polynomial) with bit reversed data

CRC32R

Calculate a CRC-16-CCITT

CRC16

Calculate a CRC-16-CCITT with bit reversed data

CRC16R

XOR reduction over all data. == 1 if the total 1 population count is odd.

EVEN

Calculate a simple 32-bit checksum (addition with a 32 bit accumulator)

SUM

SNIFF_CTRL_DMACH_Field

subtype SNIFF_CTRL_DMACH_Field is HAL.UInt4;

SNIFF_CTRL_Register

type SNIFF_CTRL_Register is record
   EN             : Boolean := False;
   DMACH          : SNIFF_CTRL_DMACH_Field := 16#0#;
   CALC           : SNIFF_CTRL_CALC_Field := RP2040_SVD.DMA.CRC32;
   BSWAP          : Boolean := False;
   OUT_REV        : Boolean := False;
   OUT_INV        : Boolean := False;
   Reserved_12_31 : HAL.UInt20 := 16#0#;
end record;
Record fields
EN

DMA channel for Sniffer to observe

DMACH

Locally perform a byte reverse on the sniffed data, before feeding into checksum.\n\n Note that the sniff hardware is downstream of the DMA channel byteswap performed in the read master: if channel CTRL_BSWAP and SNIFF_CTRL_BSWAP are both enabled, their effects cancel from the sniffer's point of view.

CALC

Locally perform a byte reverse on the sniffed data, before feeding into checksum.\n\n Note that the sniff hardware is downstream of the DMA channel byteswap performed in the read master: if channel CTRL_BSWAP and SNIFF_CTRL_BSWAP are both enabled, their effects cancel from the sniffer's point of view.

BSWAP

If set, the result appears bit-reversed when read. This does not affect the way the checksum is calculated; the result is transformed on-the-fly between the result register and the bus.

OUT_REV

If set, the result appears inverted (bitwise complement) when read. This does not affect the way the checksum is calculated; the result is transformed on-the-fly between the result register and the bus.

OUT_INV

unspecified

Reserved_12_31

TIMER_Register

type TIMER_Register is record
   Y : TIMER_Y_Field := 16#0#;
   X : TIMER_X_Field := 16#0#;
end record;
Record fields
Y

Pacing Timer Dividend. Specifies the X value for the (X/Y) fractional timer.

X

TIMER_X_Field

subtype TIMER_X_Field is HAL.UInt16;

TIMER_Y_Field

subtype TIMER_Y_Field is HAL.UInt16;