------------- Registers -- -------------
subtype CH0_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH0_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH0_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH0_CTRL_TRIG_TREQ_SEL_Field is
CH0_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH0_DBG_CTDREQ_CH0_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CH10_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH10_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH10_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH10_CTRL_TRIG_TREQ_SEL_Field is
CH10_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH10_DBG_CTDREQ_CH10_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CH11_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH11_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH11_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH11_CTRL_TRIG_TREQ_SEL_Field is
CH11_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH11_DBG_CTDREQ_CH11_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CH1_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH1_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH1_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH1_CTRL_TRIG_TREQ_SEL_Field is
CH1_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH1_DBG_CTDREQ_CH1_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CH2_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH2_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH2_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH2_CTRL_TRIG_TREQ_SEL_Field is
CH2_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH2_DBG_CTDREQ_CH2_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CH3_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH3_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH3_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH3_CTRL_TRIG_TREQ_SEL_Field is
CH3_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH3_DBG_CTDREQ_CH3_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CH4_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH4_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH4_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH4_CTRL_TRIG_TREQ_SEL_Field is
CH4_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH4_DBG_CTDREQ_CH4_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CH5_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH5_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH5_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH5_CTRL_TRIG_TREQ_SEL_Field is
CH5_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH5_DBG_CTDREQ_CH5_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CH6_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH6_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH6_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH6_CTRL_TRIG_TREQ_SEL_Field is
CH6_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH6_DBG_CTDREQ_CH6_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CH7_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH7_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH7_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH7_CTRL_TRIG_TREQ_SEL_Field is
CH7_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH7_DBG_CTDREQ_CH7_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CH8_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH8_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH8_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH8_CTRL_TRIG_TREQ_SEL_Field is
CH8_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH8_DBG_CTDREQ_CH8_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CH9_CTRL_TRIG_CHAIN_TO_Field is HAL.UInt4;
type CH9_CTRL_TRIG_DATA_SIZE_Field is
(SIZE_BYTE,
SIZE_HALFWORD,
SIZE_WORD)
with Size => 2;
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;
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.
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.
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.
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.
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.
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.
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).
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
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.
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.
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.
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.
unspecified
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 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-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.
type CH9_CTRL_TRIG_RING_SIZE_Field is
(RING_NONE)
with Size => 4;
type CH9_CTRL_TRIG_TREQ_SEL_Field is
CH9_CTRL_TRIG_TREQ_SEL_Field_Reset,
TIMER0,
TIMER1,
TIMER2,
TIMER3,
PERMANENT)
with Size => 6;
Select Timer 0 as TREQ
Select Timer 1 as TREQ
Select Timer 2 as TREQ (Optional)
Select Timer 3 as TREQ (Optional)
Permanent request, for unpaced transfers.
subtype CH9_DBG_CTDREQ_CH9_DBG_CTDREQ_Field is HAL.UInt6;
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;
unspecified
subtype CHAN_ABORT_CHAN_ABORT_Field is HAL.UInt16;
type CHAN_ABORT_Register is record
CHAN_ABORT : CHAN_ABORT_CHAN_ABORT_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
DMA_Periph : aliased DMA_Peripheral
with Import, Address => DMA_Base;
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;
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.
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.
DMA Channel 0 Control and Status
Alias for channel 0 CTRL register
Alias for channel 0 READ_ADDR register
Alias for channel 0 WRITE_ADDR register
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.
Alias for channel 0 CTRL register
Alias for channel 0 TRANS_COUNT register
Alias for channel 0 READ_ADDR register
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.
Alias for channel 0 CTRL register
Alias for channel 0 WRITE_ADDR register
Alias for channel 0 TRANS_COUNT register
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.
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.
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.
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.
DMA Channel 1 Control and Status
Alias for channel 1 CTRL register
Alias for channel 1 READ_ADDR register
Alias for channel 1 WRITE_ADDR register
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.
Alias for channel 1 CTRL register
Alias for channel 1 TRANS_COUNT register
Alias for channel 1 READ_ADDR register
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.
Alias for channel 1 CTRL register
Alias for channel 1 WRITE_ADDR register
Alias for channel 1 TRANS_COUNT register
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.
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.
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.
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.
DMA Channel 2 Control and Status
Alias for channel 2 CTRL register
Alias for channel 2 READ_ADDR register
Alias for channel 2 WRITE_ADDR register
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.
Alias for channel 2 CTRL register
Alias for channel 2 TRANS_COUNT register
Alias for channel 2 READ_ADDR register
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.
Alias for channel 2 CTRL register
Alias for channel 2 WRITE_ADDR register
Alias for channel 2 TRANS_COUNT register
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.
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.
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.
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.
DMA Channel 3 Control and Status
Alias for channel 3 CTRL register
Alias for channel 3 READ_ADDR register
Alias for channel 3 WRITE_ADDR register
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.
Alias for channel 3 CTRL register
Alias for channel 3 TRANS_COUNT register
Alias for channel 3 READ_ADDR register
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.
Alias for channel 3 CTRL register
Alias for channel 3 WRITE_ADDR register
Alias for channel 3 TRANS_COUNT register
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.
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.
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.
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.
DMA Channel 4 Control and Status
Alias for channel 4 CTRL register
Alias for channel 4 READ_ADDR register
Alias for channel 4 WRITE_ADDR register
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.
Alias for channel 4 CTRL register
Alias for channel 4 TRANS_COUNT register
Alias for channel 4 READ_ADDR register
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.
Alias for channel 4 CTRL register
Alias for channel 4 WRITE_ADDR register
Alias for channel 4 TRANS_COUNT register
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.
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.
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.
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.
DMA Channel 5 Control and Status
Alias for channel 5 CTRL register
Alias for channel 5 READ_ADDR register
Alias for channel 5 WRITE_ADDR register
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.
Alias for channel 5 CTRL register
Alias for channel 5 TRANS_COUNT register
Alias for channel 5 READ_ADDR register
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.
Alias for channel 5 CTRL register
Alias for channel 5 WRITE_ADDR register
Alias for channel 5 TRANS_COUNT register
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.
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.
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.
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.
DMA Channel 6 Control and Status
Alias for channel 6 CTRL register
Alias for channel 6 READ_ADDR register
Alias for channel 6 WRITE_ADDR register
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.
Alias for channel 6 CTRL register
Alias for channel 6 TRANS_COUNT register
Alias for channel 6 READ_ADDR register
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.
Alias for channel 6 CTRL register
Alias for channel 6 WRITE_ADDR register
Alias for channel 6 TRANS_COUNT register
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.
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.
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.
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.
DMA Channel 7 Control and Status
Alias for channel 7 CTRL register
Alias for channel 7 READ_ADDR register
Alias for channel 7 WRITE_ADDR register
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.
Alias for channel 7 CTRL register
Alias for channel 7 TRANS_COUNT register
Alias for channel 7 READ_ADDR register
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.
Alias for channel 7 CTRL register
Alias for channel 7 WRITE_ADDR register
Alias for channel 7 TRANS_COUNT register
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.
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.
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.
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.
DMA Channel 8 Control and Status
Alias for channel 8 CTRL register
Alias for channel 8 READ_ADDR register
Alias for channel 8 WRITE_ADDR register
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.
Alias for channel 8 CTRL register
Alias for channel 8 TRANS_COUNT register
Alias for channel 8 READ_ADDR register
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.
Alias for channel 8 CTRL register
Alias for channel 8 WRITE_ADDR register
Alias for channel 8 TRANS_COUNT register
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.
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.
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.
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.
DMA Channel 9 Control and Status
Alias for channel 9 CTRL register
Alias for channel 9 READ_ADDR register
Alias for channel 9 WRITE_ADDR register
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.
Alias for channel 9 CTRL register
Alias for channel 9 TRANS_COUNT register
Alias for channel 9 READ_ADDR register
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.
Alias for channel 9 CTRL register
Alias for channel 9 WRITE_ADDR register
Alias for channel 9 TRANS_COUNT register
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.
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.
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.
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.
DMA Channel 10 Control and Status
Alias for channel 10 CTRL register
Alias for channel 10 READ_ADDR register
Alias for channel 10 WRITE_ADDR register
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.
Alias for channel 10 CTRL register
Alias for channel 10 TRANS_COUNT register
Alias for channel 10 READ_ADDR register
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.
Alias for channel 10 CTRL register
Alias for channel 10 WRITE_ADDR register
Alias for channel 10 TRANS_COUNT register
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.
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.
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.
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.
DMA Channel 11 Control and Status
Alias for channel 11 CTRL register
Alias for channel 11 READ_ADDR register
Alias for channel 11 WRITE_ADDR register
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.
Alias for channel 11 CTRL register
Alias for channel 11 TRANS_COUNT register
Alias for channel 11 READ_ADDR register
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.
Alias for channel 11 CTRL register
Alias for channel 11 WRITE_ADDR register
Alias for channel 11 TRANS_COUNT register
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.
Interrupt Status (raw)
Interrupt Enables for IRQ 0
Force Interrupts
Interrupt Status for IRQ 0
Interrupt Enables for IRQ 1
Force Interrupts for IRQ 1
Interrupt Status (masked) for IRQ 1
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.
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.
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.
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.
Trigger one or more channels simultaneously
Sniffer Control
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.
Debug RAF, WAF, TDF levels
Abort an in-progress transfer sequence on one or more channels
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.
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
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.
Read to get channel TRANS_COUNT reload value, i.e. the length of the next transfer
subtype FIFO_LEVELS_RAF_LVL_Field is HAL.UInt8;
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;
Read-only. Current Write-Address-FIFO fill level
Read-only. Current Read-Address-FIFO fill level
unspecified
subtype FIFO_LEVELS_TDF_LVL_Field is HAL.UInt8;
subtype FIFO_LEVELS_WAF_LVL_Field is HAL.UInt8;
subtype INTE0_INTE0_Field is HAL.UInt16;
type INTE0_Register is record
INTE0 : INTE0_INTE0_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INTE1_INTE1_Field is HAL.UInt16;
type INTE1_Register is record
INTE1 : INTE1_INTE1_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INTF0_INTF0_Field is HAL.UInt16;
type INTF0_Register is record
INTF0 : INTF0_INTF0_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INTF1_INTF1_Field is HAL.UInt16;
type INTF1_Register is record
INTF1 : INTF1_INTF1_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INTR_INTR_Field is HAL.UInt16;
type INTR_Register is record
INTR : INTR_INTR_Field;
Reserved_16_31 : HAL.UInt16;
end record;
unspecified
subtype INTS0_INTS0_Field is HAL.UInt16;
type INTS0_Register is record
INTS0 : INTS0_INTS0_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype INTS1_INTS1_Field is HAL.UInt16;
type INTS1_Register is record
INTS1 : INTS1_INTS1_Field := 16#0#;
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record;
unspecified
subtype MULTI_CHAN_TRIGGER_MULTI_CHAN_TRIGGER_Field is HAL.UInt16;
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;
unspecified
subtype N_CHANNELS_N_CHANNELS_Field is HAL.UInt5;
type N_CHANNELS_Register is record
N_CHANNELS : N_CHANNELS_N_CHANNELS_Field;
Reserved_5_31 : HAL.UInt27;
end record;
unspecified
type SNIFF_CTRL_CALC_Field is
CRC32,
CRC32R,
CRC16,
CRC16R,
EVEN,
SUM)
with Size => 4;
Calculate a CRC-32 (IEEE802.3 polynomial) with bit reversed data
Calculate a CRC-16-CCITT
Calculate a CRC-16-CCITT with bit reversed data
XOR reduction over all data. == 1 if the total 1 population count is odd.
Calculate a simple 32-bit checksum (addition with a 32 bit accumulator)
subtype SNIFF_CTRL_DMACH_Field is HAL.UInt4;
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;
DMA channel for Sniffer to observe
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.
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.
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.
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.
unspecified
type TIMER_Register is record
Y : TIMER_Y_Field := 16#0#;
X : TIMER_X_Field := 16#0#;
end record;
Pacing Timer Dividend. Specifies the X value for the (X/Y) fractional timer.
subtype TIMER_X_Field is HAL.UInt16;
subtype TIMER_Y_Field is HAL.UInt16;