rcc

package
v0.0.0-...-3d984ba Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 29, 2018 License: BSD-3-Clause Imports: 4 Imported by: 0

Documentation

Overview

Package rcc provides interface to Reset and Clock Control.

Peripheral: RCC_Periph Reset and Clock Control. Instances: 

RCC  mmap.RCC_BASE

Registers: 

0x00 32  CR         Clock control register.
0x04 32  PLLCFGR    PLL configuration register.
0x08 32  CFGR       Clock configuration register.
0x0C 32  CIR        Clock interrupt register.
0x10 32  AHB1RSTR   AHB1 peripheral reset register.
0x14 32  AHB2RSTR   AHB2 peripheral reset register.
0x18 32  AHB3RSTR   AHB3 peripheral reset register.
0x20 32  APB1RSTR   APB1 peripheral reset register.
0x24 32  APB2RSTR   APB2 peripheral reset register.
0x30 32  AHB1ENR    AHB1 peripheral clock register.
0x34 32  AHB2ENR    AHB2 peripheral clock register.
0x38 32  AHB3ENR    AHB3 peripheral clock register.
0x40 32  APB1ENR    APB1 peripheral clock enable register.
0x44 32  APB2ENR    APB2 peripheral clock enable register.
0x50 32  AHB1LPENR  AHB1 peripheral clock enable in low power mode register.
0x54 32  AHB2LPENR  AHB2 peripheral clock enable in low power mode register.
0x58 32  AHB3LPENR  AHB3 peripheral clock enable in low power mode register.
0x60 32  APB1LPENR  APB1 peripheral clock enable in low power mode register.
0x64 32  APB2LPENR  APB2 peripheral clock enable in low power mode register.
0x70 32  BDCR       Backup domain control register.
0x74 32  CSR        Clock control & status register.
0x80 32  SSCGR      Spread spectrum clock generation register.
0x84 32  PLLI2SCFGR PLLI2S configuration register.
0x88 32  PLLSAICFGR PLLSAI configuration register.
0x8C 32  DCKCFGR    Dedicated Clocks configuration register.
0x90 32  CKGATENR   Clocks Gated Enable Register.
0x94 32  DCKCFGR2   Dedicated Clocks configuration register 2.

Import: 

stm32/o/f40_41xxx/mmap

Index

Constants

View Source 
const (
	HSIONn     = 0
	HSIRDYn    = 1
	HSITRIMn   = 3
	HSICALn    = 8
	HSEONn     = 16
	HSERDYn    = 17
	HSEBYPn    = 18
	CSSONn     = 19
	PLLONn     = 24
	PLLRDYn    = 25
	PLLI2SONn  = 26
	PLLI2SRDYn = 27
	PLLSAIONn  = 28
	PLLSAIRDYn = 29
)
View Source 
const (
	PLLMn   = 0
	PLLNn   = 6
	PLLPn   = 16
	PLLSRCn = 22
	PLLQn   = 24
)
View Source 
const (
	SWn      = 0
	SWSn     = 2
	HPREn    = 4
	PPRE1n   = 10
	PPRE2n   = 13
	RTCPREn  = 16
	MCO1n    = 21
	I2SSRCn  = 23
	MCO1PREn = 24
	MCO2PREn = 27
	MCO2n    = 30
)
View Source 
const (
	LSIRDYFn     = 0
	LSERDYFn     = 1
	HSIRDYFn     = 2
	HSERDYFn     = 3
	PLLRDYFn     = 4
	PLLI2SRDYFn  = 5
	PLLSAIRDYFn  = 6
	CSSFn        = 7
	LSIRDYIEn    = 8
	LSERDYIEn    = 9
	HSIRDYIEn    = 10
	HSERDYIEn    = 11
	PLLRDYIEn    = 12
	PLLI2SRDYIEn = 13
	PLLSAIRDYIEn = 14
	LSIRDYCn     = 16
	LSERDYCn     = 17
	HSIRDYCn     = 18
	HSERDYCn     = 19
	PLLRDYCn     = 20
	PLLI2SRDYCn  = 21
	PLLSAIRDYCn  = 22
	CSSCn        = 23
)
View Source 
const (
	GPIOARSTn  = 0
	GPIOBRSTn  = 1
	GPIOCRSTn  = 2
	GPIODRSTn  = 3
	GPIOERSTn  = 4
	GPIOFRSTn  = 5
	GPIOGRSTn  = 6
	GPIOHRSTn  = 7
	GPIOIRSTn  = 8
	GPIOJRSTn  = 9
	GPIOKRSTn  = 10
	CRCRSTn    = 12
	DMA1RSTn   = 21
	DMA2RSTn   = 22
	DMA2DRSTn  = 23
	ETHMACRSTn = 25
	OTGHRSTn   = 28
)
View Source 
const (
	DCMIRSTn  = 0
	CRYPRSTn  = 4
	HASHRSTn  = 5
	RNGRSTn   = 6
	OTGFSRSTn = 7
)
View Source 
const (
	TIM2RSTn   = 0
	TIM3RSTn   = 1
	TIM4RSTn   = 2
	TIM5RSTn   = 3
	TIM6RSTn   = 4
	TIM7RSTn   = 5
	TIM12RSTn  = 6
	TIM13RSTn  = 7
	TIM14RSTn  = 8
	WWDGRSTn   = 11
	SPI2RSTn   = 14
	SPI3RSTn   = 15
	USART2RSTn = 17
	USART3RSTn = 18
	UART4RSTn  = 19
	UART5RSTn  = 20
	I2C1RSTn   = 21
	I2C2RSTn   = 22
	I2C3RSTn   = 23
	CAN1RSTn   = 25
	CAN2RSTn   = 26
	PWRRSTn    = 28
	DACRSTn    = 29
	UART7RSTn  = 30
	UART8RSTn  = 31
)
View Source 
const (
	TIM1RSTn   = 0
	TIM8RSTn   = 1
	USART1RSTn = 4
	USART6RSTn = 5
	ADCRSTn    = 8
	SDIORSTn   = 11
	SPI1RSTn   = 12
	SPI4RSTn   = 13
	SYSCFGRSTn = 14
	TIM9RSTn   = 16
	TIM10RSTn  = 17
	TIM11RSTn  = 18
	SPI5RSTn   = 20
	SPI6RSTn   = 21
	SAI1RSTn   = 22
	LTDCRSTn   = 26
)
View Source 
const (
	GPIOAENn      = 0
	GPIOBENn      = 1
	GPIOCENn      = 2
	GPIODENn      = 3
	GPIOEENn      = 4
	GPIOFENn      = 5
	GPIOGENn      = 6
	GPIOHENn      = 7
	GPIOIENn      = 8
	GPIOJENn      = 9
	GPIOKENn      = 10
	CRCENn        = 12
	BKPSRAMENn    = 18
	CCMDATARAMENn = 20
	DMA1ENn       = 21
	DMA2ENn       = 22
	DMA2DENn      = 23
	ETHMACENn     = 25
	ETHMACTXENn   = 26
	ETHMACRXENn   = 27
	ETHMACPTPENn  = 28
	OTGHSENn      = 29
	OTGHSULPIENn  = 30
)
View Source 
const (
	DCMIENn  = 0
	CRYPENn  = 4
	HASHENn  = 5
	RNGENn   = 6
	OTGFSENn = 7
)
View Source 
const (
	TIM2ENn   = 0
	TIM3ENn   = 1
	TIM4ENn   = 2
	TIM5ENn   = 3
	TIM6ENn   = 4
	TIM7ENn   = 5
	TIM12ENn  = 6
	TIM13ENn  = 7
	TIM14ENn  = 8
	WWDGENn   = 11
	SPI2ENn   = 14
	SPI3ENn   = 15
	USART2ENn = 17
	USART3ENn = 18
	UART4ENn  = 19
	UART5ENn  = 20
	I2C1ENn   = 21
	I2C2ENn   = 22
	I2C3ENn   = 23
	CAN1ENn   = 25
	CAN2ENn   = 26
	PWRENn    = 28
	DACENn    = 29
	UART7ENn  = 30
	UART8ENn  = 31
)
View Source 
const (
	TIM1ENn   = 0
	TIM8ENn   = 1
	USART1ENn = 4
	USART6ENn = 5
	ADC1ENn   = 8
	ADC2ENn   = 9
	ADC3ENn   = 10
	SDIOENn   = 11
	SPI1ENn   = 12
	SPI4ENn   = 13
	SYSCFGENn = 14
	TIM9ENn   = 16
	TIM10ENn  = 17
	TIM11ENn  = 18
	SPI5ENn   = 20
	SPI6ENn   = 21
	SAI1ENn   = 22
	LTDCENn   = 26
)
View Source 
const (
	GPIOALPENn     = 0
	GPIOBLPENn     = 1
	GPIOCLPENn     = 2
	GPIODLPENn     = 3
	GPIOELPENn     = 4
	GPIOFLPENn     = 5
	GPIOGLPENn     = 6
	GPIOHLPENn     = 7
	GPIOILPENn     = 8
	GPIOJLPENn     = 9
	GPIOKLPENn     = 10
	CRCLPENn       = 12
	FLITFLPENn     = 15
	SRAM1LPENn     = 16
	SRAM2LPENn     = 17
	BKPSRAMLPENn   = 18
	SRAM3LPENn     = 19
	DMA1LPENn      = 21
	DMA2LPENn      = 22
	DMA2DLPENn     = 23
	ETHMACLPENn    = 25
	ETHMACTXLPENn  = 26
	ETHMACRXLPENn  = 27
	ETHMACPTPLPENn = 28
	OTGHSLPENn     = 29
	OTGHSULPILPENn = 30
)
View Source 
const (
	DCMILPENn  = 0
	CRYPLPENn  = 4
	HASHLPENn  = 5
	RNGLPENn   = 6
	OTGFSLPENn = 7
)
View Source 
const (
	TIM2LPENn   = 0
	TIM3LPENn   = 1
	TIM4LPENn   = 2
	TIM5LPENn   = 3
	TIM6LPENn   = 4
	TIM7LPENn   = 5
	TIM12LPENn  = 6
	TIM13LPENn  = 7
	TIM14LPENn  = 8
	WWDGLPENn   = 11
	SPI2LPENn   = 14
	SPI3LPENn   = 15
	USART2LPENn = 17
	USART3LPENn = 18
	UART4LPENn  = 19
	UART5LPENn  = 20
	I2C1LPENn   = 21
	I2C2LPENn   = 22
	I2C3LPENn   = 23
	CAN1LPENn   = 25
	CAN2LPENn   = 26
	PWRLPENn    = 28
	DACLPENn    = 29
	UART7LPENn  = 30
	UART8LPENn  = 31
)
View Source 
const (
	TIM1LPENn   = 0
	TIM8LPENn   = 1
	USART1LPENn = 4
	USART6LPENn = 5
	ADC1LPENn   = 8
	ADC2PENn    = 9
	ADC3LPENn   = 10
	SDIOLPENn   = 11
	SPI1LPENn   = 12
	SPI4LPENn   = 13
	SYSCFGLPENn = 14
	TIM9LPENn   = 16
	TIM10LPENn  = 17
	TIM11LPENn  = 18
	SPI5LPENn   = 20
	SPI6LPENn   = 21
	SAI1LPENn   = 22
	LTDCLPENn   = 26
)
View Source 
const (
	LSEONn  = 0
	LSERDYn = 1
	LSEBYPn = 2
	LSEMODn = 3
	RTCSELn = 8
	RTCENn  = 15
	BDRSTn  = 16
)
View Source 
const (
	LSIONn    = 0
	LSIRDYn   = 1
	RMVFn     = 24
	BORRSTFn  = 25
	PADRSTFn  = 26
	PORRSTFn  = 27
	SFTRSTFn  = 28
	WDGRSTFn  = 29
	WWDGRSTFn = 30
	LPWRRSTFn = 31
)
View Source 
const (
	MODPERn    = 0
	INCSTEPn   = 13
	SPREADSELn = 30
	SSCGENn    = 31
)
View Source 
const (
	PLLI2SMn = 0
	PLLI2SNn = 6
	PLLI2SQn = 24
	PLLI2SRn = 28
)
View Source 
const (
	PLLSAINn = 6
	PLLSAIQn = 24
	PLLSAIRn = 28
)
View Source 
const (
	PLLI2SDIVQn = 0
	PLLSAIDIVQn = 8
	PLLSAIDIVRn = 16
	SAI1ASRCn   = 20
	SAI1BSRCn   = 22
	TIMPREn     = 24
)
View Source 
const (
	FSMCENn = 0
)
View Source 
const (
	FSMCLPENn = 0
)
View Source 
const (
	FSMCRSTn = 0
)

Variables

View Source 
var RCC = (*RCC_Periph)(unsafe.Pointer(uintptr(mmap.RCC_BASE)))

Functions

This section is empty.

Types

type AHB1ENR 

type AHB1ENR uint32
const (
	GPIOAEN      AHB1ENR = 0x01 << 0  //+
	GPIOBEN      AHB1ENR = 0x01 << 1  //+
	GPIOCEN      AHB1ENR = 0x01 << 2  //+
	GPIODEN      AHB1ENR = 0x01 << 3  //+
	GPIOEEN      AHB1ENR = 0x01 << 4  //+
	GPIOFEN      AHB1ENR = 0x01 << 5  //+
	GPIOGEN      AHB1ENR = 0x01 << 6  //+
	GPIOHEN      AHB1ENR = 0x01 << 7  //+
	GPIOIEN      AHB1ENR = 0x01 << 8  //+
	GPIOJEN      AHB1ENR = 0x01 << 9  //+
	GPIOKEN      AHB1ENR = 0x01 << 10 //+
	CRCEN        AHB1ENR = 0x01 << 12 //+
	BKPSRAMEN    AHB1ENR = 0x01 << 18 //+
	CCMDATARAMEN AHB1ENR = 0x01 << 20 //+
	DMA1EN       AHB1ENR = 0x01 << 21 //+
	DMA2EN       AHB1ENR = 0x01 << 22 //+
	DMA2DEN      AHB1ENR = 0x01 << 23 //+
	ETHMACEN     AHB1ENR = 0x01 << 25 //+
	ETHMACTXEN   AHB1ENR = 0x01 << 26 //+
	ETHMACRXEN   AHB1ENR = 0x01 << 27 //+
	ETHMACPTPEN  AHB1ENR = 0x01 << 28 //+
	OTGHSEN      AHB1ENR = 0x01 << 29 //+
	OTGHSULPIEN  AHB1ENR = 0x01 << 30 //+
)

func (AHB1ENR) Field 

func (b AHB1ENR) Field(mask AHB1ENR) int

func (AHB1ENR) J 

func (mask AHB1ENR) J(v int) AHB1ENR

type AHB1LPENR 

type AHB1LPENR uint32
const (
	GPIOALPEN     AHB1LPENR = 0x01 << 0  //+
	GPIOBLPEN     AHB1LPENR = 0x01 << 1  //+
	GPIOCLPEN     AHB1LPENR = 0x01 << 2  //+
	GPIODLPEN     AHB1LPENR = 0x01 << 3  //+
	GPIOELPEN     AHB1LPENR = 0x01 << 4  //+
	GPIOFLPEN     AHB1LPENR = 0x01 << 5  //+
	GPIOGLPEN     AHB1LPENR = 0x01 << 6  //+
	GPIOHLPEN     AHB1LPENR = 0x01 << 7  //+
	GPIOILPEN     AHB1LPENR = 0x01 << 8  //+
	GPIOJLPEN     AHB1LPENR = 0x01 << 9  //+
	GPIOKLPEN     AHB1LPENR = 0x01 << 10 //+
	CRCLPEN       AHB1LPENR = 0x01 << 12 //+
	FLITFLPEN     AHB1LPENR = 0x01 << 15 //+
	SRAM1LPEN     AHB1LPENR = 0x01 << 16 //+
	SRAM2LPEN     AHB1LPENR = 0x01 << 17 //+
	BKPSRAMLPEN   AHB1LPENR = 0x01 << 18 //+
	SRAM3LPEN     AHB1LPENR = 0x01 << 19 //+
	DMA1LPEN      AHB1LPENR = 0x01 << 21 //+
	DMA2LPEN      AHB1LPENR = 0x01 << 22 //+
	DMA2DLPEN     AHB1LPENR = 0x01 << 23 //+
	ETHMACLPEN    AHB1LPENR = 0x01 << 25 //+
	ETHMACTXLPEN  AHB1LPENR = 0x01 << 26 //+
	ETHMACRXLPEN  AHB1LPENR = 0x01 << 27 //+
	ETHMACPTPLPEN AHB1LPENR = 0x01 << 28 //+
	OTGHSLPEN     AHB1LPENR = 0x01 << 29 //+
	OTGHSULPILPEN AHB1LPENR = 0x01 << 30 //+
)

func (AHB1LPENR) Field 

func (b AHB1LPENR) Field(mask AHB1LPENR) int

func (AHB1LPENR) J 

func (mask AHB1LPENR) J(v int) AHB1LPENR

type AHB1RSTR 

type AHB1RSTR uint32
const (
	GPIOARST  AHB1RSTR = 0x01 << 0  //+
	GPIOBRST  AHB1RSTR = 0x01 << 1  //+
	GPIOCRST  AHB1RSTR = 0x01 << 2  //+
	GPIODRST  AHB1RSTR = 0x01 << 3  //+
	GPIOERST  AHB1RSTR = 0x01 << 4  //+
	GPIOFRST  AHB1RSTR = 0x01 << 5  //+
	GPIOGRST  AHB1RSTR = 0x01 << 6  //+
	GPIOHRST  AHB1RSTR = 0x01 << 7  //+
	GPIOIRST  AHB1RSTR = 0x01 << 8  //+
	GPIOJRST  AHB1RSTR = 0x01 << 9  //+
	GPIOKRST  AHB1RSTR = 0x01 << 10 //+
	CRCRST    AHB1RSTR = 0x01 << 12 //+
	DMA1RST   AHB1RSTR = 0x01 << 21 //+
	DMA2RST   AHB1RSTR = 0x01 << 22 //+
	DMA2DRST  AHB1RSTR = 0x01 << 23 //+
	ETHMACRST AHB1RSTR = 0x01 << 25 //+
	OTGHRST   AHB1RSTR = 0x01 << 28 //+
)

func (AHB1RSTR) Field 

func (b AHB1RSTR) Field(mask AHB1RSTR) int

func (AHB1RSTR) J 

func (mask AHB1RSTR) J(v int) AHB1RSTR

type AHB2ENR 

type AHB2ENR uint32
const (
	DCMIEN  AHB2ENR = 0x01 << 0 //+
	CRYPEN  AHB2ENR = 0x01 << 4 //+
	HASHEN  AHB2ENR = 0x01 << 5 //+
	RNGEN   AHB2ENR = 0x01 << 6 //+
	OTGFSEN AHB2ENR = 0x01 << 7 //+
)

func (AHB2ENR) Field 

func (b AHB2ENR) Field(mask AHB2ENR) int

func (AHB2ENR) J 

func (mask AHB2ENR) J(v int) AHB2ENR

type AHB2LPENR 

type AHB2LPENR uint32
const (
	DCMILPEN  AHB2LPENR = 0x01 << 0 //+
	CRYPLPEN  AHB2LPENR = 0x01 << 4 //+
	HASHLPEN  AHB2LPENR = 0x01 << 5 //+
	RNGLPEN   AHB2LPENR = 0x01 << 6 //+
	OTGFSLPEN AHB2LPENR = 0x01 << 7 //+
)

func (AHB2LPENR) Field 

func (b AHB2LPENR) Field(mask AHB2LPENR) int

func (AHB2LPENR) J 

func (mask AHB2LPENR) J(v int) AHB2LPENR

type AHB2RSTR 

type AHB2RSTR uint32
const (
	DCMIRST  AHB2RSTR = 0x01 << 0 //+
	CRYPRST  AHB2RSTR = 0x01 << 4 //+
	HASHRST  AHB2RSTR = 0x01 << 5 //+
	RNGRST   AHB2RSTR = 0x01 << 6 //+
	OTGFSRST AHB2RSTR = 0x01 << 7 //+
)

func (AHB2RSTR) Field 

func (b AHB2RSTR) Field(mask AHB2RSTR) int

func (AHB2RSTR) J 

func (mask AHB2RSTR) J(v int) AHB2RSTR

type AHB3ENR 

type AHB3ENR uint32
const (
	FSMCEN AHB3ENR = 0x01 << 0 //+
)

func (AHB3ENR) Field 

func (b AHB3ENR) Field(mask AHB3ENR) int

func (AHB3ENR) J 

func (mask AHB3ENR) J(v int) AHB3ENR

type AHB3LPENR 

type AHB3LPENR uint32
const (
	FSMCLPEN AHB3LPENR = 0x01 << 0 //+
)

func (AHB3LPENR) Field 

func (b AHB3LPENR) Field(mask AHB3LPENR) int

func (AHB3LPENR) J 

func (mask AHB3LPENR) J(v int) AHB3LPENR

type AHB3RSTR 

type AHB3RSTR uint32
const (
	FSMCRST AHB3RSTR = 0x01 << 0 //+
)

func (AHB3RSTR) Field 

func (b AHB3RSTR) Field(mask AHB3RSTR) int

func (AHB3RSTR) J 

func (mask AHB3RSTR) J(v int) AHB3RSTR

type APB1ENR 

type APB1ENR uint32
const (
	TIM2EN   APB1ENR = 0x01 << 0  //+
	TIM3EN   APB1ENR = 0x01 << 1  //+
	TIM4EN   APB1ENR = 0x01 << 2  //+
	TIM5EN   APB1ENR = 0x01 << 3  //+
	TIM6EN   APB1ENR = 0x01 << 4  //+
	TIM7EN   APB1ENR = 0x01 << 5  //+
	TIM12EN  APB1ENR = 0x01 << 6  //+
	TIM13EN  APB1ENR = 0x01 << 7  //+
	TIM14EN  APB1ENR = 0x01 << 8  //+
	WWDGEN   APB1ENR = 0x01 << 11 //+
	SPI2EN   APB1ENR = 0x01 << 14 //+
	SPI3EN   APB1ENR = 0x01 << 15 //+
	USART2EN APB1ENR = 0x01 << 17 //+
	USART3EN APB1ENR = 0x01 << 18 //+
	UART4EN  APB1ENR = 0x01 << 19 //+
	UART5EN  APB1ENR = 0x01 << 20 //+
	I2C1EN   APB1ENR = 0x01 << 21 //+
	I2C2EN   APB1ENR = 0x01 << 22 //+
	I2C3EN   APB1ENR = 0x01 << 23 //+
	CAN1EN   APB1ENR = 0x01 << 25 //+
	CAN2EN   APB1ENR = 0x01 << 26 //+
	PWREN    APB1ENR = 0x01 << 28 //+
	DACEN    APB1ENR = 0x01 << 29 //+
	UART7EN  APB1ENR = 0x01 << 30 //+
	UART8EN  APB1ENR = 0x01 << 31 //+
)

func (APB1ENR) Field 

func (b APB1ENR) Field(mask APB1ENR) int

func (APB1ENR) J 

func (mask APB1ENR) J(v int) APB1ENR

type APB1LPENR 

type APB1LPENR uint32
const (
	TIM2LPEN   APB1LPENR = 0x01 << 0  //+
	TIM3LPEN   APB1LPENR = 0x01 << 1  //+
	TIM4LPEN   APB1LPENR = 0x01 << 2  //+
	TIM5LPEN   APB1LPENR = 0x01 << 3  //+
	TIM6LPEN   APB1LPENR = 0x01 << 4  //+
	TIM7LPEN   APB1LPENR = 0x01 << 5  //+
	TIM12LPEN  APB1LPENR = 0x01 << 6  //+
	TIM13LPEN  APB1LPENR = 0x01 << 7  //+
	TIM14LPEN  APB1LPENR = 0x01 << 8  //+
	WWDGLPEN   APB1LPENR = 0x01 << 11 //+
	SPI2LPEN   APB1LPENR = 0x01 << 14 //+
	SPI3LPEN   APB1LPENR = 0x01 << 15 //+
	USART2LPEN APB1LPENR = 0x01 << 17 //+
	USART3LPEN APB1LPENR = 0x01 << 18 //+
	UART4LPEN  APB1LPENR = 0x01 << 19 //+
	UART5LPEN  APB1LPENR = 0x01 << 20 //+
	I2C1LPEN   APB1LPENR = 0x01 << 21 //+
	I2C2LPEN   APB1LPENR = 0x01 << 22 //+
	I2C3LPEN   APB1LPENR = 0x01 << 23 //+
	CAN1LPEN   APB1LPENR = 0x01 << 25 //+
	CAN2LPEN   APB1LPENR = 0x01 << 26 //+
	PWRLPEN    APB1LPENR = 0x01 << 28 //+
	DACLPEN    APB1LPENR = 0x01 << 29 //+
	UART7LPEN  APB1LPENR = 0x01 << 30 //+
	UART8LPEN  APB1LPENR = 0x01 << 31 //+
)

func (APB1LPENR) Field 

func (b APB1LPENR) Field(mask APB1LPENR) int

func (APB1LPENR) J 

func (mask APB1LPENR) J(v int) APB1LPENR

type APB1RSTR 

type APB1RSTR uint32
const (
	TIM2RST   APB1RSTR = 0x01 << 0  //+
	TIM3RST   APB1RSTR = 0x01 << 1  //+
	TIM4RST   APB1RSTR = 0x01 << 2  //+
	TIM5RST   APB1RSTR = 0x01 << 3  //+
	TIM6RST   APB1RSTR = 0x01 << 4  //+
	TIM7RST   APB1RSTR = 0x01 << 5  //+
	TIM12RST  APB1RSTR = 0x01 << 6  //+
	TIM13RST  APB1RSTR = 0x01 << 7  //+
	TIM14RST  APB1RSTR = 0x01 << 8  //+
	WWDGRST   APB1RSTR = 0x01 << 11 //+
	SPI2RST   APB1RSTR = 0x01 << 14 //+
	SPI3RST   APB1RSTR = 0x01 << 15 //+
	USART2RST APB1RSTR = 0x01 << 17 //+
	USART3RST APB1RSTR = 0x01 << 18 //+
	UART4RST  APB1RSTR = 0x01 << 19 //+
	UART5RST  APB1RSTR = 0x01 << 20 //+
	I2C1RST   APB1RSTR = 0x01 << 21 //+
	I2C2RST   APB1RSTR = 0x01 << 22 //+
	I2C3RST   APB1RSTR = 0x01 << 23 //+
	CAN1RST   APB1RSTR = 0x01 << 25 //+
	CAN2RST   APB1RSTR = 0x01 << 26 //+
	PWRRST    APB1RSTR = 0x01 << 28 //+
	DACRST    APB1RSTR = 0x01 << 29 //+
	UART7RST  APB1RSTR = 0x01 << 30 //+
	UART8RST  APB1RSTR = 0x01 << 31 //+
)

func (APB1RSTR) Field 

func (b APB1RSTR) Field(mask APB1RSTR) int

func (APB1RSTR) J 

func (mask APB1RSTR) J(v int) APB1RSTR

type APB2ENR 

type APB2ENR uint32
const (
	TIM1EN   APB2ENR = 0x01 << 0  //+
	TIM8EN   APB2ENR = 0x01 << 1  //+
	USART1EN APB2ENR = 0x01 << 4  //+
	USART6EN APB2ENR = 0x01 << 5  //+
	ADC1EN   APB2ENR = 0x01 << 8  //+
	ADC2EN   APB2ENR = 0x01 << 9  //+
	ADC3EN   APB2ENR = 0x01 << 10 //+
	SDIOEN   APB2ENR = 0x01 << 11 //+
	SPI1EN   APB2ENR = 0x01 << 12 //+
	SPI4EN   APB2ENR = 0x01 << 13 //+
	SYSCFGEN APB2ENR = 0x01 << 14 //+
	TIM9EN   APB2ENR = 0x01 << 16 //+
	TIM10EN  APB2ENR = 0x01 << 17 //+
	TIM11EN  APB2ENR = 0x01 << 18 //+
	SPI5EN   APB2ENR = 0x01 << 20 //+
	SPI6EN   APB2ENR = 0x01 << 21 //+
	SAI1EN   APB2ENR = 0x01 << 22 //+
	LTDCEN   APB2ENR = 0x01 << 26 //+
)

func (APB2ENR) Field 

func (b APB2ENR) Field(mask APB2ENR) int

func (APB2ENR) J 

func (mask APB2ENR) J(v int) APB2ENR

type APB2LPENR 

type APB2LPENR uint32
const (
	TIM1LPEN   APB2LPENR = 0x01 << 0  //+
	TIM8LPEN   APB2LPENR = 0x01 << 1  //+
	USART1LPEN APB2LPENR = 0x01 << 4  //+
	USART6LPEN APB2LPENR = 0x01 << 5  //+
	ADC1LPEN   APB2LPENR = 0x01 << 8  //+
	ADC2PEN    APB2LPENR = 0x01 << 9  //+
	ADC3LPEN   APB2LPENR = 0x01 << 10 //+
	SDIOLPEN   APB2LPENR = 0x01 << 11 //+
	SPI1LPEN   APB2LPENR = 0x01 << 12 //+
	SPI4LPEN   APB2LPENR = 0x01 << 13 //+
	SYSCFGLPEN APB2LPENR = 0x01 << 14 //+
	TIM9LPEN   APB2LPENR = 0x01 << 16 //+
	TIM10LPEN  APB2LPENR = 0x01 << 17 //+
	TIM11LPEN  APB2LPENR = 0x01 << 18 //+
	SPI5LPEN   APB2LPENR = 0x01 << 20 //+
	SPI6LPEN   APB2LPENR = 0x01 << 21 //+
	SAI1LPEN   APB2LPENR = 0x01 << 22 //+
	LTDCLPEN   APB2LPENR = 0x01 << 26 //+
)

func (APB2LPENR) Field 

func (b APB2LPENR) Field(mask APB2LPENR) int

func (APB2LPENR) J 

func (mask APB2LPENR) J(v int) APB2LPENR

type APB2RSTR 

type APB2RSTR uint32
const (
	TIM1RST   APB2RSTR = 0x01 << 0  //+
	TIM8RST   APB2RSTR = 0x01 << 1  //+
	USART1RST APB2RSTR = 0x01 << 4  //+
	USART6RST APB2RSTR = 0x01 << 5  //+
	ADCRST    APB2RSTR = 0x01 << 8  //+
	SDIORST   APB2RSTR = 0x01 << 11 //+
	SPI1RST   APB2RSTR = 0x01 << 12 //+
	SPI4RST   APB2RSTR = 0x01 << 13 //+
	SYSCFGRST APB2RSTR = 0x01 << 14 //+
	TIM9RST   APB2RSTR = 0x01 << 16 //+
	TIM10RST  APB2RSTR = 0x01 << 17 //+
	TIM11RST  APB2RSTR = 0x01 << 18 //+
	SPI5RST   APB2RSTR = 0x01 << 20 //+
	SPI6RST   APB2RSTR = 0x01 << 21 //+
	SAI1RST   APB2RSTR = 0x01 << 22 //+
	LTDCRST   APB2RSTR = 0x01 << 26 //+
)

func (APB2RSTR) Field 

func (b APB2RSTR) Field(mask APB2RSTR) int

func (APB2RSTR) J 

func (mask APB2RSTR) J(v int) APB2RSTR

type BDCR 

type BDCR uint32
const (
	LSEON    BDCR = 0x01 << 0 //+
	LSERDY   BDCR = 0x01 << 1 //+
	LSEBYP   BDCR = 0x01 << 2 //+
	LSEMOD   BDCR = 0x01 << 3 //+
	RTCSEL   BDCR = 0x03 << 8 //+
	RTCSEL_0 BDCR = 0x01 << 8
	RTCSEL_1 BDCR = 0x02 << 8
	RTCEN    BDCR = 0x01 << 15 //+
	BDRST    BDCR = 0x01 << 16 //+
)

func (BDCR) Field 

func (b BDCR) Field(mask BDCR) int

func (BDCR) J 

func (mask BDCR) J(v int) BDCR

type CFGR 

type CFGR uint32
const (
	SW          CFGR = 0x03 << 0  //+ SW[1:0] bits (System clock Switch).
	SW_0        CFGR = 0x01 << 0  //  Bit 0.
	SW_1        CFGR = 0x02 << 0  //  Bit 1.
	SW_HSI      CFGR = 0x00 << 0  //  HSI selected as system clock.
	SW_HSE      CFGR = 0x01 << 0  //  HSE selected as system clock.
	SW_PLL      CFGR = 0x02 << 0  //  PLL/PLLP selected as system clock.
	SWS         CFGR = 0x03 << 2  //+ SWS[1:0] bits (System Clock Switch Status).
	SWS_0       CFGR = 0x01 << 2  //  Bit 0.
	SWS_1       CFGR = 0x02 << 2  //  Bit 1.
	SWS_HSI     CFGR = 0x00 << 2  //  HSI oscillator used as system clock.
	SWS_HSE     CFGR = 0x01 << 2  //  HSE oscillator used as system clock.
	SWS_PLL     CFGR = 0x02 << 2  //  PLL/PLLP used as system clock.
	HPRE        CFGR = 0x0F << 4  //+ HPRE[3:0] bits (AHB prescaler).
	HPRE_0      CFGR = 0x01 << 4  //  Bit 0.
	HPRE_1      CFGR = 0x02 << 4  //  Bit 1.
	HPRE_2      CFGR = 0x04 << 4  //  Bit 2.
	HPRE_3      CFGR = 0x08 << 4  //  Bit 3.
	HPRE_DIV1   CFGR = 0x00 << 4  //  SYSCLK not divided.
	HPRE_DIV2   CFGR = 0x08 << 4  //  SYSCLK divided by 2.
	HPRE_DIV4   CFGR = 0x09 << 4  //  SYSCLK divided by 4.
	HPRE_DIV8   CFGR = 0x0A << 4  //  SYSCLK divided by 8.
	HPRE_DIV16  CFGR = 0x0B << 4  //  SYSCLK divided by 16.
	HPRE_DIV64  CFGR = 0x0C << 4  //  SYSCLK divided by 64.
	HPRE_DIV128 CFGR = 0x0D << 4  //  SYSCLK divided by 128.
	HPRE_DIV256 CFGR = 0x0E << 4  //  SYSCLK divided by 256.
	HPRE_DIV512 CFGR = 0x0F << 4  //  SYSCLK divided by 512.
	PPRE1       CFGR = 0x07 << 10 //+ PRE1[2:0] bits (APB1 prescaler).
	PPRE1_0     CFGR = 0x01 << 10 //  Bit 0.
	PPRE1_1     CFGR = 0x02 << 10 //  Bit 1.
	PPRE1_2     CFGR = 0x04 << 10 //  Bit 2.
	PPRE1_DIV1  CFGR = 0x00 << 10 //  HCLK not divided.
	PPRE1_DIV2  CFGR = 0x04 << 10 //  HCLK divided by 2.
	PPRE1_DIV4  CFGR = 0x05 << 10 //  HCLK divided by 4.
	PPRE1_DIV8  CFGR = 0x06 << 10 //  HCLK divided by 8.
	PPRE1_DIV16 CFGR = 0x07 << 10 //  HCLK divided by 16.
	PPRE2       CFGR = 0x07 << 13 //+ PRE2[2:0] bits (APB2 prescaler).
	PPRE2_0     CFGR = 0x01 << 13 //  Bit 0.
	PPRE2_1     CFGR = 0x02 << 13 //  Bit 1.
	PPRE2_2     CFGR = 0x04 << 13 //  Bit 2.
	PPRE2_DIV1  CFGR = 0x00 << 13 //  HCLK not divided.
	PPRE2_DIV2  CFGR = 0x04 << 13 //  HCLK divided by 2.
	PPRE2_DIV4  CFGR = 0x05 << 13 //  HCLK divided by 4.
	PPRE2_DIV8  CFGR = 0x06 << 13 //  HCLK divided by 8.
	PPRE2_DIV16 CFGR = 0x07 << 13 //  HCLK divided by 16.
	RTCPRE      CFGR = 0x1F << 16 //+
	RTCPRE_0    CFGR = 0x01 << 16
	RTCPRE_1    CFGR = 0x02 << 16
	RTCPRE_2    CFGR = 0x04 << 16
	RTCPRE_3    CFGR = 0x08 << 16
	RTCPRE_4    CFGR = 0x10 << 16
	MCO1        CFGR = 0x03 << 21 //+
	MCO1_0      CFGR = 0x01 << 21
	MCO1_1      CFGR = 0x02 << 21
	I2SSRC      CFGR = 0x01 << 23 //+
	MCO1PRE     CFGR = 0x07 << 24 //+
	MCO1PRE_0   CFGR = 0x01 << 24
	MCO1PRE_1   CFGR = 0x02 << 24
	MCO1PRE_2   CFGR = 0x04 << 24
	MCO2PRE     CFGR = 0x07 << 27 //+
	MCO2PRE_0   CFGR = 0x01 << 27
	MCO2PRE_1   CFGR = 0x02 << 27
	MCO2PRE_2   CFGR = 0x04 << 27
	MCO2        CFGR = 0x03 << 30 //+
	MCO2_0      CFGR = 0x01 << 30
	MCO2_1      CFGR = 0x02 << 30
)

func (CFGR) Field 

func (b CFGR) Field(mask CFGR) int

func (CFGR) J 

func (mask CFGR) J(v int) CFGR

type CIR 

type CIR uint32
const (
	LSIRDYF     CIR = 0x01 << 0  //+
	LSERDYF     CIR = 0x01 << 1  //+
	HSIRDYF     CIR = 0x01 << 2  //+
	HSERDYF     CIR = 0x01 << 3  //+
	PLLRDYF     CIR = 0x01 << 4  //+
	PLLI2SRDYF  CIR = 0x01 << 5  //+
	PLLSAIRDYF  CIR = 0x01 << 6  //+
	CSSF        CIR = 0x01 << 7  //+
	LSIRDYIE    CIR = 0x01 << 8  //+
	LSERDYIE    CIR = 0x01 << 9  //+
	HSIRDYIE    CIR = 0x01 << 10 //+
	HSERDYIE    CIR = 0x01 << 11 //+
	PLLRDYIE    CIR = 0x01 << 12 //+
	PLLI2SRDYIE CIR = 0x01 << 13 //+
	PLLSAIRDYIE CIR = 0x01 << 14 //+
	LSIRDYC     CIR = 0x01 << 16 //+
	LSERDYC     CIR = 0x01 << 17 //+
	HSIRDYC     CIR = 0x01 << 18 //+
	HSERDYC     CIR = 0x01 << 19 //+
	PLLRDYC     CIR = 0x01 << 20 //+
	PLLI2SRDYC  CIR = 0x01 << 21 //+
	PLLSAIRDYC  CIR = 0x01 << 22 //+
	CSSC        CIR = 0x01 << 23 //+
)

func (CIR) Field 

func (b CIR) Field(mask CIR) int

func (CIR) J 

func (mask CIR) J(v int) CIR

type CKGATENR 

type CKGATENR uint32

func (CKGATENR) Field 

func (b CKGATENR) Field(mask CKGATENR) int

func (CKGATENR) J 

func (mask CKGATENR) J(v int) CKGATENR

type CR 

type CR uint32
const (
	HSION     CR = 0x01 << 0  //+
	HSIRDY    CR = 0x01 << 1  //+
	HSITRIM   CR = 0x1F << 3  //+
	HSITRIM_0 CR = 0x01 << 3  //  Bit 0.
	HSITRIM_1 CR = 0x02 << 3  //  Bit 1.
	HSITRIM_2 CR = 0x04 << 3  //  Bit 2.
	HSITRIM_3 CR = 0x08 << 3  //  Bit 3.
	HSITRIM_4 CR = 0x10 << 3  //  Bit 4.
	HSICAL    CR = 0xFF << 8  //+
	HSICAL_0  CR = 0x01 << 8  //  Bit 0.
	HSICAL_1  CR = 0x02 << 8  //  Bit 1.
	HSICAL_2  CR = 0x04 << 8  //  Bit 2.
	HSICAL_3  CR = 0x08 << 8  //  Bit 3.
	HSICAL_4  CR = 0x10 << 8  //  Bit 4.
	HSICAL_5  CR = 0x20 << 8  //  Bit 5.
	HSICAL_6  CR = 0x40 << 8  //  Bit 6.
	HSICAL_7  CR = 0x80 << 8  //  Bit 7.
	HSEON     CR = 0x01 << 16 //+
	HSERDY    CR = 0x01 << 17 //+
	HSEBYP    CR = 0x01 << 18 //+
	CSSON     CR = 0x01 << 19 //+
	PLLON     CR = 0x01 << 24 //+
	PLLRDY    CR = 0x01 << 25 //+
	PLLI2SON  CR = 0x01 << 26 //+
	PLLI2SRDY CR = 0x01 << 27 //+
	PLLSAION  CR = 0x01 << 28 //+
	PLLSAIRDY CR = 0x01 << 29 //+
)

func (CR) Field 

func (b CR) Field(mask CR) int

func (CR) J 

func (mask CR) J(v int) CR

type CSR 

type CSR uint32
const (
	LSION    CSR = 0x01 << 0  //+
	LSIRDY   CSR = 0x01 << 1  //+
	RMVF     CSR = 0x01 << 24 //+
	BORRSTF  CSR = 0x01 << 25 //+
	PADRSTF  CSR = 0x01 << 26 //+
	PORRSTF  CSR = 0x01 << 27 //+
	SFTRSTF  CSR = 0x01 << 28 //+
	WDGRSTF  CSR = 0x01 << 29 //+
	WWDGRSTF CSR = 0x01 << 30 //+
	LPWRRSTF CSR = 0x01 << 31 //+
)

func (CSR) Field 

func (b CSR) Field(mask CSR) int

func (CSR) J 

func (mask CSR) J(v int) CSR

type DCKCFGR 

type DCKCFGR uint32
const (
	PLLI2SDIVQ DCKCFGR = 0x1F << 0  //+
	PLLSAIDIVQ DCKCFGR = 0x1F << 8  //+
	PLLSAIDIVR DCKCFGR = 0x03 << 16 //+
	SAI1ASRC   DCKCFGR = 0x03 << 20 //+
	SAI1ASRC_0 DCKCFGR = 0x01 << 20
	SAI1ASRC_1 DCKCFGR = 0x02 << 20
	SAI1BSRC   DCKCFGR = 0x03 << 22 //+
	SAI1BSRC_0 DCKCFGR = 0x01 << 22
	SAI1BSRC_1 DCKCFGR = 0x02 << 22
	TIMPRE     DCKCFGR = 0x01 << 24 //+
)

func (DCKCFGR) Field 

func (b DCKCFGR) Field(mask DCKCFGR) int

func (DCKCFGR) J 

func (mask DCKCFGR) J(v int) DCKCFGR

type DCKCFGR2 

type DCKCFGR2 uint32

func (DCKCFGR2) Field 

func (b DCKCFGR2) Field(mask DCKCFGR2) int

func (DCKCFGR2) J 

func (mask DCKCFGR2) J(v int) DCKCFGR2

type PLLCFGR 

type PLLCFGR uint32
const (
	PLLM       PLLCFGR = 0x3F << 0 //+
	PLLM_0     PLLCFGR = 0x01 << 0
	PLLM_1     PLLCFGR = 0x02 << 0
	PLLM_2     PLLCFGR = 0x04 << 0
	PLLM_3     PLLCFGR = 0x08 << 0
	PLLM_4     PLLCFGR = 0x10 << 0
	PLLM_5     PLLCFGR = 0x20 << 0
	PLLN       PLLCFGR = 0x1FF << 6 //+
	PLLN_0     PLLCFGR = 0x01 << 6
	PLLN_1     PLLCFGR = 0x02 << 6
	PLLN_2     PLLCFGR = 0x04 << 6
	PLLN_3     PLLCFGR = 0x08 << 6
	PLLN_4     PLLCFGR = 0x10 << 6
	PLLN_5     PLLCFGR = 0x20 << 6
	PLLN_6     PLLCFGR = 0x40 << 6
	PLLN_7     PLLCFGR = 0x80 << 6
	PLLN_8     PLLCFGR = 0x100 << 6
	PLLP       PLLCFGR = 0x03 << 16 //+
	PLLP_0     PLLCFGR = 0x01 << 16
	PLLP_1     PLLCFGR = 0x02 << 16
	PLLSRC     PLLCFGR = 0x01 << 22 //+
	PLLSRC_HSE PLLCFGR = 0x01 << 22
	PLLSRC_HSI PLLCFGR = 0x00 << 22
	PLLQ       PLLCFGR = 0x0F << 24 //+
	PLLQ_0     PLLCFGR = 0x01 << 24
	PLLQ_1     PLLCFGR = 0x02 << 24
	PLLQ_2     PLLCFGR = 0x04 << 24
	PLLQ_3     PLLCFGR = 0x08 << 24
)

func (PLLCFGR) Field 

func (b PLLCFGR) Field(mask PLLCFGR) int

func (PLLCFGR) J 

func (mask PLLCFGR) J(v int) PLLCFGR

type PLLI2SCFGR 

type PLLI2SCFGR uint32
const (
	PLLI2SM   PLLI2SCFGR = 0x3F << 0 //+
	PLLI2SM_0 PLLI2SCFGR = 0x01 << 0
	PLLI2SM_1 PLLI2SCFGR = 0x02 << 0
	PLLI2SM_2 PLLI2SCFGR = 0x04 << 0
	PLLI2SM_3 PLLI2SCFGR = 0x08 << 0
	PLLI2SM_4 PLLI2SCFGR = 0x10 << 0
	PLLI2SM_5 PLLI2SCFGR = 0x20 << 0
	PLLI2SN   PLLI2SCFGR = 0x1FF << 6 //+
	PLLI2SN_0 PLLI2SCFGR = 0x01 << 6
	PLLI2SN_1 PLLI2SCFGR = 0x02 << 6
	PLLI2SN_2 PLLI2SCFGR = 0x04 << 6
	PLLI2SN_3 PLLI2SCFGR = 0x08 << 6
	PLLI2SN_4 PLLI2SCFGR = 0x10 << 6
	PLLI2SN_5 PLLI2SCFGR = 0x20 << 6
	PLLI2SN_6 PLLI2SCFGR = 0x40 << 6
	PLLI2SN_7 PLLI2SCFGR = 0x80 << 6
	PLLI2SN_8 PLLI2SCFGR = 0x100 << 6
	PLLI2SQ   PLLI2SCFGR = 0x0F << 24 //+
	PLLI2SQ_0 PLLI2SCFGR = 0x01 << 24
	PLLI2SQ_1 PLLI2SCFGR = 0x02 << 24
	PLLI2SQ_2 PLLI2SCFGR = 0x04 << 24
	PLLI2SQ_3 PLLI2SCFGR = 0x08 << 24
	PLLI2SR   PLLI2SCFGR = 0x07 << 28 //+
	PLLI2SR_0 PLLI2SCFGR = 0x01 << 28
	PLLI2SR_1 PLLI2SCFGR = 0x02 << 28
	PLLI2SR_2 PLLI2SCFGR = 0x04 << 28
)

func (PLLI2SCFGR) Field 

func (b PLLI2SCFGR) Field(mask PLLI2SCFGR) int

func (PLLI2SCFGR) J 

func (mask PLLI2SCFGR) J(v int) PLLI2SCFGR

type PLLSAICFGR 

type PLLSAICFGR uint32
const (
	PLLSAIN   PLLSAICFGR = 0x1FF << 6 //+
	PLLSAIN_0 PLLSAICFGR = 0x01 << 6
	PLLSAIN_1 PLLSAICFGR = 0x02 << 6
	PLLSAIN_2 PLLSAICFGR = 0x04 << 6
	PLLSAIN_3 PLLSAICFGR = 0x08 << 6
	PLLSAIN_4 PLLSAICFGR = 0x10 << 6
	PLLSAIN_5 PLLSAICFGR = 0x20 << 6
	PLLSAIN_6 PLLSAICFGR = 0x40 << 6
	PLLSAIN_7 PLLSAICFGR = 0x80 << 6
	PLLSAIN_8 PLLSAICFGR = 0x100 << 6
	PLLSAIQ   PLLSAICFGR = 0x0F << 24 //+
	PLLSAIQ_0 PLLSAICFGR = 0x01 << 24
	PLLSAIQ_1 PLLSAICFGR = 0x02 << 24
	PLLSAIQ_2 PLLSAICFGR = 0x04 << 24
	PLLSAIQ_3 PLLSAICFGR = 0x08 << 24
	PLLSAIR   PLLSAICFGR = 0x07 << 28 //+
	PLLSAIR_0 PLLSAICFGR = 0x01 << 28
	PLLSAIR_1 PLLSAICFGR = 0x02 << 28
	PLLSAIR_2 PLLSAICFGR = 0x04 << 28
)

func (PLLSAICFGR) Field 

func (b PLLSAICFGR) Field(mask PLLSAICFGR) int

func (PLLSAICFGR) J 

func (mask PLLSAICFGR) J(v int) PLLSAICFGR

type RAHB1ENR 

type RAHB1ENR struct{ mmio.U32 }

func (*RAHB1ENR) AtomicClearBits 

func (r *RAHB1ENR) AtomicClearBits(mask AHB1ENR)

func (*RAHB1ENR) AtomicSetBits 

func (r *RAHB1ENR) AtomicSetBits(mask AHB1ENR)

func (*RAHB1ENR) AtomicStoreBits 

func (r *RAHB1ENR) AtomicStoreBits(mask, b AHB1ENR)

func (*RAHB1ENR) Bits 

func (r *RAHB1ENR) Bits(mask AHB1ENR) AHB1ENR

func (*RAHB1ENR) ClearBits 

func (r *RAHB1ENR) ClearBits(mask AHB1ENR)

func (*RAHB1ENR) Load 

func (r *RAHB1ENR) Load() AHB1ENR

func (*RAHB1ENR) SetBits 

func (r *RAHB1ENR) SetBits(mask AHB1ENR)

func (*RAHB1ENR) Store 

func (r *RAHB1ENR) Store(b AHB1ENR)

func (*RAHB1ENR) StoreBits 

func (r *RAHB1ENR) StoreBits(mask, b AHB1ENR)

type RAHB1LPENR 

type RAHB1LPENR struct{ mmio.U32 }

func (*RAHB1LPENR) AtomicClearBits 

func (r *RAHB1LPENR) AtomicClearBits(mask AHB1LPENR)

func (*RAHB1LPENR) AtomicSetBits 

func (r *RAHB1LPENR) AtomicSetBits(mask AHB1LPENR)

func (*RAHB1LPENR) AtomicStoreBits 

func (r *RAHB1LPENR) AtomicStoreBits(mask, b AHB1LPENR)

func (*RAHB1LPENR) Bits 

func (r *RAHB1LPENR) Bits(mask AHB1LPENR) AHB1LPENR

func (*RAHB1LPENR) ClearBits 

func (r *RAHB1LPENR) ClearBits(mask AHB1LPENR)

func (*RAHB1LPENR) Load 

func (r *RAHB1LPENR) Load() AHB1LPENR

func (*RAHB1LPENR) SetBits 

func (r *RAHB1LPENR) SetBits(mask AHB1LPENR)

func (*RAHB1LPENR) Store 

func (r *RAHB1LPENR) Store(b AHB1LPENR)

func (*RAHB1LPENR) StoreBits 

func (r *RAHB1LPENR) StoreBits(mask, b AHB1LPENR)

type RAHB1RSTR 

type RAHB1RSTR struct{ mmio.U32 }

func (*RAHB1RSTR) AtomicClearBits 

func (r *RAHB1RSTR) AtomicClearBits(mask AHB1RSTR)

func (*RAHB1RSTR) AtomicSetBits 

func (r *RAHB1RSTR) AtomicSetBits(mask AHB1RSTR)

func (*RAHB1RSTR) AtomicStoreBits 

func (r *RAHB1RSTR) AtomicStoreBits(mask, b AHB1RSTR)

func (*RAHB1RSTR) Bits 

func (r *RAHB1RSTR) Bits(mask AHB1RSTR) AHB1RSTR

func (*RAHB1RSTR) ClearBits 

func (r *RAHB1RSTR) ClearBits(mask AHB1RSTR)

func (*RAHB1RSTR) Load 

func (r *RAHB1RSTR) Load() AHB1RSTR

func (*RAHB1RSTR) SetBits 

func (r *RAHB1RSTR) SetBits(mask AHB1RSTR)

func (*RAHB1RSTR) Store 

func (r *RAHB1RSTR) Store(b AHB1RSTR)

func (*RAHB1RSTR) StoreBits 

func (r *RAHB1RSTR) StoreBits(mask, b AHB1RSTR)

type RAHB2ENR 

type RAHB2ENR struct{ mmio.U32 }

func (*RAHB2ENR) AtomicClearBits 

func (r *RAHB2ENR) AtomicClearBits(mask AHB2ENR)

func (*RAHB2ENR) AtomicSetBits 

func (r *RAHB2ENR) AtomicSetBits(mask AHB2ENR)

func (*RAHB2ENR) AtomicStoreBits 

func (r *RAHB2ENR) AtomicStoreBits(mask, b AHB2ENR)

func (*RAHB2ENR) Bits 

func (r *RAHB2ENR) Bits(mask AHB2ENR) AHB2ENR

func (*RAHB2ENR) ClearBits 

func (r *RAHB2ENR) ClearBits(mask AHB2ENR)

func (*RAHB2ENR) Load 

func (r *RAHB2ENR) Load() AHB2ENR

func (*RAHB2ENR) SetBits 

func (r *RAHB2ENR) SetBits(mask AHB2ENR)

func (*RAHB2ENR) Store 

func (r *RAHB2ENR) Store(b AHB2ENR)

func (*RAHB2ENR) StoreBits 

func (r *RAHB2ENR) StoreBits(mask, b AHB2ENR)

type RAHB2LPENR 

type RAHB2LPENR struct{ mmio.U32 }

func (*RAHB2LPENR) AtomicClearBits 

func (r *RAHB2LPENR) AtomicClearBits(mask AHB2LPENR)

func (*RAHB2LPENR) AtomicSetBits 

func (r *RAHB2LPENR) AtomicSetBits(mask AHB2LPENR)

func (*RAHB2LPENR) AtomicStoreBits 

func (r *RAHB2LPENR) AtomicStoreBits(mask, b AHB2LPENR)

func (*RAHB2LPENR) Bits 

func (r *RAHB2LPENR) Bits(mask AHB2LPENR) AHB2LPENR

func (*RAHB2LPENR) ClearBits 

func (r *RAHB2LPENR) ClearBits(mask AHB2LPENR)

func (*RAHB2LPENR) Load 

func (r *RAHB2LPENR) Load() AHB2LPENR

func (*RAHB2LPENR) SetBits 

func (r *RAHB2LPENR) SetBits(mask AHB2LPENR)

func (*RAHB2LPENR) Store 

func (r *RAHB2LPENR) Store(b AHB2LPENR)

func (*RAHB2LPENR) StoreBits 

func (r *RAHB2LPENR) StoreBits(mask, b AHB2LPENR)

type RAHB2RSTR 

type RAHB2RSTR struct{ mmio.U32 }

func (*RAHB2RSTR) AtomicClearBits 

func (r *RAHB2RSTR) AtomicClearBits(mask AHB2RSTR)

func (*RAHB2RSTR) AtomicSetBits 

func (r *RAHB2RSTR) AtomicSetBits(mask AHB2RSTR)

func (*RAHB2RSTR) AtomicStoreBits 

func (r *RAHB2RSTR) AtomicStoreBits(mask, b AHB2RSTR)

func (*RAHB2RSTR) Bits 

func (r *RAHB2RSTR) Bits(mask AHB2RSTR) AHB2RSTR

func (*RAHB2RSTR) ClearBits 

func (r *RAHB2RSTR) ClearBits(mask AHB2RSTR)

func (*RAHB2RSTR) Load 

func (r *RAHB2RSTR) Load() AHB2RSTR

func (*RAHB2RSTR) SetBits 

func (r *RAHB2RSTR) SetBits(mask AHB2RSTR)

func (*RAHB2RSTR) Store 

func (r *RAHB2RSTR) Store(b AHB2RSTR)

func (*RAHB2RSTR) StoreBits 

func (r *RAHB2RSTR) StoreBits(mask, b AHB2RSTR)

type RAHB3ENR 

type RAHB3ENR struct{ mmio.U32 }

func (*RAHB3ENR) AtomicClearBits 

func (r *RAHB3ENR) AtomicClearBits(mask AHB3ENR)

func (*RAHB3ENR) AtomicSetBits 

func (r *RAHB3ENR) AtomicSetBits(mask AHB3ENR)

func (*RAHB3ENR) AtomicStoreBits 

func (r *RAHB3ENR) AtomicStoreBits(mask, b AHB3ENR)

func (*RAHB3ENR) Bits 

func (r *RAHB3ENR) Bits(mask AHB3ENR) AHB3ENR

func (*RAHB3ENR) ClearBits 

func (r *RAHB3ENR) ClearBits(mask AHB3ENR)

func (*RAHB3ENR) Load 

func (r *RAHB3ENR) Load() AHB3ENR

func (*RAHB3ENR) SetBits 

func (r *RAHB3ENR) SetBits(mask AHB3ENR)

func (*RAHB3ENR) Store 

func (r *RAHB3ENR) Store(b AHB3ENR)

func (*RAHB3ENR) StoreBits 

func (r *RAHB3ENR) StoreBits(mask, b AHB3ENR)

type RAHB3LPENR 

type RAHB3LPENR struct{ mmio.U32 }

func (*RAHB3LPENR) AtomicClearBits 

func (r *RAHB3LPENR) AtomicClearBits(mask AHB3LPENR)

func (*RAHB3LPENR) AtomicSetBits 

func (r *RAHB3LPENR) AtomicSetBits(mask AHB3LPENR)

func (*RAHB3LPENR) AtomicStoreBits 

func (r *RAHB3LPENR) AtomicStoreBits(mask, b AHB3LPENR)

func (*RAHB3LPENR) Bits 

func (r *RAHB3LPENR) Bits(mask AHB3LPENR) AHB3LPENR

func (*RAHB3LPENR) ClearBits 

func (r *RAHB3LPENR) ClearBits(mask AHB3LPENR)

func (*RAHB3LPENR) Load 

func (r *RAHB3LPENR) Load() AHB3LPENR

func (*RAHB3LPENR) SetBits 

func (r *RAHB3LPENR) SetBits(mask AHB3LPENR)

func (*RAHB3LPENR) Store 

func (r *RAHB3LPENR) Store(b AHB3LPENR)

func (*RAHB3LPENR) StoreBits 

func (r *RAHB3LPENR) StoreBits(mask, b AHB3LPENR)

type RAHB3RSTR 

type RAHB3RSTR struct{ mmio.U32 }

func (*RAHB3RSTR) AtomicClearBits 

func (r *RAHB3RSTR) AtomicClearBits(mask AHB3RSTR)

func (*RAHB3RSTR) AtomicSetBits 

func (r *RAHB3RSTR) AtomicSetBits(mask AHB3RSTR)

func (*RAHB3RSTR) AtomicStoreBits 

func (r *RAHB3RSTR) AtomicStoreBits(mask, b AHB3RSTR)

func (*RAHB3RSTR) Bits 

func (r *RAHB3RSTR) Bits(mask AHB3RSTR) AHB3RSTR

func (*RAHB3RSTR) ClearBits 

func (r *RAHB3RSTR) ClearBits(mask AHB3RSTR)

func (*RAHB3RSTR) Load 

func (r *RAHB3RSTR) Load() AHB3RSTR

func (*RAHB3RSTR) SetBits 

func (r *RAHB3RSTR) SetBits(mask AHB3RSTR)

func (*RAHB3RSTR) Store 

func (r *RAHB3RSTR) Store(b AHB3RSTR)

func (*RAHB3RSTR) StoreBits 

func (r *RAHB3RSTR) StoreBits(mask, b AHB3RSTR)

type RAPB1ENR 

type RAPB1ENR struct{ mmio.U32 }

func (*RAPB1ENR) AtomicClearBits 

func (r *RAPB1ENR) AtomicClearBits(mask APB1ENR)

func (*RAPB1ENR) AtomicSetBits 

func (r *RAPB1ENR) AtomicSetBits(mask APB1ENR)

func (*RAPB1ENR) AtomicStoreBits 

func (r *RAPB1ENR) AtomicStoreBits(mask, b APB1ENR)

func (*RAPB1ENR) Bits 

func (r *RAPB1ENR) Bits(mask APB1ENR) APB1ENR

func (*RAPB1ENR) ClearBits 

func (r *RAPB1ENR) ClearBits(mask APB1ENR)

func (*RAPB1ENR) Load 

func (r *RAPB1ENR) Load() APB1ENR

func (*RAPB1ENR) SetBits 

func (r *RAPB1ENR) SetBits(mask APB1ENR)

func (*RAPB1ENR) Store 

func (r *RAPB1ENR) Store(b APB1ENR)

func (*RAPB1ENR) StoreBits 

func (r *RAPB1ENR) StoreBits(mask, b APB1ENR)

type RAPB1LPENR 

type RAPB1LPENR struct{ mmio.U32 }

func (*RAPB1LPENR) AtomicClearBits 

func (r *RAPB1LPENR) AtomicClearBits(mask APB1LPENR)

func (*RAPB1LPENR) AtomicSetBits 

func (r *RAPB1LPENR) AtomicSetBits(mask APB1LPENR)

func (*RAPB1LPENR) AtomicStoreBits 

func (r *RAPB1LPENR) AtomicStoreBits(mask, b APB1LPENR)

func (*RAPB1LPENR) Bits 

func (r *RAPB1LPENR) Bits(mask APB1LPENR) APB1LPENR

func (*RAPB1LPENR) ClearBits 

func (r *RAPB1LPENR) ClearBits(mask APB1LPENR)

func (*RAPB1LPENR) Load 

func (r *RAPB1LPENR) Load() APB1LPENR

func (*RAPB1LPENR) SetBits 

func (r *RAPB1LPENR) SetBits(mask APB1LPENR)

func (*RAPB1LPENR) Store 

func (r *RAPB1LPENR) Store(b APB1LPENR)

func (*RAPB1LPENR) StoreBits 

func (r *RAPB1LPENR) StoreBits(mask, b APB1LPENR)

type RAPB1RSTR 

type RAPB1RSTR struct{ mmio.U32 }

func (*RAPB1RSTR) AtomicClearBits 

func (r *RAPB1RSTR) AtomicClearBits(mask APB1RSTR)

func (*RAPB1RSTR) AtomicSetBits 

func (r *RAPB1RSTR) AtomicSetBits(mask APB1RSTR)

func (*RAPB1RSTR) AtomicStoreBits 

func (r *RAPB1RSTR) AtomicStoreBits(mask, b APB1RSTR)

func (*RAPB1RSTR) Bits 

func (r *RAPB1RSTR) Bits(mask APB1RSTR) APB1RSTR

func (*RAPB1RSTR) ClearBits 

func (r *RAPB1RSTR) ClearBits(mask APB1RSTR)

func (*RAPB1RSTR) Load 

func (r *RAPB1RSTR) Load() APB1RSTR

func (*RAPB1RSTR) SetBits 

func (r *RAPB1RSTR) SetBits(mask APB1RSTR)

func (*RAPB1RSTR) Store 

func (r *RAPB1RSTR) Store(b APB1RSTR)

func (*RAPB1RSTR) StoreBits 

func (r *RAPB1RSTR) StoreBits(mask, b APB1RSTR)

type RAPB2ENR 

type RAPB2ENR struct{ mmio.U32 }

func (*RAPB2ENR) AtomicClearBits 

func (r *RAPB2ENR) AtomicClearBits(mask APB2ENR)

func (*RAPB2ENR) AtomicSetBits 

func (r *RAPB2ENR) AtomicSetBits(mask APB2ENR)

func (*RAPB2ENR) AtomicStoreBits 

func (r *RAPB2ENR) AtomicStoreBits(mask, b APB2ENR)

func (*RAPB2ENR) Bits 

func (r *RAPB2ENR) Bits(mask APB2ENR) APB2ENR

func (*RAPB2ENR) ClearBits 

func (r *RAPB2ENR) ClearBits(mask APB2ENR)

func (*RAPB2ENR) Load 

func (r *RAPB2ENR) Load() APB2ENR

func (*RAPB2ENR) SetBits 

func (r *RAPB2ENR) SetBits(mask APB2ENR)

func (*RAPB2ENR) Store 

func (r *RAPB2ENR) Store(b APB2ENR)

func (*RAPB2ENR) StoreBits 

func (r *RAPB2ENR) StoreBits(mask, b APB2ENR)

type RAPB2LPENR 

type RAPB2LPENR struct{ mmio.U32 }

func (*RAPB2LPENR) AtomicClearBits 

func (r *RAPB2LPENR) AtomicClearBits(mask APB2LPENR)

func (*RAPB2LPENR) AtomicSetBits 

func (r *RAPB2LPENR) AtomicSetBits(mask APB2LPENR)

func (*RAPB2LPENR) AtomicStoreBits 

func (r *RAPB2LPENR) AtomicStoreBits(mask, b APB2LPENR)

func (*RAPB2LPENR) Bits 

func (r *RAPB2LPENR) Bits(mask APB2LPENR) APB2LPENR

func (*RAPB2LPENR) ClearBits 

func (r *RAPB2LPENR) ClearBits(mask APB2LPENR)

func (*RAPB2LPENR) Load 

func (r *RAPB2LPENR) Load() APB2LPENR

func (*RAPB2LPENR) SetBits 

func (r *RAPB2LPENR) SetBits(mask APB2LPENR)

func (*RAPB2LPENR) Store 

func (r *RAPB2LPENR) Store(b APB2LPENR)

func (*RAPB2LPENR) StoreBits 

func (r *RAPB2LPENR) StoreBits(mask, b APB2LPENR)

type RAPB2RSTR 

type RAPB2RSTR struct{ mmio.U32 }

func (*RAPB2RSTR) AtomicClearBits 

func (r *RAPB2RSTR) AtomicClearBits(mask APB2RSTR)

func (*RAPB2RSTR) AtomicSetBits 

func (r *RAPB2RSTR) AtomicSetBits(mask APB2RSTR)

func (*RAPB2RSTR) AtomicStoreBits 

func (r *RAPB2RSTR) AtomicStoreBits(mask, b APB2RSTR)

func (*RAPB2RSTR) Bits 

func (r *RAPB2RSTR) Bits(mask APB2RSTR) APB2RSTR

func (*RAPB2RSTR) ClearBits 

func (r *RAPB2RSTR) ClearBits(mask APB2RSTR)

func (*RAPB2RSTR) Load 

func (r *RAPB2RSTR) Load() APB2RSTR

func (*RAPB2RSTR) SetBits 

func (r *RAPB2RSTR) SetBits(mask APB2RSTR)

func (*RAPB2RSTR) Store 

func (r *RAPB2RSTR) Store(b APB2RSTR)

func (*RAPB2RSTR) StoreBits 

func (r *RAPB2RSTR) StoreBits(mask, b APB2RSTR)

type RBDCR 

type RBDCR struct{ mmio.U32 }

func (*RBDCR) AtomicClearBits 

func (r *RBDCR) AtomicClearBits(mask BDCR)

func (*RBDCR) AtomicSetBits 

func (r *RBDCR) AtomicSetBits(mask BDCR)

func (*RBDCR) AtomicStoreBits 

func (r *RBDCR) AtomicStoreBits(mask, b BDCR)

func (*RBDCR) Bits 

func (r *RBDCR) Bits(mask BDCR) BDCR

func (*RBDCR) ClearBits 

func (r *RBDCR) ClearBits(mask BDCR)

func (*RBDCR) Load 

func (r *RBDCR) Load() BDCR

func (*RBDCR) SetBits 

func (r *RBDCR) SetBits(mask BDCR)

func (*RBDCR) Store 

func (r *RBDCR) Store(b BDCR)

func (*RBDCR) StoreBits 

func (r *RBDCR) StoreBits(mask, b BDCR)

type RCC_Periph 

type RCC_Periph struct {
	CR       RCR
	PLLCFGR  RPLLCFGR
	CFGR     RCFGR
	CIR      RCIR
	AHB1RSTR RAHB1RSTR
	AHB2RSTR RAHB2RSTR
	AHB3RSTR RAHB3RSTR

	APB1RSTR RAPB1RSTR
	APB2RSTR RAPB2RSTR

	AHB1ENR RAHB1ENR
	AHB2ENR RAHB2ENR
	AHB3ENR RAHB3ENR

	APB1ENR RAPB1ENR
	APB2ENR RAPB2ENR

	AHB1LPENR RAHB1LPENR
	AHB2LPENR RAHB2LPENR
	AHB3LPENR RAHB3LPENR

	APB1LPENR RAPB1LPENR
	APB2LPENR RAPB2LPENR

	BDCR RBDCR
	CSR  RCSR

	SSCGR      RSSCGR
	PLLI2SCFGR RPLLI2SCFGR
	PLLSAICFGR RPLLSAICFGR
	DCKCFGR    RDCKCFGR
	CKGATENR   RCKGATENR
	DCKCFGR2   RDCKCFGR2
	// contains filtered or unexported fields
}

func (*RCC_Periph) ADC1EN 

func (p *RCC_Periph) ADC1EN() RMAPB2ENR

func (*RCC_Periph) ADC1LPEN 

func (p *RCC_Periph) ADC1LPEN() RMAPB2LPENR

func (*RCC_Periph) ADC2EN 

func (p *RCC_Periph) ADC2EN() RMAPB2ENR

func (*RCC_Periph) ADC2PEN 

func (p *RCC_Periph) ADC2PEN() RMAPB2LPENR

func (*RCC_Periph) ADC3EN 

func (p *RCC_Periph) ADC3EN() RMAPB2ENR

func (*RCC_Periph) ADC3LPEN 

func (p *RCC_Periph) ADC3LPEN() RMAPB2LPENR

func (*RCC_Periph) ADCRST 

func (p *RCC_Periph) ADCRST() RMAPB2RSTR

func (*RCC_Periph) BDRST 

func (p *RCC_Periph) BDRST() RMBDCR

func (*RCC_Periph) BKPSRAMEN 

func (p *RCC_Periph) BKPSRAMEN() RMAHB1ENR

func (*RCC_Periph) BKPSRAMLPEN 

func (p *RCC_Periph) BKPSRAMLPEN() RMAHB1LPENR

func (*RCC_Periph) BORRSTF 

func (p *RCC_Periph) BORRSTF() RMCSR

func (*RCC_Periph) BaseAddr 

func (p *RCC_Periph) BaseAddr() uintptr

func (*RCC_Periph) CAN1EN 

func (p *RCC_Periph) CAN1EN() RMAPB1ENR

func (*RCC_Periph) CAN1LPEN 

func (p *RCC_Periph) CAN1LPEN() RMAPB1LPENR

func (*RCC_Periph) CAN1RST 

func (p *RCC_Periph) CAN1RST() RMAPB1RSTR

func (*RCC_Periph) CAN2EN 

func (p *RCC_Periph) CAN2EN() RMAPB1ENR

func (*RCC_Periph) CAN2LPEN 

func (p *RCC_Periph) CAN2LPEN() RMAPB1LPENR

func (*RCC_Periph) CAN2RST 

func (p *RCC_Periph) CAN2RST() RMAPB1RSTR

func (*RCC_Periph) CCMDATARAMEN 

func (p *RCC_Periph) CCMDATARAMEN() RMAHB1ENR

func (*RCC_Periph) CRCEN 

func (p *RCC_Periph) CRCEN() RMAHB1ENR

func (*RCC_Periph) CRCLPEN 

func (p *RCC_Periph) CRCLPEN() RMAHB1LPENR

func (*RCC_Periph) CRCRST 

func (p *RCC_Periph) CRCRST() RMAHB1RSTR

func (*RCC_Periph) CRYPEN 

func (p *RCC_Periph) CRYPEN() RMAHB2ENR

func (*RCC_Periph) CRYPLPEN 

func (p *RCC_Periph) CRYPLPEN() RMAHB2LPENR

func (*RCC_Periph) CRYPRST 

func (p *RCC_Periph) CRYPRST() RMAHB2RSTR

func (*RCC_Periph) CSSC 

func (p *RCC_Periph) CSSC() RMCIR

func (*RCC_Periph) CSSF 

func (p *RCC_Periph) CSSF() RMCIR

func (*RCC_Periph) CSSON 

func (p *RCC_Periph) CSSON() RMCR

func (*RCC_Periph) DACEN 

func (p *RCC_Periph) DACEN() RMAPB1ENR

func (*RCC_Periph) DACLPEN 

func (p *RCC_Periph) DACLPEN() RMAPB1LPENR

func (*RCC_Periph) DACRST 

func (p *RCC_Periph) DACRST() RMAPB1RSTR

func (*RCC_Periph) DCMIEN 

func (p *RCC_Periph) DCMIEN() RMAHB2ENR

func (*RCC_Periph) DCMILPEN 

func (p *RCC_Periph) DCMILPEN() RMAHB2LPENR

func (*RCC_Periph) DCMIRST 

func (p *RCC_Periph) DCMIRST() RMAHB2RSTR

func (*RCC_Periph) DMA1EN 

func (p *RCC_Periph) DMA1EN() RMAHB1ENR

func (*RCC_Periph) DMA1LPEN 

func (p *RCC_Periph) DMA1LPEN() RMAHB1LPENR

func (*RCC_Periph) DMA1RST 

func (p *RCC_Periph) DMA1RST() RMAHB1RSTR

func (*RCC_Periph) DMA2DEN 

func (p *RCC_Periph) DMA2DEN() RMAHB1ENR

func (*RCC_Periph) DMA2DLPEN 

func (p *RCC_Periph) DMA2DLPEN() RMAHB1LPENR

func (*RCC_Periph) DMA2DRST 

func (p *RCC_Periph) DMA2DRST() RMAHB1RSTR

func (*RCC_Periph) DMA2EN 

func (p *RCC_Periph) DMA2EN() RMAHB1ENR

func (*RCC_Periph) DMA2LPEN 

func (p *RCC_Periph) DMA2LPEN() RMAHB1LPENR

func (*RCC_Periph) DMA2RST 

func (p *RCC_Periph) DMA2RST() RMAHB1RSTR

func (*RCC_Periph) ETHMACEN 

func (p *RCC_Periph) ETHMACEN() RMAHB1ENR

func (*RCC_Periph) ETHMACLPEN 

func (p *RCC_Periph) ETHMACLPEN() RMAHB1LPENR

func (*RCC_Periph) ETHMACPTPEN 

func (p *RCC_Periph) ETHMACPTPEN() RMAHB1ENR

func (*RCC_Periph) ETHMACPTPLPEN 

func (p *RCC_Periph) ETHMACPTPLPEN() RMAHB1LPENR

func (*RCC_Periph) ETHMACRST 

func (p *RCC_Periph) ETHMACRST() RMAHB1RSTR

func (*RCC_Periph) ETHMACRXEN 

func (p *RCC_Periph) ETHMACRXEN() RMAHB1ENR

func (*RCC_Periph) ETHMACRXLPEN 

func (p *RCC_Periph) ETHMACRXLPEN() RMAHB1LPENR

func (*RCC_Periph) ETHMACTXEN 

func (p *RCC_Periph) ETHMACTXEN() RMAHB1ENR

func (*RCC_Periph) ETHMACTXLPEN 

func (p *RCC_Periph) ETHMACTXLPEN() RMAHB1LPENR

func (*RCC_Periph) FLITFLPEN 

func (p *RCC_Periph) FLITFLPEN() RMAHB1LPENR

func (*RCC_Periph) FSMCEN 

func (p *RCC_Periph) FSMCEN() RMAHB3ENR

func (*RCC_Periph) FSMCLPEN 

func (p *RCC_Periph) FSMCLPEN() RMAHB3LPENR

func (*RCC_Periph) FSMCRST 

func (p *RCC_Periph) FSMCRST() RMAHB3RSTR

func (*RCC_Periph) GPIOAEN 

func (p *RCC_Periph) GPIOAEN() RMAHB1ENR

func (*RCC_Periph) GPIOALPEN 

func (p *RCC_Periph) GPIOALPEN() RMAHB1LPENR

func (*RCC_Periph) GPIOARST 

func (p *RCC_Periph) GPIOARST() RMAHB1RSTR

func (*RCC_Periph) GPIOBEN 

func (p *RCC_Periph) GPIOBEN() RMAHB1ENR

func (*RCC_Periph) GPIOBLPEN 

func (p *RCC_Periph) GPIOBLPEN() RMAHB1LPENR

func (*RCC_Periph) GPIOBRST 

func (p *RCC_Periph) GPIOBRST() RMAHB1RSTR

func (*RCC_Periph) GPIOCEN 

func (p *RCC_Periph) GPIOCEN() RMAHB1ENR

func (*RCC_Periph) GPIOCLPEN 

func (p *RCC_Periph) GPIOCLPEN() RMAHB1LPENR

func (*RCC_Periph) GPIOCRST 

func (p *RCC_Periph) GPIOCRST() RMAHB1RSTR

func (*RCC_Periph) GPIODEN 

func (p *RCC_Periph) GPIODEN() RMAHB1ENR

func (*RCC_Periph) GPIODLPEN 

func (p *RCC_Periph) GPIODLPEN() RMAHB1LPENR

func (*RCC_Periph) GPIODRST 

func (p *RCC_Periph) GPIODRST() RMAHB1RSTR

func (*RCC_Periph) GPIOEEN 

func (p *RCC_Periph) GPIOEEN() RMAHB1ENR

func (*RCC_Periph) GPIOELPEN 

func (p *RCC_Periph) GPIOELPEN() RMAHB1LPENR

func (*RCC_Periph) GPIOERST 

func (p *RCC_Periph) GPIOERST() RMAHB1RSTR

func (*RCC_Periph) GPIOFEN 

func (p *RCC_Periph) GPIOFEN() RMAHB1ENR

func (*RCC_Periph) GPIOFLPEN 

func (p *RCC_Periph) GPIOFLPEN() RMAHB1LPENR

func (*RCC_Periph) GPIOFRST 

func (p *RCC_Periph) GPIOFRST() RMAHB1RSTR

func (*RCC_Periph) GPIOGEN 

func (p *RCC_Periph) GPIOGEN() RMAHB1ENR

func (*RCC_Periph) GPIOGLPEN 

func (p *RCC_Periph) GPIOGLPEN() RMAHB1LPENR

func (*RCC_Periph) GPIOGRST 

func (p *RCC_Periph) GPIOGRST() RMAHB1RSTR

func (*RCC_Periph) GPIOHEN 

func (p *RCC_Periph) GPIOHEN() RMAHB1ENR

func (*RCC_Periph) GPIOHLPEN 

func (p *RCC_Periph) GPIOHLPEN() RMAHB1LPENR

func (*RCC_Periph) GPIOHRST 

func (p *RCC_Periph) GPIOHRST() RMAHB1RSTR

func (*RCC_Periph) GPIOIEN 

func (p *RCC_Periph) GPIOIEN() RMAHB1ENR

func (*RCC_Periph) GPIOILPEN 

func (p *RCC_Periph) GPIOILPEN() RMAHB1LPENR

func (*RCC_Periph) GPIOIRST 

func (p *RCC_Periph) GPIOIRST() RMAHB1RSTR

func (*RCC_Periph) GPIOJEN 

func (p *RCC_Periph) GPIOJEN() RMAHB1ENR

func (*RCC_Periph) GPIOJLPEN 

func (p *RCC_Periph) GPIOJLPEN() RMAHB1LPENR

func (*RCC_Periph) GPIOJRST 

func (p *RCC_Periph) GPIOJRST() RMAHB1RSTR

func (*RCC_Periph) GPIOKEN 

func (p *RCC_Periph) GPIOKEN() RMAHB1ENR

func (*RCC_Periph) GPIOKLPEN 

func (p *RCC_Periph) GPIOKLPEN() RMAHB1LPENR

func (*RCC_Periph) GPIOKRST 

func (p *RCC_Periph) GPIOKRST() RMAHB1RSTR

func (*RCC_Periph) HASHEN 

func (p *RCC_Periph) HASHEN() RMAHB2ENR

func (*RCC_Periph) HASHLPEN 

func (p *RCC_Periph) HASHLPEN() RMAHB2LPENR

func (*RCC_Periph) HASHRST 

func (p *RCC_Periph) HASHRST() RMAHB2RSTR

func (*RCC_Periph) HPRE 

func (p *RCC_Periph) HPRE() RMCFGR

func (*RCC_Periph) HSEBYP 

func (p *RCC_Periph) HSEBYP() RMCR

func (*RCC_Periph) HSEON 

func (p *RCC_Periph) HSEON() RMCR

func (*RCC_Periph) HSERDY 

func (p *RCC_Periph) HSERDY() RMCR

func (*RCC_Periph) HSERDYC 

func (p *RCC_Periph) HSERDYC() RMCIR

func (*RCC_Periph) HSERDYF 

func (p *RCC_Periph) HSERDYF() RMCIR

func (*RCC_Periph) HSERDYIE 

func (p *RCC_Periph) HSERDYIE() RMCIR

func (*RCC_Periph) HSICAL 

func (p *RCC_Periph) HSICAL() RMCR

func (*RCC_Periph) HSION 

func (p *RCC_Periph) HSION() RMCR

func (*RCC_Periph) HSIRDY 

func (p *RCC_Periph) HSIRDY() RMCR

func (*RCC_Periph) HSIRDYC 

func (p *RCC_Periph) HSIRDYC() RMCIR

func (*RCC_Periph) HSIRDYF 

func (p *RCC_Periph) HSIRDYF() RMCIR

func (*RCC_Periph) HSIRDYIE 

func (p *RCC_Periph) HSIRDYIE() RMCIR

func (*RCC_Periph) HSITRIM 

func (p *RCC_Periph) HSITRIM() RMCR

func (*RCC_Periph) I2C1EN 

func (p *RCC_Periph) I2C1EN() RMAPB1ENR

func (*RCC_Periph) I2C1LPEN 

func (p *RCC_Periph) I2C1LPEN() RMAPB1LPENR

func (*RCC_Periph) I2C1RST 

func (p *RCC_Periph) I2C1RST() RMAPB1RSTR

func (*RCC_Periph) I2C2EN 

func (p *RCC_Periph) I2C2EN() RMAPB1ENR

func (*RCC_Periph) I2C2LPEN 

func (p *RCC_Periph) I2C2LPEN() RMAPB1LPENR

func (*RCC_Periph) I2C2RST 

func (p *RCC_Periph) I2C2RST() RMAPB1RSTR

func (*RCC_Periph) I2C3EN 

func (p *RCC_Periph) I2C3EN() RMAPB1ENR

func (*RCC_Periph) I2C3LPEN 

func (p *RCC_Periph) I2C3LPEN() RMAPB1LPENR

func (*RCC_Periph) I2C3RST 

func (p *RCC_Periph) I2C3RST() RMAPB1RSTR

func (*RCC_Periph) I2SSRC 

func (p *RCC_Periph) I2SSRC() RMCFGR

func (*RCC_Periph) INCSTEP 

func (p *RCC_Periph) INCSTEP() RMSSCGR

func (*RCC_Periph) LPWRRSTF 

func (p *RCC_Periph) LPWRRSTF() RMCSR

func (*RCC_Periph) LSEBYP 

func (p *RCC_Periph) LSEBYP() RMBDCR

func (*RCC_Periph) LSEMOD 

func (p *RCC_Periph) LSEMOD() RMBDCR

func (*RCC_Periph) LSEON 

func (p *RCC_Periph) LSEON() RMBDCR

func (*RCC_Periph) LSERDY 

func (p *RCC_Periph) LSERDY() RMBDCR

func (*RCC_Periph) LSERDYC 

func (p *RCC_Periph) LSERDYC() RMCIR

func (*RCC_Periph) LSERDYF 

func (p *RCC_Periph) LSERDYF() RMCIR

func (*RCC_Periph) LSERDYIE 

func (p *RCC_Periph) LSERDYIE() RMCIR

func (*RCC_Periph) LSION 

func (p *RCC_Periph) LSION() RMCSR

func (*RCC_Periph) LSIRDY 

func (p *RCC_Periph) LSIRDY() RMCSR

func (*RCC_Periph) LSIRDYC 

func (p *RCC_Periph) LSIRDYC() RMCIR

func (*RCC_Periph) LSIRDYF 

func (p *RCC_Periph) LSIRDYF() RMCIR

func (*RCC_Periph) LSIRDYIE 

func (p *RCC_Periph) LSIRDYIE() RMCIR

func (*RCC_Periph) LTDCEN 

func (p *RCC_Periph) LTDCEN() RMAPB2ENR

func (*RCC_Periph) LTDCLPEN 

func (p *RCC_Periph) LTDCLPEN() RMAPB2LPENR

func (*RCC_Periph) LTDCRST 

func (p *RCC_Periph) LTDCRST() RMAPB2RSTR

func (*RCC_Periph) MCO1 

func (p *RCC_Periph) MCO1() RMCFGR

func (*RCC_Periph) MCO1PRE 

func (p *RCC_Periph) MCO1PRE() RMCFGR

func (*RCC_Periph) MCO2 

func (p *RCC_Periph) MCO2() RMCFGR

func (*RCC_Periph) MCO2PRE 

func (p *RCC_Periph) MCO2PRE() RMCFGR

func (*RCC_Periph) MODPER 

func (p *RCC_Periph) MODPER() RMSSCGR

func (*RCC_Periph) OTGFSEN 

func (p *RCC_Periph) OTGFSEN() RMAHB2ENR

func (*RCC_Periph) OTGFSLPEN 

func (p *RCC_Periph) OTGFSLPEN() RMAHB2LPENR

func (*RCC_Periph) OTGFSRST 

func (p *RCC_Periph) OTGFSRST() RMAHB2RSTR

func (*RCC_Periph) OTGHRST 

func (p *RCC_Periph) OTGHRST() RMAHB1RSTR

func (*RCC_Periph) OTGHSEN 

func (p *RCC_Periph) OTGHSEN() RMAHB1ENR

func (*RCC_Periph) OTGHSLPEN 

func (p *RCC_Periph) OTGHSLPEN() RMAHB1LPENR

func (*RCC_Periph) OTGHSULPIEN 

func (p *RCC_Periph) OTGHSULPIEN() RMAHB1ENR

func (*RCC_Periph) OTGHSULPILPEN 

func (p *RCC_Periph) OTGHSULPILPEN() RMAHB1LPENR

func (*RCC_Periph) PADRSTF 

func (p *RCC_Periph) PADRSTF() RMCSR

func (*RCC_Periph) PLLI2SDIVQ 

func (p *RCC_Periph) PLLI2SDIVQ() RMDCKCFGR

func (*RCC_Periph) PLLI2SM 

func (p *RCC_Periph) PLLI2SM() RMPLLI2SCFGR

func (*RCC_Periph) PLLI2SN 

func (p *RCC_Periph) PLLI2SN() RMPLLI2SCFGR

func (*RCC_Periph) PLLI2SON 

func (p *RCC_Periph) PLLI2SON() RMCR

func (*RCC_Periph) PLLI2SQ 

func (p *RCC_Periph) PLLI2SQ() RMPLLI2SCFGR

func (*RCC_Periph) PLLI2SR 

func (p *RCC_Periph) PLLI2SR() RMPLLI2SCFGR

func (*RCC_Periph) PLLI2SRDY 

func (p *RCC_Periph) PLLI2SRDY() RMCR

func (*RCC_Periph) PLLI2SRDYC 

func (p *RCC_Periph) PLLI2SRDYC() RMCIR

func (*RCC_Periph) PLLI2SRDYF 

func (p *RCC_Periph) PLLI2SRDYF() RMCIR

func (*RCC_Periph) PLLI2SRDYIE 

func (p *RCC_Periph) PLLI2SRDYIE() RMCIR

func (*RCC_Periph) PLLM 

func (p *RCC_Periph) PLLM() RMPLLCFGR

func (*RCC_Periph) PLLN 

func (p *RCC_Periph) PLLN() RMPLLCFGR

func (*RCC_Periph) PLLON 

func (p *RCC_Periph) PLLON() RMCR

func (*RCC_Periph) PLLP 

func (p *RCC_Periph) PLLP() RMPLLCFGR

func (*RCC_Periph) PLLQ 

func (p *RCC_Periph) PLLQ() RMPLLCFGR

func (*RCC_Periph) PLLRDY 

func (p *RCC_Periph) PLLRDY() RMCR

func (*RCC_Periph) PLLRDYC 

func (p *RCC_Periph) PLLRDYC() RMCIR

func (*RCC_Periph) PLLRDYF 

func (p *RCC_Periph) PLLRDYF() RMCIR

func (*RCC_Periph) PLLRDYIE 

func (p *RCC_Periph) PLLRDYIE() RMCIR

func (*RCC_Periph) PLLSAIDIVQ 

func (p *RCC_Periph) PLLSAIDIVQ() RMDCKCFGR

func (*RCC_Periph) PLLSAIDIVR 

func (p *RCC_Periph) PLLSAIDIVR() RMDCKCFGR

func (*RCC_Periph) PLLSAIN 

func (p *RCC_Periph) PLLSAIN() RMPLLSAICFGR

func (*RCC_Periph) PLLSAION 

func (p *RCC_Periph) PLLSAION() RMCR

func (*RCC_Periph) PLLSAIQ 

func (p *RCC_Periph) PLLSAIQ() RMPLLSAICFGR

func (*RCC_Periph) PLLSAIR 

func (p *RCC_Periph) PLLSAIR() RMPLLSAICFGR

func (*RCC_Periph) PLLSAIRDY 

func (p *RCC_Periph) PLLSAIRDY() RMCR

func (*RCC_Periph) PLLSAIRDYC 

func (p *RCC_Periph) PLLSAIRDYC() RMCIR

func (*RCC_Periph) PLLSAIRDYF 

func (p *RCC_Periph) PLLSAIRDYF() RMCIR

func (*RCC_Periph) PLLSAIRDYIE 

func (p *RCC_Periph) PLLSAIRDYIE() RMCIR

func (*RCC_Periph) PLLSRC 

func (p *RCC_Periph) PLLSRC() RMPLLCFGR

func (*RCC_Periph) PORRSTF 

func (p *RCC_Periph) PORRSTF() RMCSR

func (*RCC_Periph) PPRE1 

func (p *RCC_Periph) PPRE1() RMCFGR

func (*RCC_Periph) PPRE2 

func (p *RCC_Periph) PPRE2() RMCFGR

func (*RCC_Periph) PWREN 

func (p *RCC_Periph) PWREN() RMAPB1ENR

func (*RCC_Periph) PWRLPEN 

func (p *RCC_Periph) PWRLPEN() RMAPB1LPENR

func (*RCC_Periph) PWRRST 

func (p *RCC_Periph) PWRRST() RMAPB1RSTR

func (*RCC_Periph) RMVF 

func (p *RCC_Periph) RMVF() RMCSR

func (*RCC_Periph) RNGEN 

func (p *RCC_Periph) RNGEN() RMAHB2ENR

func (*RCC_Periph) RNGLPEN 

func (p *RCC_Periph) RNGLPEN() RMAHB2LPENR

func (*RCC_Periph) RNGRST 

func (p *RCC_Periph) RNGRST() RMAHB2RSTR

func (*RCC_Periph) RTCEN 

func (p *RCC_Periph) RTCEN() RMBDCR

func (*RCC_Periph) RTCPRE 

func (p *RCC_Periph) RTCPRE() RMCFGR

func (*RCC_Periph) RTCSEL 

func (p *RCC_Periph) RTCSEL() RMBDCR

func (*RCC_Periph) SAI1ASRC 

func (p *RCC_Periph) SAI1ASRC() RMDCKCFGR

func (*RCC_Periph) SAI1BSRC 

func (p *RCC_Periph) SAI1BSRC() RMDCKCFGR

func (*RCC_Periph) SAI1EN 

func (p *RCC_Periph) SAI1EN() RMAPB2ENR

func (*RCC_Periph) SAI1LPEN 

func (p *RCC_Periph) SAI1LPEN() RMAPB2LPENR

func (*RCC_Periph) SAI1RST 

func (p *RCC_Periph) SAI1RST() RMAPB2RSTR

func (*RCC_Periph) SDIOEN 

func (p *RCC_Periph) SDIOEN() RMAPB2ENR

func (*RCC_Periph) SDIOLPEN 

func (p *RCC_Periph) SDIOLPEN() RMAPB2LPENR

func (*RCC_Periph) SDIORST 

func (p *RCC_Periph) SDIORST() RMAPB2RSTR

func (*RCC_Periph) SFTRSTF 

func (p *RCC_Periph) SFTRSTF() RMCSR

func (*RCC_Periph) SPI1EN 

func (p *RCC_Periph) SPI1EN() RMAPB2ENR

func (*RCC_Periph) SPI1LPEN 

func (p *RCC_Periph) SPI1LPEN() RMAPB2LPENR

func (*RCC_Periph) SPI1RST 

func (p *RCC_Periph) SPI1RST() RMAPB2RSTR

func (*RCC_Periph) SPI2EN 

func (p *RCC_Periph) SPI2EN() RMAPB1ENR

func (*RCC_Periph) SPI2LPEN 

func (p *RCC_Periph) SPI2LPEN() RMAPB1LPENR

func (*RCC_Periph) SPI2RST 

func (p *RCC_Periph) SPI2RST() RMAPB1RSTR

func (*RCC_Periph) SPI3EN 

func (p *RCC_Periph) SPI3EN() RMAPB1ENR

func (*RCC_Periph) SPI3LPEN 

func (p *RCC_Periph) SPI3LPEN() RMAPB1LPENR

func (*RCC_Periph) SPI3RST 

func (p *RCC_Periph) SPI3RST() RMAPB1RSTR

func (*RCC_Periph) SPI4EN 

func (p *RCC_Periph) SPI4EN() RMAPB2ENR

func (*RCC_Periph) SPI4LPEN 

func (p *RCC_Periph) SPI4LPEN() RMAPB2LPENR

func (*RCC_Periph) SPI4RST 

func (p *RCC_Periph) SPI4RST() RMAPB2RSTR

func (*RCC_Periph) SPI5EN 

func (p *RCC_Periph) SPI5EN() RMAPB2ENR

func (*RCC_Periph) SPI5LPEN 

func (p *RCC_Periph) SPI5LPEN() RMAPB2LPENR

func (*RCC_Periph) SPI5RST 

func (p *RCC_Periph) SPI5RST() RMAPB2RSTR

func (*RCC_Periph) SPI6EN 

func (p *RCC_Periph) SPI6EN() RMAPB2ENR

func (*RCC_Periph) SPI6LPEN 

func (p *RCC_Periph) SPI6LPEN() RMAPB2LPENR

func (*RCC_Periph) SPI6RST 

func (p *RCC_Periph) SPI6RST() RMAPB2RSTR

func (*RCC_Periph) SPREADSEL 

func (p *RCC_Periph) SPREADSEL() RMSSCGR

func (*RCC_Periph) SRAM1LPEN 

func (p *RCC_Periph) SRAM1LPEN() RMAHB1LPENR

func (*RCC_Periph) SRAM2LPEN 

func (p *RCC_Periph) SRAM2LPEN() RMAHB1LPENR

func (*RCC_Periph) SRAM3LPEN 

func (p *RCC_Periph) SRAM3LPEN() RMAHB1LPENR

func (*RCC_Periph) SSCGEN 

func (p *RCC_Periph) SSCGEN() RMSSCGR

func (*RCC_Periph) SW 

func (p *RCC_Periph) SW() RMCFGR

func (*RCC_Periph) SWS 

func (p *RCC_Periph) SWS() RMCFGR

func (*RCC_Periph) SYSCFGEN 

func (p *RCC_Periph) SYSCFGEN() RMAPB2ENR

func (*RCC_Periph) SYSCFGLPEN 

func (p *RCC_Periph) SYSCFGLPEN() RMAPB2LPENR

func (*RCC_Periph) SYSCFGRST 

func (p *RCC_Periph) SYSCFGRST() RMAPB2RSTR

func (*RCC_Periph) TIM10EN 

func (p *RCC_Periph) TIM10EN() RMAPB2ENR

func (*RCC_Periph) TIM10LPEN 

func (p *RCC_Periph) TIM10LPEN() RMAPB2LPENR

func (*RCC_Periph) TIM10RST 

func (p *RCC_Periph) TIM10RST() RMAPB2RSTR

func (*RCC_Periph) TIM11EN 

func (p *RCC_Periph) TIM11EN() RMAPB2ENR

func (*RCC_Periph) TIM11LPEN 

func (p *RCC_Periph) TIM11LPEN() RMAPB2LPENR

func (*RCC_Periph) TIM11RST 

func (p *RCC_Periph) TIM11RST() RMAPB2RSTR

func (*RCC_Periph) TIM12EN 

func (p *RCC_Periph) TIM12EN() RMAPB1ENR

func (*RCC_Periph) TIM12LPEN 

func (p *RCC_Periph) TIM12LPEN() RMAPB1LPENR

func (*RCC_Periph) TIM12RST 

func (p *RCC_Periph) TIM12RST() RMAPB1RSTR

func (*RCC_Periph) TIM13EN 

func (p *RCC_Periph) TIM13EN() RMAPB1ENR

func (*RCC_Periph) TIM13LPEN 

func (p *RCC_Periph) TIM13LPEN() RMAPB1LPENR

func (*RCC_Periph) TIM13RST 

func (p *RCC_Periph) TIM13RST() RMAPB1RSTR

func (*RCC_Periph) TIM14EN 

func (p *RCC_Periph) TIM14EN() RMAPB1ENR

func (*RCC_Periph) TIM14LPEN 

func (p *RCC_Periph) TIM14LPEN() RMAPB1LPENR

func (*RCC_Periph) TIM14RST 

func (p *RCC_Periph) TIM14RST() RMAPB1RSTR

func (*RCC_Periph) TIM1EN 

func (p *RCC_Periph) TIM1EN() RMAPB2ENR

func (*RCC_Periph) TIM1LPEN 

func (p *RCC_Periph) TIM1LPEN() RMAPB2LPENR

func (*RCC_Periph) TIM1RST 

func (p *RCC_Periph) TIM1RST() RMAPB2RSTR

func (*RCC_Periph) TIM2EN 

func (p *RCC_Periph) TIM2EN() RMAPB1ENR

func (*RCC_Periph) TIM2LPEN 

func (p *RCC_Periph) TIM2LPEN() RMAPB1LPENR

func (*RCC_Periph) TIM2RST 

func (p *RCC_Periph) TIM2RST() RMAPB1RSTR

func (*RCC_Periph) TIM3EN 

func (p *RCC_Periph) TIM3EN() RMAPB1ENR

func (*RCC_Periph) TIM3LPEN 

func (p *RCC_Periph) TIM3LPEN() RMAPB1LPENR

func (*RCC_Periph) TIM3RST 

func (p *RCC_Periph) TIM3RST() RMAPB1RSTR

func (*RCC_Periph) TIM4EN 

func (p *RCC_Periph) TIM4EN() RMAPB1ENR

func (*RCC_Periph) TIM4LPEN 

func (p *RCC_Periph) TIM4LPEN() RMAPB1LPENR

func (*RCC_Periph) TIM4RST 

func (p *RCC_Periph) TIM4RST() RMAPB1RSTR

func (*RCC_Periph) TIM5EN 

func (p *RCC_Periph) TIM5EN() RMAPB1ENR

func (*RCC_Periph) TIM5LPEN 

func (p *RCC_Periph) TIM5LPEN() RMAPB1LPENR

func (*RCC_Periph) TIM5RST 

func (p *RCC_Periph) TIM5RST() RMAPB1RSTR

func (*RCC_Periph) TIM6EN 

func (p *RCC_Periph) TIM6EN() RMAPB1ENR

func (*RCC_Periph) TIM6LPEN 

func (p *RCC_Periph) TIM6LPEN() RMAPB1LPENR

func (*RCC_Periph) TIM6RST 

func (p *RCC_Periph) TIM6RST() RMAPB1RSTR

func (*RCC_Periph) TIM7EN 

func (p *RCC_Periph) TIM7EN() RMAPB1ENR

func (*RCC_Periph) TIM7LPEN 

func (p *RCC_Periph) TIM7LPEN() RMAPB1LPENR

func (*RCC_Periph) TIM7RST 

func (p *RCC_Periph) TIM7RST() RMAPB1RSTR

func (*RCC_Periph) TIM8EN 

func (p *RCC_Periph) TIM8EN() RMAPB2ENR

func (*RCC_Periph) TIM8LPEN 

func (p *RCC_Periph) TIM8LPEN() RMAPB2LPENR

func (*RCC_Periph) TIM8RST 

func (p *RCC_Periph) TIM8RST() RMAPB2RSTR

func (*RCC_Periph) TIM9EN 

func (p *RCC_Periph) TIM9EN() RMAPB2ENR

func (*RCC_Periph) TIM9LPEN 

func (p *RCC_Periph) TIM9LPEN() RMAPB2LPENR

func (*RCC_Periph) TIM9RST 

func (p *RCC_Periph) TIM9RST() RMAPB2RSTR

func (*RCC_Periph) TIMPRE 

func (p *RCC_Periph) TIMPRE() RMDCKCFGR

func (*RCC_Periph) UART4EN 

func (p *RCC_Periph) UART4EN() RMAPB1ENR

func (*RCC_Periph) UART4LPEN 

func (p *RCC_Periph) UART4LPEN() RMAPB1LPENR

func (*RCC_Periph) UART4RST 

func (p *RCC_Periph) UART4RST() RMAPB1RSTR

func (*RCC_Periph) UART5EN 

func (p *RCC_Periph) UART5EN() RMAPB1ENR

func (*RCC_Periph) UART5LPEN 

func (p *RCC_Periph) UART5LPEN() RMAPB1LPENR

func (*RCC_Periph) UART5RST 

func (p *RCC_Periph) UART5RST() RMAPB1RSTR

func (*RCC_Periph) UART7EN 

func (p *RCC_Periph) UART7EN() RMAPB1ENR

func (*RCC_Periph) UART7LPEN 

func (p *RCC_Periph) UART7LPEN() RMAPB1LPENR

func (*RCC_Periph) UART7RST 

func (p *RCC_Periph) UART7RST() RMAPB1RSTR

func (*RCC_Periph) UART8EN 

func (p *RCC_Periph) UART8EN() RMAPB1ENR

func (*RCC_Periph) UART8LPEN 

func (p *RCC_Periph) UART8LPEN() RMAPB1LPENR

func (*RCC_Periph) UART8RST 

func (p *RCC_Periph) UART8RST() RMAPB1RSTR

func (*RCC_Periph) USART1EN 

func (p *RCC_Periph) USART1EN() RMAPB2ENR

func (*RCC_Periph) USART1LPEN 

func (p *RCC_Periph) USART1LPEN() RMAPB2LPENR

func (*RCC_Periph) USART1RST 

func (p *RCC_Periph) USART1RST() RMAPB2RSTR

func (*RCC_Periph) USART2EN 

func (p *RCC_Periph) USART2EN() RMAPB1ENR

func (*RCC_Periph) USART2LPEN 

func (p *RCC_Periph) USART2LPEN() RMAPB1LPENR

func (*RCC_Periph) USART2RST 

func (p *RCC_Periph) USART2RST() RMAPB1RSTR

func (*RCC_Periph) USART3EN 

func (p *RCC_Periph) USART3EN() RMAPB1ENR

func (*RCC_Periph) USART3LPEN 

func (p *RCC_Periph) USART3LPEN() RMAPB1LPENR

func (*RCC_Periph) USART3RST 

func (p *RCC_Periph) USART3RST() RMAPB1RSTR

func (*RCC_Periph) USART6EN 

func (p *RCC_Periph) USART6EN() RMAPB2ENR

func (*RCC_Periph) USART6LPEN 

func (p *RCC_Periph) USART6LPEN() RMAPB2LPENR

func (*RCC_Periph) USART6RST 

func (p *RCC_Periph) USART6RST() RMAPB2RSTR

func (*RCC_Periph) WDGRSTF 

func (p *RCC_Periph) WDGRSTF() RMCSR

func (*RCC_Periph) WWDGEN 

func (p *RCC_Periph) WWDGEN() RMAPB1ENR

func (*RCC_Periph) WWDGLPEN 

func (p *RCC_Periph) WWDGLPEN() RMAPB1LPENR

func (*RCC_Periph) WWDGRST 

func (p *RCC_Periph) WWDGRST() RMAPB1RSTR

func (*RCC_Periph) WWDGRSTF 

func (p *RCC_Periph) WWDGRSTF() RMCSR

type RCFGR 

type RCFGR struct{ mmio.U32 }

func (*RCFGR) AtomicClearBits 

func (r *RCFGR) AtomicClearBits(mask CFGR)

func (*RCFGR) AtomicSetBits 

func (r *RCFGR) AtomicSetBits(mask CFGR)

func (*RCFGR) AtomicStoreBits 

func (r *RCFGR) AtomicStoreBits(mask, b CFGR)

func (*RCFGR) Bits 

func (r *RCFGR) Bits(mask CFGR) CFGR

func (*RCFGR) ClearBits 

func (r *RCFGR) ClearBits(mask CFGR)

func (*RCFGR) Load 

func (r *RCFGR) Load() CFGR

func (*RCFGR) SetBits 

func (r *RCFGR) SetBits(mask CFGR)

func (*RCFGR) Store 

func (r *RCFGR) Store(b CFGR)

func (*RCFGR) StoreBits 

func (r *RCFGR) StoreBits(mask, b CFGR)

type RCIR 

type RCIR struct{ mmio.U32 }

func (*RCIR) AtomicClearBits 

func (r *RCIR) AtomicClearBits(mask CIR)

func (*RCIR) AtomicSetBits 

func (r *RCIR) AtomicSetBits(mask CIR)

func (*RCIR) AtomicStoreBits 

func (r *RCIR) AtomicStoreBits(mask, b CIR)

func (*RCIR) Bits 

func (r *RCIR) Bits(mask CIR) CIR

func (*RCIR) ClearBits 

func (r *RCIR) ClearBits(mask CIR)

func (*RCIR) Load 

func (r *RCIR) Load() CIR

func (*RCIR) SetBits 

func (r *RCIR) SetBits(mask CIR)

func (*RCIR) Store 

func (r *RCIR) Store(b CIR)

func (*RCIR) StoreBits 

func (r *RCIR) StoreBits(mask, b CIR)

type RCKGATENR 

type RCKGATENR struct{ mmio.U32 }

func (*RCKGATENR) AtomicClearBits 

func (r *RCKGATENR) AtomicClearBits(mask CKGATENR)

func (*RCKGATENR) AtomicSetBits 

func (r *RCKGATENR) AtomicSetBits(mask CKGATENR)

func (*RCKGATENR) AtomicStoreBits 

func (r *RCKGATENR) AtomicStoreBits(mask, b CKGATENR)

func (*RCKGATENR) Bits 

func (r *RCKGATENR) Bits(mask CKGATENR) CKGATENR

func (*RCKGATENR) ClearBits 

func (r *RCKGATENR) ClearBits(mask CKGATENR)

func (*RCKGATENR) Load 

func (r *RCKGATENR) Load() CKGATENR

func (*RCKGATENR) SetBits 

func (r *RCKGATENR) SetBits(mask CKGATENR)

func (*RCKGATENR) Store 

func (r *RCKGATENR) Store(b CKGATENR)

func (*RCKGATENR) StoreBits 

func (r *RCKGATENR) StoreBits(mask, b CKGATENR)

type RCR 

type RCR struct{ mmio.U32 }

func (*RCR) AtomicClearBits 

func (r *RCR) AtomicClearBits(mask CR)

func (*RCR) AtomicSetBits 

func (r *RCR) AtomicSetBits(mask CR)

func (*RCR) AtomicStoreBits 

func (r *RCR) AtomicStoreBits(mask, b CR)

func (*RCR) Bits 

func (r *RCR) Bits(mask CR) CR

func (*RCR) ClearBits 

func (r *RCR) ClearBits(mask CR)

func (*RCR) Load 

func (r *RCR) Load() CR

func (*RCR) SetBits 

func (r *RCR) SetBits(mask CR)

func (*RCR) Store 

func (r *RCR) Store(b CR)

func (*RCR) StoreBits 

func (r *RCR) StoreBits(mask, b CR)

type RCSR 

type RCSR struct{ mmio.U32 }

func (*RCSR) AtomicClearBits 

func (r *RCSR) AtomicClearBits(mask CSR)

func (*RCSR) AtomicSetBits 

func (r *RCSR) AtomicSetBits(mask CSR)

func (*RCSR) AtomicStoreBits 

func (r *RCSR) AtomicStoreBits(mask, b CSR)

func (*RCSR) Bits 

func (r *RCSR) Bits(mask CSR) CSR

func (*RCSR) ClearBits 

func (r *RCSR) ClearBits(mask CSR)

func (*RCSR) Load 

func (r *RCSR) Load() CSR

func (*RCSR) SetBits 

func (r *RCSR) SetBits(mask CSR)

func (*RCSR) Store 

func (r *RCSR) Store(b CSR)

func (*RCSR) StoreBits 

func (r *RCSR) StoreBits(mask, b CSR)

type RDCKCFGR 

type RDCKCFGR struct{ mmio.U32 }

func (*RDCKCFGR) AtomicClearBits 

func (r *RDCKCFGR) AtomicClearBits(mask DCKCFGR)

func (*RDCKCFGR) AtomicSetBits 

func (r *RDCKCFGR) AtomicSetBits(mask DCKCFGR)

func (*RDCKCFGR) AtomicStoreBits 

func (r *RDCKCFGR) AtomicStoreBits(mask, b DCKCFGR)

func (*RDCKCFGR) Bits 

func (r *RDCKCFGR) Bits(mask DCKCFGR) DCKCFGR

func (*RDCKCFGR) ClearBits 

func (r *RDCKCFGR) ClearBits(mask DCKCFGR)

func (*RDCKCFGR) Load 

func (r *RDCKCFGR) Load() DCKCFGR

func (*RDCKCFGR) SetBits 

func (r *RDCKCFGR) SetBits(mask DCKCFGR)

func (*RDCKCFGR) Store 

func (r *RDCKCFGR) Store(b DCKCFGR)

func (*RDCKCFGR) StoreBits 

func (r *RDCKCFGR) StoreBits(mask, b DCKCFGR)

type RDCKCFGR2 

type RDCKCFGR2 struct{ mmio.U32 }

func (*RDCKCFGR2) AtomicClearBits 

func (r *RDCKCFGR2) AtomicClearBits(mask DCKCFGR2)

func (*RDCKCFGR2) AtomicSetBits 

func (r *RDCKCFGR2) AtomicSetBits(mask DCKCFGR2)

func (*RDCKCFGR2) AtomicStoreBits 

func (r *RDCKCFGR2) AtomicStoreBits(mask, b DCKCFGR2)

func (*RDCKCFGR2) Bits 

func (r *RDCKCFGR2) Bits(mask DCKCFGR2) DCKCFGR2

func (*RDCKCFGR2) ClearBits 

func (r *RDCKCFGR2) ClearBits(mask DCKCFGR2)

func (*RDCKCFGR2) Load 

func (r *RDCKCFGR2) Load() DCKCFGR2

func (*RDCKCFGR2) SetBits 

func (r *RDCKCFGR2) SetBits(mask DCKCFGR2)

func (*RDCKCFGR2) Store 

func (r *RDCKCFGR2) Store(b DCKCFGR2)

func (*RDCKCFGR2) StoreBits 

func (r *RDCKCFGR2) StoreBits(mask, b DCKCFGR2)

type RMAHB1ENR 

type RMAHB1ENR struct{ mmio.UM32 }

func (RMAHB1ENR) Load 

func (rm RMAHB1ENR) Load() AHB1ENR

func (RMAHB1ENR) Store 

func (rm RMAHB1ENR) Store(b AHB1ENR)

type RMAHB1LPENR 

type RMAHB1LPENR struct{ mmio.UM32 }

func (RMAHB1LPENR) Load 

func (rm RMAHB1LPENR) Load() AHB1LPENR

func (RMAHB1LPENR) Store 

func (rm RMAHB1LPENR) Store(b AHB1LPENR)

type RMAHB1RSTR 

type RMAHB1RSTR struct{ mmio.UM32 }

func (RMAHB1RSTR) Load 

func (rm RMAHB1RSTR) Load() AHB1RSTR

func (RMAHB1RSTR) Store 

func (rm RMAHB1RSTR) Store(b AHB1RSTR)

type RMAHB2ENR 

type RMAHB2ENR struct{ mmio.UM32 }

func (RMAHB2ENR) Load 

func (rm RMAHB2ENR) Load() AHB2ENR

func (RMAHB2ENR) Store 

func (rm RMAHB2ENR) Store(b AHB2ENR)

type RMAHB2LPENR 

type RMAHB2LPENR struct{ mmio.UM32 }

func (RMAHB2LPENR) Load 

func (rm RMAHB2LPENR) Load() AHB2LPENR

func (RMAHB2LPENR) Store 

func (rm RMAHB2LPENR) Store(b AHB2LPENR)

type RMAHB2RSTR 

type RMAHB2RSTR struct{ mmio.UM32 }

func (RMAHB2RSTR) Load 

func (rm RMAHB2RSTR) Load() AHB2RSTR

func (RMAHB2RSTR) Store 

func (rm RMAHB2RSTR) Store(b AHB2RSTR)

type RMAHB3ENR 

type RMAHB3ENR struct{ mmio.UM32 }

func (RMAHB3ENR) Load 

func (rm RMAHB3ENR) Load() AHB3ENR

func (RMAHB3ENR) Store 

func (rm RMAHB3ENR) Store(b AHB3ENR)

type RMAHB3LPENR 

type RMAHB3LPENR struct{ mmio.UM32 }

func (RMAHB3LPENR) Load 

func (rm RMAHB3LPENR) Load() AHB3LPENR

func (RMAHB3LPENR) Store 

func (rm RMAHB3LPENR) Store(b AHB3LPENR)

type RMAHB3RSTR 

type RMAHB3RSTR struct{ mmio.UM32 }

func (RMAHB3RSTR) Load 

func (rm RMAHB3RSTR) Load() AHB3RSTR

func (RMAHB3RSTR) Store 

func (rm RMAHB3RSTR) Store(b AHB3RSTR)

type RMAPB1ENR 

type RMAPB1ENR struct{ mmio.UM32 }

func (RMAPB1ENR) Load 

func (rm RMAPB1ENR) Load() APB1ENR

func (RMAPB1ENR) Store 

func (rm RMAPB1ENR) Store(b APB1ENR)

type RMAPB1LPENR 

type RMAPB1LPENR struct{ mmio.UM32 }

func (RMAPB1LPENR) Load 

func (rm RMAPB1LPENR) Load() APB1LPENR

func (RMAPB1LPENR) Store 

func (rm RMAPB1LPENR) Store(b APB1LPENR)

type RMAPB1RSTR 

type RMAPB1RSTR struct{ mmio.UM32 }

func (RMAPB1RSTR) Load 

func (rm RMAPB1RSTR) Load() APB1RSTR

func (RMAPB1RSTR) Store 

func (rm RMAPB1RSTR) Store(b APB1RSTR)

type RMAPB2ENR 

type RMAPB2ENR struct{ mmio.UM32 }

func (RMAPB2ENR) Load 

func (rm RMAPB2ENR) Load() APB2ENR

func (RMAPB2ENR) Store 

func (rm RMAPB2ENR) Store(b APB2ENR)

type RMAPB2LPENR 

type RMAPB2LPENR struct{ mmio.UM32 }

func (RMAPB2LPENR) Load 

func (rm RMAPB2LPENR) Load() APB2LPENR

func (RMAPB2LPENR) Store 

func (rm RMAPB2LPENR) Store(b APB2LPENR)

type RMAPB2RSTR 

type RMAPB2RSTR struct{ mmio.UM32 }

func (RMAPB2RSTR) Load 

func (rm RMAPB2RSTR) Load() APB2RSTR

func (RMAPB2RSTR) Store 

func (rm RMAPB2RSTR) Store(b APB2RSTR)

type RMBDCR 

type RMBDCR struct{ mmio.UM32 }

func (RMBDCR) Load 

func (rm RMBDCR) Load() BDCR

func (RMBDCR) Store 

func (rm RMBDCR) Store(b BDCR)

type RMCFGR 

type RMCFGR struct{ mmio.UM32 }

func (RMCFGR) Load 

func (rm RMCFGR) Load() CFGR

func (RMCFGR) Store 

func (rm RMCFGR) Store(b CFGR)

type RMCIR 

type RMCIR struct{ mmio.UM32 }

func (RMCIR) Load 

func (rm RMCIR) Load() CIR

func (RMCIR) Store 

func (rm RMCIR) Store(b CIR)

type RMCKGATENR 

type RMCKGATENR struct{ mmio.UM32 }

func (RMCKGATENR) Load 

func (rm RMCKGATENR) Load() CKGATENR

func (RMCKGATENR) Store 

func (rm RMCKGATENR) Store(b CKGATENR)

type RMCR 

type RMCR struct{ mmio.UM32 }

func (RMCR) Load 

func (rm RMCR) Load() CR

func (RMCR) Store 

func (rm RMCR) Store(b CR)

type RMCSR 

type RMCSR struct{ mmio.UM32 }

func (RMCSR) Load 

func (rm RMCSR) Load() CSR

func (RMCSR) Store 

func (rm RMCSR) Store(b CSR)

type RMDCKCFGR 

type RMDCKCFGR struct{ mmio.UM32 }

func (RMDCKCFGR) Load 

func (rm RMDCKCFGR) Load() DCKCFGR

func (RMDCKCFGR) Store 

func (rm RMDCKCFGR) Store(b DCKCFGR)

type RMDCKCFGR2 

type RMDCKCFGR2 struct{ mmio.UM32 }

func (RMDCKCFGR2) Load 

func (rm RMDCKCFGR2) Load() DCKCFGR2

func (RMDCKCFGR2) Store 

func (rm RMDCKCFGR2) Store(b DCKCFGR2)

type RMPLLCFGR 

type RMPLLCFGR struct{ mmio.UM32 }

func (RMPLLCFGR) Load 

func (rm RMPLLCFGR) Load() PLLCFGR

func (RMPLLCFGR) Store 

func (rm RMPLLCFGR) Store(b PLLCFGR)

type RMPLLI2SCFGR 

type RMPLLI2SCFGR struct{ mmio.UM32 }

func (RMPLLI2SCFGR) Load 

func (rm RMPLLI2SCFGR) Load() PLLI2SCFGR

func (RMPLLI2SCFGR) Store 

func (rm RMPLLI2SCFGR) Store(b PLLI2SCFGR)

type RMPLLSAICFGR 

type RMPLLSAICFGR struct{ mmio.UM32 }

func (RMPLLSAICFGR) Load 

func (rm RMPLLSAICFGR) Load() PLLSAICFGR

func (RMPLLSAICFGR) Store 

func (rm RMPLLSAICFGR) Store(b PLLSAICFGR)

type RMSSCGR 

type RMSSCGR struct{ mmio.UM32 }

func (RMSSCGR) Load 

func (rm RMSSCGR) Load() SSCGR

func (RMSSCGR) Store 

func (rm RMSSCGR) Store(b SSCGR)

type RPLLCFGR 

type RPLLCFGR struct{ mmio.U32 }

func (*RPLLCFGR) AtomicClearBits 

func (r *RPLLCFGR) AtomicClearBits(mask PLLCFGR)

func (*RPLLCFGR) AtomicSetBits 

func (r *RPLLCFGR) AtomicSetBits(mask PLLCFGR)

func (*RPLLCFGR) AtomicStoreBits 

func (r *RPLLCFGR) AtomicStoreBits(mask, b PLLCFGR)

func (*RPLLCFGR) Bits 

func (r *RPLLCFGR) Bits(mask PLLCFGR) PLLCFGR

func (*RPLLCFGR) ClearBits 

func (r *RPLLCFGR) ClearBits(mask PLLCFGR)

func (*RPLLCFGR) Load 

func (r *RPLLCFGR) Load() PLLCFGR

func (*RPLLCFGR) SetBits 

func (r *RPLLCFGR) SetBits(mask PLLCFGR)

func (*RPLLCFGR) Store 

func (r *RPLLCFGR) Store(b PLLCFGR)

func (*RPLLCFGR) StoreBits 

func (r *RPLLCFGR) StoreBits(mask, b PLLCFGR)

type RPLLI2SCFGR 

type RPLLI2SCFGR struct{ mmio.U32 }

func (*RPLLI2SCFGR) AtomicClearBits 

func (r *RPLLI2SCFGR) AtomicClearBits(mask PLLI2SCFGR)

func (*RPLLI2SCFGR) AtomicSetBits 

func (r *RPLLI2SCFGR) AtomicSetBits(mask PLLI2SCFGR)

func (*RPLLI2SCFGR) AtomicStoreBits 

func (r *RPLLI2SCFGR) AtomicStoreBits(mask, b PLLI2SCFGR)

func (*RPLLI2SCFGR) Bits 

func (r *RPLLI2SCFGR) Bits(mask PLLI2SCFGR) PLLI2SCFGR

func (*RPLLI2SCFGR) ClearBits 

func (r *RPLLI2SCFGR) ClearBits(mask PLLI2SCFGR)

func (*RPLLI2SCFGR) Load 

func (r *RPLLI2SCFGR) Load() PLLI2SCFGR

func (*RPLLI2SCFGR) SetBits 

func (r *RPLLI2SCFGR) SetBits(mask PLLI2SCFGR)

func (*RPLLI2SCFGR) Store 

func (r *RPLLI2SCFGR) Store(b PLLI2SCFGR)

func (*RPLLI2SCFGR) StoreBits 

func (r *RPLLI2SCFGR) StoreBits(mask, b PLLI2SCFGR)

type RPLLSAICFGR 

type RPLLSAICFGR struct{ mmio.U32 }

func (*RPLLSAICFGR) AtomicClearBits 

func (r *RPLLSAICFGR) AtomicClearBits(mask PLLSAICFGR)

func (*RPLLSAICFGR) AtomicSetBits 

func (r *RPLLSAICFGR) AtomicSetBits(mask PLLSAICFGR)

func (*RPLLSAICFGR) AtomicStoreBits 

func (r *RPLLSAICFGR) AtomicStoreBits(mask, b PLLSAICFGR)

func (*RPLLSAICFGR) Bits 

func (r *RPLLSAICFGR) Bits(mask PLLSAICFGR) PLLSAICFGR

func (*RPLLSAICFGR) ClearBits 

func (r *RPLLSAICFGR) ClearBits(mask PLLSAICFGR)

func (*RPLLSAICFGR) Load 

func (r *RPLLSAICFGR) Load() PLLSAICFGR

func (*RPLLSAICFGR) SetBits 

func (r *RPLLSAICFGR) SetBits(mask PLLSAICFGR)

func (*RPLLSAICFGR) Store 

func (r *RPLLSAICFGR) Store(b PLLSAICFGR)

func (*RPLLSAICFGR) StoreBits 

func (r *RPLLSAICFGR) StoreBits(mask, b PLLSAICFGR)

type RSSCGR 

type RSSCGR struct{ mmio.U32 }

func (*RSSCGR) AtomicClearBits 

func (r *RSSCGR) AtomicClearBits(mask SSCGR)

func (*RSSCGR) AtomicSetBits 

func (r *RSSCGR) AtomicSetBits(mask SSCGR)

func (*RSSCGR) AtomicStoreBits 

func (r *RSSCGR) AtomicStoreBits(mask, b SSCGR)

func (*RSSCGR) Bits 

func (r *RSSCGR) Bits(mask SSCGR) SSCGR

func (*RSSCGR) ClearBits 

func (r *RSSCGR) ClearBits(mask SSCGR)

func (*RSSCGR) Load 

func (r *RSSCGR) Load() SSCGR

func (*RSSCGR) SetBits 

func (r *RSSCGR) SetBits(mask SSCGR)

func (*RSSCGR) Store 

func (r *RSSCGR) Store(b SSCGR)

func (*RSSCGR) StoreBits 

func (r *RSSCGR) StoreBits(mask, b SSCGR)

type SSCGR 

type SSCGR uint32
const (
	MODPER    SSCGR = 0x1FFF << 0  //+
	INCSTEP   SSCGR = 0x7FFF << 13 //+
	SPREADSEL SSCGR = 0x01 << 30   //+
	SSCGEN    SSCGR = 0x01 << 31   //+
)

func (SSCGR) Field 

func (b SSCGR) Field(mask SSCGR) int

func (SSCGR) J 

func (mask SSCGR) J(v int) SSCGR

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.