Apollo Register Documentation  v2.4.2
CLKGEN - Clock Generator

CLKGEN Register Index

  0x00000000:   CALXT - XT Oscillator Control
  0x00000004:   CALRC - RC Oscillator Control
  0x00000008:   ACALCTR - Autocalibration Counter
  0x0000000C:   OCTRL - Oscillator Control
  0x00000010:   CLKOUT - CLKOUT Frequency Select
  0x00000014:   CLKKEY - Key Register for Clock Control Register
  0x00000018:   CCTRL - HFRC Clock Control
  0x0000001C:   STATUS - Clock Generator Status
  0x00000020:   HFADJ - HFRC Adjustment
  0x00000024:   HFVAL - HFADJ readback
  0x00000028:   CLOCKEN - Clock Enable Status
  0x0000002C:   UARTEN - UART Enable
  0x00000100:   INTEN - CLKGEN Interrupt Register: Enable
  0x00000104:   INTSTAT - CLKGEN Interrupt Register: Status
  0x00000108:   INTCLR - CLKGEN Interrupt Register: Clear
  0x0000010C:   INTSET - CLKGEN Interrupt Register: Set

CALXT - XT Oscillator Control

Address:

  Instance 0 Address:   0x40004000

Description:

XT Oscillator Control

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
CALXT
0x0

Bits Name RW Description
31:11 RSVD RO RESERVED

10:0 CALXT RW XT Oscillator calibration value


CALRC - RC Oscillator Control

Address:

  Instance 0 Address:   0x40004004

Description:

RC Oscillator Control

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
CALRC
0x0

Bits Name RW Description
31:18 RSVD RO RESERVED

17:0 CALRC RW LFRC Oscillator calibration value


ACALCTR - Autocalibration Counter

Address:

  Instance 0 Address:   0x40004008

Description:

Autocalibration Counter

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
ACALCTR
0x0

Bits Name RW Description
31:24 RSVD RO RESERVED

23:0 ACALCTR RO Autocalibration Counter result.


OCTRL - Oscillator Control

Address:

  Instance 0 Address:   0x4000400C

Description:

Oscillator Control

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
ACAL
0x0
OSEL
0x0
FOS
0x0
RSVD
0x0
STOPRC
0x0
STOPXT
0x0

Bits Name RW Description
31:11 RSVD RO RESERVED

10:8 ACAL RW Autocalibration control

DIS = 0x0 - Disable Autocalibration
1024SEC = 0x2 - Autocalibrate every 1024 seconds
512SEC = 0x3 - Autocalibrate every 512 seconds
XTFREQ = 0x6 - Frequency measurement using XT
EXTFREQ = 0x7 - Frequency measurement using external clock
7 OSEL RW Selects the RTC oscillator (1 => LFRC, 0 => XT)

RTC_XT = 0x0 - RTC uses the XT
RTC_LFRC = 0x1 - RTC uses the LFRC
6 FOS RW Oscillator switch on failure function

DIS = 0x0 - Disable the oscillator switch on failure function
EN = 0x1 - Enable the oscillator switch on failure function
5:2 RSVD RO RESERVED

1 STOPRC RW Stop the LFRC Oscillator to the RTC

EN = 0x0 - Enable the LFRC Oscillator to drive the RTC
STOP = 0x1 - Stop the LFRC Oscillator when driving the RTC
0 STOPXT RW Stop the XT Oscillator to the RTC

EN = 0x0 - Enable the XT Oscillator to drive the RTC
STOP = 0x1 - Stop the XT Oscillator when driving the RTC

CLKOUT - CLKOUT Frequency Select

Address:

  Instance 0 Address:   0x40004010

Description:

CLKOUT Frequency Select

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
CKEN
0x0
RSVD
0x0
CKSEL
0x0

Bits Name RW Description
31:8 RSVD RO RESERVED

7 CKEN RW Enable the CLKOUT signal

DIS = 0x0 - Disable CLKOUT
EN = 0x1 - Enable CLKOUT
6 RSVD RO RESERVED

5:0 CKSEL RW CLKOUT signal select

LFRC = 0x0 - LFRC
XT_DIV2 = 0x1 - XT / 2
XT_DIV4 = 0x2 - XT / 4
XT_DIV8 = 0x3 - XT / 8
XT_DIV16 = 0x4 - XT / 16
XT_DIV32 = 0x5 - XT / 32
RTC_1Hz = 0x10 - 1 Hz as selected in RTC
XT_DIV2M = 0x16 - XT / 2^21
XT = 0x17 - XT
CG_100Hz = 0x18 - 100 Hz as selected in CLKGEN
HFRC = 0x19 - HFRC
HFRC_DIV2 = 0x1A - HFRC / 2
HFRC_DIV4 = 0x1B - HFRC / 4
HFRC_DIV8 = 0x1C - HFRC / 8
HFRC_DIV32 = 0x1D - HFRC / 32
HFRC_DIV64 = 0x1E - HFRC / 64
HFRC_DIV128 = 0x1F - HFRC / 128
HFRC_DIV256 = 0x20 - HFRC / 256
FLASH_CLK = 0x22 - Flash Clock
LFRC_DIV2 = 0x23 - LFRC / 2
LFRC_DIV32 = 0x24 - LFRC / 32
LFRC_DIV512 = 0x25 - LFRC / 512
LFRC_DIV32K = 0x26 - LFRC / 32768
XT_DIV256 = 0x27 - XT / 256
XT_DIV8K = 0x28 - XT / 8192
XT_DIV64K = 0x29 - XT / 2^16
ULFRC_DIV16 = 0x2A - Uncal LFRC / 16
ULFRC_DIV128 = 0x2B - Uncal LFRC / 128
ULFRC_1Hz = 0x2C - Uncal LFRC / 1024
ULFRC_DIV4K = 0x2D - Uncal LFRC / 4096
ULFRC_DIV1M = 0x2E - Uncal LFRC / 2^20
HFRC_DIV64K = 0x2F - HFRC / 2^16
HFRC_DIV16M = 0x30 - HFRC / 2^24
LFRC_DIV2M = 0x31 - LFRC / 2^20
HFRCNE = 0x32 - HFRC (not autoenabled)
HFRCNE_DIV8 = 0x33 - HFRC / 8 (not autoenabled)
XTNE = 0x35 - XT (not autoenabled)
XTNE_DIV16 = 0x36 - XT / 16 (not autoenabled)
LFRCNE_DIV32 = 0x37 - LFRC / 32 (not autoenabled)
LFRCNE = 0x39 - LFRC (not autoenabled) - Default for undefined values

CLKKEY - Key Register for Clock Control Register

Address:

  Instance 0 Address:   0x40004014

Description:

Key Register for Clock Control Register

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
CLKKEY
0x0

Bits Name RW Description
31:0 CLKKEY RW Key register value.

Key = 0x47 - Key

CCTRL - HFRC Clock Control

Address:

  Instance 0 Address:   0x40004018

Description:

HFRC Clock Control

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
MEMSEL
0x0
CORESEL
0x7

Bits Name RW Description
31:4 RSVD RO RESERVED

3 MEMSEL RW Flash Clock divisor

HFRC_DIV25 = 0x0 - Flash Clock is HFRC / 25
HFRC_DIV45 = 0x1 - Flash Clock is HFRC / 45
2:0 CORESEL RW Core Clock divisor

HFRC = 0x0 - Core Clock is HFRC
HFRC_DIV2 = 0x1 - Core Clock is HFRC / 2
HFRC_DIV3 = 0x2 - Core Clock is HFRC / 3
HFRC_DIV4 = 0x3 - Core Clock is HFRC / 4
HFRC_DIV5 = 0x4 - Core Clock is HFRC / 5
HFRC_DIV6 = 0x5 - Core Clock is HFRC / 6
HFRC_DIV7 = 0x6 - Core Clock is HFRC / 7
HFRC_DIV8 = 0x7 - Core Clock is HFRC / 8

STATUS - Clock Generator Status

Address:

  Instance 0 Address:   0x4000401C

Description:

Clock Generator Status

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
OSCF
0x0
OMODE
0x0

Bits Name RW Description
31:2 RSVD RO RESERVED

1 OSCF RO XT Oscillator is enabled but not oscillating

0 OMODE RO Current RTC oscillator (1 => LFRC, 0 => XT)


HFADJ - HFRC Adjustment

Address:

  Instance 0 Address:   0x40004020

Description:

HFRC Adjustment

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
HFWARMUP
0x0
HFXTADJ
0x0
RSVD
0x0
HFADJCK
0x0
HFADJEN
0x0

Bits Name RW Description
31:20 RSVD RO RESERVED

19 HFWARMUP RW XT warmup period for HFRC adjustment

1SEC = 0x0 - Autoadjust XT warmup period = 1-2 seconds
2SEC = 0x1 - Autoadjust XT warmup period = 2-4 seconds
18:8 HFXTADJ RW Target HFRC adjustment value.

7:4 RSVD RO RESERVED

3:1 HFADJCK RW Repeat period for HFRC adjustment

4SEC = 0x0 - Autoadjust repeat period = 4 seconds
16SEC = 0x1 - Autoadjust repeat period = 16 seconds
32SEC = 0x2 - Autoadjust repeat period = 32 seconds
64SEC = 0x3 - Autoadjust repeat period = 64 seconds
128SEC = 0x4 - Autoadjust repeat period = 128 seconds
256SEC = 0x5 - Autoadjust repeat period = 256 seconds
512SEC = 0x6 - Autoadjust repeat period = 512 seconds
1024SEC = 0x7 - Autoadjust repeat period = 1024 seconds
0 HFADJEN RW HFRC adjustment control

DIS = 0x0 - Disable the HFRC adjustment
EN = 0x1 - Enable the HFRC adjustment

HFVAL - HFADJ readback

Address:

  Instance 0 Address:   0x40004024

Description:

HFADJ readback

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
HFTUNERB
0x0

Bits Name RW Description
31:11 RSVD RO RESERVED

10:0 HFTUNERB RO Current HFTUNE value


CLOCKEN - Clock Enable Status

Address:

  Instance 0 Address:   0x40004028

Description:

Clock Enable Status

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
CLOCKEN
0x0

Bits Name RW Description
31:0 CLOCKEN RO Clock enable status


UARTEN - UART Enable

Address:

  Instance 0 Address:   0x4000402C

Description:

UART Enable

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
UARTEN
0x0

Bits Name RW Description
31:1 RSVD RO RESERVED

0 UARTEN RW UART system clock control

DIS = 0x0 - Disable the UART system clock
EN = 0x1 - Enable the UART system clock

INTEN - CLKGEN Interrupt Register: Enable

Address:

  Instance 0 Address:   0x40004100

Description:

Set bits in this register to allow this module to generate the corresponding interrupt.

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
ALM
0x0
OF
0x0
ACC
0x0
ACF
0x0

Bits Name RW Description
31:4 RSVD RO RESERVED

3 ALM RW RTC Alarm interrupt

2 OF RW XT Oscillator Fail interrupt

1 ACC RW Autocalibration Complete interrupt

0 ACF RW Autocalibration Fail interrupt


INTSTAT - CLKGEN Interrupt Register: Status

Address:

  Instance 0 Address:   0x40004104

Description:

Read bits from this register to discover the cause of a recent interrupt.

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
ALM
0x0
OF
0x0
ACC
0x0
ACF
0x0

Bits Name RW Description
31:4 RSVD RO RESERVED

3 ALM RW RTC Alarm interrupt

2 OF RW XT Oscillator Fail interrupt

1 ACC RW Autocalibration Complete interrupt

0 ACF RW Autocalibration Fail interrupt


INTCLR - CLKGEN Interrupt Register: Clear

Address:

  Instance 0 Address:   0x40004108

Description:

Write a 1 to a bit in this register to clear the interrupt status associated with that bit.

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
ALM
0x0
OF
0x0
ACC
0x0
ACF
0x0

Bits Name RW Description
31:4 RSVD RO RESERVED

3 ALM RW RTC Alarm interrupt

2 OF RW XT Oscillator Fail interrupt

1 ACC RW Autocalibration Complete interrupt

0 ACF RW Autocalibration Fail interrupt


INTSET - CLKGEN Interrupt Register: Set

Address:

  Instance 0 Address:   0x4000410C

Description:

Write a 1 to a bit in this register to instantly generate an interrupt from this module. (Generally used for testing purposes).

Example Macro Usage:

//
// All macro-based register writes follow the same basic format. For
// single-instance modules, you may use the simpler AM_REG macro. For
// multi-instance macros, you will need to specify the instance number using
// the AM_REGn macro format.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
// AM_REGn(<MODULE>, <INSTANCE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>_<VALUE>;
//
// For registers that do not have specific enumeration values, you may use this alternate format instead.
//
// AM_REG(<MODULE>, <REGISTER>) |= AM_REG_<MODULE>_<REGISTER>_<FIELD>(<NUMBER>);
//
// For example, the following three lines of code are equivalent methods of
// writing the value for 12MHZ to the CLKSEL field in the ADC_CFG register.
//
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REGn(ADC, 0, CFG) |= AM_REG_ADC_CFG_CLKSEL_12MHZ;
AM_REG(ADC, CFG) |= AM_REG_ADC_CFG_CLKSEL(0x1);

Register Fields:

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
RSVD
0x0
ALM
0x0
OF
0x0
ACC
0x0
ACF
0x0

Bits Name RW Description
31:4 RSVD RO RESERVED

3 ALM RW RTC Alarm interrupt

2 OF RW XT Oscillator Fail interrupt

1 ACC RW Autocalibration Complete interrupt

0 ACF RW Autocalibration Fail interrupt