263 lines
8.6 KiB
Go
263 lines
8.6 KiB
Go
package common
|
|
|
|
// Bit field constants for PAD_CFG_DW0 register
|
|
const (
|
|
AllFields uint32 = 0xffffffff
|
|
|
|
PadRstCfgShift uint8 = 30
|
|
PadRstCfgMask uint32 = 0x3 << PadRstCfgShift
|
|
|
|
RxPadStateSelectShift uint8 = 29
|
|
RxPadStateSelectMask uint32 = 0x1 << RxPadStateSelectShift
|
|
|
|
RxRawOverrideTo1Shift uint8 = 28
|
|
RxRawOverrideTo1Mask uint32 = 0x1 << RxRawOverrideTo1Shift
|
|
|
|
RxLevelEdgeConfigurationShift uint8 = 25
|
|
RxLevelEdgeConfigurationMask uint32 = 0x3 << RxLevelEdgeConfigurationShift
|
|
|
|
RxInvertShift uint8 = 23
|
|
RxInvertMask uint32 = 0x1 << RxInvertShift
|
|
|
|
RxTxEnableConfigShift uint8 = 21
|
|
RxTxEnableConfigMask uint32 = 0x3 << RxTxEnableConfigShift
|
|
|
|
InputRouteIOxApicShift uint8 = 20
|
|
InputRouteIOxApicMask uint32 = 0x1 << InputRouteIOxApicShift
|
|
|
|
InputRouteSCIShift uint8 = 19
|
|
InputRouteSCIMask uint32 = 0x1 << InputRouteSCIShift
|
|
|
|
InputRouteSMIShift uint8 = 18
|
|
InputRouteSMIMask uint32 = 0x1 << InputRouteSMIShift
|
|
|
|
InputRouteNMIShift uint8 = 17
|
|
InputRouteNMIMask uint32 = 0x1 << InputRouteNMIShift
|
|
|
|
PadModeShift uint8 = 10
|
|
PadModeMask uint32 = 0x7 << PadModeShift
|
|
|
|
RxTxBufDisableShift uint8 = 8
|
|
RxTxBufDisableMask uint32 = 0x3 << RxTxBufDisableShift
|
|
|
|
RxStateShift uint8 = 1
|
|
RxStateMask uint32 = 0x1 << RxStateShift
|
|
|
|
TxStateMask uint32 = 0x1
|
|
)
|
|
|
|
// config DW registers
|
|
const (
|
|
PAD_CFG_DW0 = 0
|
|
PAD_CFG_DW1 = 1
|
|
MAX_DW_NUM = 2
|
|
)
|
|
|
|
// Register - configuration data structure based on DW0/1 dw value
|
|
// value : register value
|
|
// mask : bit fileds mask
|
|
// roFileds : read only fields mask
|
|
type Register struct {
|
|
value uint32
|
|
mask uint32
|
|
roFileds uint32
|
|
}
|
|
|
|
func (reg *Register) ValueSet(value uint32) *Register {
|
|
reg.value = value
|
|
return reg
|
|
}
|
|
|
|
func (reg *Register) ValueGet() uint32 {
|
|
return reg.value
|
|
}
|
|
|
|
func (reg *Register) ReadOnlyFieldsSet(fileldMask uint32) *Register {
|
|
reg.roFileds = fileldMask
|
|
return reg
|
|
}
|
|
|
|
func (reg *Register) ReadOnlyFieldsGet() uint32 {
|
|
return reg.roFileds
|
|
}
|
|
|
|
// Check the mask of the new macro
|
|
// Returns true if the macro is generated correctly
|
|
func (reg *Register) MaskCheck() bool {
|
|
mask := ^(reg.mask | reg.roFileds)
|
|
return reg.value&mask == 0
|
|
}
|
|
|
|
// getResetConfig - get Reset Configuration from PADRSTCFG field in PAD_CFG_DW0_GPx register
|
|
func (reg *Register) getFieldVal(mask uint32, shift uint8) uint8 {
|
|
reg.mask |= mask
|
|
return uint8((reg.value & mask) >> shift)
|
|
}
|
|
|
|
// CntrMaskFieldsClear - clear filed in control mask
|
|
// fieldMask - mask of the field to be cleared
|
|
func (reg *Register) CntrMaskFieldsClear(fieldMask uint32) {
|
|
reg.mask &= ^fieldMask;
|
|
}
|
|
|
|
// IgnoredFieldsGet - return mask of unchecked (ignored) fields.
|
|
// These bit fields were not read when the macro was
|
|
// generated.
|
|
// return
|
|
// mask of ignored bit field
|
|
func (reg *Register) IgnoredFieldsGet() uint32 {
|
|
mask := reg.mask | reg.roFileds
|
|
return reg.value & ^mask
|
|
}
|
|
|
|
// getResetConfig - returns type reset source for corresponding pad
|
|
// PADRSTCFG field in PAD_CFG_DW0 register
|
|
func (reg *Register) GetResetConfig() uint8 {
|
|
return reg.getFieldVal(PadRstCfgMask, PadRstCfgShift)
|
|
}
|
|
|
|
// getRXPadStateSelect - returns RX Pad State (RXINV)
|
|
// 0 = Raw RX pad state directly from RX buffer
|
|
// 1 = Internal RX pad state
|
|
func (reg *Register) GetRXPadStateSelect() uint8 {
|
|
return reg.getFieldVal(RxPadStateSelectMask, RxPadStateSelectShift)
|
|
}
|
|
|
|
// getRXRawOverrideStatus - returns 1 if the selected pad state is being
|
|
// overridden to '1' (RXRAW1 field)
|
|
func (reg *Register) GetRXRawOverrideStatus() uint8 {
|
|
return reg.getFieldVal(RxRawOverrideTo1Mask, RxRawOverrideTo1Shift)
|
|
}
|
|
|
|
// getRXLevelEdgeConfiguration - returns RX Level/Edge Configuration (RXEVCFG)
|
|
// 0h = Level, 1h = Edge, 2h = Drive '0', 3h = Reserved (implement as setting 0h)
|
|
func (reg *Register) GetRXLevelEdgeConfiguration() uint8 {
|
|
return reg.getFieldVal(RxLevelEdgeConfigurationMask, RxLevelEdgeConfigurationShift)
|
|
}
|
|
|
|
// GetRxInvert - returns RX Invert state (RXINV)
|
|
// 1 - Inversion, 0 - No inversion
|
|
func (reg *Register) GetRxInvert() uint8 {
|
|
return reg.getFieldVal(RxInvertMask, RxInvertShift)
|
|
}
|
|
|
|
// getRxTxEnableConfig - returns RX/TX Enable Config (RXTXENCFG)
|
|
// 0 = Function defined in Pad Mode controls TX and RX Enables
|
|
// 1 = Function controls TX Enable and RX Disabled with RX drive 0 internally
|
|
// 2 = Function controls TX Enable and RX Disabled with RX drive 1 internally
|
|
// 3 = Function controls TX Enabled and RX is always enabled
|
|
func (reg *Register) GetRxTxEnableConfig() uint8 {
|
|
return reg.getFieldVal(RxTxEnableConfigMask, RxTxEnableConfigShift)
|
|
}
|
|
|
|
// getGPIOInputRouteIOxAPIC - returns 1 if the pad can be routed to cause
|
|
// peripheral IRQ when configured in GPIO input mode.
|
|
func (reg *Register) GetGPIOInputRouteIOxAPIC() uint8 {
|
|
return reg.getFieldVal(InputRouteIOxApicMask, InputRouteIOxApicShift)
|
|
}
|
|
|
|
// getGPIOInputRouteSCI - returns 1 if the pad can be routed to cause SCI when
|
|
// configured in GPIO input mode.
|
|
func (reg *Register) GetGPIOInputRouteSCI() uint8 {
|
|
return reg.getFieldVal(InputRouteSCIMask, InputRouteSCIShift)
|
|
}
|
|
|
|
// getGPIOInputRouteSMI - returns 1 if the pad can be routed to cause SMI when
|
|
// configured in GPIO input mode
|
|
func (reg *Register) GetGPIOInputRouteSMI() uint8 {
|
|
return reg.getFieldVal(InputRouteSMIMask, InputRouteSMIShift)
|
|
}
|
|
|
|
// getGPIOInputRouteNMI - returns 1 if the pad can be routed to cause NMI when
|
|
// configured in GPIO input mode
|
|
func (reg *Register) GetGPIOInputRouteNMI() uint8 {
|
|
return reg.getFieldVal(InputRouteNMIMask, InputRouteNMIShift)
|
|
}
|
|
|
|
// getPadMode - reutrns pad mode or one of the native functions
|
|
// 0h = GPIO control the Pad.
|
|
// 1h = native function 1, if applicable, controls the Pad
|
|
// 2h = native function 2, if applicable, controls the Pad
|
|
// 3h = native function 3, if applicable, controls the Pad
|
|
// 4h = enable GPIO blink/PWM capability if applicable
|
|
func (reg *Register) GetPadMode() uint8 {
|
|
return reg.getFieldVal(PadModeMask, PadModeShift)
|
|
}
|
|
|
|
// getGPIORxTxDisableStatus - returns GPIO RX/TX buffer state (GPIORXDIS | GPIOTXDIS)
|
|
// 0 - both are enabled, 1 - TX Disable, 2 - RX Disable, 3 - both are disabled
|
|
func (reg *Register) GetGPIORxTxDisableStatus() uint8 {
|
|
return reg.getFieldVal(RxTxBufDisableMask, RxTxBufDisableShift)
|
|
}
|
|
|
|
// getGPIORXState - returns GPIO RX State (GPIORXSTATE)
|
|
func (reg *Register) GetGPIORXState() uint8 {
|
|
return reg.getFieldVal(RxStateMask, RxStateShift)
|
|
}
|
|
|
|
// getGPIOTXState - returns GPIO TX State (GPIOTXSTATE)
|
|
func (reg *Register) GetGPIOTXState() uint8 {
|
|
return reg.getFieldVal(TxStateMask, 0)
|
|
}
|
|
|
|
// Bit field constants for PAD_CFG_DW1 register
|
|
const (
|
|
PadTolShift uint8 = 25
|
|
PadTolMask uint32 = 0x1 << PadTolShift
|
|
|
|
IOStandbyStateShift uint8 = 14
|
|
IOStandbyStateMask uint32 = 0xF << IOStandbyStateShift
|
|
|
|
TermShift uint8 = 10
|
|
TermMask uint32 = 0xF << TermShift
|
|
|
|
IOStandbyTerminationShift uint8 = 8
|
|
IOStandbyTerminationMask uint32 = 0x3 << IOStandbyTerminationShift
|
|
|
|
InterruptSelectMask uint32 = 0xFF
|
|
)
|
|
|
|
// GetPadTol
|
|
func (reg *Register) GetPadTol() uint8 {
|
|
return reg.getFieldVal(PadTolMask, PadTolShift)
|
|
}
|
|
|
|
// getIOStandbyState - return IO Standby State (IOSSTATE)
|
|
// 0 = Tx enabled driving last value driven, Rx enabled
|
|
// 1 = Tx enabled driving 0, Rx disabled and Rx driving 0 back to its controller internally
|
|
// 2 = Tx enabled driving 0, Rx disabled and Rx driving 1 back to its controller internally
|
|
// 3 = Tx enabled driving 1, Rx disabled and Rx driving 0 back to its controller internally
|
|
// 4 = Tx enabled driving 1, Rx disabled and Rx driving 1 back to its controller internally
|
|
// 5 = Tx enabled driving 0, Rx enabled
|
|
// 6 = Tx enabled driving 1, Rx enabled
|
|
// 7 = Hi-Z, Rx driving 0 back to its controller internally
|
|
// 8 = Hi-Z, Rx driving 1 back to its controller internally
|
|
// 9 = Tx disabled, Rx enabled
|
|
// 15 = IO-Standby is ignored for this pin (same as functional mode)
|
|
// Others reserved
|
|
func (reg *Register) GetIOStandbyState() uint8 {
|
|
return reg.getFieldVal(IOStandbyStateMask, IOStandbyStateShift)
|
|
}
|
|
|
|
// getIOStandbyTermination - return IO Standby Termination (IOSTERM)
|
|
// 0 = Same as functional mode (no change)
|
|
// 1 = Disable Pull-up and Pull-down (no on-die termination)
|
|
// 2 = Enable Pull-down
|
|
// 3 = Enable Pull-up
|
|
func (reg *Register) GetIOStandbyTermination() uint8 {
|
|
return reg.getFieldVal(IOStandbyTerminationMask, IOStandbyTerminationShift)
|
|
}
|
|
|
|
// getTermination - returns the pad termination state defines the different weak
|
|
// pull-up and pull-down settings that are supported by the buffer
|
|
// 0000 = none; 0010 = 5k PD; 0100 = 20k PD; 1010 = 5k PU; 1100 = 20k PU;
|
|
// 1111 = Native controller selected
|
|
func (reg *Register) GetTermination() uint8 {
|
|
return reg.getFieldVal(TermMask, TermShift)
|
|
}
|
|
|
|
// getInterruptSelect - returns Interrupt Line number from the GPIO controller
|
|
func (reg *Register) GetInterruptSelect() uint8 {
|
|
return reg.getFieldVal(InterruptSelectMask, 0)
|
|
}
|