Unit BCM2838

Return to Unit Reference

IRQ lines of BCM2838 peripherals

`BCM2838_SPI_BASE = 32;`	Added to the SPI ID in device tree to obtain the real ID
`BCM2838_PPI_BASE = 16;`	Added to the PPI ID in device tree to obtain the real ID
`BCM2838_SGI_BASE = 0;`
ARM Generic Timer
`BCM2838_IRQ_TIMER0 = BCM2838_PPI_BASE + 13;`	IRQ_TYPE_LEVEL_LOW / CPU_MASK_0 or CPU_MASK_1 or CPU_MASK_2 or CPU_MASK_3 (Core n PS timer IRQ)
`BCM2838_IRQ_TIMER1 = BCM2838_PPI_BASE + 14;`	IRQ_TYPE_LEVEL_LOW / CPU_MASK_0 or CPU_MASK_1 or CPU_MASK_2 or CPU_MASK_3 (Core n PNS timer IRQ)
`BCM2838_IRQ_TIMER2 = BCM2838_PPI_BASE + 11;`	IRQ_TYPE_LEVEL_LOW / CPU_MASK_0 or CPU_MASK_1 or CPU_MASK_2 or CPU_MASK_3 (Core n V timer IRQ)
`BCM2838_IRQ_TIMER3 = BCM2838_PPI_BASE + 10;`	IRQ_TYPE_LEVEL_LOW / CPU_MASK_0 or CPU_MASK_1 or CPU_MASK_2 or CPU_MASK_3 (Core n HP timer IRQ)
Legacy IRQ/FIQ
`BCM2838_FIQ_LEGACY = BCM2838_PPI_BASE + 12;`	Legacy FIQn
`BCM2838_IRQ_LEGACY = BCM2838_PPI_BASE + 15;`	Legacy IRQn
ARM Mailbox IRQs (BCM2838_SPI_BASE + 0 to 15)
`BCM2838_IRQ_MAILBOX0_0 = BCM2838_SPI_BASE + 0;`	IRQ_TYPE_LEVEL_HIGH(Core 0)
`BCM2838_IRQ_MAILBOX1_0 = BCM2838_SPI_BASE + 1;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MAILBOX2_0 = BCM2838_SPI_BASE + 2;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MAILBOX3_0 = BCM2838_SPI_BASE + 3;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MAILBOX0_1 = BCM2838_SPI_BASE + 4;`	IRQ_TYPE_LEVEL_HIGH (Core 1)
`BCM2838_IRQ_MAILBOX1_1 = BCM2838_SPI_BASE + 5;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MAILBOX2_1 = BCM2838_SPI_BASE + 6;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MAILBOX3_1 = BCM2838_SPI_BASE + 7;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MAILBOX0_2 = BCM2838_SPI_BASE + 8;`	IRQ_TYPE_LEVEL_HIGH (Core 2)
`BCM2838_IRQ_MAILBOX1_2 = BCM2838_SPI_BASE + 9;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MAILBOX2_2 = BCM2838_SPI_BASE + 10;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MAILBOX3_2 = BCM2838_SPI_BASE + 11;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MAILBOX0_3 = BCM2838_SPI_BASE + 12;`	IRQ_TYPE_LEVEL_HIGH (Core 3)
`BCM2838_IRQ_MAILBOX1_3 = BCM2838_SPI_BASE + 13;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MAILBOX2_3 = BCM2838_SPI_BASE + 14;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MAILBOX3_3 = BCM2838_SPI_BASE + 15;`	IRQ_TYPE_LEVEL_HIGH
ARM PMU
`BCM2838_IRQ_PMU0 = BCM2838_SPI_BASE + 16;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_PMU1 = BCM2838_SPI_BASE + 17;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_PMU2 = BCM2838_SPI_BASE + 18;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_PMU3 = BCM2838_SPI_BASE + 19;`	IRQ_TYPE_LEVEL_HIGH
AXI Quiet
`BCM2838_IRQ_LOCAL_AXIQUIET = BCM2838_SPI_BASE + 20;`	IRQ_TYPE_LEVEL_HIGH
ARM Local Timer
`BCM2838_IRQ_LOCAL_TIMER = BCM2838_SPI_BASE + 21;`	IRQ_TYPE_LEVEL_HIGH
AXI Error
`BCM2838_IRQ_LOCAL_AXIERR = BCM2838_SPI_BASE + 22;`	IRQ_TYPE_LEVEL_HIGH (TBD)
ARM peripheral IRQs (BCM2838_SPI_BASE + 32 to 47)
ARM Timer
`BCM2838_IRQ_ARM_TIMER = BCM2838_SPI_BASE + 32;`	IRQ_TYPE_LEVEL_HIGH
ARM Mailbox
`BCM2838_IRQ_ARM_MAILBOX = BCM2838_SPI_BASE + 33;`	IRQ_TYPE_LEVEL_HIGH
ARM Doorbell (VCHIQ)
`BCM2838_IRQ_ARM_DOORBELL0 = BCM2838_SPI_BASE + 34;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_ARM_DOORBELL1 = BCM2838_SPI_BASE + 35;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_VCHIQ = BCM2838_IRQ_ARM_DOORBELL0;`
ARM VPU Halted
`BCM2838_IRQ_ARM_VPU0HALTED = BCM2838_SPI_BASE + 36;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_ARM_VPU1HALTED = BCM2838_SPI_BASE + 37;`	IRQ_TYPE_LEVEL_HIGH
ARM Error
`BCM2838_IRQ_ARM_ADDRERROR = BCM2838_SPI_BASE + 38;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_ARM_AXIERROR = BCM2838_SPI_BASE + 39;`	IRQ_TYPE_LEVEL_HIGH
ARM Software Interrupt (SWI)
`BCM2838_IRQ_ARM_SWI0 = BCM2838_SPI_BASE + 40;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_ARM_SWI1 = BCM2838_SPI_BASE + 41;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_ARM_SWI2 = BCM2838_SPI_BASE + 42;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_ARM_SWI3 = BCM2838_SPI_BASE + 43;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_ARM_SWI4 = BCM2838_SPI_BASE + 44;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_ARM_SWI5 = BCM2838_SPI_BASE + 45;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_ARM_SWI6 = BCM2838_SPI_BASE + 46;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_ARM_SWI7 = BCM2838_SPI_BASE + 47;`	IRQ_TYPE_LEVEL_HIGH
VC peripheral IRQs (BCM2838_SPI_BASE + 64 to 127)
System Timer
`BCM2838_IRQ_SYSTEM_TIMER_0 = BCM2838_SPI_BASE + 64;`	Already used by the VideoCore GPU (Do not use)
`BCM2838_IRQ_SYSTEM_TIMER_1 = BCM2838_SPI_BASE + 65;`
`BCM2838_IRQ_SYSTEM_TIMER_2 = BCM2838_SPI_BASE + 66;`	Already used by the VideoCore GPU (Do not use)
`BCM2838_IRQ_SYSTEM_TIMER_3 = BCM2838_SPI_BASE + 67;`
H264 Codec
`BCM2838_IRQ_H264_0 = BCM2838_SPI_BASE + 68;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_H264_1 = BCM2838_SPI_BASE + 69;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_H264_2 = BCM2838_SPI_BASE + 70;`	IRQ_TYPE_LEVEL_HIGH
JPEG
`BCM2838_IRQ_JPEG = BCM2838_SPI_BASE + 71;`	IRQ_TYPE_LEVEL_HIGH
ISP
`BCM2838_IRQ_ISP = BCM2838_SPI_BASE + 72;`	IRQ_TYPE_LEVEL_HIGH
USB (Synopsys DesignWare Hi-Speed USB 2.0 On-The-Go Controller)
`BCM2838_IRQ_USB = BCM2838_SPI_BASE + 73;`	IRQ_TYPE_LEVEL_HIGH
V3D
`BCM2838_IRQ_V3D = BCM2838_SPI_BASE + 74;`	IRQ_TYPE_LEVEL_HIGH
Transposer
`BCM2838_IRQ_TXP = BCM2838_SPI_BASE + 75;`	IRQ_TYPE_LEVEL_HIGH
Multicore Sync
`BCM2838_IRQ_MULTICORESYNC0 = BCM2838_SPI_BASE + 76;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MULTICORESYNC1 = BCM2838_SPI_BASE + 77;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MULTICORESYNC2 = BCM2838_SPI_BASE + 78;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_MULTICORESYNC3 = BCM2838_SPI_BASE + 79;`	IRQ_TYPE_LEVEL_HIGH
DMA
`BCM2838_IRQ_DMA0 = BCM2838_SPI_BASE + 80;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA1 = BCM2838_SPI_BASE + 81;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA2 = BCM2838_SPI_BASE + 82;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA3 = BCM2838_SPI_BASE + 83;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA4 = BCM2838_SPI_BASE + 84;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA5 = BCM2838_SPI_BASE + 85;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA6 = BCM2838_SPI_BASE + 86;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA7 = BCM2838_SPI_BASE + 87;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA8 = BCM2838_SPI_BASE + 87;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA9 = BCM2838_SPI_BASE + 88;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA10 = BCM2838_SPI_BASE + 88;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA11 = BCM2838_SPI_BASE + 89;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA12 = BCM2838_SPI_BASE + 90;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA13 = BCM2838_SPI_BASE + 91;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_DMA14 = BCM2838_SPI_BASE + 92;`	IRQ_TYPE_LEVEL_HIGH

`BCM2838_IRQ_DMA7_8 = BCM2838_IRQ_DMA7;`
`BCM2838_IRQ_DMA9_10 = BCM2838_IRQ_DMA9;`
AUX (UART1, SPI1 and SPI2)
`BCM2838_IRQ_AUX = BCM2838_SPI_BASE + 93;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_UART1 = BCM2838_IRQ_AUX;`
`BCM2838_IRQ_SPI1 = BCM2838_IRQ_AUX;`
`BCM2838_IRQ_SPI2 = BCM2838_IRQ_AUX;`
ARM
`BCM2838_IRQ_ARM = BCM2838_SPI_BASE + 94;`	IRQ_TYPE_LEVEL_HIGH
DMA Note: DMA15 is exclusively used by the VPU
`BCM2838_IRQ_DMA15 = BCM2838_SPI_BASE + 95;`	IRQ_TYPE_LEVEL_HIGH
HDMI CEC
`BCM2838_IRQ_HDMI_CEC = BCM2838_SPI_BASE + 96;`	IRQ_TYPE_LEVEL_HIGH
HVS
`BCM2838_IRQ_HVS = BCM2838_SPI_BASE + 97;`	IRQ_TYPE_LEVEL_HIGH
ARGON (RPIVID)
`BCM2838_IRQ_ARGON = BCM2838_SPI_BASE + 98;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_RPIVID = BCM2838_IRQ_ARGON;`
SDC
`BCM2838_IRQ_SDC = BCM2838_SPI_BASE + 99;`	IRQ_TYPE_LEVEL_HIGH
DSI0
`BCM2838_IRQ_DSI0 = BCM2838_SPI_BASE + 100;`	IRQ_TYPE_LEVEL_HIGH
Pixel Valve 2
`BCM2838_IRQ_PIXELVALVE2 = BCM2838_SPI_BASE + 101;`	IRQ_TYPE_LEVEL_HIGH
CSI0 (Camera Serial Interface)
`BCM2838_IRQ_CSI0 = BCM2838_SPI_BASE + 102;`	IRQ_TYPE_LEVEL_HIGH
CSI1 (Camera Serial Interface)
`BCM2838_IRQ_CSI1 = BCM2838_SPI_BASE + 103;`	IRQ_TYPE_LEVEL_HIGH
HDMI
`BCM2838_IRQ_HDMI_0 = BCM2838_SPI_BASE + 104;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_HDMI_1 = BCM2838_SPI_BASE + 105;`	IRQ_TYPE_LEVEL_HIGH
Pixel Valve 3
`BCM2838_IRQ_PIXELVALVE3 = BCM2838_SPI_BASE + 106;`	IRQ_TYPE_LEVEL_HIGH
I2C / SPI Slave
`BCM2838_IRQ_I2CSPI = BCM2838_SPI_BASE + 107;`	IRQ_TYPE_LEVEL_HIGH
DSI1
`BCM2838_IRQ_DSI1 = BCM2838_SPI_BASE + 108;`	IRQ_TYPE_LEVEL_HIGH
Pixel Valve 0
`BCM2838_IRQ_PIXELVALVE0 = BCM2838_SPI_BASE + 109;`	IRQ_TYPE_LEVEL_HIGH
Pixel Valve 1/4
`BCM2838_IRQ_PIXELVALVE1 = BCM2838_SPI_BASE + 110;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_PIXELVALVE4 = BCM2838_IRQ_PIXELVALVE1;`
CPR
`BCM2838_IRQ_CPR = BCM2838_SPI_BASE + 111;`	IRQ_TYPE_LEVEL_HIGH
SMI (Firmware KMS)
`BCM2838_IRQ_SMI = BCM2838_SPI_BASE + 112;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_FIRMWAREKMS = BCM2838_IRQ_SMI;`
GPIO
`BCM2838_IRQ_GPIO_0 = BCM2838_SPI_BASE + 113;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_GPIO_1 = BCM2838_SPI_BASE + 114;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_GPIO_2 = BCM2838_SPI_BASE + 115;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_GPIO_3 = BCM2838_SPI_BASE + 116;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_GPIO_ALL = BCM2838_IRQ_GPIO_3;`
BSC0 (I2C0) (Broadcom Serial Controller)
`BCM2838_IRQ_BSC0 = BCM2838_SPI_BASE + 117;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_I2C0 = BCM2838_IRQ_BSC0;`
BSC1 (I2C1) (Broadcom Serial Controller)
`BCM2838_IRQ_BSC1 = BCM2838_SPI_BASE + 117;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_I2C1 = BCM2838_IRQ_BSC1;`
BSC2 (I2C2) (Broadcom Serial Controller)
`BCM2838_IRQ_BSC2 = BCM2838_SPI_BASE + 117;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_I2C2 = BCM2838_IRQ_BSC2;`
I2C3
`BCM2838_IRQ_I2C3 = BCM2838_SPI_BASE + 117;`	IRQ_TYPE_LEVEL_HIGH
I2C4
`BCM2838_IRQ_I2C4 = BCM2838_SPI_BASE + 117;`	IRQ_TYPE_LEVEL_HIGH
I2C5
`BCM2838_IRQ_I2C5 = BCM2838_SPI_BASE + 117;`	IRQ_TYPE_LEVEL_HIGH
I2C6
`BCM2838_IRQ_I2C6 = BCM2838_SPI_BASE + 117;`	IRQ_TYPE_LEVEL_HIGH
I2C7
`BCM2838_IRQ_I2C7 = BCM2838_SPI_BASE + 117;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_I2C0_IRQS:array[0..7] of LongWord = (BCM2838_IRQ_I2C0, BCM2838_IRQ_I2C1, BCM2838_IRQ_I2C2, BCM2838_IRQ_I2C3, BCM2838_IRQ_I2C4, BCM2838_IRQ_I2C5, BCM2838_IRQ_I2C6, BCM2838_IRQ_I2C7);`
SPI0
`BCM2838_IRQ_SPI0 = BCM2838_SPI_BASE + 118;`	IRQ_TYPE_LEVEL_HIGH
SPI3
`BCM2838_IRQ_SPI3 = BCM2838_SPI_BASE + 118;`	IRQ_TYPE_LEVEL_HIGH
SPI4
`BCM2838_IRQ_SPI4 = BCM2838_SPI_BASE + 118;`	IRQ_TYPE_LEVEL_HIGH
SPI5
`BCM2838_IRQ_SPI5 = BCM2838_SPI_BASE + 118;`	IRQ_TYPE_LEVEL_HIGH
SPI6
`BCM2838_IRQ_SPI6 = BCM2838_SPI_BASE + 118;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_SPI0_IRQS:array[0..6] of LongWord = (BCM2838_IRQ_SPI0, 0, 0, BCM2838_IRQ_SPI3, BCM2838_IRQ_SPI4, BCM2838_IRQ_SPI5, BCM2838_IRQ_SPI6);`
I2S PCM sound
`BCM2838_IRQ_I2SPCM = BCM2838_SPI_BASE + 119;`	IRQ_TYPE_LEVEL_HIGH
EMMC1 (SDHOST)
`BCM2838_IRQ_EMMC1 = BCM2838_SPI_BASE + 120;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_SDHOST = BCM2838_IRQ_EMMC1;`
UART0 (PL011)
`BCM2838_IRQ_PL011 = BCM2838_SPI_BASE + 121;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_UART0 = BCM2838_IRQ_PL011;`
UART2 (PL011)
`BCM2838_IRQ_UART2 = BCM2838_SPI_BASE + 121;`	IRQ_TYPE_LEVEL_HIGH
UART3 (PL011)
`BCM2838_IRQ_UART3 = BCM2838_SPI_BASE + 121;`	IRQ_TYPE_LEVEL_HIGH
UART4 (PL011)
`BCM2838_IRQ_UART4 = BCM2838_SPI_BASE + 121;`	IRQ_TYPE_LEVEL_HIGH
UART5 (PL011)
`BCM2838_IRQ_UART5 = BCM2838_SPI_BASE + 121;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_UART0_IRQS:array[0..5] of LongWord = (BCM2838_IRQ_UART0, 0, BCM2838_IRQ_UART2, BCM2838_IRQ_UART3, BCM2838_IRQ_UART4, BCM2838_IRQ_UART5);`
ETH_PCIe L2
`BCM2838_IRQ_ETH_PCIE = BCM2838_SPI_BASE + 122;`	IRQ_TYPE_LEVEL_HIGH
VEC
`BCM2838_IRQ_VEC = BCM2838_SPI_BASE + 123;`	IRQ_TYPE_LEVEL_HIGH
CPG
`BCM2838_IRQ_CPG = BCM2838_SPI_BASE + 124;`	IRQ_TYPE_LEVEL_HIGH
Random Number Generator
`BCM2838_IRQ_RNG = BCM2838_SPI_BASE + 125;`	IRQ_TYPE_LEVEL_HIGH
EMMC0 (SDHCI)
`BCM2838_IRQ_EMMC0 = BCM2838_SPI_BASE + 126;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_SDHCI = BCM2838_IRQ_EMMC0;`
EMMC2 (SDHCI)
`BCM2838_IRQ_EMMC2 = BCM2838_SPI_BASE + 126;`	IRQ_TYPE_LEVEL_HIGH
ETH_PCIe Secure
`BCM2838_IRQ_ETH_PCIE_SEC = BCM2838_SPI_BASE + 127;`	IRQ_TYPE_LEVEL_HIGH
ETH_PCIe L2 IRQs (BCM2838_SPI_BASE + 128 to 184)
Thermal (AVS)
`BCM2838_IRQ_THERMAL = BCM2838_SPI_BASE + 137;`	IRQ_TYPE_LEVEL_HIGH
PCIe
`BCM2838_IRQ_PCIE_INTA = BCM2838_SPI_BASE + 143;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_PCIE_INTB = BCM2838_SPI_BASE + 144;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_PCIE_INTC = BCM2838_SPI_BASE + 145;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_PCIE_INTD = BCM2838_SPI_BASE + 146;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_PCIE_MSI = BCM2838_SPI_BASE + 148;`	IRQ_TYPE_LEVEL_HIGH
GENET
`BCM2838_IRQ_GENET_0 = BCM2838_SPI_BASE + 157;`	IRQ_TYPE_LEVEL_HIGH
`BCM2838_IRQ_GENET_1 = BCM2838_SPI_BASE + 158;`	IRQ_TYPE_LEVEL_HIGH
XHCI (Additional on chip generic XHCI USB host controller)
`BCM2838_IRQ_XHCI = BCM2838_SPI_BASE + 176;`	IRQ_TYPE_LEVEL_HIGH (This is separate to the VL805 XHCI controller)
Number of shared IRQs
`BCM2838_SHARED_IRQ_COUNT = 988;`	SPI 32-1019
Number of private IRQs
`BCM2838_PRIVATE_IRQ_COUNT = 16;`	PPI 16-31
Number of software IRQs
`BCM2838_SOFTWARE_IRQ_COUNT = 16;`	SGI 0-15
Number of reserved IRQs
`BCM2838_RESERVED_IRQ_COUNT = 4;`	ID 1020-1023
Total number of IRQs available
`BCM2838_IRQ_COUNT = BCM2838_SHARED_IRQ_COUNT + BCM2838_PRIVATE_IRQ_COUNT + BCM2838_SOFTWARE_IRQ_COUNT + BCM2838_RESERVED_IRQ_COUNT;`
Total number of FIQs available
`BCM2838_FIQ_COUNT = BCM2838_IRQ_COUNT;`

[Expand]

BCM2838 system timer frequency BCM2838_SYSTEM_TIMER_BCM2838_SYSTEM_TIMER_FREQUENCY*

[Expand]

BCM2838 system timer control/status BCM2838_SYSTEM_TIMER_CS_*

[Expand]

BCM2838 DMA control/status BCM2838_DMA_CS_*

See: Section 4

`BCM2838_DMA_CS_ACTIVE = (1 shl 0);`	Activate the DMA (This bit enables the DMA. The DMA will start if this bit is set and the CB_ADDR is non zero. The DMA transfer can be paused and resumed by clearing, then setting it again.)
`BCM2838_DMA_CS_END = (1 shl 1);`	DMA End Flag (Set when the transfer described by the current control block is complete. Write 1 to clear.)
`BCM2838_DMA_CS_INT = (1 shl 2);`	Interrupt Status (This is set when the transfer for the CB ends and INTEN is set to 1. Write 1 to clear.)
`BCM2838_DMA_CS_DREQ = (1 shl 3);`	DREQ State (Indicates the state of the selected DREQ (Data Request) signal, ie. the DREQ selected by the PERMAP field of the transfer info.)
`BCM2838_DMA_CS_PAUSED = (1 shl 4);`	DMA Paused State (Indicates if the DMA is currently paused and not transferring data)
`BCM2838_DMA_CS_DREQ_PAUSED = (1 shl 5);`	DMA Paused by DREQ State (Indicates if the DMA is currently paused and not transferring data due to the DREQ being inactive)
`BCM2838_DMA_CS_WAITING_FOR_OUTSTANDING_WRITES = (1 shl 6);`	DMA is Waiting for the Last Write to be Received (Indicates if the DMA is currently waiting for any outstanding writes to be received, and is not transferring data.)
Bit 7 Reserved - Write as 0, read as don't care
`BCM2838_DMA_CS_ERROR = (1 shl 8);`	DMA Error (Indicates if the DMA has detected an error)
`BCM2838_DMA_CS_PRIORITY = ($F shl 16);`	AXI Priority Level (Sets the priority of normal AXI bus transactions. Zero is the lowest priority.)
`BCM2838_DMA_CS_PANIC_PRIORITY = ($F shl 20);`	AXI Panic Priority Level (Sets the priority of panicking AXI bus transactions)
Bits 24:27 Reserved - Write as 0, read as don't care
`BCM2838_DMA_CS_WAIT_FOR_OUTSTANDING_WRITES = (1 shl 28);`	Wait for outstanding writes (When set to 1, the DMA will keep a tally of the AXI writes going out and the write responses coming in.)
`BCM2838_DMA_CS_DISDEBUG = (1 shl 29);`	Disable debug pause signal (When set to 1, the DMA will not stop when the debug pause signal is asserted.)
`BCM2838_DMA_CS_ABORT = (1 shl 30);`	Abort DMA (Writing a 1 to this bit will abort the current DMA CB. The DMA will load the next CB and attempt to continue. The bit cannot be read, and will self clear.)
`BCM2838_DMA_CS_RESET = (1 shl 31);`	DMA Channel Reset (Writing a 1 to this bit will reset the DMA. The bit cannot be read, and will self clear.)

`BCM2838_DMA_CS_PRIORITY_DEFAULT = 0;`

[Expand]

BCM2838 DMA transfer information BCM2838_DMA_TI_*

See: Section 4

`BCM2838_DMA_TI_INTEN = (1 shl 0);`	Interrupt Enable (1 = Generate an interrupt when the transfer described by the current Control Block completes)
`BCM2838_DMA_TI_2DMODE = (1 shl 1);`	2D Mode (1 = 2D mode interpret the TXFR_LEN register as YLENGTH number of transfers each of XLENGTH, and add the strides to the address after each transfer.)
Bit 2 Reserved - Write as 0, read as don't care
`BCM2838_DMA_TI_WAIT_RESP = (1 shl 3);`	Wait for a Write Response (When set this makes the DMA wait until it receives the AXI write response for each write. This ensures that multiple writes cannot get stacked in the AXI bus pipeline.)
`BCM2838_DMA_TI_DEST_INC = (1 shl 4);`	Destination Address Increment (1 = Destination address increments after each write. The address will increment by 4, if DEST_WIDTH=0 else by 32.)
`BCM2838_DMA_TI_DEST_WIDTH = (1 shl 5);`	Destination Transfer Width (1 = Use 128-bit destination write width. 0 = Use 32-bit destination write width.)
`BCM2838_DMA_TI_DEST_DREQ = (1 shl 6);`	Control Destination Writes with DREQ (1 = The DREQ selected by PERMAP will gate the destination writes)
`BCM2838_DMA_TI_DEST_IGNORE = (1 shl 7);`	Ignore Writes (1 = Do not perform destination writes. 0 = Write data to destination.)
`BCM2838_DMA_TI_SRC_INC = (1 shl 8);`	Source Address Increment (1 = Source address increments after each read. The address will increment by 4, if S_WIDTH=0 else by 32.)
`BCM2838_DMA_TI_SRC_WIDTH = (1 shl 9);`	Source Transfer Width (1 = Use 128-bit source read width. 0 = Use 32-bit source read width.)
`BCM2838_DMA_TI_SRC_DREQ = (1 shl 10);`	Control Source Reads with DREQ (1 = The DREQ selected by PERMAP will gate the source reads)
`BCM2838_DMA_TI_SRC_IGNORE = (1 shl 11);`	Ignore Reads (1 = Do not perform source reads. In addition, destination writes will zero all the write strobes. This is used for fast cache fill operations.)
`BCM2838_DMA_TI_BURST_LENGTH = ($F shl 12);`	Burst Transfer Length (Indicates the burst length of the DMA transfers)
`BCM2838_DMA_TI_PERMAP = ($1F shl 16);`	Peripheral Mapping (Indicates the peripheral number (1-31) whose ready signal shall be used to control the rate of the transfers)
`BCM2838_DMA_TI_WAITS = ($3E shl 21);`	Add Wait Cycles (This slows down the DMA throughput by setting the number of dummy cycles burnt after each DMA read or write operation is completed)
`BCM2838_DMA_TI_NO_WIDE_BURSTS = (1 shl 26);`	Don't Do wide writes as a 2 beat burst (This prevents the DMA from issuing wide writes as 2 beat AXI bursts. This is an inefficient access mode, so the default is to use the bursts.)
Bits 27:31 Reserved - Write as 0, read as don't care

Note: BCM2838_DMA_TI_2DMODE, BCM2838_DMA_TI_DEST_IGNORE, BCM2838_DMA_TI_SRC_IGNORE and BCM2838_DMA_TI_NO_WIDE_BURSTS not available on DMA Lite channels

`BCM2838_DMA_TI_PERMAP_SHIFT = 16;`
`BCM2838_DMA_TI_BURST_LENGTH_SHIFT = 12;`

`BCM2838_DMA_TI_BURST_LENGTH_DEFAULT = 0;`

[Expand]

BCM2838 DMA transfer length BCM2838_DMA_TXFR_LEN_*

[Expand]

BCM2838 DMA 2D stride BCM2838_DMA_STRIDE_*

[Expand]

BCM2838 DMA debug BCM2838_DMA_DEBUG_*

[Expand]

BCM2838 DMA4 control/status BCM2838_DMA4_CS_*

See: Section 4

`BCM2838_DMA4_CS_ACTIVE = (1 shl 0);`	Activate the DMA4 (This bit enables the DMA4 to start transferring data)
`BCM2838_DMA4_CS_END = (1 shl 1);`	End Flag (Set when the transfer described by the current Control Block is complete)
`BCM2838_DMA4_CS_INT = (1 shl 2);`	Interrupt Status (If interrupts are enabled (INTEN is set to 1) the interrupt is set when the transfer for the current CB is completed)
`BCM2838_DMA4_CS_DREQ = (1 shl 3);`	DREQ State (Indicates the state of the selected DREQ (Data Request) signal)
`BCM2838_DMA4_CS_RD_PAUSED = (1 shl 4);`	DMA read Paused State (Indicates that the DMA4 is currently paused and not reading data)
`BCM2838_DMA4_CS_WR_PAUSED = (1 shl 5);`	DMA Write Paused State (Indicates that the DMA4 is currently paused and not writing data)
`BCM2838_DMA4_CS_DREQ_STOPS_DMA = (1 shl 6);`	DMA Paused by DREQ State (This indicates that the DMA4 is currently paused and not transferring data due to the selected DREQ being inactive)
`BCM2838_DMA4_CS_WAITING_FOR_OUTSTANDING_WRITES = (1 shl 7);`	The DMA4 is Waiting for all the Write Response to be returned
Bits 8:9 Reserved
`BCM2838_DMA4_CS_ERROR = (1 shl 10);`	DMA Error (Indicates if the DMA4 has detected an error)
Bits 11:15 Reserved
`BCM2838_DMA4_CS_QOS_MASK = ($F shl 16);`	AXI QOS Level (Sets the QOS level of normal AXI bus transactions)
`BCM2838_DMA4_CS_QOS_DEFAULT = (0 shl 16);`
`BCM2838_DMA4_CS_PANIC_QOS_MASK = ($F shl 20);`	AXI Panic QOS Level (Sets the QOS level of AXI bus transactions when the DMA4 is panicking)
`BCM2838_DMA4_CS_PANIC_QOS_DEFAULT = (0 shl 20);`
`BCM2838_DMA4_CS_DMA_BUSY = (1 shl 24);`	Indicates the DMA4 is BUSY (This indicates that the DMA4 is operating or waiting for outstanding data or otherwise in use)
`BCM2838_DMA4_CS_OUTSTANDING_TRANSACTIONS = (1 shl 25);`	Indicates that there are outstanding AXI transfers, either outstanding read data or outstanding write responses.
Bits 26:27 Reserved
`BCM2838_DMA4_CS_WAIT_FOR_OUTSTANDING_WRITES = (1 shl 28);`	Wait for outstanding writes (The DMA4 keeps a tally of the AXI writes requests going out and the write responses coming in)
`BCM2838_DMA4_CS_DISDEBUG = (1 shl 29);`	Disable Debug Pause Signal (When set to 1, the DMA4 will not pause when the debug pause signal is asserted.)
`BCM2838_DMA4_CS_ABORT = (1 shl 30);`	Abort DMA (Writing a 1 to this bit will cleanly abort the current DMA transfer. The abort will cause the DMA4 to zero its length counters and thus it will complete the current transfer and wait until all outstanding bus activity has finished)
`BCM2838_DMA4_CS_HALT = (1 shl 31);`	Halt DMA (Writing a 1 to this bit will cleanly halt the current DMA transfer. The halt will cause the DMA4 to zero its length counters and thus it will complete the current transfer and wait until all outstanding bus activity has finished.)

[Expand]

BCM2838 DMA4 control block address BCM2838_DMA4_CB_*

[Expand]

BCM2838 DMA4 debug register BCM2838_DMA4_DEBUG_*

See: Section 4

`BCM2838_DMA4_DEBUG_WRITE_ERROR = (1 shl 0);`	Slave Write Response Error
`BCM2838_DMA4_DEBUG_FIFO_ERROR = (1 shl 1);`	FIFO Error
`BCM2838_DMA4_DEBUG_READ_ERROR = (1 shl 2);`	Slave Read Response Error
`BCM2838_DMA4_DEBUG_READ_CB_ERROR = (1 shl 3);`	Slave Read Response Error During Control Block Read
Bits 4:7 Reserved
`BCM2838_DMA4_DEBUG_INT_ON_ERROR = (1 shl 8);`	Generate an interrupt if an error is detected
`BCM2838_DMA4_DEBUG_HALT_ON_ERROR = (1 shl 9);`	Instruct the DMA4 to HALT if it detects an error
`BCM2838_DMA4_DEBUG_ABORT_ON_ERROR = (1 shl 10);`	Instruct the DMA4 to ABORT if it detects an error
`BCM2838_DMA4_DEBUG_DISABLE_CLK_GATE = (1 shl 11);`	Disable the clock gating logic
Bits 12:13 Reserved
`BCM2838_DMA4_DEBUG_R_STATE_MASK = ($F shl 14);`	Read State Machine State (Returns the value of the DMA4 engines read state machine)
`BCM2838_DMA4_DEBUG_R_IDLE = (0 shl 14);`
`BCM2838_DMA4_DEBUG_R_WAIT_CB_DATA = (1 shl 14);`
`BCM2838_DMA4_DEBUG_R_CALC = (2 shl 14);`
`BCM2838_DMA4_DEBUG_R_READ4K = (3 shl 14);`
`BCM2838_DMA4_DEBUG_R_READING = (4 shl 14);`
`BCM2838_DMA4_DEBUG_R_READFIFO_FULL = (5 shl 14);`
`BCM2838_DMA4_DEBUG_R_WAIT_WRITE_COMPLETE = (6 shl 14);`
`BCM2838_DMA4_DEBUG_W_STATE_MASK = ($F shl 18);`	Write State Machine State (Returns the value of the DMA4 engines write state machine)
`BCM2838_DMA4_DEBUG_W_IDLE = (0 shl 18);`
`BCM2838_DMA4_DEBUG_W_PRELOAD = (1 shl 18);`
`BCM2838_DMA4_DEBUG_W_CALC = (2 shl 18);`
`BCM2838_DMA4_DEBUG_W_WRITE4K = (3 shl 18);`
`BCM2838_DMA4_DEBUG_W_READFIFO_EMPTY = (4 shl 18);`
`BCM2838_DMA4_DEBUG_W_WAIT_OUTSTANDING = (5 shl 18);`
Bit 22 Reserved
`BCM2838_DMA4_DEBUG_RESET = (1 shl 23);`	DMA Reset (This is a hard reset of the DMA4 state machine and certain internal registers)
`BCM2838_DMA4_DEBUG_ID_MASK = ($F shl 24);`	ID (Returns the ID of this DMA4. This is also used as the AXI subid.)
`BCM2838_DMA4_DEBUG_VERSION_MASK = ($F shl 28);`	DMA Version (DMA version number, indicating control bit field changes.)

[Expand]

BCM2838 DMA4 transfer information BCM2838_DMA4_TI_*

[Expand]

BCM2838 DMA4 source address BCM2838_DMA4_SRC_ADDR_*

[Expand]

BCM2838 DMA4 source information BCM2838_DMA4_SRCI_*

[Expand]

BCM2838 DMA4 dest address BCM2838_DMA4_DEST_ADDR_*

[Expand]

BCM2838 DMA4 dest information BCM2838_DMA4_DESTI_*

[Expand]

BCM2838 DMA4 transfer length BCM2838_DMA4_LEN_*

[Expand]

BCM2838 DMA4 next control block address BCM2838_DMA4_NEXT_CB_ *

[Expand]

BCM2838 DMA4 Debug BCM2838_DMA4_DEBUG2_*

[Expand]

BCM2838 DMA engine interrupt status BCM2838_DMA_INT_*

[Expand]

BCM2838 DMA engine enable BCM2838_DMA_ENABLE_*

[Expand]

BCM2838 DMA engine DREQ peripheral BCM2838_DMA_DREQ_*

See: Section 4

`BCM2838_DMA_DREQ_NONE = 0;`
`BCM2838_DMA_DREQ_DSI0 = 1;`
`BCM2838_DMA_DREQ_PWM1 = 1;`	The alternate DREQs are available by changing the DMA_CNTRL_MUX bits in the PACTL_CS register
`BCM2838_DMA_DREQ_PCMTX = 2;`
`BCM2838_DMA_DREQ_PCMRX = 3;`
`BCM2838_DMA_DREQ_SMI = 4;`
`BCM2838_DMA_DREQ_PWM0 = 5;`
`BCM2838_DMA_DREQ_SPI0TX = 6;`
`BCM2838_DMA_DREQ_SPI0RX = 7;`
`BCM2838_DMA_DREQ_BSCSPITX = 8;`	BSC/SPI Slave
`BCM2838_DMA_DREQ_BSCSPIRX = 9;`	BSC/SPI Slave
`BCM2838_DMA_DREQ_HDMI0 = 10;`
`BCM2838_DMA_DREQ_EMMC0 = 11;`	SDHCI
`BCM2838_DMA_DREQ_UART0TX = 12;`
`BCM2838_DMA_DREQ_EMMC1 = 13;`	SDHOST
`BCM2838_DMA_DREQ_UART0RX = 14;`
`BCM2838_DMA_DREQ_DSI1 = 15;`
`BCM2838_DMA_DREQ_SPI1TX = 16;`
`BCM2838_DMA_DREQ_HDMI1 = 17;`
`BCM2838_DMA_DREQ_SPI1RX = 18;`
`BCM2838_DMA_DREQ_UART3TX = 19;`
`BCM2838_DMA_DREQ_SPI4TX = 19;`	The alternate DREQs are available by changing the DMA_CNTRL_MUX bits in the PACTL_CS register
`BCM2838_DMA_DREQ_UART3RX = 20;`
`BCM2838_DMA_DREQ_SPI4RX = 20;`	The alternate DREQs are available by changing the DMA_CNTRL_MUX bits in the PACTL_CS register
`BCM2838_DMA_DREQ_UART5TX = 21;`
`BCM2838_DMA_DREQ_SPI5TX = 21;`	The alternate DREQs are available by changing the DMA_CNTRL_MUX bits in the PACTL_CS register
`BCM2838_DMA_DREQ_UART5RX = 22;`
`BCM2838_DMA_DREQ_SPI5RX = 22;`	The alternate DREQs are available by changing the DMA_CNTRL_MUX bits in the PACTL_CS register
`BCM2838_DMA_DREQ_SPI6TX = 23;`
`BCM2838_DMA_DREQ_SCALER_FIFO0 = 24;`	Scaler FIFO 0 & SMI (The SMI element can be disabled by setting the SMI_DISABLE bit in the DMA_DREQ_CONTROL register)
`BCM2838_DMA_DREQ_SCALER_FIFO1 = 25;`	Scaler FIFO 0 & SMI (The SMI element can be disabled by setting the SMI_DISABLE bit in the DMA_DREQ_CONTROL register)
`BCM2838_DMA_DREQ_SCALER_FIFO2 = 26;`	Scaler FIFO 0 & SMI (The SMI element can be disabled by setting the SMI_DISABLE bit in the DMA_DREQ_CONTROL register)
`BCM2838_DMA_DREQ_SPI6RX = 27;`
`BCM2838_DMA_DREQ_UART2TX = 28;`
`BCM2838_DMA_DREQ_UART2RX = 29;`
`BCM2838_DMA_DREQ_UART4TX = 30;`
`BCM2838_DMA_DREQ_UART4RX = 31;`

[Expand]

BCM2838 BSC (I2C0/1/2) control BCM2838_BSC_C_*

[Expand]

BCM2838 BSC (I2C0/1/2) status BCM2838_BSC_S_*

[Expand]

BCM2838 BSC (I2C0/1/2) data length BCM2838_BSC_DLEN_*

[Expand]

BCM2838 BSC (I2C0/1/2) slave address BCM2838_BSC_A_*

[Expand]

BCM2838 BSC (I2C0/1/2) data FIFO BCM2838_BSC_FIFO_*

[Expand]

BCM2838 BSC (I2C0/1/2) clock divider BCM2838_BSC_CDIV_*

[Expand]

BCM2838 BSC (I2C0/1/2) data delay BCM2838_BSC_DEL_*

[Expand]

BCM2838 BSC (I2C0/1/2) clock stretch timeout BCM2838_BSC_CLKT_TOUT_*

[Expand]

BCM2838 SPI0 BCM2838_SPI0_*

See: Section 10.5

`BCM2838_SPI0_CS_LEN_LONG = (1 shl 25);`	Enable Long data word in Lossi mode if DMA_LEN is set (0 = writing to the FIFO will write a single byte / 1 = writing to the FIFO will write a 32 bit word)
`BCM2838_SPI0_CS_DMA_LEN = (1 shl 24);`	Enable DMA mode in Lossi mode
`BCM2838_SPI0_CS_CSPOL2 = (1 shl 23);`	Chip Select 2 Polarity (0 = Chip select is active low / 1 = Chip select is active high)
`BCM2838_SPI0_CS_CSPOL1 = (1 shl 22);`	Chip Select 1 Polarity (0 = Chip select is active low / 1 = Chip select is active high)
`BCM2838_SPI0_CS_CSPOL0 = (1 shl 21);`	Chip Select 0 Polarity (0 = Chip select is active low / 1 = Chip select is active high)
`BCM2838_SPI0_CS_RXF = (1 shl 20);`	RXF - RX FIFO Full (0 = RXFIFO is not full / 1 = RX FIFO is full. No further serial data will be sent/received until data is read from FIFO.)
`BCM2838_SPI0_CS_RXR = (1 shl 19);`	RXR RX FIFO needs Reading (full) (0 = RX FIFO is less than full (or not active TA = 0) / 1 = RX FIFO is or more full. Cleared by reading sufficient data from the RX FIFO or setting TA to 0.)
`BCM2838_SPI0_CS_TXD = (1 shl 18);`	TXD TX FIFO can accept Data (0 = TX FIFO is full and so cannot accept more data / 1 = TX FIFO has space for at least 1 byte)
`BCM2838_SPI0_CS_RXD = (1 shl 17);`	RXD RX FIFO contains Data (0 = RX FIFO is empty / 1 = RX FIFO contains at least 1 byte)
`BCM2838_SPI0_CS_DONE = (1 shl 16);`	DONE Transfer Done (0 = Transfer is in progress (or not active TA = 0) / 1 = Transfer is complete. Cleared by writing more data to the TX FIFO or setting TA to 0.)
`BCM2838_SPI0_CS_TE_EN = (1 shl 15);`	Unused
`BCM2838_SPI0_CS_LMONO = (1 shl 14);`	Unused
`BCM2838_SPI0_CS_LEN = (1 shl 13);`	LEN LoSSI enable (0 = The serial interface will behave as an SPI master / 1 = The serial interface will behave as a LoSSI master)
`BCM2838_SPI0_CS_REN = (1 shl 12);`	REN Read Enable. If this bit is set, the SPI peripheral will be able to send data to this device (0 = We intend to write to the SPI peripheral / 1 = We intend to read from the SPI peripheral)
`BCM2838_SPI0_CS_ADCS = (1 shl 11);`	ADCS Automatically Deassert Chip Select (0 = Don t automatically deassert chip select at the end of a DMA transfer chip select is manually controlled by software / 1 = Automatically deassert chip select at the end of a DMA transfer as determined by SPIDLEN)
`BCM2838_SPI0_CS_INTR = (1 shl 10);`	INTR Interrupt on RXR (0 = Don t generate interrupts on RX FIFO condition / 1 = Generate interrupt while RXR = 1)
`BCM2838_SPI0_CS_INTD = (1 shl 9);`	INTD Interrupt on Done (0 = Don t generate interrupt on transfer complete / 1 = Generate interrupt when DONE = 1)
`BCM2838_SPI0_CS_DMAEN = (1 shl 8);`	DMAEN DMA Enable (0 = No DMA requests will be issued / 1 = Enable DMA operation. Peripheral generates data requests. These will be taken in four-byte words until the SPIDLEN has been reached.
`BCM2838_SPI0_CS_TA = (1 shl 7);`	Transfer Active (0 = Transfer not active / 1 = Transfer active)
`BCM2838_SPI0_CS_CSPOL = (1 shl 6);`	Chip Select Polarity (0 = Chip select lines are active low / 1 = Chip select lines are active high
`BCM2838_SPI0_CS_CLEAR_RX = (1 shl 5);`	CLEAR FIFO Clear (00 = No action / x1 = Clear TX FIFO. One shot operation / 1x = Clear RX FIFO. One shot operation.)
`BCM2838_SPI0_CS_CLEAR_TX = (1 shl 4);`	As above
`BCM2838_SPI0_CS_CPOL = (1 shl 3);`	Clock Polarity (0 = Rest state of clock = low / 1 = Rest state of clock = high)
`BCM2838_SPI0_CS_CPHA = (1 shl 2);`	Clock Phase (0 = First SCLK transition at middle of data bit / 1 = First SCLK transition at beginning of data bit)
`BCM2838_SPI0_CS_CS_0 = (0 shl 0);`	Chip Select (00 = Chip select 0 / 01 = Chip select 1 / 10 = Chip select 2 / 11 = Reserved
`BCM2838_SPI0_CS_CS_1 = (1 shl 0);`	As above
`BCM2838_SPI0_CS_CS_2 = (2 shl 0);`	As above

`BCM2838_SPI0_CS_CS_MASK = (3 shl 0);`

`BCM2838_SPI0_FIFO_DMA_DATA = $FFFFFFFF;`	DMA Mode (DMAEN set) If TA is clear, the first 32-bit write to this register will control SPIDLEN and SPICS. Subsequent reads and writes will be taken as four-byte data words to be read/written to the FIFOs.
`BCM2838_SPI0_FIFO_IRQ_DATA = $000000FF;`	Poll/Interrupt Mode (DMAEN clear, TA set) Writes to the register write bytes to TX FIFO. Reads from register read bytes from the RX FIFO.

`BCM2838_SPI0_CLK_CDIV = $0000FFFF;`	Clock Divider (SCLK = Core Clock / CDIV) If CDIV is set to 0, the divisor is 65536. The divisor must be a multiple of 2. Odd numbers rounded down. The maximum SPI clock rate is of the APB clock.

`BCM2838_SPI0_DLEN_LEN = $0000FFFF;`	Data Length. The number of bytes to transfer. This field is only valid for DMA mode (DMAEN set) and controls how many bytes to transmit (and therefore receive).

`BCM2838_SPI0_LTOH_TOH = $0000000F;`	This sets the Output Hold delay in APB clocks (A value of 0 causes a 1 clock delay)

`BCM2838_SPI0_DC_RPANIC = ($FF shl 24);`	DMA Read Panic Threshold (Generate the Panic signal to the RX DMA engine whenever the RX FIFO level is greater than this amount)
`BCM2838_SPI0_DC_RDREQ = ($FF shl 16);`	DMA Read Request Threshold (Generate A DREQ to the RX DMA engine whenever the RX FIFO level is greater than this amount) (RX DREQ is also generated if thetransfer has finished but the RXFIFO isn't empty)
`BCM2838_SPI0_DC_TPANIC = ($FF shl 8);`	DMA Write Panic Threshold (Generate the Panic signal to the TX DMA engine whenever the TX FIFO level is less than or equal to this amount)
`BCM2838_SPI0_DC_TDREQ = ($FF shl 0);`	DMA Write Request Threshold (Generate a DREQ signal to the TX DMA engine whenever the TX FIFO level is less than or equal to this amount)

[Expand]

BCM2838 I2C/SPI Slave register

[Expand]

BCM2838 AUX (UART1, SPI1 and SPI2) register

[Expand]

BCM2838 PCM/I2S register

[Expand]

BCM2838 PWM control BCM2838_PWM_CTL_*

[Expand]

BCM2838 PWM status BCM2838_PWM_STA_*

[Expand]

BCM2838 PWM DMA configuration BCM2838_PWM_DMAC_*

[Expand]

BCM2838 Pulse Width Modulator (PWM) BCM2838_PWM_ *

[Expand]

BCM2838 PL011 UART data BCM2838_PL011_*

[Expand]

BCM2838 PL011 UART receive status/error clear BCM2838_PL011_RSRECR_*

[Expand]

BCM2838 PL011 UART flag BCM2838_PL011_FR_*

[Expand]

BCM2838 PL011 UART IrDA

[Expand]

BCM2838 PL011 UART integer baud rate divisor BCM2838_PL011_IBRD_*

[Expand]

BCM2838 PL011 UART fractional baud rate divisor BCM2838_PL011_FBRD_*

[Expand]

BCM2838 PL011 UART line control BCM2838_PL011_LCRH_*

[Expand]

BCM2838 PL011 UART control BCM2838_PL011_CR_*

[Expand]

BCM2838 PL011 UART interrupt FIFO level select BCM2838_PL011_IFLS_*

[Expand]

BCM2838 PL011 UART interrupt mask set/clear BCM2838_PL011_IMSC_*

[Expand]

BCM2838 PL011 UART raw interrupt status BCM2838_PL011_RIS_*

[Expand]

BCM2838 PL011 UART masked interrupt status BCM2838_PL011_MIS_*

[Expand]

BCM2838 PL011 UART interrupt clear BCM2838_PL011_ICR_*

[Expand]

BCM2838 PL011 UART DMA control

[Expand]

BCM2838 PL011 UART test control

[Expand]

BCM2838 PL011 UART integration test input

[Expand]

BCM2838 PL011 UART integration test output

[Expand]

BCM2838 PL011 UART test data

[Expand]

BCM2838 ARM legacy interrupt controller BCM2838_ARM_INTERRUPT_*

`BCM2838_ARM_INTERRUPT_IRQ0_PENDING0 = $00000000;`	ARM Core 0 IRQ Enabled Interrupt Pending bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ0_PENDING1 = $00000004;`	ARM Core 0 IRQ Enabled Interrupt pending bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ0_PENDING2 = $00000008;`	ARM Core 0 IRQ Enabled Interrupt pending bits [79:64]
`BCM2838_ARM_INTERRUPT_IRQ0_SET_EN_0 = $00000010;`	Write to Set ARM Core 0 IRQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ0_SET_EN_1 = $00000014;`	Write to Set ARM Core 0 IRQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ0_SET_EN_2 = $00000018;`	Write to Set ARM Core 0 IRQ enable bits [79:64]
`BCM2838_ARM_INTERRUPT_IRQ0_CLR_EN_0 = $00000020;`	Write to Clear ARM Core 0 IRQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ0_CLR_EN_1 = $00000024;`	Write to Clear ARM Core 0 IRQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ0_CLR_EN_2 = $00000028;`	Write to Clear ARM Core 0 IRQ enable bits [79:64]
`BCM2838_ARM_INTERRUPT_IRQ_STATUS0 = $00000030;`	Interrupt Line bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ_STATUS1 = $00000034;`	Interrupt Line bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ_STATUS2 = $00000038;`	Interrupt Line bits [79:64]

`BCM2838_ARM_INTERRUPT_IRQ1_PENDING0 = $00000040;`	ARM Core 1 IRQ Enabled Interrupt pending bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ1_PENDING1 = $00000044;`	ARM Core 1 IRQ Enabled Interrupt pending bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ1_PENDING2 = $00000048;`	ARM Core 1 IRQ Enabled Interrupt pending bits [79:64]
`BCM2838_ARM_INTERRUPT_IRQ1_SET_EN_0 = $00000050;`	Write to Set ARM Core 1 IRQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ1_SET_EN_1 = $00000054;`	Write to Set ARM Core 1 IRQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ1_SET_EN_2 = $00000058;`	Write to Set ARM Core 1 IRQ enable bits [79:64]
`BCM2838_ARM_INTERRUPT_IRQ1_CLR_EN_0 = $00000060;`	Write to Clear ARM Core 1 IRQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ1_CLR_EN_1 = $00000064;`	Write to Clear ARM Core 1 IRQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ1_CLR_EN_2 = $00000068;`	Write to Clear ARM Core 1 IRQ enable bits [79:64]

`BCM2838_ARM_INTERRUPT_IRQ2_PENDING0 = $00000080;`	ARM Core 2 IRQ Enabled Interrupt pending bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ2_PENDING1 = $00000084;`	ARM Core 2 IRQ Enabled Interrupt pending bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ2_PENDING2 = $00000088;`	ARM Core 2 IRQ Enabled Interrupt pending bits [79:64]
`BCM2838_ARM_INTERRUPT_IRQ2_SET_EN_0 = $00000090;`	Write to Set ARM Core 2 IRQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ2_SET_EN_1 = $00000094;`	Write to Set ARM Core 2 IRQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ2_SET_EN_2 = $00000098;`	Write to Set ARM Core 2 IRQ enable bits [79:64]
`BCM2838_ARM_INTERRUPT_IRQ2_CLR_EN_0 = $000000A0;`	Write to Clear ARM Core 2 IRQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ2_CLR_EN_1 = $000000A4;`	Write to Clear ARM Core 2 IRQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ2_CLR_EN_2 = $000000A8;`	Write to Clear ARM Core 2 IRQ enable bits [79:64]

`BCM2838_ARM_INTERRUPT_IRQ3_PENDING0 = $000000C0;`	ARM Core 3 IRQ Enabled Interrupt pending bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ3_PENDING1 = $000000C4;`	ARM Core 3 IRQ Enabled Interrupt pending bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ3_PENDING2 = $000000C8;`	ARM Core 3 IRQ Enabled Interrupt pending bits [79:64]
`BCM2838_ARM_INTERRUPT_IRQ3_SET_EN_0 = $000000D0;`	Write to Set ARM Core 3 IRQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ3_SET_EN_1 = $000000D4;`	Write to Set ARM Core 3 IRQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ3_SET_EN_2 = $000000D8;`	Write to Set ARM Core 3 IRQ enable bits [79:64]
`BCM2838_ARM_INTERRUPT_IRQ3_CLR_EN_0 = $000000E0;`	Write to Clear ARM Core 3 IRQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_IRQ3_CLR_EN_1 = $000000E4;`	Write to Clear ARM Core 3 IRQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_IRQ3_CLR_EN_2 = $000000E8;`	Write to Clear ARM Core 3 IRQ enable bits [79:64]

`BCM2838_ARM_INTERRUPT_FIQ0_PENDING0 = $00000100;`	ARM Core 0 FIQ Enabled Interrupt pending bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ0_PENDING1 = $00000104;`	ARM Core 0 FIQ Enabled Interrupt pending bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ0_PENDING2 = $00000108;`	ARM Core 0 FIQ Enabled Interrupt pending bits [79:64]
`BCM2838_ARM_INTERRUPT_FIQ0_SET_EN_0 = $00000110;`	Write to Set ARM Core 0 FIQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ0_SET_EN_1 = $00000114;`	Write to Set ARM Core 0 FIQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ0_SET_EN_2 = $00000118;`	Write to Set ARM Core 0 FIQ enable bits [79:64]
`BCM2838_ARM_INTERRUPT_FIQ0_CLR_EN_0 = $00000120;`	Write to Clear ARM Core 0 FIQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ0_CLR_EN_1 = $00000124;`	Write to Clear ARM Core 0 FIQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ0_CLR_EN_2 = $00000128;`	Write to Clear ARM Core 0 FIQ enable bits [79:64]

`BCM2838_ARM_INTERRUPT_FIQ1_PENDING0 = $00000140;`	ARM Core 1 FIQ Enabled Interrupt pending bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ1_PENDING1 = $00000144;`	ARM Core 1 FIQ Enabled Interrupt pending bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ1_PENDING2 = $00000148;`	ARM Core 1 FIQ Enabled Interrupt pending bits [79:64]
`BCM2838_ARM_INTERRUPT_FIQ1_SET_EN_0 = $00000150;`	Write to Set ARM Core 1 FIQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ1_SET_EN_1 = $00000154;`	Write to Set ARM Core 1 FIQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ1_SET_EN_2 = $00000158;`	Write to Set ARM Core 1 FIQ enable bits [79:64]
`BCM2838_ARM_INTERRUPT_FIQ1_CLR_EN_0 = $00000160;`	Write to Clear ARM Core 1 FIQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ1_CLR_EN_1 = $00000164;`	Write to Clear ARM Core 1 FIQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ1_CLR_EN_2 = $00000168;`	Write to Clear ARM Core 1 FIQ enable bits [79:64]

`BCM2838_ARM_INTERRUPT_FIQ2_PENDING0 = $00000180;`	ARM Core 2 FIQ Enabled Interrupt pending bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ2_PENDING1 = $00000184;`	ARM Core 2 FIQ Enabled Interrupt pending bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ2_PENDING2 = $00000188;`	ARM Core 2 FIQ Enabled Interrupt pending bits [79:64]
`BCM2838_ARM_INTERRUPT_FIQ2_SET_EN_0 = $00000190;`	Write to Set ARM Core 2 FIQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ2_SET_EN_1 = $00000194;`	Write to Set ARM Core 2 FIQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ2_SET_EN_2 = $00000198;`	Write to Set ARM Core 2 FIQ enable bits [79:64]
`BCM2838_ARM_INTERRUPT_FIQ2_CLR_EN_0 = $000001A0;`	Write to Clear ARM Core 2 FIQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ2_CLR_EN_1 = $000001A4;`	Write to Clear ARM Core 2 FIQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ2_CLR_EN_2 = $000001A8;`	Write to Clear ARM Core 2 FIQ enable bits [79:64]

`BCM2838_ARM_INTERRUPT_FIQ3_PENDING0 = $000001C0;`	ARM Core 3 FIQ Enabled Interrupt pending bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ3_PENDING1 = $000001C4;`	ARM Core 3 FIQ Enabled Interrupt pending bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ3_PENDING2 = $000001C8;`	ARM Core 3 FIQ Enabled Interrupt pending bits [79:64]
`BCM2838_ARM_INTERRUPT_FIQ3_SET_EN_0 = $000001D0;`	Write to Set ARM Core 3 FIQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ3_SET_EN_1 = $000001D4;`	Write to Set ARM Core 3 FIQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ3_SET_EN_2 = $000001D8;`	Write to Set ARM Core 3 FIQ enable bits [79:64]
`BCM2838_ARM_INTERRUPT_FIQ3_CLR_EN_0 = $000001E0;`	Write to Clear ARM Core 3 FIQ enable bits [31:0]
`BCM2838_ARM_INTERRUPT_FIQ3_CLR_EN_1 = $000001E4;`	Write to Clear ARM Core 3 FIQ enable bits [63:32]
`BCM2838_ARM_INTERRUPT_FIQ3_CLR_EN_2 = $000001E8;`	Write to Clear ARM Core 3 FIQ enable bits [79:64]

`BCM2838_ARM_INTERRUPT_SWIRQ_SET = $000001F0;`	Write to Set Software Interrupt sources
`BCM2838_ARM_INTERRUPT_SWIRQ_CLEAR = $000001F4;`	Write to Clear Software Interrupt sources

`BCM2838_ARM_INTERRUPT_CORE_OFFSET = BCM2838_ARM_INTERRUPT_IRQ1_PENDING0 - BCM2838_ARM_INTERRUPT_IRQ0_PENDING0;`	Offset between Core registers
`BCM2838_ARM_INTERRUPT_FIQ_OFFSET = BCM2838_ARM_INTERRUPT_FIQ0_PENDING0 - BCM2838_ARM_INTERRUPT_IRQ0_PENDING0;`	Offset betwwen IRQ and FIQ registers

[Expand]

BCM2838 ARM timer BCM2838_ARM_TIMER_*

[Expand]

BCM2838 power management, reset controller and watchdog BCM2838_PM_*

[Expand]

BCM2838 random number generator BCM2838_RNG_*

[Expand]

BCM2838 clock management BCM2838_CM_*

[Expand]

BCM2838 clock manager control BCM2838_CM_CTL_*

[Expand]

BCM2838 clock manager divisor BCM2838_CM_DIV_*

[Expand]

BCM2838 clock manager BCM2838_CM_*

`BCM2838_CM_GNRICCTL = $00000000;`	Generic Clock Control
`BCM2838_CM_GNRICDIV = $00000004;`	Generic Clock Divisor
`BCM2838_CM_VPUCTL = $00000008;`	VPU Clock Control
`BCM2838_CM_VPUDIV = $0000000C;`	VPU Clock Divisor
`BCM2838_CM_SYSCTL = $00000010;`	System Clock Control
`BCM2838_CM_SYSDIV = $00000014;`	System Clock Divisor
`BCM2838_CM_PERIACTL = $00000018;`	PERIA Clock Control
`BCM2838_CM_PERIADIV = $0000001C;`	PERIA Clock Divisor
`BCM2838_CM_PERIICTL = $00000020;`	PERII Clock Control
`BCM2838_CM_PERIIDIV = $00000024;`	PERII Clock Divisor
`BCM2838_CM_H264CTL = $00000028;`	H264 Clock Control
`BCM2838_CM_H264DIV = $0000002C;`	H264 Clock Divisor
`BCM2838_CM_ISPCTL = $00000030;`	ISP Clock Control
`BCM2838_CM_ISPDIV = $00000034;`	ISP Clock Divisor
`BCM2838_CM_V3DCTL = $00000038;`	V3D Clock Control
`BCM2838_CM_V3DDIV = $0000003C;`	V3D Clock Divisor
`BCM2838_CM_CAM0CTL = $00000040;`	Camera 0 Clock Control
`BCM2838_CM_CAM0DIV = $00000044;`	Camera 0 Clock Divisor
`BCM2838_CM_CAM1CTL = $00000048;`	Camera 1 Clock Control
`BCM2838_CM_CAM1DIV = $0000004C;`	Camera 1 Clock Divisor
`BCM2838_CM_CCP2CTL = $00000050;`	CCP2 Clock Control
`BCM2838_CM_CCP2DIV = $00000054;`	CCP2 Clock Divisor
`BCM2838_CM_DSI0ECTL = $00000058;`	DSI0E Clock Control
`BCM2838_CM_DSI0EDIV = $0000005C;`	DSI0E Clock Divisor
`BCM2838_CM_DSI0PCTL = $00000060;`	DSI0P Clock Control
`BCM2838_CM_DSI0PDIV = $00000064;`	DSI0P Clock Divisor
`BCM2838_CM_DPICTL = $00000068;`	DPI Clock Control
`BCM2838_CM_DPIDIV = $0000006C;`	DPI Clock Divisor
`BCM2838_CM_GP0CTL = $00000070;`	General Purpose 0 Clock Control
`BCM2838_CM_GP0DIV = $00000074;`	General Purpose 0 Clock Divisor
`BCM2838_CM_GP1CTL = $00000078;`	General Purpose 1 Clock Control
`BCM2838_CM_GP1DIV = $0000007C;`	General Purpose 1 Clock Divisor
`BCM2838_CM_GP2CTL = $00000080;`	General Purpose 2 Clock Control
`BCM2838_CM_GP2DIV = $00000084;`	General Purpose 2 Clock Divisor
`BCM2838_CM_HSMCTL = $00000088;`	HSM Clock Control
`BCM2838_CM_HSMDIV = $0000008C;`	HSM Clock Divisor
`BCM2838_CM_OTPCTL = $00000090;`	OTP Clock Control
`BCM2838_CM_OTPDIV = $00000094;`	OTP Clock Divisor
`BCM2838_CM_PCMCTL = $00000098;`	PCM / I2S Clock Control
`BCM2838_CM_PCMDIV = $0000009C;`	PCM / I2S Clock Divisor
`BCM2838_CM_PWMCTL = $000000A0;`	PWM Clock Control
`BCM2838_CM_PWMDIV = $000000A4;`	PWM Clock Divisor
`BCM2838_CM_SLIMCTL = $000000A8;`	SLIM Clock Control
`BCM2838_CM_SLIMDIV = $000000AC;`	SLIM Clock Divisor
`BCM2838_CM_SMICTL = $000000B0;`	SMI Clock Control
`BCM2838_CM_SMIDIV = $000000B4;`	SMI Clock Divisor
`BCM2838_CM_TCNTCTL = $000000C0;`	TCNT Clock Control
`BCM2838_CM_TCNTDIV = $000000C4;`	TCNT Clock Divisor
`BCM2838_CM_TECCTL = $000000C8;`	TEC Clock Control
`BCM2838_CM_TECDIV = $000000CC;`	TEC Clock Divisor
`BCM2838_CM_TD0CTL = $000000D0;`	TD0 Clock Control
`BCM2838_CM_TD0DIV = $000000D4;`	TD0 Clock Divisor
`BCM2838_CM_TD1CTL = $000000D8;`	TD1 Clock Control
`BCM2838_CM_TD1DIV = $000000DC;`	TD1 Clock Divisor
`BCM2838_CM_TSENSCTL = $000000E0;`	TSENS Clock Control
`BCM2838_CM_TSENSDIV = $000000E4;`	TSENS Clock Divisor
`BCM2838_CM_TIMERCTL = $000000E8;`	Timer Clock Control
`BCM2838_CM_TIMERDIV = $000000EC;`	Timer Clock Divisor
`BCM2838_CM_UARTCTL = $000000F0;`	UART Clock Control
`BCM2838_CM_UARTDIV = $000000F4;`	UART Clock Divisor
`BCM2838_CM_VECCTL = $000000F8;`	VEC Clock Control
`BCM2838_CM_VECDIV = $000000FC;`	VEC Clock Divisor

`BCM2838_CM_OSCCOUNT = $00000100;`	Oscillator Count
`BCM2838_CM_PLLA = $00000104;`	PLLA
`BCM2838_CM_PLLC = $00000108;`	PLLC
`BCM2838_CM_PLLD = $0000010C;`	PLLD
`BCM2838_CM_PLLH = $00000110;`	PLLH
`BCM2838_CM_LOCK = $00000114;`	Lock
`BCM2838_CM_EVENT = $00000118;`	Event
`BCM2838_CM_INTEN = $00000118;`	INTEN
`BCM2838_CM_DSI0HSCK = $00000120;`	DSI0HSCK
`BCM2838_CM_CKSM = $00000124;`	CKSM
`BCM2838_CM_OSCFREQI = $00000128;`	Oscillator Frequency Integer
`BCM2838_CM_OSCFREQF = $0000012C;`	Oscillator Frequency Fraction
`BCM2838_CM_PLLTCTL = $00000130;`	PLLT Control
`BCM2838_CM_PLLTCNT0 = $00000134;`	PLLT0 Count
`BCM2838_CM_PLLTCNT1 = $00000138;`	PLLT1 Count
`BCM2838_CM_PLLTCNT2 = $0000013C;`	PLLT2 Count
`BCM2838_CM_PLLTCNT3 = $00000140;`	PLLT3 Count
`BCM2838_CM_TDCLKEN = $00000144;`	TD Clock Enable
`BCM2838_CM_BURSTCTL = $00000148;`	Burst Control
`BCM2838_CM_BURSTCNT = $0000014C;`	Burst Count
`BCM2838_CM_DSI1ECTL = $00000158;`	DSI1E Clock Control
`BCM2838_CM_DSI1EDIV = $0000015C;`	DSI1E Clock Divisor
`BCM2838_CM_DSI1PCTL = $00000160;`	DSI1P Clock Control
`BCM2838_CM_DSI1PDIV = $00000164;`	DSI1P Clock Divisor
`BCM2838_CM_DFTCTL = $00000168;`	DFT Clock Control
`BCM2838_CM_DFTDIV = $0000016C;`	DFT Clock Divisor
`BCM2838_CM_PLLB = $00000170;`	PLLB

`BCM2838_CM_PULSECTL = $00000190;`	Pulse Clock Control
`BCM2838_CM_PULSEDIV = $00000194;`	Pulse Clock Divisor
`BCM2838_CM_SDCCTL = $000001A8;`	SDC Clock Control
`BCM2838_CM_SDCDIV = $000001AC;`	SDC Clock Divisor
`BCM2838_CM_ARMCTL = $000001B0;`	ARM Clock Control
`BCM2838_CM_ARMDIV = $000001B4;`	ARM Clock Divisor
`BCM2838_CM_AVEOCTL = $000001B8;`	AVEO Clock Control
`BCM2838_CM_AVEODIV = $000001BC;`	AVEO Clock Divisor
`BCM2838_CM_EMMCCTL = $000001C0;`	EMMC Clock Control
`BCM2838_CM_EMMCDIV = $000001C4;`	EMMC Clock Divisor

[Expand]

BCM2838 mailbox BCM2838_MAILBOX_*

[Expand]

BCM2838 mailbox 0 channel BCM2838_MAILBOX0_CHANNEL_*

[Expand]

BCM2838 mailbox 1 channel BCM2838_MAILBOX_*_MASK*

[Expand]

BCM2838 mailbox status flag BCM2838_MAILBOX_STATUS_*

[Expand]

BCM2838 mailbox configuration flag BCM2838_MAILBOX_CONFIG_*

[Expand]

BCM2838 mailbox property tag BCM2838_MBOX_TAG_GET_*

See: https://github.com/raspberrypi/firmware/wiki/Mailbox-property-interface or \include\soc\bcm2835\raspberrypi-firmware.h

VideoCore
`BCM2838_MBOX_TAG_GET_FIRMWARE_REV = $00000001;`
Hardware
`BCM2838_MBOX_TAG_GET_BOARD_MODEL = $00010001;`
`BCM2838_MBOX_TAG_GET_BOARD_REV = $00010002;`

`BCM2838_MBOX_TAG_GET_MAC_ADDRESS = $00010003;`

`BCM2838_MBOX_TAG_GET_BOARD_SERIAL = $00010004;`

`BCM2838_MBOX_TAG_GET_ARM_MEMORY = $00010005;`
`BCM2838_MBOX_TAG_GET_VC_MEMORY = $00010006;`

`BCM2838_MBOX_TAG_GET_CLOCKS = $00010007;`
Shared Resource Management
`BCM2838_MBOX_TAG_GET_POWER_STATE = $00020001;`	Response indicates current state
`BCM2838_MBOX_TAG_GET_TIMING = $00020002;`	Response indicates wait time required after turning a device on before power is stable
`BCM2838_MBOX_TAG_SET_POWER_STATE = $00028001;`	Response indicates new state, with/without waiting for the power to become stable.

`BCM2838_MBOX_TAG_GET_CLOCK_STATE = $00030001;`
`BCM2838_MBOX_TAG_SET_CLOCK_STATE = $00038001;`

`BCM2838_MBOX_TAG_GET_CLOCK_RATE = $00030002;`
`BCM2838_MBOX_TAG_SET_CLOCK_RATE = $00038002;`

`BCM2838_MBOX_TAG_GET_CLOCK_MAX_RATE = $00030004;`	Return the maximum supported clock rate for the given clock. Clocks should not be set higher than this.
`BCM2838_MBOX_TAG_GET_CLOCK_MIN_RATE = $00030007;`	Return the minimum supported clock rate for the given clock. This may be used when idle.

`BCM2838_MBOX_TAG_GET_TURBO = $00030009;`	Get the turbo state for index id. id should be 0. level will be zero for non-turbo and one for turbo.
`BCM2838_MBOX_TAG_SET_TURBO = $00038009;`	Set the turbo state for index id. id should be zero. level will be zero for non-turbo and one for turbo. This will cause GPU clocks to be set to maximum when enabled and minimum when disabled.

`BCM2838_MBOX_TAG_GET_STC = $0003000b;`
Voltage
`BCM2838_MBOX_TAG_GET_VOLTAGE = $00030003;`	The voltage value may be clamped to the supported range. A value of 0x80000000 means the id was not valid.
`BCM2838_MBOX_TAG_SET_VOLTAGE = $00038003;`	The voltage value may be clamped to the supported range. A value of 0x80000000 means the id was not valid.

`BCM2838_MBOX_TAG_GET_MAX_VOLTAGE = $00030005;`	Return the maximum supported voltage rate for the given id. Voltages should not be set higher than this.
`BCM2838_MBOX_TAG_GET_MIN_VOLTAGE = $00030008;`	Return the minimum supported voltage rate for the given id. This may be used when idle.
`BCM2838_MBOX_TAG_GET_TEMP = $00030006;`	Return the temperature of the SoC in thousandths of a degree C. id should be zero.
`BCM2838_MBOX_TAG_GET_MAX_TEMP = $0003000a;`	Return the maximum safe temperature of the SoC in thousandths of a degree C. id should be zero. Overclock may be disabled above this temperature.
GPU
`BCM2838_MBOX_TAG_ALLOCATE_MEMORY = $0003000c;`	Allocates contiguous memory on the GPU. size and alignment are in bytes.
`BCM2838_MBOX_TAG_LOCK_MEMORY = $0003000d;`	Lock buffer in place, and return a bus address. Must be done before memory can be accessed.
`BCM2838_MBOX_TAG_UNLOCK_MEMORY = $0003000e;`	Unlock buffer. It retains contents, but may move. Needs to be locked before next use. status=0 is success.
`BCM2838_MBOX_TAG_RELEASE_MEMORY = $0003000f;`	Free the memory buffer. status=0 is success.

`BCM2838_MBOX_TAG_EXECUTE_CODE = $00030010;`	Calls the function at given (bus) address and with arguments given. E.g. r0 = fn(r0, r1, r2, r3, r4, r5); It blocks until call completes
`BCM2838_MBOX_TAG_EXECUTE_QPU = $00030011;`	Execute an assembled block of code using one or more Quad Processing Units (QPUs)
`BCM2838_MBOX_TAG_ENABLE_QPU = $00030012;`	Enable the Quad Processing Units (QPUs)

`BCM2838_MBOX_TAG_GET_DISPMANX_HANDLE = $00030014;`	Gets the mem_handle associated with a created dispmanx resource. This can be locked and the memory directly written from the arm to avoid having to copy the image data to GPU.
`BCM2838_MBOX_TAG_GET_EDID_BLOCK = $00030020;`	This reads the specified EDID block from attached HDMI/DVI device. There will always be at least one block of 128 bytes, but there may be additional blocks. You should keep requesting blocks (starting from 0) until the status returned is non-zero.

`BCM2838_MBOX_TAG_GET_CUSTOMER_OTP = $00030021;`
`BCM2838_MBOX_TAG_SET_CUSTOMER_OTP = $00038021;`

`BCM2838_MBOX_TAG_GET_DOMAIN_STATE = $00030030;`
`BCM2838_MBOX_TAG_SET_DOMAIN_STATE = $00038030;`

`BCM2838_MBOX_TAG_GET_GPIO_STATE = $00030041;`	Get the current state of a GPIO expander pin
`BCM2838_MBOX_TAG_SET_GPIO_STATE = $00038041;`	Set the current state of a GPIO expander pin

`BCM2838_MBOX_TAG_SET_SDHOST_CLOCK = $00038042;`	Tell the firmware the SD Host clock setting so it will be adjusted for changes in core frequency

`BCM2838_MBOX_TAG_GET_GPIO_CONFIG = $00030043;`	Get the current configuration of a GPIO expander pin
`BCM2838_MBOX_TAG_SET_GPIO_CONFIG = $00038043;`	Set the current configuration of a GPIO expander pin

`BCM2838_MBOX_TAG_GET_THROTTLED = $00030046;`

`BCM2838_MBOX_TAG_GET_PERIPH_REG = $00030045;`
`BCM2838_MBOX_TAG_SET_PERIPH_REG = $00038045;`
Frame Buffer
`BCM2838_MBOX_TAG_ALLOCATE_BUFFER = $00040001;`	If the requested alignment is unsupported then the current base and size (which may be 0 if not allocated) is returned and no change occurs
`BCM2838_MBOX_TAG_RELEASE_BUFFER = $00048001;`	Releases and disables the frame buffer

`BCM2838_MBOX_TAG_SET_BLANK_SCREEN = $00040002;`
`BCM2838_MBOX_TAG_TST_BLANK_SCREEN = $00044002;`

`BCM2838_MBOX_TAG_GET_PHYSICAL_W_H = $00040003;`	Note that the "physical (display)" size is the size of the allocated buffer in memory, not the resolution of the video signal sent to the display device.
`BCM2838_MBOX_TAG_TEST_PHYSICAL_W_H = $00044003;`
`BCM2838_MBOX_TAG_SET_PHYSICAL_W_H = $00048003;`

`BCM2838_MBOX_TAG_GET_VIRTUAL_W_H = $00040004;`	Note that the "virtual (buffer)" size is the portion of buffer that is sent to the display device, not the resolution the buffer itself. This may be smaller than the allocated buffer size in order to implement panning.
`BCM2838_MBOX_TAG_TEST_VIRTUAL_W_H = $00044004;`
`BCM2838_MBOX_TAG_SET_VIRTUAL_W_H = $00048004;`

`BCM2838_MBOX_TAG_GET_DEPTH = $00040005;`
`BCM2838_MBOX_TAG_TEST_DEPTH = $00044005;`
`BCM2838_MBOX_TAG_SET_DEPTH = $00048005;`

`BCM2838_MBOX_TAG_GET_PIXEL_ORDER = $00040006;`
`BCM2838_MBOX_TAG_TEST_PIXEL_ORDER = $00044006;`
`BCM2838_MBOX_TAG_SET_PIXEL_ORDER = $00048006;`

`BCM2838_MBOX_TAG_GET_ALPHA_MODE = $00040007;`
`BCM2838_MBOX_TAG_TEST_ALPHA_MODE = $00044007;`
`BCM2838_MBOX_TAG_SET_ALPHA_MODE = $00048007;`

`BCM2838_MBOX_TAG_GET_PITCH = $00040008;`
`BCM2838_MBOX_TAG_TST_PITCH = $00044008;`
`BCM2838_MBOX_TAG_SET_PITCH = $00048008;`

`BCM2838_MBOX_TAG_GET_VIRTUAL_OFFSET = $00040009;`	Offset of physical display window within virtual buffer
`BCM2838_MBOX_TAG_TEST_VIRTUAL_OFFSET = $00044009;`
`BCM2838_MBOX_TAG_SET_VIRTUAL_OFFSET = $00048009;`

`BCM2838_MBOX_TAG_GET_OVERSCAN = $0004000a;`
`BCM2838_MBOX_TAG_TEST_OVERSCAN = $0004400a;`
`BCM2838_MBOX_TAG_SET_OVERSCAN = $0004800a;`

`BCM2838_MBOX_TAG_GET_PALETTE = $0004000b;`
`BCM2838_MBOX_TAG_TEST_PALETTE = $0004400b;`
`BCM2838_MBOX_TAG_SET_PALETTE = $0004800b;`

`BCM2838_MBOX_TAG_GET_TOUCHBUF = $0004000f;`
`BCM2838_MBOX_TAG_SET_TOUCHBUF = $0004801f;`

`BCM2838_MBOX_TAG_GET_GPIOVIRTBUF = $00040010;`
`BCM2838_MBOX_TAG_SET_GPIOVIRTBUF = $00048020;`

`BCM2838_MBOX_TAG_GET_LAYER = $0004000c;`
`BCM2838_MBOX_TAG_TST_LAYER = $0004400c;`
`BCM2838_MBOX_TAG_SET_LAYER = $0004800c;`

`BCM2838_MBOX_TAG_GET_TRANSFORM = $0004000d;`
`BCM2838_MBOX_TAG_TST_TRANSFORM = $0004400d;`
`BCM2838_MBOX_TAG_SET_TRANSFORM = $0004800d;`

`BCM2838_MBOX_TAG_TST_VSYNC = $0004400e;`
`BCM2838_MBOX_TAG_SET_VSYNC = $0004800e;`

`BCM2838_MBOX_TAG_SET_BACKLIGHT = $0004800f;`

`BCM2838_MBOX_TAG_GET_DISPLAY_ID = $00040016;`
`BCM2838_MBOX_TAG_SET_DISPLAY_NUM = $00048013;`
`BCM2838_MBOX_TAG_GET_NUM_DISPLAYS = $00040013;`
`BCM2838_MBOX_TAG_GET_DISPLAY_SETTINGS = $00040014;`

`BCM2838_MBOX_TAG_SET_PLANE = $00048015;`
`BCM2838_MBOX_TAG_GET_DISPLAY_TIMING = $00040017;`
`BCM2838_MBOX_TAG_SET_TIMING = $00048017;`
`BCM2838_MBOX_TAG_GET_DISPLAY_CFG = $00040018;`
`BCM2838_MBOX_TAG_SET_DISPLAY_POWER = $00048019;`

`BCM2838_MBOX_TAG_SET_CURSOR_INFO = $00008010;`	00008011 These were reversed in the documentation, see Linux \include\soc\bcm2835\raspberrypi-firmware.h
`BCM2838_MBOX_TAG_SET_CURSOR_STATE = $00008011;`	00008010
VCHIQ
`BCM2838_MBOX_TAG_VCHIQ_INIT = $00048010;`
Config
`BCM2838_MBOX_TAG_GET_COMMAND_LINE = $00050001;`
Shared Resource Management
`BCM2838_MBOX_TAG_GET_DMA_CHANNELS = $00060001;`	Caller assumes that the VC has enabled all the usable DMA channels
End
`BCM2838_MBOX_TAG_END = $00000000;`

[Expand]

BCM2838 mailbox board revision value BCM2838_BOARD_REV_*

[Expand]

BCM2838 mailbox board revision BCM2838_BOARD_REVISION_*

See: https://www.raspberrypi.org/documentation/hardware/raspberrypi/revision-codes/README.md

`BCM2838_BOARD_REVISION_PCB_MASK = ($F shl 0);`	PCB Revision Number

`BCM2838_BOARD_REVISION_MODEL_MASK = ($FF shl 4);`	Model Number
`BCM2838_BOARD_REVISION_MODEL_A = (0 shl 4);`	Model A (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_B = (1 shl 4);`	Model B (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_APLUS = (2 shl 4);`	Model A+ (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_BPLUS = (3 shl 4);`	Model B+ (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_2B = (4 shl 4);`	Model 2B (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_ALPHA = (5 shl 4);`	Unknown
`BCM2838_BOARD_REVISION_MODEL_COMPUTE = (6 shl 4);`	Compute Module (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_UNKNOWN = (7 shl 4);`	Unknown
`BCM2838_BOARD_REVISION_MODEL_3B = (8 shl 4);`	Model 3B (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_ZERO = (9 shl 4);`	Model Zero (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_COMPUTE3 = (10 shl 4);`	Compute Module 3 (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_UNKNOWN_2 = (11 shl 4);`	Unknown
`BCM2838_BOARD_REVISION_MODEL_ZERO_W = (12 shl 4);`	Model Zero W (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_3BPLUS = (13 shl 4);`	Model 3B+ (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_3APLUS = (14 shl 4);`	Model 3A+ (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_COMPUTE3PLUS = (16 shl 4);`	Compute Module 3+ (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_MODEL_4B = (17 shl 4);`	Model 4B
`BCM2838_BOARD_REVISION_MODEL_400 = (19 shl 4);`	Pi 400
`BCM2838_BOARD_REVISION_MODEL_CM4 = (20 shl 4);`	Compute Module 4

`BCM2838_BOARD_REVISION_PROCESSOR_MASK = ($F shl 12);`	Processor Type
`BCM2838_BOARD_REVISION_PROCESSOR_BCM2835 = (0 shl 12);`	BCM2835 (Cannot occur on BCM2838)
`BCM2838_BOARD_REVISION_PROCESSOR_BCM2836 = (1 shl 12);`	BCM2836
`BCM2838_BOARD_REVISION_PROCESSOR_BCM2837 = (2 shl 12);`	BCM2837
`BCM2838_BOARD_REVISION_PROCESSOR_BCM2838 = (3 shl 12);`	BCM2838

`BCM2838_BOARD_REVISION_MANUFACTURER_MASK = ($F shl 16);`	Manufacturer
`BCM2838_BOARD_REVISION_MANUFACTURER_SONY = (0 shl 16);`	Sony
`BCM2838_BOARD_REVISION_MANUFACTURER_EGOMAN = (1 shl 16);`	Egoman
`BCM2838_BOARD_REVISION_MANUFACTURER_EMBEST = (2 shl 16);`	Embest
`BCM2838_BOARD_REVISION_MANUFACTURER_SONY_JAPAN = (3 shl 16);`	Sony (Japan)
`BCM2838_BOARD_REVISION_MANUFACTURER_EMBEST2 = (4 shl 16);`	Embest
`BCM2838_BOARD_REVISION_MANUFACTURER_STADIUM = (5 shl 16);`	Stadium

`BCM2838_BOARD_REVISION_MEMORY_MASK = ($7 shl 20);`	Memory Size
`BCM2838_BOARD_REVISION_MEMORY_256M = (0 shl 20);`	256M
`BCM2838_BOARD_REVISION_MEMORY_512M = (1 shl 20);`	512M
`BCM2838_BOARD_REVISION_MEMORY_1024M = (2 shl 20);`	1024M
`BCM2838_BOARD_REVISION_MEMORY_2048M = (3 shl 20);`	2048M
`BCM2838_BOARD_REVISION_MEMORY_4096M = (4 shl 20);`	4096M
`BCM2838_BOARD_REVISION_MEMORY_8192M = (5 shl 20);`	8192M

`BCM2838_BOARD_REVISION_ENCODED_FLAG = (1 shl 23);`	Encoded Flag, if set then revision uses this encoding.

`BCM2838_BOARD_REVISION_MASK = $00FFFFFF;`	Mask off the warranty bits

[Expand]

BCM2838 mailbox tag power state device BCM2838_MBOX_POWER_DEVID_*

[Expand]

BCM2838 mailbox tag power state request BCM2838_MBOX_SET_POWER_STATE_REQ_*

[Expand]

BCM2838 mailbox tag power state response BCM2838_MBOX_POWER_STATE_RESP_*

[Expand]

BCM2838 mailbox tag clock state/rate id BCM2838_MBOX_CLOCK_ID_*

[Expand]

BCM2838 mailbox tag clock state request BCM2838_MBOX_SET_CLOCK_STATE__REQ_*

[Expand]

BCM2838 mailbox tag clock state response BCM2838_MBOX_CLOCK_STATE_RESP_ *

[Expand]

BCM2838 mailbox tag clock rate turbo BCM2838_MBOX_CLOCK_RATE_*

[Expand]

BCM2838 mailbox tag voltage id BCM2838_MBOX_VOLTAGE_ID_*

[Expand]

BCM2838 mailbox tag voltage BCM2838_MBOX_VOLTAGE_*

[Expand]

BCM2838 mailbox tag temperature id BCM2838_MBOX_TEMP_ID_*

[Expand]

BCM2838 mailbox display id BCM2838_MBOX_DISPLAY_ID_*

[Expand]

BCM2838 mailbox tag memory flag BCM2838_MBOX_MEM_FLAG_*

[Expand]

BCM2838 mailbox tag blank screen BCM2838_MBOX_BLANK_SCREEN_*

[Expand]

BCM2838 mailbox tag pixel order BCM2838_MBOX_PIXEL_ORDER_*

[Expand]

BCM2838 mailbox tag alpha mode BCM2838_MBOX_ALPHA_MODE_*

[Expand]

BCM2838 mailbox tag palette BCM2838_MBOX_PALETTE_*

[Expand]

BCM2838 mailbox tag cursor state BCM2838_MBOX_CURSOR_*

[Expand]

BCM2838 mailbox tag cursor state flag BCM2838_MBOX_CURSOR_STATE_*

[Expand]

BCM2838 mailbox tag cursor BCM2838_MBOX_CURSOR_INVALID*

[Expand]

BCM2838 mailbox request/response BCM2838_MBOX_REQUEST_*

[Expand]

BCM2838 mailbox tag request/response BCM2838_MBOX_TAG_REQUEST_*

[Expand]

BCM2838 GPIO BCM2838_GPIO_*

[Expand]

BCM2838 virtual GPIO BCM2838_VIRTUAL_GPIO_*

[Expand]

BCM2838 function select register BCM2838_GP*

`BCM2838_GPFSEL0 = $00000000;`	GPIO Function Select 0
`BCM2838_GPFSEL1 = $00000004;`	GPIO Function Select 1
`BCM2838_GPFSEL2 = $00000008;`	GPIO Function Select 2
`BCM2838_GPFSEL3 = $0000000C;`	GPIO Function Select 3
`BCM2838_GPFSEL4 = $00000010;`	GPIO Function Select 4
`BCM2838_GPFSEL5 = $00000014;`	GPIO Function Select 5

Pin Output Set Registers
`BCM2838_GPSET0 = $0000001C;`	GPIO Pin Output Set 0
`BCM2838_GPSET1 = $00000020;`	GPIO Pin Output Set 1

Pin Output Clear Registers
`BCM2838_GPCLR0 = $00000028;`	GPIO Pin Output Clear 0
`BCM2838_GPCLR1 = $0000002C;`	GPIO Pin Output Clear 1

Pin Level Registers
`BCM2838_GPLEV0 = $00000034;`	GPIO Pin Level 0
`BCM2838_GPLEV1 = $00000038;`	GPIO Pin Level 1

Pin Event Detect Status Registers
`BCM2838_GPEDS0 = $00000040;`	GPIO Pin Event Detect Status 0
`BCM2838_GPEDS1 = $00000044;`	GPIO Pin Event Detect Status 1

Pin Rising Edge Detect Enable Registers
`BCM2838_GPREN0 = $0000004c;`	GPIO Pin Rising Edge Detect Enable 0
`BCM2838_GPREN1 = $00000050;`	GPIO Pin Rising Edge Detect Enable 1

Pin Falling Edge Detect Enable Registers
`BCM2838_GPFEN0 = $00000058;`	GPIO Pin Falling Edge Detect Enable 0
`BCM2838_GPFEN1 = $0000005c;`	GPIO Pin Falling Edge Detect Enable 1

Pin High Detect Enable Registers
`BCM2838_GPHEN0 = $00000064;`	GPIO Pin High Detect Enable 0
`BCM2838_GPHEN1 = $00000068;`	GPIO Pin High Detect Enable 1

Pin Low Detect Enable Registers
`BCM2838_GPLEN0 = $00000070;`	GPIO Pin Low Detect Enable 0
`BCM2838_GPLEN1 = $00000074;`	GPIO Pin Low Detect Enable 1

Pin Async. Rising Edge Detect Registers
`BCM2838_GPAREN0 = $0000007c;`	GPIO Pin Async. Rising Edge Detect 0
`BCM2838_GPAREN1 = $00000080;`	GPIO Pin Async. Rising Edge Detect 1

Pin Async. Falling Edge Detect Registers
`BCM2838_GPAFEN0 = $00000088;`	GPIO Pin Async. Falling Edge Detect 0
`BCM2838_GPAFEN1 = $0000008c;`	GPIO Pin Async. Falling Edge Detect 1

Pin Mux Register (See: https://github.com/raspberrypi/documentation/issues/1209)
`BCM2838_GPPINMUX = $000000D0;`

Pin Pull-up/down Mode Registers
`BCM2838_GPPUD0 = $000000E4;`	GPIO Pin Pull-up/down Mode 0
`BCM2838_GPPUD1 = $000000E8;`	GPIO Pin Pull-up/down Mode 1
`BCM2838_GPPUD2 = $000000EC;`	GPIO Pin Pull-up/down Mode 2
`BCM2838_GPPUD3 = $000000F0;`	GPIO Pin Pull-up/down Mode 3

Function Select Mask
`BCM2838_GPFSEL_MASK = 7;`

Function Select Values
`BCM2838_GPFSEL_IN = 0;`
`BCM2838_GPFSEL_OUT = 1;`
`BCM2838_GPFSEL_ALT0 = 4;`
`BCM2838_GPFSEL_ALT1 = 5;`
`BCM2838_GPFSEL_ALT2 = 6;`
`BCM2838_GPFSEL_ALT3 = 7;`
`BCM2838_GPFSEL_ALT4 = 3;`
`BCM2838_GPFSEL_ALT5 = 2;`

Pin Output Set Mask
`BCM2838_GPSET_MASK = 1;`

Pin Output Clear Mask
`BCM2838_GPCLR_MASK = 1;`

Pin Level Mask
`BCM2838_GPLEV_MASK = 1;`

Pin Event Detect Status Mask
`BCM2838_GPEDS_MASK = 1;`

Pin Rising Edge Detect Enable Mask
`BCM2838_GPREN_MASK = 1;`

Pin Falling Edge Detect Enable Mask
`BCM2838_GPFEN_MASK = 1;`

Pin High Detect Enable Mask
`BCM2838_GPHEN_MASK = 1;`

Pin Low Detect Enable Mask
`BCM2838_GPLEN_MASK = 1;`

Pin Async. Rising Edge Detect Mask
`BCM2838_GPAREN_MASK = 1;`

Pin Async. Falling Edge Detect Mask
`BCM2838_GPAFEN_MASK = 1;`

Pull-up/down Mode Mask
`BCM2838_GPPUD_MASK = 3;`

Pull-up/down Mode Values
`BCM2838_GPPUD_NONE = 0;`
`BCM2838_GPPUD_UP = 1;`
`BCM2838_GPPUD_DOWN = 2;`

Pin Mux Values
`BCM2838_GPPINMUX_RGMII_PHY_GPIO = 1;`	If set enables the RGMII PHY signals onto GPIOs 46+
`BCM2838_GPPINMUX_LEGACY_EMMC = 2;`	If set legacy EMMC controller (Arasan SD) is connected to the SD card socket

[Expand]

BCM2838 ARM local BCM2838_ARM_LOCAL_*

[Expand]

BCM2838 ARM local peripheral BCM2838_ARM_*_REGS_ BASE*

[Expand]

BCM2838 IRQ local ARM peripheral BCM2838_IRQ_LOCAL_ARM_*

[Expand]

BCM2838 ARM local control BCM2838_ARM_LOCAL_CONTROL_*

[Expand]

BCM2838 ARM local core interrupt routing BCM2838_ARM_LOCAL_AXI_ERR_ *

[Expand]

BCM2838 ARM local PM interrupt routing set/clear BCM2838_ARM_LOCAL_PM_INT_ROUTING_*

[Expand]

BCM2838 ARM local peripheral interrupt routing BCM2838_ARM_LOCAL_*

[Expand]

BCM2838 ARM local AXI outstanding count BCM2838_ARM_LOCAL_AXI_COUNT_*

[Expand]

BCM2838 ARM local AXI outstanding IRQ BCM2838_ARM_LOCAL_AXI_QUIET_*

[Expand]

BCM2838 ARM local timer control BCM2838_ARM_LOCAL_TIMER_CONTROL_*

[Expand]

BCM2838 ARM local timer clear reload BCM2838_ARM_LOCAL_TIMER_CLEAR_*

[Expand]

BCM2838 ARM local timer interrupt control BCM2838_ARM_LOCAL_TIMER_INT_CONTROL_*

[Expand]

BCM2838 ARM local mailbox interrupt control BCM2838_ARM_LOCAL_MAILBOX_INT_CONTROL_*

[Expand]

BCM2838 ARM local IRQ source BCM2838_ARM_LOCAL_IRQ_SOURCE_*

[Expand]

BCM2838 ARM local FIQ source BCM2838_ARM_LOCAL_FIQ_SOURCE_*

Type definitions

BCM2838 system timer registers

[Expand]

PBCM2838SystemTimerRegisters = ^TBCM2838SystemTimerRegisters;

TBCM2838SystemTimerRegisters = record

BCM2838 DMA channel registers

[Expand]

PBCM2838DMARegisters = ^TBCM2838DMARegisters;

TBCM2838DMARegisters = record

BCM2838 DMA40 channel registers

[Expand]

PBCM2838DMA40Registers = ^TBCM2838DMA40Registers;

TBCM2838DMA40Registers = record

BCM2838 DMA control block structure

[Expand]

PBCM2838DMAControlBlock = ^TBCM2838DMAControlBlock;

TBCM2838DMAControlBlock = record

BCM2838 DMA40 control block structure

[Expand]

PBCM2838DMA40ControlBlock = ^TBCM2838DMA40ControlBlock;

TBCM2838DMA40ControlBlock = record

BCM2838 BSC (I2C) registers

[Expand]

PBCM2838BSCRegisters = ^TBCM2838BSCRegisters;

TBCM2838BSCRegisters = record

BCM2838 SPI0 registers

[Expand]

PBCM2838SPI0Registers = ^TBCM2838SPI0Registers;

TBCM2838SPI0Registers = record

BCM2838 I2C/SPI slave registers

[Expand]

PBCM2838I2CSPIRegisters = ^TBCM2838I2CSPIRegisters;

TBCM2838I2CSPIRegisters = record

BCM2838 AUX (UART1, SPI1 and SPI2) registers

[Expand]

PBCM2838AUXRegisters = ^TBCM2838AUXRegisters;

TBCM2838AUXRegisters = record

Note: Layout of the BCM2838 AUX (UART1, SPI1 and SPI2) registers
`AUX_IRQ:LongWord;`	Auxiliary Interrupt status
`AUX_ENABLE:LongWord;`	Auxiliary enables
`Reserved01:LongWord;`
`Reserved02:LongWord;`
`Reserved03:LongWord;`
`Reserved04:LongWord;`
`Reserved05:LongWord;`
`Reserved06:LongWord;`
`Reserved07:LongWord;`
`Reserved08:LongWord;`
`Reserved09:LongWord;`
`Reserved0A:LongWord;`
`Reserved0B:LongWord;`
`Reserved0C:LongWord;`
`Reserved0D:LongWord;`
`Reserved0E:LongWord;`
`AUX_MU_IO:LongWord;`	Mini Uart I/O Data
`AUX_MU_IER:LongWord;`	Mini Uart Interrupt Enable
`AUX_MU_IIR:LongWord;`	Mini Uart Interrupt Identify
`AUX_MU_LCR:LongWord;`	Mini Uart Line Control
`AUX_MU_MCR:LongWord;`	Mini Uart Modem Control
`AUX_MU_LSR:LongWord;`	Mini Uart Line Status
`AUX_MU_MSR:LongWord;`	Mini Uart Modem Status
`AUX_MU_SCRATCH:LongWord;`	Mini Uart Scratch
`AUX_MU_CNTL:LongWord;`	Mini Uart Extra Control
`AUX_MU_STAT:LongWord;`	Mini Uart Extra Status
`AUX_MU_BAUD:LongWord;`	Mini Uart Baudrate
`Reserved11:LongWord;`
`Reserved12:LongWord;`
`Reserved13:LongWord;`
`Reserved14:LongWord;`
`Reserved15:LongWord;`
`AUX_SPI1_CNTL0:LongWord;`	SPI 1 Control register 0
`AUX_SPI1_CNTL1:LongWord;`	SPI 1 Control register 1
`AUX_SPI1_STAT:LongWord;`	SPI 1 Status
`Reserved21:LongWord;`
`AUX_SPI1_IO:LongWord;`	SPI 1 Data
`AUX_SPI1_PEEK:LongWord;`	SPI 1 Peek
`Reserved31:LongWord;`
`Reserved32:LongWord;`
`Reserved33:LongWord;`
`Reserved34:LongWord;`
`Reserved35:LongWord;`
`Reserved36:LongWord;`
`Reserved37:LongWord;`
`Reserved38:LongWord;`
`Reserved39:LongWord;`
`Reserved3A:LongWord;`
`AUX_SPI2_CNTL0:LongWord;`	SPI 2 Control register 0
`AUX_SPI2_CNTL1:LongWord;`	SPI 2 Control register 1
`AUX_SPI2_STAT:LongWord;`	SPI 2 Status
`Reserved40:LongWord;`
`AUX_SPI2_IO:LongWord;`	SPI 2 Data
`AUX_SPI2_PEEK:LongWord;`	SPI 2 Peek

BCM2838 PCM/I2S registers

[Expand]

PBCM2838PCMRegisters = ^TBCM2838PCMRegisters;

TBCM2838PCMRegisters = record

BCM2838 pulse width modulator (PWM) registers

[Expand]

PBCM2838PWMRegisters = ^TBCM2838PWMRegisters;

TBCM2838PWMRegisters = record

BCM2838 PL011 UART registers

[Expand]

PBCM2838PL011Registers = ^TBCM2838PL011Registers;

TBCM2838PL011Registers = record

BCM2838 ARM timer registers

[Expand]

PBCM2838ARMTimerRegisters = ^TBCM2838ARMTimerRegisters;

TBCM2838ARMTimerRegisters = record

BCM2838 power management watchdog registers

[Expand]

PBCM2838PMWatchdogRegisters = ^TBCM2838PMWatchdogRegisters;

TBCM2838PMWatchdogRegisters = record

BCM2838 random number generator registers

[Expand]

PBCM2838RNGRegisters = ^TBCM2838RNGRegisters;

TBCM2838RNGRegisters = record

BCM2838 GPIO registers

[Expand]

PBCM2838GPIORegisters = ^TBCM2838GPIORegisters;

TBCM2838GPIORegisters = record

Note: Layout of the BCM2838 GPIO registers
`GPFSEL0:LongWord;`	GPIO Function Select 0
`GPFSEL1:LongWord;`	GPIO Function Select 1
`GPFSEL2:LongWord;`	GPIO Function Select 2
`GPFSEL3:LongWord;`	GPIO Function Select 3
`GPFSEL4:LongWord;`	GPIO Function Select 4
`GPFSEL5:LongWord;`	GPIO Function Select 5
`Reserved1:LongWord;`
`GPSET0:LongWord;`	GPIO Pin Output Set 0
`GPSET1:LongWord;`	GPIO Pin Output Set 1
`Reserved2:LongWord;`
`GPCLR0:LongWord;`	GPIO Pin Output Clear 0
`GPCLR1:LongWord;`	GPIO Pin Output Clear 1
`Reserved3:LongWord;`
`GPLEV0:LongWord;`	GPIO Pin Level 0
`GPLEV1:LongWord;`	GPIO Pin Level 1
`Reserved4:LongWord;`
`GPEDS0:LongWord;`	GPIO Pin Event Detect Status 0
`GPEDS1:LongWord;`	GPIO Pin Event Detect Status 1
`Reserved5:LongWord;`
`GPREN0:LongWord;`	GPIO Pin Rising Edge Detect Enable 0
`GPREN1:LongWord;`	GPIO Pin Rising Edge Detect Enable 1
`Reserved6:LongWord;`
`GPFEN0:LongWord;`	GPIO Pin Falling Edge Detect Enable 0
`GPFEN1:LongWord;`	GPIO Pin Falling Edge Detect Enable 1
`Reserved7:LongWord;`
`GPHEN0:LongWord;`	GPIO Pin High Detect Enable 0
`GPHEN1:LongWord;`	GPIO Pin High Detect Enable 1
`Reserved8:LongWord;`
`GPLEN0:LongWord;`	GPIO Pin Low Detect Enable 0
`GPLEN1:LongWord;`	GPIO Pin Low Detect Enable 1
`Reserved9:LongWord;`
`GPAREN0:LongWord;`	GPIO Pin Async. Rising Edge Detect 0
`GPAREN1:LongWord;`	GPIO Pin Async. Rising Edge Detect 1
`Reserved10:LongWord;`
`GPAFEN0:LongWord;`	GPIO Pin Async. Falling Edge Detect 0
`GPAFEN1:LongWord;`	GPIO Pin Async. Falling Edge Detect 1
`Reserved11:LongWord;`
`Reserved12:LongWord;`
`Reserved13:LongWord;`
`Reserved14:LongWord;`
`Reserved15:LongWord;`
`Reserved16:LongWord;`
`Reserved17:LongWord;`
`Reserved18:LongWord;`
`Reserved19:LongWord;`
`Reserved20:LongWord;`
`Reserved21:LongWord;`
`Reserved22:LongWord;`
`Reserved23:LongWord;`
`Reserved24:LongWord;`
`Reserved25:LongWord;`
`Reserved26:LongWord;`
`Reserved27:LongWord;`
`Reserved28:LongWord;`
`Reserved29:LongWord;`
`Reserved30:LongWord;`
`Reserved31:LongWord;`
`GPPUD0:LongWord;`	GPIO Pin Pull-up/down Mode 0
`GPPUD1:LongWord;`	GPIO Pin Pull-up/down Mode 1
`GPPUD2:LongWord;`	GPIO Pin Pull-up/down Mode 2
`GPPUD3:LongWord;`	GPIO Pin Pull-up/down Mode 3

BCM2838 mailbox0 registers

[Expand]

PBCM2838Mailbox0Registers = ^TBCM2838Mailbox0Registers;

TBCM2838Mailbox0Registers = record

BCM2838 mailbox1 registers

[Expand]

PBCM2838Mailbox1Registers = ^TBCM2838Mailbox1Registers;

TBCM2838Mailbox1Registers = record

BCM2838 mailbox framebuffer request

[Expand]

PBCM2838MailboxFramebuffer = ^TBCM2838MailboxFramebuffer;

TBCM2838MailboxFramebuffer = record

BCM2838 mailbox header property tags

[Expand]

PBCM2838MailboxHeader = ^TBCM2838MailboxHeader;

TBCM2838MailboxHeader = record

BCM2838 mailbox footer property tags

[Expand]

PBCM2838MailboxFooter = ^TBCM2838MailboxFooter;

TBCM2838MailboxFooter = record

BCM2838 mailbox tag header

[Expand]

PBCM2838MailboxTagHeader = ^TBCM2838MailboxTagHeader;

TBCM2838MailboxTagHeader = record

BCM2838 mailbox tag no request

[Expand]

PBCM2838MailboxTagNoRequest = ^TBCM2838MailboxTagNoRequest;

TBCM2838MailboxTagNoRequest = record

BCM2838 mailbox tag no response

[Expand]

PBCM2838MailboxTagNoResponse = ^TBCM2838MailboxTagNoResponse;

TBCM2838MailboxTagNoResponse = record

BCM2838 mailbox tag firmware revision response

[Expand]

TBCM2838MailboxTagFirmwareRevisionResponse = record

BCM2838 mailbox tag get firmware revision

[Expand]

PBCM2838MailboxTagGetFirmwareRevision = ^TBCM2838MailboxTagGetFirmwareRevision;

TBCM2838MailboxTagGetFirmwareRevision = record

BCM2838 mailbox tag board model response

[Expand]

TBCM2838MailboxTagBoardModelResponse = record

BCM2838 mailbox tag get board model

[Expand]

PBCM2838MailboxTagGetBoardModel = ^TBCM2838MailboxTagGetBoardModel;

TBCM2838MailboxTagGetBoardModel = record

BCM2838 mailbox tag board revision response

[Expand]

TBCM2838MailboxTagBoardRevisionResponse = record

BCM2838 mailbox tag get board revision

[Expand]

PBCM2838MailboxTagGetBoardRevision = ^TBCM2838MailboxTagGetBoardRevision;

TBCM2838MailboxTagGetBoardRevision = record

BCM2838 mailbox tag MAC address response

[Expand]

TBCM2838MailboxTagMACAddressResponse = record

BCM2838 mailbox tag get MAC address

[Expand]

PBCM2838MailboxTagGetMACAddress = ^TBCM2838MailboxTagGetMACAddress;

TBCM2838MailboxTagGetMACAddress = record

BCM2838 mailbox tag board serial response

[Expand]

TBCM2838MailboxTagBoardSerialResponse = record

BCM2838 mailbox tag get board serial

[Expand]

PBCM2838MailboxTagGetBoardSerial = ^TBCM2838MailboxTagGetBoardSerial;

TBCM2838MailboxTagGetBoardSerial = record

BCM2838 mailbox tag ARM memory response

[Expand]

TBCM2838MailboxTagARMMemoryResponse = record

BCM2838 mailbox tag get ARM memory

[Expand]

PBCM2838MailboxTagGetARMMemory = ^TBCM2838MailboxTagGetARMMemory;

TBCM2838MailboxTagGetARMMemory = record

BCM2838 mailbox tag VC memory response

[Expand]

TBCM2838MailboxTagVCMemoryResponse = record

BCM2838 mailbox tag get VC memory

[Expand]

PBCM2838MailboxTagGetVCMemory = ^TBCM2838MailboxTagGetVCMemory;

TBCM2838MailboxTagGetVCMemory = record

BCM2838 mailbox tag clock response

[Expand]

TBCM2838MailboxTagClockResponse = record

BCM2838 mailbox tag clocks response

[Expand]

TBCM2838MailboxTagClocksResponse = record

BCM2838 mailbox tag get clocks

[Expand]

PBCM2838MailboxTagGetClocks = ^TBCM2838MailboxTagGetClocks;

TBCM2838MailboxTagGetClocks = record

BCM2838 mailbox tag get power state request

[Expand]

TBCM2838MailboxTagGetPowerStateRequest = record

BCM2838 mailbox tag power state response

[Expand]

TBCM2838MailboxTagPowerStateResponse = record

BCM2838 mailbox tag get power state

[Expand]

PBCM2838MailboxTagGetPowerState = ^TBCM2838MailboxTagGetPowerState;

TBCM2838MailboxTagGetPowerState = record

BCM2838 mailbox tag timing request

[Expand]

TBCM2838MailboxTagTimingRequest = record

BCM2838 mailbox tag timing response

[Expand]

TBCM2838MailboxTagTimingResponse = record

BCM2838 mailbox tag get timing

[Expand]

PBCM2838MailboxTagGetTiming = ^TBCM2838MailboxTagGetTiming;

TBCM2838MailboxTagGetTiming = record

BCM2838 mailbox tag set power state request

[Expand]

TBCM2838MailboxTagSetPowerStateRequest = record

BCM2838 mailbox tag set power state

[Expand]

PBCM2838MailboxTagSetPowerState = ^TBCM2838MailboxTagSetPowerState;

TBCM2838MailboxTagSetPowerState = record

BCM2838 mailbox tag get clock state request

[Expand]

TBCM2838MailboxTagGetClockStateRequest = record

BCM2838 mailbox tag clock state response

[Expand]

TBCM2838MailboxTagClockStateResponse = record

BCM2838 mailbox tag get clock state

[Expand]

PBCM2838MailboxTagGetClockState = ^TBCM2838MailboxTagGetClockState;

TBCM2838MailboxTagGetClockState = record

BCM2838 mailbox tag set clock state request

[Expand]

TBCM2838MailboxTagSetClockStateRequest = record

BCM2838 mailbox tag set clock state

[Expand]

PBCM2838MailboxTagSetClockState = ^TBCM2838MailboxTagSetClockState;

TBCM2838MailboxTagSetClockState = record

BCM2838 mailbox tag get clock rate request

[Expand]

TBCM2838MailboxTagGetClockRateRequest = record

BCM2838 mailbox tag clock rate response

[Expand]

TBCM2838MailboxTagClockRateResponse = record

BCM2838 mailbox tag get clock rate

[Expand]

PBCM2838MailboxTagGetClockRate = ^TBCM2838MailboxTagGetClockRate;

TBCM2838MailboxTagGetClockRate = record

BCM2838 mailbox tag set clock rate request

[Expand]

TBCM2838MailboxTagSetClockRateRequest = record

BCM2838 mailbox tag set clock rate

[Expand]

PBCM2838MailboxTagSetClockRate = ^TBCM2838MailboxTagSetClockRate;

TBCM2838MailboxTagSetClockRate = record

BCM2838 mailbox tag get clock max rate request

[Expand]

TBCM2838MailboxTagGetClockMaxRateRequest = record

BCM2838 mailbox tag get clock max rate response

[Expand]

TBCM2838MailboxTagGetClockMaxRateResponse = record

BCM2838 mailbox tag get clock max rate

[Expand]

PBCM2838MailboxTagGetClockMaxRate = ^TBCM2838MailboxTagGetClockMaxRate;

TBCM2838MailboxTagGetClockMaxRate = record

BCM2838 mailbox tag get clock min rate

[Expand]

PBCM2838MailboxTagGetClockMinRate = ^TBCM2838MailboxTagGetClockMinRate;

TBCM2838MailboxTagGetClockMinRate = record

BCM2838 mailbox tag get turbo request

[Expand]

TBCM2838MailboxTagGetTurboRequest = record

BCM2838 mailbox tag turbo response

[Expand]

TBCM2838MailboxTagTurboResponse = record

BCM2838 mailbox tag get turbo

[Expand]

PBCM2838MailboxTagGetTurbo = ^TBCM2838MailboxTagGetTurbo;

TBCM2838MailboxTagGetTurbo = record

BCM2838 mailbox tag set turbo request

[Expand]

TBCM2838MailboxTagSetTurboRequest = record

BCM2838 mailbox tag set turbo

[Expand]

PBCM2838MailboxTagSetTurbo = ^TBCM2838MailboxTagSetTurbo;

TBCM2838MailboxTagSetTurbo = record

BCM2838 mailbox tag get voltage request

[Expand]

TBCM2838MailboxTagGetVoltageRequest = record

BCM2838 mailbox tag voltage response

[Expand]

TBCM2838MailboxTagVoltageResponse = record

BCM2838 mailbox tag get voltage

[Expand]

PBCM2838MailboxTagGetVoltage = ^TBCM2838MailboxTagGetVoltage;

TBCM2838MailboxTagGetVoltage = record

BCM2838 mailbox tag set voltage request

[Expand]

TBCM2838MailboxTagSetVoltageRequest = record

BCM2838 mailbox tag set voltage

[Expand]

PBCM2838MailboxTagSetVoltage = ^TBCM2838MailboxTagSetVoltage;

TBCM2838MailboxTagSetVoltage = record

BCM2838 mailbox tag get max voltage

[Expand]

PBCM2838MailboxTagGetMaxVoltage = ^TBCM2838MailboxTagGetMaxVoltage;

TBCM2838MailboxTagGetMaxVoltage = record

BCM2838 mailbox tag get min voltage

[Expand]

PBCM2838MailboxTagGetMinVoltage = ^TBCM2838MailboxTagGetMinVoltage;

TBCM2838MailboxTagGetMinVoltage = record

BCM2838 mailbox tag temperature request

[Expand]

TBCM2838MailboxTagTemperatureRequest = record

BCM2838 mailbox tag temperature response

[Expand]

TBCM2838MailboxTagTemperatureResponse = record

BCM2838 mailbox tag get temperature

[Expand]

PBCM2838MailboxTagGetTemperature = ^TBCM2838MailboxTagGetTemperature;

TBCM2838MailboxTagGetTemperature = record

BCM2838 mailbox tag get max temperature

[Expand]

PBCM2838MailboxTagGetMaxTemperature = ^TBCM2838MailboxTagGetMaxTemperature;

TBCM2838MailboxTagGetMaxTemperature = record

BCM2838 mailbox tag allocate memory request

[Expand]

TBCM2838MailboxTagAllocateMemoryRequest = record

BCM2838 mailbox tag allocate memory response

[Expand]

TBCM2838MailboxTagAllocateMemoryResponse = record

BCM2838 mailbox tag allocate memory

[Expand]

PBCM2838MailboxTagAllocateMemory = ^TBCM2838MailboxTagAllocateMemory;

TBCM2838MailboxTagAllocateMemory = record

BCM2838 mailbox tag lock memory request

[Expand]

TBCM2838MailboxTagLockMemoryRequest = record

BCM2838 mailbox tag lock memory response

[Expand]

TBCM2838MailboxTagLockMemoryResponse = record

BCM2838 mailbox tag lock memory

[Expand]

PBCM2838MailboxTagLockMemory = ^TBCM2838MailboxTagLockMemory;

TBCM2838MailboxTagLockMemory = record

BCM2838 mailbox tag unlock memory response

[Expand]

TBCM2838MailboxTagUnlockMemoryResponse = record

BCM2838 mailbox tag unlock memory

[Expand]

PBCM2838MailboxTagUnlockMemory = ^TBCM2838MailboxTagUnlockMemory;

TBCM2838MailboxTagUnlockMemory = record

BCM2838 mailbox tag release memory

[Expand]

PBCM2838MailboxTagReleaseMemory = ^TBCM2838MailboxTagReleaseMemory;

TBCM2838MailboxTagReleaseMemory = record

BCM2838 mailbox tag execute code request

[Expand]

TBCM2838MailboxTagExecuteCodeRequest = record

BCM2838 mailbox tag execute code response

[Expand]

TBCM2838MailboxTagExecuteCodeResponse = record

BCM2838 mailbox tag execute code

[Expand]

PBCM2838MailboxTagExecuteCode = ^TBCM2838MailboxTagExecuteCode;

TBCM2838MailboxTagExecuteCode = record

BCM2838 mailbox tag execute QPU request

[Expand]

TBCM2838MailboxTagExecuteQPURequest = record

BCM2838 mailbox tag execute QPU response

[Expand]

TBCM2838MailboxTagExecuteQPUResponse = record

BCM2838 mailbox tag execute QPU

[Expand]

PBCM2838MailboxTagExecuteQPU = ^TBCM2838MailboxTagExecuteQPU;

TBCM2838MailboxTagExecuteQPU = record

BCM2838 mailbox tag enable QPU request

[Expand]

TBCM2838MailboxTagEnableQPURequest = record

BCM2838 mailbox tag enable QPU response

[Expand]

TBCM2838MailboxTagEnableQPUResponse = record

BCM2838 mailbox tag enable QPU

[Expand]

PBCM2838MailboxTagEnableQPU = ^TBCM2838MailboxTagEnableQPU;

TBCM2838MailboxTagEnableQPU = record

BCM2838 mailbox tag get dispmanx handle request

[Expand]

TBCM2838MailboxTagGetDispmanxHandleRequest = record

BCM2838 mailbox tag get dispmanx handle response

[Expand]

TBCM2838MailboxTagGetDispmanxHandleResponse = record

BCM2838 mailbox tag get dispmanx handle

[Expand]

PBCM2838MailboxTagGetDispmanxHandle = ^TBCM2838MailboxTagGetDispmanxHandle;

TBCM2838MailboxTagGetDispmanxHandle = record

BCM2838 mailbox tag get EDID block request

[Expand]

TBCM2838MailboxTagGetEDIDBlockRequest = record

BCM2838 mailbox tag get EDID block response

[Expand]

TBCM2838MailboxTagGetEDIDBlockResponse = record

BCM2838 mailbox tag get EDID block

[Expand]

PBCM2838MailboxTagGetEDIDBlock = ^TBCM2838MailboxTagGetEDIDBlock;

TBCM2838MailboxTagGetEDIDBlock = record

BCM2838 mailbox tag GPIO state request

[Expand]

TBCM2838MailboxTagGPIOStateRequest = record

BCM2838 mailbox tag GPIO state response

[Expand]

TBCM2838MailboxTagGPIOStateResponse = record

BCM2838 mailbox tag get GPIO state

[Expand]

PBCM2838MailboxTagGetGPIOState = ^TBCM2838MailboxTagGetGPIOState;

TBCM2838MailboxTagGetGPIOState = record

BCM2838 mailbox tag set GPIO state

[Expand]

PBCM2838MailboxTagSetGPIOState = ^TBCM2838MailboxTagSetGPIOState;

TBCM2838MailboxTagSetGPIOState = record

BCM2838 mailbox tag get GPIO config request

[Expand]

TBCM2838MailboxTagGetGPIOConfigRequest = record

BCM2838 mailbox tag get GPIO config response

[Expand]

TBCM2838MailboxTagGetGPIOConfigResponse = record

BCM2838 mailbox tag get GPIO config

[Expand]

PBCM2838MailboxTagGetGPIOConfig = ^TBCM2838MailboxTagGetGPIOConfig;

TBCM2838MailboxTagGetGPIOConfig = record

BCM2838 mailbox tag set GPIO config request

[Expand]

TBCM2838MailboxTagSetGPIOConfigRequest = record

BCM2838 mailbox tag set GPIO config response

[Expand]

TBCM2838MailboxTagSetGPIOConfigResponse = record

BCM2838 mailbox tag set GPIO config

[Expand]

PBCM2838MailboxTagSetGPIOConfig = ^TBCM2838MailboxTagSetGPIOConfig;

TBCM2838MailboxTagSetGPIOConfig = record

BCM2838 mailbox tag get throttled request

[Expand]

TBCM2838MailboxTagGetThrottledRequest = record

BCM2838 mailbox tag get throttled response

[Expand]

TBCM2838MailboxTagGetThrottledResponse = record

BCM2838 mailbox tag get throttled

[Expand]

PBCM2838MailboxTagGetThrottled = ^TBCM2838MailboxTagGetThrottled;

TBCM2838MailboxTagGetThrottled = record

BCM2838 mailbox tag allocate buffer request

[Expand]

TBCM2838MailboxTagAllocateBufferRequest = record

BCM2838 mailbox tag allocate buffer response

[Expand]

TBCM2838MailboxTagAllocateBufferResponse = record

BCM2838 mailbox tag allocate buffer

[Expand]

PBCM2838MailboxTagAllocateBuffer = ^TBCM2838MailboxTagAllocateBuffer;

TBCM2838MailboxTagAllocateBuffer = record

BCM2838 mailbox tag release buffer

[Expand]

PBCM2838MailboxTagReleaseBuffer = ^TBCM2838MailboxTagReleaseBuffer;

TBCM2838MailboxTagReleaseBuffer = record

BCM2838 mailbox tag blank screen request

[Expand]

TBCM2838MailboxTagBlankScreenRequest = record

BCM2838 mailbox tag blank screen response

[Expand]

TBCM2838MailboxTagBlankScreenResponse = record

BCM2838 mailbox tag blank screen

[Expand]

PBCM2838MailboxTagBlankScreen = ^TBCM2838MailboxTagBlankScreen;

TBCM2838MailboxTagBlankScreen = record

BCM2838 mailbox tag physical request

[Expand]

TBCM2838MailboxTagPhysicalRequest = record

BCM2838 mailbox tag physical response

[Expand]

TBCM2838MailboxTagPhysicalResponse = record

BCM2838 mailbox tag get physical

[Expand]

PBCM2838MailboxTagGetPhysical = ^TBCM2838MailboxTagGetPhysical;

TBCM2838MailboxTagGetPhysical = record

BCM2838 mailbox tag test physical

[Expand]

PBCM2838MailboxTagTestPhysical = ^TBCM2838MailboxTagTestPhysical;

TBCM2838MailboxTagTestPhysical = record

BCM2838 mailbox tag set physical

[Expand]

PBCM2838MailboxTagSetPhysical = ^TBCM2838MailboxTagSetPhysical;

TBCM2838MailboxTagSetPhysical = record

BCM2838 mailbox tag virtual request

[Expand]

TBCM2838MailboxTagVirtualRequest = record

BCM2838 mailbox tag virtual response

[Expand]

TBCM2838MailboxTagVirtualResponse = record

BCM2838 mailbox tag get virtual

[Expand]

PBCM2838MailboxTagGetVirtual = ^TBCM2838MailboxTagGetVirtual;

TBCM2838MailboxTagGetVirtual = record

BCM2838 mailbox tag test virtual

[Expand]

PBCM2838MailboxTagTestVirtual = ^TBCM2838MailboxTagTestVirtual;

TBCM2838MailboxTagTestVirtual = record

BCM2838 mailbox tag set virtual

[Expand]

PBCM2838MailboxTagSetVirtual = ^TBCM2838MailboxTagSetVirtual;

TBCM2838MailboxTagSetVirtual = record

BCM2838 mailbox tag depth request

[Expand]

TBCM2838MailboxTagDepthRequest = record

BCM2838 mailbox tag depth response

[Expand]

TBCM2838MailboxTagDepthResponse = record

BCM2838 mailbox tag get depth

[Expand]

PBCM2838MailboxTagGetDepth = ^TBCM2838MailboxTagGetDepth;

TBCM2838MailboxTagGetDepth = record

BCM2838 mailbox tag test depth

[Expand]

PBCM2838MailboxTagTestDepth = ^TBCM2838MailboxTagTestDepth;

TBCM2838MailboxTagTestDepth = record

BCM2838 mailbox tag set depth

[Expand]

PBCM2838MailboxTagSetDepth = ^TBCM2838MailboxTagSetDepth;

TBCM2838MailboxTagSetDepth = record

BCM2838 mailbox tag pixel order request

[Expand]

TBCM2838MailboxTagPixelOrderRequest = record

BCM2838 mailbox tag pixel order response

[Expand]

TBCM2838MailboxTagPixelOrderResponse = record

BCM2838 mailbox tag get pixel order

[Expand]

PBCM2838MailboxTagGetPixelOrder = ^TBCM2838MailboxTagGetPixelOrder;

TBCM2838MailboxTagGetPixelOrder = record

BCM2838 mailbox tag test pixel order

[Expand]

PBCM2838MailboxTagTestPixelOrder = ^TBCM2838MailboxTagTestPixelOrder;

TBCM2838MailboxTagTestPixelOrder = record

BCM2838 mailbox tag set pixel order

[Expand]

PBCM2838MailboxTagSetPixelOrder = ^TBCM2838MailboxTagSetPixelOrder;

TBCM2838MailboxTagSetPixelOrder = record

BCM2838 mailbox tag alpha mode request

[Expand]

TBCM2838MailboxTagAlphaModeRequest = record

BCM2838 mailbox tag alpha mode response

[Expand]

TBCM2838MailboxTagAlphaModeResponse = record

BCM2838 mailbox tag get alpha mode

[Expand]

PBCM2838MailboxTagGetAlphaMode = ^TBCM2838MailboxTagGetAlphaMode;

TBCM2838MailboxTagGetAlphaMode = record

BCM2838 mailbox tag test alpha mode

[Expand]

PBCM2838MailboxTagTestAlphaMode = ^TBCM2838MailboxTagTestAlphaMode;

TBCM2838MailboxTagTestAlphaMode = record

BCM2838 mailbox tag set alpha mode

[Expand]

PBCM2838MailboxTagSetAlphaMode = ^TBCM2838MailboxTagSetAlphaMode;

TBCM2838MailboxTagSetAlphaMode = record

BCM2838 mailbox tag pitch response

[Expand]

TBCM2838MailboxTagPitchResponse = record

BCM2838 mailbox tag get pitch

[Expand]

PBCM2838MailboxTagGetPitch = ^TBCM2838MailboxTagGetPitch;

TBCM2838MailboxTagGetPitch = record

BCM2838 mailbox tag virtual offset request

[Expand]

TBCM2838MailboxTagVirtualOffsetRequest = record

BCM2838 mailbox tag virtual offset response

[Expand]

TBCM2838MailboxTagVirtualOffsetResponse = record

BCM2838 mailbox tag get virtual offset

[Expand]

PBCM2838MailboxTagGetVirtualOffset = ^TBCM2838MailboxTagGetVirtualOffset;

TBCM2838MailboxTagGetVirtualOffset = record

BCM2838 mailbox tag test virtual offset

[Expand]

PBCM2838MailboxTagTestVirtualOffset = ^TBCM2838MailboxTagTestVirtualOffset;

TBCM2838MailboxTagTestVirtualOffset = record

BCM2838 mailbox tag set virtual offset

[Expand]

PBCM2838MailboxTagSetVirtualOffset = ^TBCM2838MailboxTagSetVirtualOffset;

TBCM2838MailboxTagSetVirtualOffset = record

BCM2838 mailbox tag overscan request

[Expand]

TBCM2838MailboxTagOverscanRequest = record

BCM2838 mailbox tag overscan response

[Expand]

TBCM2838MailboxTagOverscanResponse = record

BCM2838 mailbox tag get overscan

[Expand]

PBCM2838MailboxTagGetOverscan = ^TBCM2838MailboxTagGetOverscan;

TBCM2838MailboxTagGetOverscan = record

BCM2838 mailbox tag test overscan

[Expand]

PBCM2838MailboxTagTestOverscan = ^TBCM2838MailboxTagTestOverscan;

TBCM2838MailboxTagTestOverscan = record

BCM2838 mailbox tag set overscan

[Expand]

PBCM2838MailboxTagSetOverscan = ^TBCM2838MailboxTagSetOverscan;

TBCM2838MailboxTagSetOverscan = record

BCM2838 mailbox tag get palette response

[Expand]

TBCM2838MailboxTagGetPaletteResponse = record

BCM2838 mailbox tag get palette

[Expand]

PBCM2838MailboxTagGetPalette = ^TBCM2838MailboxTagGetPalette;

TBCM2838MailboxTagGetPalette = record

BCM2838 mailbox tag palette request

[Expand]

TBCM2838MailboxTagPaletteRequest = record

BCM2838 mailbox tag palette response

[Expand]

TBCM2838MailboxTagPaletteResponse = record

BCM2838 mailbox tag test palette

[Expand]

PBCM2838MailboxTagTestPalette = ^TBCM2838MailboxTagTestPalette;

TBCM2838MailboxTagTestPalette = record

BCM2838 mailbox tag set palette

[Expand]

PBCM2838MailboxTagSetPalette = ^TBCM2838MailboxTagSetPalette;

TBCM2838MailboxTagSetPalette = record

BCM2838 mailbox tag layer request

[Expand]

TBCM2838MailboxTagLayerRequest = record

BCM2838 mailbox tag layer response

[Expand]

TBCM2838MailboxTagLayerResponse = record

BCM2838 mailbox tag get layer

[Expand]

PBCM2838MailboxTagGetLayer = ^TBCM2838MailboxTagGetLayer;

TBCM2838MailboxTagGetLayer = record

BCM2838 mailbox tag test layer

[Expand]

PBCM2838MailboxTagTestLayer = ^TBCM2838MailboxTagTestLayer;

TBCM2838MailboxTagTestLayer = record

BCM2838 mailbox tag set layer

[Expand]

PBCM2838MailboxTagSetLayer = ^TBCM2838MailboxTagSetLayer;

TBCM2838MailboxTagSetLayer = record

BCM2838 mailbox tag get touch response

[Expand]

TBCM2838MailboxTagGetTouchResponse = record

BCM2838 mailbox tag get touch

[Expand]

PBCM2838MailboxTagGetTouch = ^TBCM2838MailboxTagGetTouch;

TBCM2838MailboxTagGetTouch = record

BCM2838 mailbox tag set touch request

[Expand]

TBCM2838MailboxTagSetTouchRequest = record

BCM2838 mailbox tag set touch response

[Expand]

TBCM2838MailboxTagSetTouchResponse = record

BCM2838 mailbox tag set touch

[Expand]

PBCM2838MailboxTagSetTouch = ^TBCM2838MailboxTagSetTouch;

TBCM2838MailboxTagSetTouch = record

BCM2838 mailbox tag get virtual GPIO response

[Expand]

TBCM2838MailboxTagGetVirtualGPIOResponse = record

BCM2838 mailbox tag get virtual GPIO

[Expand]

PBCM2838MailboxTagGetVirtualGPIO = ^TBCM2838MailboxTagGetVirtualGPIO;

TBCM2838MailboxTagGetVirtualGPIO = record

BCM2838 mailbox tag set virtual GPIO request

[Expand]

TBCM2838MailboxTagSetVirtualGPIORequest = record

BCM2838 mailbox tag set virtual GPIO response

[Expand]

TBCM2876MailboxTagSetVirtualGPIOResponse = record

BCM2838 mailbox tag set virtual GPIO

[Expand]

PBCM2838MailboxTagSetVirtualGPIO = ^TBCM2838MailboxTagSetVirtualGPIO;

TBCM2838MailboxTagSetVirtualGPIO = record

BCM2838 mailbox tag test vsync

[Expand]

PBCM2838MailboxTagTestVsync = ^TBCM2838MailboxTagTestVsync;

TBCM2838MailboxTagTestVsync = record

BCM2838 mailbox tag set vsync

[Expand]

PBCM2838MailboxTagSetVsync = ^TBCM2838MailboxTagSetVsync;

TBCM2838MailboxTagSetVsync = record

BCM2838 mailbox tag set backlight request

[Expand]

TBCM2838MailboxTagSetBacklightRequest = record

BCM2838 mailbox tag set backlight response

[Expand]

TBCM2838MailboxTagSetBacklightResponse = record

BCM2838 mailbox tag set backlight

[Expand]

PBCM2838MailboxTagSetBacklight = ^TBCM2838MailboxTagSetBacklight;

TBCM2838MailboxTagSetBacklight = record

BCM2838 mailbox tag get display id request

[Expand]

TBCM2838MailboxTagGetDisplayIdRequest = record

BCM2838 mailbox tag get display id response

[Expand]

TBCM2838MailboxTagGetDisplayIdResponse = record

BCM2838 mailbox tag get display id

[Expand]

PBCM2838MailboxTagGetDisplayId = ^TBCM2838MailboxTagGetDisplayId;

TBCM2838MailboxTagGetDisplayId = record

BCM2838 mailbox tag set display number request

[Expand]

TBCM2838MailboxTagSetDisplayNumRequest = record

BCM2838 mailbox tag set display number response

[Expand]

TBCM2838MailboxTagSetDisplayNumResponse = record

BCM2838 mailbox tag set display number

[Expand]

PBCM2838MailboxTagSetDisplayNum = ^TBCM2838MailboxTagSetDisplayNum;

TBCM2838MailboxTagSetDisplayNum = record

BCM2838 mailbox tag get number displays request

[Expand]

TBCM2838MailboxTagGetNumDisplaysRequest = record

BCM2838 mailbox tag get number displays response

[Expand]

TBCM2838MailboxTagGetNumDisplaysResponse = record

BCM2838 mailbox tag get number displays

[Expand]

PBCM2838MailboxTagGetNumDisplays = ^TBCM2838MailboxTagGetNumDisplays;

TBCM2838MailboxTagGetNumDisplays = record

BCM2838 mailbox tag get display settings request

[Expand]

TBCM2838MailboxTagGetDisplaySettingsRequest = record

BCM2838 mailbox tag get display settings response

[Expand]

TBCM2838MailboxTagGetDisplaySettingsResponse = record

BCM2838 mailbox tag get display settings

[Expand]

PBCM2838MailboxTagGetDisplaySettings = ^TBCM2838MailboxTagGetDisplaySettings;

TBCM2838MailboxTagGetDisplaySettings = record

BCM2838 mailbox tag set cursor info request

[Expand]

TBCM2838MailboxTagSetCursorInfoRequest = record

BCM2838 mailbox tag cursor response

[Expand]

TBCM2838MailboxTagCursorResponse = record

BCM2838 mailbox tag set cursor info

[Expand]

PBCM2838MailboxTagSetCursorInfo = ^TBCM2838MailboxTagSetCursorInfo;

TBCM2838MailboxTagSetCursorInfo = record

BCM2838 mailbox tag set cursor state request

[Expand]

TBCM2838MailboxTagSetCursorStateRequest = record

BCM2838 mailbox tag set cursor state

[Expand]

PBCM2838MailboxTagSetCursorState = ^TBCM2838MailboxTagSetCursorState;

TBCM2838MailboxTagSetCursorState = record

BCM2838 mailbox tag VCHIQ init request

[Expand]

TBCM2838MailboxTagVCHIQInitRequest = record

BCM2838 mailbox tag VCHIQ init response

[Expand]

TBCM2838MailboxTagVCHIQInitResponse = record

BCM2838 mailbox tag VCHIQ init

[Expand]

PBCM2838MailboxTagVCHIQInit = ^TBCM2838MailboxTagVCHIQInit;

TBCM2838MailboxTagVCHIQInit = record

BCM2838 mailbox tag command line response

[Expand]

TBCM2838MailboxTagCommandLineResponse = record

BCM2838 mailbox tag get command line

[Expand]

PBCM2838MailboxTagGetCommandLine = ^TBCM2838MailboxTagGetCommandLine;

TBCM2838MailboxTagGetCommandLine = record

BCM2838 mailbox tag DMA channels response

[Expand]

TBCM2838MailboxTagDMAChannelsResponse = record

BCM2838 mailbox tag get DMA channels

[Expand]

PBCM2838MailboxTagGetDMAChannels = ^TBCM2838MailboxTagGetDMAChannels;

TBCM2838MailboxTagGetDMAChannels = record

BCM2838 mailbox tag create buffer

[Expand]

PBCM2838MailboxTagCreateBuffer = ^TBCM2838MailboxTagCreateBuffer;

TBCM2838MailboxTagCreateBuffer = record

BCM2838 mailbox tag query buffer

[Expand]

PBCM2838MailboxTagQueryBuffer = ^TBCM2838MailboxTagQueryBuffer;

TBCM2838MailboxTagQueryBuffer = record

BCM2838 ARM local mailbox write registers

[Expand]

PBCM2838ARMLocalMailboxWriteRegisters = ^TBCM2838ARMLocalMailboxWriteRegisters;

TBCM2838ARMLocalMailboxWriteRegisters = record

BCM2838 ARM local mailbox read clear registers

[Expand]

PBCM2838ARMLocalMailboxReadClearRegisters = ^TBCM2838ARMLocalMailboxReadClearRegisters;

TBCM2838ARMLocalMailboxReadClearRegisters = record

BCM2838 ARM local registers

[Expand]

PBCM2838ARMLocalRegisters = ^TBCM2838ARMLocalRegisters;

TBCM2838ARMLocalRegisters = record

BCM2838 virtual GPIO buffer

[Expand]

PBCM2838VirtualGPIOBuffer = ^TBCM2838VirtualGPIOBuffer;

TBCM2838VirtualGPIOBuffer = record

Public variables

None defined

Function declarations

None defined

Return to Unit Reference

`BCM2838_VCBUS_0_ALIAS = $00000000;`	0 Alias - L1 and L2 cached
`BCM2838_VCBUS_4_ALIAS = $40000000;`	4 Alias - L2 cache coherent (non allocating)
`BCM2838_VCBUS_8_ALIAS = $80000000;`	8 Alias - L2 cached (only)
`BCM2838_VCBUS_C_ALIAS = $C0000000;`	C Alias - Direct uncached (Suitable for RPi 4 Model B)

`BCM2838_PERIPHERALS_BASE = $FE000000;`	Mapped to VC legacy address 7E000000
`BCM2838_PERIPHERALS_SIZE = SIZE_16M + SIZE_8M;`	24M

Channels 0 to 14

`BCM2838_DMA0_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7000;`
`BCM2838_DMA1_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7100;`
`BCM2838_DMA2_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7200;`
`BCM2838_DMA3_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7300;`
`BCM2838_DMA4_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7400;`
`BCM2838_DMA5_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7500;`
`BCM2838_DMA6_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7600;`
`BCM2838_DMA7_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7700;`	Lite DMA engine
`BCM2838_DMA8_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7800;`	Lite DMA engine
`BCM2838_DMA9_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7900;`	Lite DMA engine
`BCM2838_DMA10_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7A00;`	Lite DMA engine
`BCM2838_DMA11_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7B00;`	40bit DMA engine (DMA channel 11 is able to access the PCIe interface)
`BCM2838_DMA12_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7C00;`	40bit DMA engine
`BCM2838_DMA13_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7D00;`	40bit DMA engine
`BCM2838_DMA14_REGS_BASE = BCM2838_PERIPHERALS_BASE + $7E00;`	40bit DMA engine

`BCM2838_DMA_INT_STATUS_BASE = BCM2838_PERIPHERALS_BASE + $7FE0;`
`BCM2838_DMA_ENABLE_BASE = BCM2838_PERIPHERALS_BASE + $7FF0;`

`BCM2838_AUX_REGS_BASE = BCM2838_PERIPHERALS_BASE + $215000;`
`BCM2838_UART1_REGS_BASE = BCM2838_PERIPHERALS_BASE + $215040;`
`BCM2838_SPI1_REGS_BASE = BCM2838_PERIPHERALS_BASE + $215080;`
`BCM2838_SPI2_REGS_BASE = BCM2838_PERIPHERALS_BASE + $2150C0;`

Note: I2C2 master is used dedicated with the HDMI interface and must not be used

`BCM2838_BSC2_REGS_BASE = BCM2838_PERIPHERALS_BASE + $805000;`
`BCM2838_I2C2_REGS_BASE = BCM2838_BSC2_REGS_BASE;`
`BCM2838_I2C0_REGS_BASES:array[0..7] of LongWord = (BCM2838_I2C0_REGS_BASE, BCM2838_I2C1_REGS_BASE, BCM2838_I2C2_REGS_BASE, BCM2838_I2C3_REGS_BASE, BCM2838_I2C4_REGS_BASE, BCM2838_I2C5_REGS_BASE, BCM2838_I2C6_REGS_BASE, BCM2838_I2C7_REGS_BASE);`

Unit BCM2838

Contents

Description

Constants

Type definitions

Public variables

Function declarations

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Navigation

Tools

`BCM2838_EXT_PERIPHERALS_BASE = $FC000000;`	Mapped to VC legacy address 7C000000
`BCM2838_EXT_PERIPHERALS_SIZE = SIZE_32M;`

`BCM2838_PCI_ADDRESS_BASE = $600000000;`
`BCM2838_PCI_ADDRESS_SIZE = SIZE_64M;`

`BCM2838_PCI_OUTBOUND_BASE = $F8000000;`
`BCM2838_PCI_OUTBOUND_SIZE = SIZE_64M;`

`BCM2838_PCI_INBOUND_BASE = $00000000;`
`BCM2838_PCI_INBOUND_SIZE = SIZE_4G;`	Limited to 3GB on some revisions

`BCM2838_DOORBELL_REGS_BASE = BCM2838_PERIPHERALS_BASE + $B840;`
`BCM2838_VCHIQ_REGS_BASE = BCM2838_DOORBELL_REGS_BASE;`

`BCM2838_PL011_REGS_BASE = BCM2838_PERIPHERALS_BASE + $201000;`
`BCM2838_UART0_REGS_BASE = BCM2838_PL011_REGS_BASE;`

`BCM2838_UART5_REGS_BASE = BCM2838_PERIPHERALS_BASE + $201A00;`

`BCM2838_UART0_REGS_BASES:array[0..5] of LongWord = (BCM2838_UART0_REGS_BASE, 0, BCM2838_UART2_REGS_BASE, BCM2838_UART3_REGS_BASE, BCM2838_UART4_REGS_BASE, BCM2838_UART5_REGS_BASE);`

`BCM2838_EMMC1_REGS_BASE = BCM2838_PERIPHERALS_BASE + $202000;`
`BCM2838_SDHOST_REGS_BASE = BCM2838_EMMC1_REGS_BASE;`

`BCM2838_SPI6_REGS_BASE = BCM2838_PERIPHERALS_BASE + $204C00;`

`BCM2838_SPI0_REGS_BASES:array[0..6] of LongWord = (BCM2838_SPI0_REGS_BASE, 0, 0, BCM2838_SPI3_REGS_BASE, BCM2838_SPI4_REGS_BASE, BCM2838_SPI5_REGS_BASE, BCM2838_SPI6_REGS_BASE);`

`BCM2838_BSC0_REGS_BASE = BCM2838_PERIPHERALS_BASE + $205000;`
`BCM2838_I2C0_REGS_BASE = BCM2838_BSC0_REGS_BASE;`

`BCM2838_PIXELVALVE0_REGS_BASE = BCM2838_PERIPHERALS_BASE + $206000;`	Pixel Valve 0
`BCM2838_PIXELVALVE1_REGS_BASE = BCM2838_PERIPHERALS_BASE + $207000;`	Pixel Valve 1

Note: I2C7 master is used dedicated with the HDMI interface and must not be used

`BCM2838_I2C7_REGS_BASE = BCM2838_PERIPHERALS_BASE + $205E00;`

`BCM2838_PWM1_REGS_BASE = BCM2838_PERIPHERALS_BASE + $20C800;`
`BCM2838_PWM0_REGS_BASES:array[0..1] of LongWord = (BCM2838_PWM0_REGS_BASE, BCM2838_PWM1_REGS_BASE);`

`BCM2838_EMMC0_REGS_BASE = BCM2838_PERIPHERALS_BASE + $300000;`
`BCM2838_SDHCI_REGS_BASE = BCM2838_EMMC0_REGS_BASE;`

`BCM2838_SMI_REGS_BASE = BCM2838_PERIPHERALS_BASE + $600000;`
`BCM2838_FIRMWAREKMS_REGS_BASE = BCM2838_SMI_REGS_BASE;`

`BCM2838_BSC1_REGS_BASE = BCM2838_PERIPHERALS_BASE + $804000;`
`BCM2838_I2C1_REGS_BASE = BCM2838_BSC1_REGS_BASE;`

`BCM2838_USB_REGS_BASE = BCM2838_PERIPHERALS_BASE + $980000;`
`BCM2838_DWCOTG_REGS_BASE = BCM2838_USB_REGS_BASE;`

Channel 15 Note: DMA15 is exclusively used by the VPU

`BCM2838_DMA15_REGS_BASE = BCM2838_PERIPHERALS_BASE + $E05000;`

See: https://elinux.org/The_Undocumented_Pi#BCM2711

`BCM2838_CHIP_REVISION_BASE = BCM2838_EXT_PERIPHERALS_BASE + $404000;`

`BCM2838_GENET_REGS_BASE = BCM2838_EXT_PERIPHERALS_BASE + $1580000;`
`BCM2838_GENET_MDIO_OFFSET = $0E14;`

See: Section 12

`BCM2838_SYSTEM_TIMER_CS_0 = (1 shl 0);`	Already used by the VideoCore GPU (Do not use)
`BCM2838_SYSTEM_TIMER_CS_1 = (1 shl 1);`
`BCM2838_SYSTEM_TIMER_CS_2 = (1 shl 2);`	Already used by the VideoCore GPU (Do not use)
`BCM2838_SYSTEM_TIMER_CS_3 = (1 shl 3);`

See: Section 4

`BCM2838_DMA_TXFR_LEN_XLENGTH = ($FFFF shl 0);`	Transfer Length in bytes
`BCM2838_DMA_TXFR_LEN_YLENGTH = ($3FFF shl 16);`	When in 2D mode, This is the Y transfer length, indicating how many xlength transfers are performed. When in normal linear mode this becomes the top bits of the XLENGTH.

Note: BCM2838_DMA_TXFR_LEN_YLENGTH not available on DMA Lite channels

See: Section 4

`BCM2838_DMA_STRIDE_S_STRIDE = ($FFFF shl 0);`	Destination Stride (2D Mode) (Signed (2 s complement) byte increment to apply to the destination address at the end of each row in 2D mode)
`BCM2838_DMA_STRIDE_D_STRIDE = ($FFFF shl 16);`	Source Stride (2D Mode) (Signed (2 s complement) byte increment to apply to the source address at the end of each row in 2D mode)

Note: BCM2838_DMA_STRIDE_S_STRIDE and BCM2838_DMA_STRIDE_D_STRIDE not available on DMA Lite channels

See: Section 4

`BCM2838_DMA_DEBUG_READ_LAST_NOT_SET_ERROR = (1 shl 0);`	Read Last Not Set Error
`BCM2838_DMA_DEBUG_FIFO_ERROR = (1 shl 1);`	Fifo Error
`BCM2838_DMA_DEBUG_READ_ERROR = (1 shl 2);`	Slave Read Response Error
Bit 3 Reserved - Write as 0, read as don't care
`BCM2838_DMA_DEBUG_OUTSTANDING_WRITES = ($F shl 4);`	DMA Outstanding Writes Counter
`BCM2838_DMA_DEBUG_DMA_ID = ($FF shl 8);`	DMA ID
`BCM2838_DMA_DEBUG_DMA_STATE = ($1FF shl 16);`	DMA State Machine State
`BCM2838_DMA_DEBUG_VERSION = (7 shl 25);`	DMA Version
`BCM2838_DMA_DEBUG_LITE = (1 shl 28);`	DMA Lite
Bits 29:31 Reserved - Write as 0, read as don't care

See: Section 4

`BCM2838_DMA4_CB_ADDR_MASK = $0000001FFFFFFFE0;`
`BCM2838_DMA4_CB_ADDR_SHIFT = 5;`	Write Address shr 5 to the register

See: Section 4

`BCM2838_DMA4_TI_INTEN = (1 shl 0);`	Interrupt Enable
`BCM2838_DMA4_TI_TDMODE = (1 shl 1);`	2D Mode (Perform a 2D transfer instead of a normal linear transfer. In 2D mode the DMA4 will interpret the length field as an X and a Y length. It will execute Y+1 transfers each of length X.)
`BCM2838_DMA4_TI_WAIT_RESP = (1 shl 2);`	Wait for a Write Response (When set this makes the DMA4 wait until it receives the AXI write response for each write)
`BCM2838_DMA4_TI_WAIT_RD_RESP = (1 shl 3);`	Wait for a Read Response (When set this makes the DMA4 wait until it receives all the data from each read)
Bits 4:8 Reserved
`BCM2838_DMA4_TI_PERMAP_MASK = ($1F shl 9);`	Peripheral Mapping (Indicates the DREQ of selected peripheral (1-31))
`BCM2838_DMA4_TI_PERMAP_SHIFT = 9;`
`BCM2838_DMA4_TI_S_DREQ = (1 shl 14);`	Control Source Reads with DREQ (This is used when reading from a peripheral that has a DREQ flow control available)
`BCM2838_DMA4_TI_D_DREQ = (1 shl 15);`	Control Destination Writes with DREQ (This is used when writing to a peripheral that has a DREQ flow control available to control the data flow)
`BCM2838_DMA4_TI_S_WAITS_MASK = ($FF shl 16);`	Read Wait Cycles (This slows down the DMA throughput by setting the number of dummy cycles burnt before each DMA AXI read operation is started)
`BCM2838_DMA4_TI_S_WAITS_DEFAULT = (0 shl 16);`
`BCM2838_DMA4_TI_D_WAITS_MASK = ($FF shl 24);`	Write Wait Cycles (This slows down the DMA throughput by setting the number of dummy cycles before each AXI Write operation is started)
`BCM2838_DMA4_TI_D_WAITS_DEFAULT = (0 shl 24);`

See: Section 4

`BCM2838_DMA4_SRC_ADDR_MASK = $00000000FFFFFFFF;`

See: Section 4

`BCM2838_DMA4_SRCI_ADDR_MASK = ($FF shl 0);`	High Bits of the Source Address [40:32]
`BCM2838_DMA4_SRCI_BURST_LENGTH_MASK = ($F shl 8);`	Burst Transfer Length
`BCM2838_DMA4_SRCI_BURST_LENGTH_SHIFT = 8;`
`BCM2838_DMA4_SRCI_BURST_LENGTH_DEFAULT = (0 shl 8);`
`BCM2838_DMA4_SRCI_INC = (1 shl 12);`	Increment the Source Address
`BCM2838_DMA4_SRCI_SIZE_MASK = (3 shl 13);`	Source Transfer Width (The DMA4 will perform all AXI source reads with this AXI transfer width)
`BCM2838_DMA4_SRCI_SIZE_256 = (3 shl 13);`	Note: On the BCM2711 the width cannot be set larger than 128
`BCM2838_DMA4_SRCI_SIZE_128 = (2 shl 13);`
`BCM2838_DMA4_SRCI_SIZE_64 = (1 shl 13);`
`BCM2838_DMA4_SRCI_SIZE_32 = (0 shl 13);`
`BCM2838_DMA4_SRCI_IGNORE = (1 shl 15);`	Ignore Reads (The DMA4 will perform a normal transfer except that it will not produce any reads. The DMA4 will write zero data.)
`BCM2838_DMA4_SRCI_STRIDE = ($FFFF shl 16);`	Source Stride (This is only used in 2D transfer mode (TDMODE))

See: Section 4

`BCM2838_DMA4_DEST_ADDR_MASK = $00000000FFFFFFFF;`

See: Section 4

`BCM2838_DMA4_DESTI_ADDR_MASK = ($FF shl 0);`	High Bits of the Destination Address [40:32]
`BCM2838_DMA4_DESTI_BURST_LENGTH_MASK = ($F shl 8);`	Burst Transfer Length
`BCM2838_DMA4_DESTI_BURST_LENGTH_SHIFT = 8;`
`BCM2838_DMA4_DESTI_BURST_LENGTH_DEFAULT = (0 shl 8);`
`BCM2838_DMA4_DESTI_INC = (1 shl 12);`	Destination Address Increment
`BCM2838_DMA4_DESTI_SIZE_MASK = (3 shl 13);`	Destination Transfer Width (The DMA4 will perform all AXI destination writes with this AXI transfer width)
`BCM2838_DMA4_DESTI_SIZE_256 = (3 shl 13);`	Note: On the BCM2711 the width cannot be set larger than 128
`BCM2838_DMA4_DESTI_SIZE_128 = (2 shl 13);`
`BCM2838_DMA4_DESTI_SIZE_64 = (1 shl 13);`
`BCM2838_DMA4_DESTI_SIZE_32 = (0 shl 13);`
`BCM2838_DMA4_DESTI_IGNORE = (1 shl 15);`	Ignore Destination Writes
`BCM2838_DMA4_DESTI_STRIDE = ($FFFF shl 16);`	Destination Stride (This is only used in 2D transfer mode (TDMODE))

See: Section 4

`BCM2838_DMA4_LEN_XLENGTH_MASK = ($FFFF shl 0);`	Transfer Length in bytes
`BCM2838_DMA4_LEN_YLENGTH_MASK = ($3FFF shl 16);`	When in 2D mode, This is the Y transfer length, indicating how many xlength transfers are performed. When in normal linear mode this becomes the top bits of the XLENGTH.
Bits 30:31 Reserved