Alert Handler Technical Specification
Overview
This document specifies the functionality of the alert handler mechanism. The alert handler is a module that is a peripheral on the chip interconnect bus, and thus follows the Comportability Specification. It gathers alerts - defined as interrupt-type signals from other peripherals that are designated as potential security threats - throughout the design, and converts them to interrupts that the processor can handle. If the processor does not handle them, the alert handler mechanism provides hardware responses to handle the threat.
Features
-
Differentially-signaled, asynchronous alert inputs from
NAlerts
peripheral sources, whereNAlerts
is a function of the requirements of the peripherals. -
Ping testing of alert sources:
- responder module requests periodic alert response from each source to ensure proper wiring.
- reset-asserted and clock-gated information is used to temporarily pause the ping mechanism on alert channels that are in a low-power state.
-
Register locking on all configuration registers.
- Once locked, can not be modified by software until next system reset.
-
Register-based assignment of alert to alert-class.
- Four classes, can be individually disabled.
- Each class generates one interrupt.
- Disambiguation history for software to determine which alert caused the class interrupt.
- Each class has configurable response time for escalation.
- Disable allows for ignoring alerts, should only be used in cases when alerts are faulty. Undesirable access is enforced by locking the register state after initial configuration.
-
Register-based escalation controls.
- Number of alerts in class before escalation.
- Timeout for unhandled alert IRQs can also trigger escalation.
- Configurable escalation enables for 4 escalation signals.
- Could map to NMI, wipe secrets signal, lower privilege, chip reset, etc.
- Escalation signals differentially-signaled with heartbeat, will trigger response if differential or heartbeat failure at destination.
- Configurable time in cycles between each escalation level.
-
Two locally sourced hardware alerts.
- Differential signaling from a source has failed.
- Ping response from a source has failed.
Description
The alert handler module manages incoming alerts from throughout the system, classifies them, sends interrupts, and escalates interrupts to hardware responses if the processor does not respond to any interrupts. The intention is for this module to be a stand-in for security responses in the case where the processor can not handle the security alerts.
It is first notable that all security alerts are rare events. Module and top level designers should only designate events as alerts if they are expected to never happen, and if they have potential security consequences. Examples are parity errors (which might indicate an attack), illegal actions on cryptography or security modules, physical sensors of environmental modification (e.g. voltage, temperature), etc. Alerts will be routed through this module and initially converted to interrupts for the processor to handle. The expectation is that the secure operating system has a protocol for handling any such alert interrupt in software. The operating system should respond, then clear the interrupt. Since these are possible security attacks, the response is not always obvious, but the response is beyond the scope of this document.
This module is designed to help the full chip respond to security threats in the case where the processor is not trusted: either it has been attacked, or is not responding. It does this by escalating alerts beyond a processor interrupt. It provides four such escalation signals that can be routed to chip functions for attack responses. This could include such functions as wiping secret chip material, power down, reset, etc. It is beyond the scope of this document to specify what those escalation responses are at the chip level.
To ease software management of alerts, classification is provided whereby each alert can be classified into one of four classes. How the classification is done by software is beyond the scope of this document, but it is suggested that alerts of a similar profile (risk of occurring, level of security concern, frequency of false trigger, etc) are classed together. For each class a counter of alerts is kept, clearable by software. If that counter exceeds a programmable maximum value, then the escalation protocol for that class begins.
The details for alert signaling, classification, and escalation are all given in the Theory of Operations section.
Theory of Operations
Block Diagram
The figure below shows a block diagram of the alert handler module, as well as a few examples of alert senders in other peripheral modules.
In this diagram, there are seven sources of alerts: three sources from external modules (two from periph0
and one from periph1
), and four local sources (alert_ping_fail
, alert_sig_int
, esc_ping_fail
, esc_sig_int
).
The local sources represent alerts that are created by this module itself. See the later section on special local alerts.
Also shown are internal modules for classification, interrupt generation, accumulation, escalation, ping generation and alert-channel low-power control. These are described later in the document. Note that the differential alert sender and receiver blocks used for alert signaling support both asynchronous and synchronous clocking schemes, and hence peripherals able to raise alerts may be placed in clock domains different from that of the alert handler (Jittered clock domains are also supported in the asynchronous clocking scheme). Proper care must however be taken when formulating the timing constraints for the diff pairs, and when determining clock-dependent parameters (such as the ping timeout) of the design. On the escalation sender / receiver side, the differential signaling blocks employ a fully synchronous clocking scheme throughout.
Hardware Interfaces
Parameters
The following table lists the main parameters used throughout the alert handler design. Note that the alert handler is generated based on the system configuration, and hence these parameters are placed into a package as “localparams”. The parameterization rules are explained in more detail in the architectural description.
Localparam | Default (Max) | Top Earlgrey | Description |
---|---|---|---|
NAlerts |
8 (248) | see RTL | Number of alert instances. Maximum number bounded by LFSR implementation that generates ping timing. |
NLpg |
1 | see RTL | Number of unique low-power groups as determined by topgen. |
LpgMap |
{0} | see RTL | Array mapping each alert to a unique low-power group as determined by topgen. |
EscCntWidth |
32 (32) | 32 | Width of the escalation counters in bit. |
AccuCntWidth |
16 (32) | 16 | Width of the alert accumulation counters in bit. |
AsyncOn |
‘0 (2^NAlerts -1) |
see RTL | This is a bit array specifying whether a certain alert sender / receiver pair goes across an asynchronous boundary or not. |
The next table lists free parameters in the prim_alert_sender
and
prim_alert receiver
submodules.
Parameter | Default (Max) | Description |
---|---|---|
AsyncOn |
1'b0 (1'b1 ) |
0: Synchronous, 1: Asynchronous, determines whether additional synchronizer flops and logic need to be instantiated. |
Signals
Referring to the Comportable guideline for peripheral device functionality, the module alert_handler
has the following hardware interfaces defined.
Primary Clock: clk_i
Other Clocks: clk_edn_i
Bus Device Interfaces (TL-UL): tl
Bus Host Interfaces (TL-UL): none
Peripheral Pins for Chip IO: none
Inter-Module Signals: Reference
Port Name | Package::Struct | Type | Act | Width | Description |
---|---|---|---|---|---|
crashdump | alert_pkg::alert_crashdump | uni | req | 1 | |
edn | edn_pkg::edn | req_rsp | req | 1 | |
esc_rx | prim_esc_pkg::esc_rx | uni | rcv | 4 | |
esc_tx | prim_esc_pkg::esc_tx | uni | req | 4 | |
tl | tlul_pkg::tl | req_rsp | rsp | 1 |
Interrupts:
Interrupt Name | Type | Description |
---|---|---|
classa | Event | Interrupt state bit of Class A. Set by HW in case an alert within this class triggered. Defaults true, write one to clear. |
classb | Event | Interrupt state bit of Class B. Set by HW in case an alert within this class triggered. Defaults true, write one to clear. |
classc | Event | Interrupt state bit of Class C. Set by HW in case an alert within this class triggered. Defaults true, write one to clear. |
classd | Event | Interrupt state bit of Class D. Set by HW in case an alert within this class triggered. Defaults true, write one to clear. |
Security Alerts: none
Security Countermeasures:
Countermeasure ID | Description |
---|---|
ALERT_HANDLER.BUS.INTEGRITY | End-to-end bus integrity scheme. |
ALERT_HANDLER.CONFIG.SHADOW | Important CSRs are shadowed. |
ALERT_HANDLER.PING_TIMER.CONFIG.REGWEN | The ping timer configuration registers are REGWEN protected. |
ALERT_HANDLER.ALERT.CONFIG.REGWEN | The individual alert enables are REGWEN protected. |
ALERT_HANDLER.ALERT_LOC.CONFIG.REGWEN | The individual local alert enables are REGWEN protected. |
ALERT_HANDLER.CLASS.CONFIG.REGWEN | The class configuration registers are REGWEN protected. |
ALERT_HANDLER.ALERT.INTERSIG.DIFF | Differentially encoded alert channels. |
ALERT_HANDLER.LPG.INTERSIG.MUBI | LPG signals are encoded with MUBI types. |
ALERT_HANDLER.ESC.INTERSIG.DIFF | Differentially encoded escalation channels. |
ALERT_HANDLER.ALERT_RX.INTERSIG.BKGN_CHK | Periodic background checks on alert channels (ping mechanism). |
ALERT_HANDLER.ESC_TX.INTERSIG.BKGN_CHK | Periodic background checks on escalation channels (ping mechanism). |
ALERT_HANDLER.ESC_RX.INTERSIG.BKGN_CHK | Escalation receivers can detect absence of periodic ping requests. |
ALERT_HANDLER.ESC_TIMER.FSM.SPARSE | Escalation timer FSMs are sparsely encoded. |
ALERT_HANDLER.PING_TIMER.FSM.SPARSE | Ping timer FSM is sparsely encoded. |
ALERT_HANDLER.ESC_TIMER.FSM.LOCAL_ESC | Escalation timer FSMs move into an invalid state upon local escalation. |
ALERT_HANDLER.PING_TIMER.FSM.LOCAL_ESC | Ping timer FSM moves into an invalid state upon local escalation. |
ALERT_HANDLER.ESC_TIMER.FSM.GLOBAL_ESC | The escalation timer FSMs are the root of global escalation, hence if any of them moves into an invalid state by virtue of ESC_TIMER.FSM.LOCAL_ESC, this will trigger all escalation actions and thereby global escalation as well. |
ALERT_HANDLER.ACCU.CTR.REDUN | Accumulator counters employ a cross-counter implementation. |
ALERT_HANDLER.ESC_TIMER.CTR.REDUN | Escalation timer counters employ a duplicated counter implementation. |
ALERT_HANDLER.PING_TIMER.CTR.REDUN | Ping timer counters employ a duplicated counter implementation. |
ALERT_HANDLER.PING_TIMER.LFSR.REDUN | Ping timer LFSR is redundant. |
The table below lists other alert handler module signals.
The number of alert instances is parametric and hence alert and ping diff pairs are grouped together in packed arrays.
The diff pair signals are indexed with the corresponding alert instance <number>
.
Signal | Direction | Type | Description |
---|---|---|---|
edn_o |
output |
otp_edn_req_t |
Entropy request to the entropy distribution network for LFSR reseeding and ephemeral key derivation. |
edn_i |
input |
otp_edn_rsp_t |
Entropy acknowledgment to the entropy distribution network for LFSR reseeding and ephemeral key derivation. |
alert_tx_i[<number>] |
input |
packed alert_tx_t array |
Incoming alert or ping response(s), differentially encoded. Index range: [NAlerts-1:0] |
alert_rx_o[<number>] |
output |
packed alert_rx_t array |
Outgoing alert acknowledgment and ping requests, differentially encoded. Index range: [NAlerts-1:0] |
esc_tx_o[<sev>] |
output |
packed esc_tx_t array |
Escalation or ping request, differentially encoded. Index corresponds to severity level, and ranges from 0 to 3. |
esc_rx_i[<sev>] |
input |
packed esc_rx_t array |
Escalation ping response, differentially encoded. Index corresponds to severity level, and ranges from 0 to 3. |
lpg_cg_en_i[<lpg>] |
input |
packed mubi4_t array |
Incoming clock gated indication from clock manager. Index range: [NLpg-1:0] |
lpg_rst_en_i[<lpg>] |
input |
packed mubi4_t array |
Incoming reset asserted indication from reset manager. Index range: [NLpg-1:0] |
crashdump_o |
output |
packed struct |
This is a collection of alert handler state registers that can be latched by hardware debugging circuitry, if needed. |
Entropy Network Connections
The LFSR ping timer needs to be periodically reseeded.
Therefore, the alert handler is connected to the entropy distribution network via the edn_i/o
signals.
Alert Channels
For each alert, there is a pair of input and two pairs of output signals. These signals are connected to a differential sender module within the source, and a differential receiver module within the alert handler. Both of these modules are described in more detail in the following section. These signal pairs carry differentially encoded messages that enable two types of signaling: a native alert and a ping/response test of the alert mechanism. The latter is to ensure that all alert senders are always active and have not been the target of an attack.
Escalation Channels
For each escalation action in the system, there is a pair of input and a pair of output signals, encapsulated in the esc_rx_t
and esc_tx_t
types.
These signals are connected to a differential sender module within the alert handler, and a differential receiver module within the module that performs a particular escalation action (for example the reset manager or life cycle controllers).
The signal pairs carry differentially encoded messages that enable two types of signaling: a native escalation and a ping/response test of the escalation mechanism.
The latter is to ensure that all escalation receivers are always active and have not been the target of an attack.
Low-power Indication Signals
The lpg_cg_en_i
and lpg_rst_en_i
are two arrays with multibit indication signals from the clock and reset managers.
These indication signals convey whether a specific group of alert senders are either clock gated or in reset.
As explained in more detail below, this information is used to temporarily halt the ping timer mechanism on channels that are in a low-power state in order to prevent false positives.
Crashdump Output
The crashdump_o
struct outputs a snapshot of CSRs and alert handler state bits that can be read by hardware debugging circuitry:
typedef struct packed {
// alerts
logic [NAlerts-1:0] alert_cause; // alert cause bits
logic [6:0] loc_alert_cause; // local alert cause bits
// class state
logic [3:0][15:0] class_accum_cnt; // current accumulator value
logic [3:0][31:0] class_esc_cnt; // current escalation counter value
cstate_e [3:0] class_esc_state; // current escalation protocol state
} alert_crashdump_t;
This can be useful for extracting more information about possible failures or bugs without having to use the tile-link bus interface (which may become unresponsive under certain circumstances). It is recommended for the top level to store this information in an always-on location.
Note that the crashdump state is continuously output via crashdump_o
until the latching trigger condition is true for the first time (see
CLASSA_CRASHDUMP_TRIGGER_SHADOWED).
After that, the crashdump_o
is held constant until all classes that have escalated are cleared.
This is done so that it is possible to capture the true alert cause before spurious alert events start to pop up due to escalation countermeasures with excessive side effects (like life cycle scrapping for example).
If classes that have escalated are not configured as clearable, then it is not possible to re-arm the crashdump latching mechanism at runtime and the alert handler has to be reset.
Design Details
This section gives the full design details of the alert handler module and its submodules.
Alert Definition
Alerts are defined as events that have security implications, and should be handled by the main processor, or escalated to other hardware modules to take action.
Each peripheral has the option to define one or more alert signals.
Those peripherals should instantiate one module (prim_alert_sender
) to convert the event associated with that alert into a signal to the alert handler module.
The alert handler instantiates one receiver module (prim_alert_receiver
) per alert, then handles the classification, accumulation, and escalation of the received signal.
The differential signaling submodules may either use a synchronous or asynchronous clocking scheme, since the message type to be transferred is a single discrete event.
Differential Alert Signaling
Each alert sender is connected to the corresponding alert receiver via the 3 differential pairs alert_tx_i/o.alert_p/n
, alert_rx_i/o.ack_p/n
and alert_rx_i/o.ping_p/n
, as illustrated below:
Alerts are encoded differentially and signaled using a full handshake on the alert_tx_i/o.alert_p/n
and alert_rx_i/o.ack_p/n
wires.
The use of a full handshake protocol allows this mechanism to be used with an asynchronous clocking strategy, where peripherals may reside in a different clock domain than the alert handler.
The full handshake guarantees that alert messages are correctly back-pressured and no alert is “lost” at the asynchronous boundary due to (possibly variable) clock ratios greater or less than 1.0.
The “native alert message” will be repeated on the output wires as long as the alert event is still true within the peripheral.
The wave pattern below illustrates differential full handshake mechanism.
The handshake pattern is repeated as long as the alert is true. The sender will wait for 2 cycles between handshakes.
Note that the alert is immediately propagated to alert_o
once the initial level change on alert_tx_i.alert_p/n
has been received and synchronized to the local clock on the receiver side.
This ensures that the first occurrence of an alert is always propagated - even if the handshake lines have been manipulated to emulate backpressure.
(In such a scenario, all subsequent alerts would be back-pressured and eventually the ping testing mechanism described in the next subsection would detect that the wires have been tampered with.)
The alert sender and receiver modules can either be used synchronously or asynchronously. The signaling protocol remains the same in both cases, but the additional synchronizer flops at the diff pair inputs may be omitted, which results in lower signaling latency.
Ping Testing
In order to ensure that the event sending modules have not been compromised, the alert receiver module prim_alert_receiver
will “ping” or line-test the senders periodically every few microseconds.
Pings timing is randomized so their appearance can not be predicted.
The ping timing is generated by a central LFSR-based timer within the alert handler that randomly asserts the ping_req_i
signal of a particular prim_alert_receiver
module.
Once ping_req_i
is asserted, the receiver module encodes the ping message as a level change on the differential alert_rx_o.ping_p/n
output, and waits until the sender responds with a full handshake on the alert_tx_i.alert_p/n
and alert_rx_o.ack_p/n
lines.
Once that handshake is complete, the ping_ok_o
signal is asserted.
The LFSR timer has a programmable ping timeout, after which it will automatically assert a “pingfail” alert.
That timeout is a function of the clock ratios present in the system, and has to be programmed accordingly at system startup (as explained later in the LFSR timer subsection).
The following wave diagram illustrates a correct ping sequence, viewed from the receiver side:
In the unlikely case that a ping request collides with a native alert at the sender side, the native alert is held back until the ping handshake has been completed. This slightly delays the transmission of a native alert, but the alert will eventually be signaled. Further, if an alert is sent out right before a ping requests comes in at the sender side, the receiver will treat the alert as a ping response. However, the “true” ping response will be returned right after the alert handshake completed, and thus the alert will eventually be signaled with a slight delay.
Note that in both collision cases mentioned, the delay will be in the order of the handshake length, plus the constant amount of pause cycles between handshakes (2 sender cycles).
Monitoring of Signal Integrity Issues
All differential pairs are monitored for signal integrity issues, and if an encoding failure is detected, the receiver module asserts a signal integrity alert via integ_fail_o
. In particular, this covers the following failure cases:
-
The
alert_tx_i.alert_p/n
pair is not correctly encoded on the receiver side. This can be directly flagged as an integrity failure on the receiver side. -
The
alert_rx_i.ping_p/n
or thealert_rx_i.ack_p/n
pairs are not correctly encoded on the sender side. This is signaled to the receiver by setting thealert_tx_o.alert_p/n
wires to the same value, and that value will be continuously toggled. This implicitly triggers a signal integrity alert on the receiver side.
Some of these failure patterns are illustrated in the wave diagram below:
Note that if signal integrity failures occur during ping or alert handshaking, it is possible that the protocol state-machines lock up and the alert sender and receiver modules become unresponsive. However, the above mechanisms ensure that this will always trigger either a signal integrity alert or eventually a “pingfail” alert.
Skew on Asynchronous Differential Pairs
Note that there is likely a (small) skew present within each differential pair of the signaling mechanism above. Since these pairs cross clock domain boundaries, it may thus happen that a level change appears in staggered manner after resynchronization, as illustrated below:
This behavior is permissible, but needs to be accounted for in the protocol logic. Further, the skew within the differential pair should be constrained to be smaller than the shortest clock period in the system. This ensures that the staggered level changes appear at most 1 cycle apart from each other.
LFSR Timer
The ping_req_i
inputs of all signaling modules (prim_alert_receiver
, prim_esc_sender
) instantiated within the alert handler are connected to a central ping timer that alternatingly pings either an alert line or an escalation line after waiting for a pseudo-random amount of clock cycles.
Further, this ping timer also randomly selects a particular alert line to be pinged (escalation senders are always pinged in-order due to the ping monitoring mechanism on the escalation side).
That should make it more difficult to predict the next ping occurrence based on past observations.
The ping timer is implemented using an LFSR-based PRNG of Galois type.
This ping timer is reseeded with fresh entropy from EDN roughly every 500k cycles which corresponds to around 16 ping operations on average.
The LFSR is 32bits wide, but only 24bits of its state are actually being used to generate the random timer count and select the alert line to be pinged.
I.e., the 32bits first go through a fixed permutation function, and then bits [23:16]
are used to determine which alert line to ping.
The random cycle count is created by OR’ing bits [15:0]
with the constant 3'b100
as follows:
cycle_cnt = permuted[15:0] | 3'b100;
This constant DC offset introduces a minimum ping spacing of 4 cycles (1 cycle + margin) to ensure that the handshake protocols of the sender/receiver pairs work.
After selecting one of the peripherals to ping, the LFSR timer waits until either the corresponding *_ping_ok[<number>]
signal is asserted, or until the programmable ping timeout value is reached.
In both cases, the LFSR timer proceeds with the next ping, but in the second case it will additionally raise a “pingfail” alert.
The ping enable signal remains asserted during the time where the LFSR counter waits.
The timeout value is a function of the ratios between the alert handler clock and peripheral clocks present in the system, and can be programmed at startup time via the register PING_TIMEOUT_CYC_SHADOWED.
Note that the ping timer directly flags a “pingfail” alert if a spurious “ping ok” message comes in that has not been requested.
As described in the programmers guide below, the ping timer has to be enabled explicitly. Only alerts that have been enabled and locked will be pinged in order to avoid spurious alerts. Escalation channels are always enabled, and hence will always be pinged once this mechanism has been turned on.
In addition to the ping timer mechanism described above, the escalation receivers contain monitoring counters that monitor the liveness of the alert handler (described in more detail in this section). This mechanism requires that the maximum wait time between escalation receiver pings is bounded. To that end, escalation senders are pinged in-order every second ping operation (i.e., the wait time is randomized, but the selection of the escalation line is not).
Alert Receiving
The alert handler module contains one alert receiver module (prim_alert_receiver
) per sending module.
This receiver module has three outputs based upon the signaling of the input alert.
Primary is the signal of a received native alert, shown in the top-level diagram as alert_triggered[<number>]
.
Also generated are two other outputs, one that signals a differential encoding error (alert_integ_fail[<number>]
), and one that signals the receipt of a ping response (alert_ping_ok[<number>]
).
Each “triggered” alert received is sent into the classification block for individual configuration.
All of the integ_fail
signals are OR’ed together to create one alert for classification.
The ping responses are fed to the LFSR timer, which determines whether a ping has correctly completed within the timeout window or not.
Alert Classification and Interrupts
Each of the incoming and local alert signals can be classified generically to one of four classes, or disabled for no classification at all. These are the classes A, B, C, and D. There is no pre-determined definition of a class, that is left to software. But for guidance, software can consider that some alert types are similar to others; some alert types are more “noisy” than others (i.e. when triggered they stay on for long periods of time); some are more critical than others, etc.
For each alert class (A-D), an interrupt is generally sent. Like all other peripheral interrupts, there is a triad of registers: enable, status, test. Thus like all other interrupts, software should handle the source of the interrupt (in this case, the original alert), then clear the state. Since the interrupt class is disassociated with the original alert (due to the classification process), software can access cause registers to determine which alerts have fired since the last clearing. Since alerts are expected to be rare (if ever) events, the complexity of dealing with multiple interrupts per class firing during the same time period should not be of concern. See the programming section on interrupt clearing.
Each of the four interrupts can optionally trigger a timeout counter that triggers escalation if the interrupt is not handled and cleared within a certain time frame. This feature is explained in more detail in the next subsection about escalation mechanisms.
Note that an interrupt always fires once an alert has been registered in the corresponding class. Interrupts are not dependent on escalation mechanisms like alert accumulation or timeout as described in the next subsection.
Escalation Mechanisms
There are two mechanisms per class that can trigger the corresponding escalation protocol:
-
The first consists of an accumulation counter that counts the amount of alert occurrences within a particular class. An alert classified to class A indicates that on every received alert trigger, the accumulation counter for class A is incremented. Note: since alerts are expected to be rare or never occur, the module does not attempt to count every alert per cycle, but rather all triggers per class are ORd before sending to the accumulation counter as an increment signal. Once the threshold has been reached, the next occurrence triggers the escalation escalation protocol for this particular class. The counter is a saturation counter, meaning that it will not wrap around once it hits the maximum representable count. This mechanism has two associated CSRs:
- Accumulation max value. This is the total number (sum of all alerts classified in this group) of alerts required to enter escalation phase (see below). Example register is CLASSA_ACCUM_THRESH_SHADOWED.
- Current accumulation register. This clearable register indicates how many alerts have been accumulated to date. Software should clear before it reaches the accumulation setting to avoid escalation. Example register is CLASSA_ACCUM_CNT.
-
The second way is an interrupt timeout counter which triggers escalation if an alert interrupt is not handled within the programmable timeout window. Once the counter hits the timeout threshold, the escalation protocol is triggered. The corresponding CSRs are:
- Interrupt timeout value in cycles CLASSA_TIMEOUT_CYC_SHADOWED. The interrupt timeout is disabled if this is set to 0 (default).
- The current interrupt timeout value can be read via
CLASSA_ESC_CNT if
CLASSA_STATE is in the
Timeout
state. Software should clear the corresponding interrupt state bit INTR_STATE.CLASSA before the timeout expires to avoid escalation.
Technically, the interrupt timeout feature (2. above) is implemented using the same counter used to time the escalation phases. This is possible since escalation phases or interrupt timeout periods are non-overlapping (escalation always takes precedence should it be triggered).
Programmable Escalation Protocol
There are four output escalation signals, 0, 1, 2, and 3. There is no predetermined definition of an escalation signal, that is left to the top-level integration. Examples could be processor Non Maskable Interrupt (NMI), privilege lowering, secret wiping, chip reset, etc. Typically the assumption is that escalation level 0 is the first to trigger, followed by 1, 2, and then 3, emulating a “fuse” that is lit that can’t be stopped once the first triggers (this is however not a requirement). See register section for discussion of counter clearing and register locking to determine the finality of accumulation triggers.
Each class can be programmed with its own escalation protocol. If one of the two mechanisms described above fires, a timer for that particular class is started. The timer can be programmed with up to 4 delays (e.g., CLASSA_PHASE0_CYC), each representing a distinct escalation phase (0 - 3). Each of the four escalation severity outputs (0 - 3) are by default configured to be asserted during the corresponding phase, e.g., severity 0 in phase 0, severity 1 in phase 1, etc. However, this mapping can be freely reassigned by modifying the corresponding enable/phase mappings (e.g., CLASSA_CTRL_SHADOWED.E0_MAP for enable bit 0 of class A). This mapping will be locked in together with the alert enable configuration after initial configuration.
SW can stop a triggered escalation protocol by clearing the corresponding escalation counter (e.g., CLASSA_ESC_CNT). Protection of this clearing is up to software, see the register control section that follows for CLASSA_CTRL_SHADOWED.LOCK.
It should be noted that each of the escalation phases have a duration of at least 1 clock cycle, even if the cycle count of a particular phase has been set to 0.
The next waveform shows the gathering of alerts of one class until eventually the escalation protocol is engaged. In this diagram, two different alerts are shown for class A, and the gathering and escalation configuration values are shown.
In this diagram, the first alert triggers an interrupt to class A. The assumption is that the processor is wedged or taken over, in which case it does not handle the interrupt. Once enough interrupts gather (16 in this case), the first escalation phase is entered, followed by three more (each phase has its own programmable length). Note that the accumulator threshold is set to 15 in order to trigger on the 16th occurrence. If escalation shall be triggered on the first occurrence within an alert class, the accumulation threshold shall be set to 0. Also note that it takes one cycle to activate escalation and enter phase 0.
The next wave shows a case where an interrupt remains unhandled and hence the interrupt timeout counter triggers escalation.
It should be noted here that the differential escalation signaling protocol distinguishes ‘true’ escalation conditions from mere pings by encoding them as pulses that are N + 1 cycles long. This is reflected in the two wave diagrams above. Refer to the subsequent section on escalation signaling for more details.
Escalation Signaling
For each of the four escalation severities, the alert handler instantiates a prim_esc_sender
module and each of the four escalation countermeasures instantiates an prim_esc_receiver
module.
The signaling mechanism has similarities with the alert signaling mechanism - but it is a fully synchronous protocol.
Hence, it must be ensured at the top-level that all escalation sender and receiver modules are using the same clock and reset
signals.
As illustrated in the following block diagram, a sender-receiver pair is connected with two differential lines, one going from sender to receiver and the other going from receiver to sender.
Upon receiving an escalation enable pulse of width N > 0 at the esc_req_i
input, the escalation sender encodes that signal as a differential pulse of width N+1 on esc_tx.esc_p/n
.
The receiver decodes that message and asserts the esc_req_o
output after one cycle of delay.
Further, it acknowledges the receipt of that message by continuously toggling the esc_rx.resp_p/n
signals as long as the escalation signal is asserted.
Any failure to respond correctly will trigger a integ_fail_o
alert, as illustrated below:
Further, any differential signal mismatch on both the esc_tx_i.esc_p/n
and esc_rx_i.resp_p/n
lines will trigger an integ_fail_o
alert.
Mismatches on esc_rx_i.resp_p/n
can be directly detected at the sender.
Mismatches on the esc_tx_i.esc_p/n
line will be signaled back to the sender by setting both the positive and negative response wires to the same value - and that value is being toggled each cycle.
This implicitly triggers a signal integrity alert on the sender side.
In addition to that, a signal integrity error on the esc_tx_i.esc_p/n
lines will lead to assertion of the esc_req_o
output, since it cannot be guaranteed that the back signalling mechanism always works when the sender / receiver pair is being tampered with.
This back-signaling mechanism can be leveraged to fast-track escalation and use another countermeasure in case it is detected that a particular escalation signaling path has been tampered with.
Some signal integrity failure cases are illustrated in the wave diagram below:
Ping Testing of the Escalation Signals
Similarly to the alert signaling scheme, the escalation signaling lines can be pinged / line tested in order to test whether the escalation receiver has been tampered with.
This is achieved by asserting ping_req_i
at the escalation sender module.
A ping request is encoded as a single cycle pulse on the esc_tx_o.esc_p/n
outputs.
Hence, the receiver module will not decode this single cycle pulse as an escalation enable message, but it will respond to it with a “1010” pattern on the esc_rx_i.resp_p/n
lines.
The escalation sender module will assert ping_ok_o
if that pattern is received correctly after one cycle of latency.
Otherwise, the escalation sender will first assert integ_fail_o
later, after the programmable ping timeout is reached, the LFSR timer will raise a “pingfail” alert.
The integ_fail_o
triggers in this case since “no ping response” and “wrong ping response” are ambiguous in this setting, and it has been decided to not suppress integrity failures when expecting a ping response.
This mechanism is illustrated below from the viewpoint of the sender module.
Note that the escalation signal always takes precedence, and the ping_req_i
will just be acknowledged with ping_ok_o
in case esc_req_i
is already asserted.
An ongoing ping sequence will be aborted immediately.
Another thing to note is that the ping and escalation response sequences have to start exactly one cycle after either a ping or escalation event has been signaled.
Otherwise the escalation sender will assert integ_fail_o
immediately.
Monitoring of Pings at the Escalation Receiver Side
Escalation receivers contain a mechanism to monitor the liveness of the alert handler itself. In particular, the receivers passively monitor the ping requests sent out by the alert handler using a timeout counter. If ping requests are absent for too long, the corresponding escalation action will be automatically asserted until reset.
The monitoring mechanism builds on top of the following properties of the alert handler system:
-
the ping mechanism can only be enabled, but not disabled. This allows us to start the timeout counter once the first ping request arrives at a particular escalation receiver.
-
the escalation receivers are in the same clock/reset domain as the alert handler. This ensures that we are seeing the same clock frequency, and the mechanism is properly reset together with the alert handler logic.
-
the maximum cycle count between subsequent pings on the same escalation line is bounded, even though the wait counts are randomized. This allows us to compute a safe and fixed timeout threshold based on design constants.
Low-power Management of Alert Channels
Due to the various clock and reset domains in the OpenTitan system, the alert handler ping mechanism needs to have additional logic to deal with alert senders that are either held in reset, or that are clock gated. This is needed to ensure that no false alarms are produced by the ping mechanism when an alert channel (sender / receiver pair) does not respond due to the sender being either in reset or clock gated.
Since the FSMs associated with an alert channel may end up in an inconsistent state when the sender is reset or gated while an asynchronous event handshake is in progress, this logic also needs to be able to re-initialize affected alert channels whenever the channels comes back from reset / clock gated state.
Assumptions
The following diagram shows a typical arrangement of alert sender (TX) and receiver (RX) pairs.
It is assumed that:
- The alert handler clock domain cannot be gated by SW. This means that this clock domain is only ever disabled as part of the power-down sequence of the corresponding power domain.
- The alert senders are in general located within different clock and reset domains than the alert receivers within the alert handler, and thus use the asynchronous event handshake mode.
- Some alert senders may be located in an always-on (AON) power domain, within different clock and reset groups than the alert handler.
- The alert handler may be located in an non-AON power domain, and may thus undergo a reset cycle where it cannot be guaranteed that all alert senders are reset as well (i.e., some alert senders may retain their state).
Further, we assume that we can get the following side-band information from the clock and reset managers in the system:
- All relevant reset signals pertaining to alert sender domains
- All relevant clock enable signals pertaining to alert sender domains
Scenarios
With the assumptions above, the following two problematic scenarios can occur.
Alert Handler in Reset
It may happen that the alert handler is reset while some alert senders (e.g. those located in the AON domain) are not. In general, if the associated alert channels are idle during an alert handler reset cycle, no problems arise.
However, if an alert channel is reset while it is handling a ping request or an alert event, the sender / receiver FSMs may end up in an inconsistent state upon deassertion of the alert handler reset. This can either lead to spurious alert or ping events, or a completely locked up alert channel which will be flagged eventually by the ping mechanism.
Alert Sender in Reset or Clock-gated
If any of the alert senders is either put into reset or its clock is disabled while the alert handler is operational, the ping mechanism inside the alert handler will eventually report a ping failure because of missing ping responses from the affected alert channel(s).
Further, if the alert sender is reset while the corresponding alert channel is handling a ping request or an alert event, the sender / receiver FSMs may end up in an inconsistent state after reset deassertion.
Employed Solution
As elaborated before, the side effects of resetting / clock gating either the alert handler or any of the alert senders are inconsistent FSM states, leading to locked up alert channels, or spurious alert or ping events. To address these issues, we have to:
- make sure spurious events (alert and ping_ok outputs of the alert receivers) are suppressed if an alert channel is clock gated or in reset,
- provide a mechanism for resetting an alert channel to an operational state once the associated clock is re-enabled, or the associated reset is released,
- trigger this reset mechanism on all alert channels whenever the alert handler itself has been reset.
To attain this, the idea is to make use of side-band information available from the clock and reset managers to detect whether an alert channel (or a group of alert channels with the same clock and reset on the sender side) has to be put into a low-power state. In the following we will refer to such a clock / reset domain grouping as a low-power group (LPG).
The mechanism is illustrated below for a single LPG (in practice, this logic is replicated for each LPG that is identified in the system):
The clock gating enable (lpg_cg_en
) and reset enable (lpg_rst_en
) indications are routed as multibit signals to the alert handler, where they are synchronized to the alert handler clock and logically combined using an OR function to form a combined low-power indication signal that is multibit encoded.
This multibit indication signal is then routed to all alert receivers, where it is used to trigger re-initialization of each alert channel, and bypass the ping requests from the ping mechanism.
To that end, two extra init states are added to the alert receiver FSMs to perform this in-band reset, as indicated in the state diagram below:
Whenever the init_trig
multibit signal of an LPG is asserted, all corresponding sender FSMs are moved into the InitReq
state.
In that state, the alert receivers immediately acknowledge ping requests from the ping mechanism, and ignore alert events from the sender side.
In addition to that, the receivers intentionally place a signal integrity error onto the ping_p
/ ping_n
, ack_p
/ ack_n
lines going from receivers to the senders.
This causes the senders to 1) move into the signal integrity error state, and 2) respond by placing a signal integrity error onto the alert_p
/ alert_n
lines, which serves as an initialization “acknowledge” signal in this case.
Since the sender FSMs fall back into the Idle
state once the signal integrity error disappears, this procedure essentially implements an in-band reset mechanism with an acknowledgement handshake that can be used to determine whether the reset has been successful.
Implementation Aspects
Ping Mechanism Bypass
Note that the ping bypass mechanism is to be implemented in a way that pings are only ack’ed immediately if 1) the FSM is in the InitReq
state, and 2) the init_trig
signal is still asserted.
This allows to subject the initialization process of each alert channel to the ping mechanism for channels that are recovering from a reset or clock gated cycle on the sender side.
I.e., alert channels that get stuck during the initialization process can be detected by the ping mechanism since ping requests are not immediately ack’ed anymore once init_trig
is deasserted.
FSM Encoding
Since there are many alert channels in the design, the receiver and sender FSMs themselves are not sparsely encoded. Instead, we rely on the ping mechanism to detect alert channels that are in a bad state. The specific implementation of the ping bypass mentioned in the previous subsection ensures that the ping mechanism can also be used to monitor the initialization sequence of alert channels.
Latency / Skew Considerations
Due to asynchronous transitions and different path latencies in the system, a change in reset or clock gating state will experience a different latency through the alert channels than through the indication signals (rst_n
and clk_en
) that are connected to the low-power control logic.
It is consequently possible for a group of alert senders to already be in reset or clock gated state, while the corresponding LPG logic does not yet know about this state change - and vice versa.
In practice, this means that ping requests may be pending for several cycles until the LPG logic detects a reset or clock-gated condition and disables the corresponding alert channel(s). Fortunately, such delay can be tolerated by setting the ping timeout to a sufficiently large value (see CLASSA_TIMEOUT_CYC_SHADOWED).
As for alert events, this latency difference should not pose a problem. Alert events may get stuck in the alert sender due to a reset or clock-gated condition - but this is to be expected.
Integration Considerations
Note that due to the aforementioned latency tolerance built into the ping timer, it is permissible to connect any reset or clock enable indication signal from the relevant clock group to the LPG logic. I.e., the only requirement is that the indication signals are logically related to the resets and clocks routed to the alert senders, and that the skew between reset / clock state changes and the indication signals is bounded.
The topgen script is extended so that it can identify all LPGs and the associated alert channels. This information is then used to parameterize the alert handler design, and make the necessary top-level connections from the reset and clock management controllers to the alert handler.
Hardening Against Glitch Attacks
In addition to the differential alert and escalation signalling scheme, the internal state machines and counters are hardened against glitch attacks as described bellow:
- Ping Timer:
- The FSM is sparsely encoded.
- The LFSR and the counter are duplicated.
- If the FSM or counter are glitched into an invalid state, all internal ping fail alerts will be permanently asserted.
- Escalation Timers:
- The escalation timer FSMs are sparsely encoded.
- The escalation timer counters are duplicated.
- The escalation accumulators are duplicated.
- If one of these FSMs, counters or accumulators are glitched into an invalid state, all escalation actions will be triggered and the affected FSM goes into a terminal
FsmError
state.
- CSRs:
- Critical configuration CSRs are shadowed.
- The shadow CSRs can trigger additional internal alerts for CSR storage and update failures. These internal alerts are fed back into the alert classifier in the same manner as the ping and integrity failure alerts.
- LPGs:
- Clock-gated and reset-asserted indication signals that are routed from clock and reset managers to the alert handler are encoded with multibit signals.
Programmers Guide
Power-up and Reset Considerations
False alerts during power-up and reset are not possible since the alerts are disabled by default, and need to be configured and locked in by the firmware. The ping timer won’t start until initial configuration is over and the registers are locked in.
The low-power state management of alert channels is handled entirely by hardware and hence this is transparent to software. Note however that the LPGs inherit the security properties of the associated clock groups and resets. This means that the low-power state of certain alerts can be controlled by SW by means of clock gating or block reset. For example, certain crypto blocks are located in a transactional clock group which can be clock gated by SW - and this also affects the associated alerts of these crypto blocks. See clock and reset managers for more detail.
Initialization
To initialize the block, software running at a high privilege levels (early in the security settings process) should do the following:
-
For each alert and each local alert:
-
Determine if alert is enabled (should only be false if alert is known to be faulty). Set ALERT_EN_SHADOWED_0.EN_A_0 and LOC_ALERT_EN_SHADOWED_0.EN_LA_0 accordingly.
-
Determine which class (A..D) the alert is associated with. Set ALERT_CLASS_SHADOWED_0.CLASS_A_0 and LOC_ALERT_CLASS_SHADOWED_0.CLASS_LA_0 accordingly.
-
Optionally lock each alert configuration by writing 0 to ALERT_REGWEN_0.EN_0 or LOC_ALERT_REGWEN_0.EN_0. Note however that only locked and enabled alerts are going to be pinged using the ping mechanism. This ensures that spurious ping failures cannot occur when previously enabled alerts are being disabled again (before locking).
-
-
Set the ping timeout value PING_TIMEOUT_CYC_SHADOWED. This value is dependent on the clock ratios present in the system.
-
For each class (A..D):
-
Determine whether to enable escalation mechanisms (accumulation / interrupt timeout) for this particular class. Set CLASSA_CTRL_SHADOWED.EN accordingly.
-
Determine if this class of alerts allows clearing of escalation once it has begun. Set CLASSA_CTRL_SHADOWED.LOCK to true if clearing should be disabled. If true, once escalation protocol begins, it can not be stopped, the assumption being that it ends in a chip reset else it will be rendered useless thenceforth.
-
Determine the number of alerts required to be accumulated before escalation protocol kicks in. Set CLASSA_ACCUM_THRESH accordingly.
-
Determine whether the interrupt associated with that class needs a timeout. If yes, set CLASSA_TIMEOUT_CYC_SHADOWED to an appropriate value greater than zero (zero corresponds to an infinite timeout and disables the mechanism).
-
For each escalation phase (0..3):
- Determine length of each escalation phase by setting CLASSA_PHASE0_CYC accordingly
-
For each escalation signal (0..3):
- Determine whether to enable the escalation signal, and set the
CLASSA_CTRL_SHADOWED.E0_EN bit accordingly (default is enabled).
Note that setting all of the
E*_EN
bits to 0 within a class has the same effect of disabling the entire class by setting CLASSA_CTRL_SHADOWED.EN to zero. - Determine the phase -> escalation mapping of this class and program it via the CLASSA_CTRL_SHADOWED.E0_MAP values if it needs to be changed from the default mapping (0->0, 1->1, 2->2, 3->3).
- Determine whether to enable the escalation signal, and set the
CLASSA_CTRL_SHADOWED.E0_EN bit accordingly (default is enabled).
Note that setting all of the
-
Optionally lock the class configuration by writing 0 to CLASSA_CTRL_SHADOWED.REGWEN.
-
-
After initial configuration at startup, enable the ping timer mechanism by writing 1 to PING_TIMER_EN. It is also recommended to lock the ping timer configuration by clearing PING_TIMER_REGWEN. Note that only locked and enabled alerts are going to be pinged using the ping mechanism. This ensures that spurious ping failures cannot occur when previously enabled alerts are being disabled again (before locking).
Interrupt Handling
For every alert that is enabled, an interrupt will be triggered on class A, B, C, or D. To handle an interrupt of a particular class, software should execute the following steps:
-
If needed, check the escalation state of this class by reading CLASSA_STATE. This reveals whether escalation protocol has been triggered and in which escalation phase the class is. In case interrupt timeouts are enabled the class will be in timeout state unless escalation has already been triggered. The current interrupt or escalation cycle counter can be read via CLASSA_ESC_CNT.
-
Since the interrupt does not indicate which alert triggered, SW must read the cause registers LOC_ALERT_CAUSE and ALERT_CAUSE etc. The cause bits of all alerts are concatenated and chunked into 32bit words. Hence the register file contains as many cause words as needed to cover all alerts present in the system. Each cause register contains a sticky bit that is set by the incoming alert, and is clearable with a write by software. This should only be cleared after software has cleared the event trigger, if applicable. It is possible that the event requires no clearing (e.g. a parity error), or can’t be cleared (a breach in the metal mesh protecting the chip).
Note that in the rare case when multiple events are triggered at or about the same time, all events should be cleared before proceeding.
-
After the event is cleared (if needed or possible), software should handle the interrupt as follows:
-
Resetting the accumulation register for the class by writing CLASSA_CLR. This also aborts the escalation protocol if it has been triggered. If for some reason it is desired to never allow the accumulator or escalation to be cleared, software can initialize the CLASSA_CLR_REGWEN register to zero. If CLASSA_CLR_REGWEN is already false when an alert interrupt is detected (either due to software control or hardware trigger via CLASSA_CTRL_SHADOWED.LOCK), then the accumulation counter can not be cleared and this step has no effect.
-
After the accumulation counter is reset (if applicable), software should clear the class A interrupt state bit INTR_STATE.CLASSA. Clearing the class A interrupt state bit also clears and stops the interrupt timeout counter (if enabled).
-
Note that testing interrupts by writing to the interrupt test registers does also trigger the internal interrupt timeout (if enabled), since the interrupt state is used as enable signal for the timer. However, alert accumulation will not be triggered by this testing mechanism.
Device Interface Functions (DIFs)
To use this DIF, include the following C header:
#include "sw/device/lib/dif/dif_alert_handler.h"
This header provides the following device interface functions:
dif_alert_handler_alert_acknowledge
Clears an alert from the cause vector, similar to an IRQ acknowledgement.dif_alert_handler_alert_is_cause
Checks whether an alert is one of the causes for an alert IRQ.dif_alert_handler_configure_alert
Configures an alert in the alert handler.dif_alert_handler_configure_class
Configures the escalation protocol of an alert class in the alert handler.dif_alert_handler_configure_local_alert
Configures a local alert in the alert handler.dif_alert_handler_configure_ping_timer
Configures the ping timer in the alert handler.dif_alert_handler_escalation_can_clear
Checks whether software can clear escalations for this class.dif_alert_handler_escalation_clear
Clears an on-going escalation, as well as the class accumulator.dif_alert_handler_escalation_disable_clearing
Disables escalation clearing for this class.dif_alert_handler_get_accumulator
Gets the accumulator value for this class.dif_alert_handler_get_class_state
Gets the current state of this class.dif_alert_handler_get_escalation_counter
Gets the current value of the "escalation counter".dif_alert_handler_is_alert_locked
Checks whether an alert handler's alert is locked.dif_alert_handler_is_class_locked
Checks whether an alert handler's class is locked.dif_alert_handler_is_local_alert_locked
Checks whether an alert handler's local alert is locked.dif_alert_handler_is_ping_timer_locked
Checks whether alert handler's ping timer is locked.dif_alert_handler_local_alert_acknowledge
Clears a local alert from the cause vector, similar to an IRQ acknowledgement.dif_alert_handler_local_alert_is_cause
Checks whether a local alert is one of the causes for an alert IRQ.dif_alert_handler_lock_alert
Locks out an alert handler alert configuration.dif_alert_handler_lock_class
Locks out an alert handler class configuration.dif_alert_handler_lock_local_alert
Locks out an alert handler local alert configuration.dif_alert_handler_lock_ping_timer
Locks out alert handler ping timer configuration.dif_alert_handler_ping_timer_set_enabled
Enables the ping timer in the alert handler.
Register Table
Summary | |||
---|---|---|---|
Name | Offset | Length | Description |
alert_handler.INTR_STATE | 0x0 | 4 | Interrupt State Register |
alert_handler.INTR_ENABLE | 0x4 | 4 | Interrupt Enable Register |
alert_handler.INTR_TEST | 0x8 | 4 | Interrupt Test Register |
alert_handler.PING_TIMER_REGWEN | 0xc | 4 | Register write enable for |
alert_handler.PING_TIMEOUT_CYC_SHADOWED | 0x10 | 4 | Ping timeout cycle count. |
alert_handler.PING_TIMER_EN_SHADOWED | 0x14 | 4 | Ping timer enable. |
alert_handler.ALERT_REGWEN_0 | 0x18 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_1 | 0x1c | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_2 | 0x20 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_3 | 0x24 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_4 | 0x28 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_5 | 0x2c | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_6 | 0x30 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_7 | 0x34 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_8 | 0x38 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_9 | 0x3c | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_10 | 0x40 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_11 | 0x44 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_12 | 0x48 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_13 | 0x4c | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_14 | 0x50 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_15 | 0x54 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_16 | 0x58 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_17 | 0x5c | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_18 | 0x60 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_19 | 0x64 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_20 | 0x68 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_21 | 0x6c | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_22 | 0x70 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_23 | 0x74 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_24 | 0x78 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_25 | 0x7c | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_26 | 0x80 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_27 | 0x84 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_28 | 0x88 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_29 | 0x8c | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_30 | 0x90 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_31 | 0x94 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_32 | 0x98 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_33 | 0x9c | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_34 | 0xa0 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_35 | 0xa4 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_36 | 0xa8 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_37 | 0xac | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_38 | 0xb0 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_39 | 0xb4 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_40 | 0xb8 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_41 | 0xbc | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_42 | 0xc0 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_43 | 0xc4 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_44 | 0xc8 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_45 | 0xcc | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_46 | 0xd0 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_47 | 0xd4 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_48 | 0xd8 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_49 | 0xdc | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_50 | 0xe0 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_51 | 0xe4 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_52 | 0xe8 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_53 | 0xec | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_54 | 0xf0 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_55 | 0xf4 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_56 | 0xf8 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_57 | 0xfc | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_58 | 0x100 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_59 | 0x104 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_60 | 0x108 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_61 | 0x10c | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_62 | 0x110 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_63 | 0x114 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_REGWEN_64 | 0x118 | 4 | Register write enable for alert enable bits. |
alert_handler.ALERT_EN_SHADOWED_0 | 0x11c | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_1 | 0x120 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_2 | 0x124 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_3 | 0x128 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_4 | 0x12c | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_5 | 0x130 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_6 | 0x134 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_7 | 0x138 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_8 | 0x13c | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_9 | 0x140 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_10 | 0x144 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_11 | 0x148 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_12 | 0x14c | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_13 | 0x150 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_14 | 0x154 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_15 | 0x158 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_16 | 0x15c | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_17 | 0x160 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_18 | 0x164 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_19 | 0x168 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_20 | 0x16c | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_21 | 0x170 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_22 | 0x174 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_23 | 0x178 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_24 | 0x17c | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_25 | 0x180 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_26 | 0x184 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_27 | 0x188 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_28 | 0x18c | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_29 | 0x190 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_30 | 0x194 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_31 | 0x198 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_32 | 0x19c | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_33 | 0x1a0 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_34 | 0x1a4 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_35 | 0x1a8 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_36 | 0x1ac | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_37 | 0x1b0 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_38 | 0x1b4 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_39 | 0x1b8 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_40 | 0x1bc | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_41 | 0x1c0 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_42 | 0x1c4 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_43 | 0x1c8 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_44 | 0x1cc | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_45 | 0x1d0 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_46 | 0x1d4 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_47 | 0x1d8 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_48 | 0x1dc | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_49 | 0x1e0 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_50 | 0x1e4 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_51 | 0x1e8 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_52 | 0x1ec | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_53 | 0x1f0 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_54 | 0x1f4 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_55 | 0x1f8 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_56 | 0x1fc | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_57 | 0x200 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_58 | 0x204 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_59 | 0x208 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_60 | 0x20c | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_61 | 0x210 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_62 | 0x214 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_63 | 0x218 | 4 | Enable register for alerts. |
alert_handler.ALERT_EN_SHADOWED_64 | 0x21c | 4 | Enable register for alerts. |
alert_handler.ALERT_CLASS_SHADOWED_0 | 0x220 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_1 | 0x224 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_2 | 0x228 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_3 | 0x22c | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_4 | 0x230 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_5 | 0x234 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_6 | 0x238 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_7 | 0x23c | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_8 | 0x240 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_9 | 0x244 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_10 | 0x248 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_11 | 0x24c | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_12 | 0x250 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_13 | 0x254 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_14 | 0x258 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_15 | 0x25c | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_16 | 0x260 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_17 | 0x264 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_18 | 0x268 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_19 | 0x26c | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_20 | 0x270 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_21 | 0x274 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_22 | 0x278 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_23 | 0x27c | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_24 | 0x280 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_25 | 0x284 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_26 | 0x288 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_27 | 0x28c | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_28 | 0x290 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_29 | 0x294 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_30 | 0x298 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_31 | 0x29c | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_32 | 0x2a0 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_33 | 0x2a4 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_34 | 0x2a8 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_35 | 0x2ac | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_36 | 0x2b0 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_37 | 0x2b4 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_38 | 0x2b8 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_39 | 0x2bc | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_40 | 0x2c0 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_41 | 0x2c4 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_42 | 0x2c8 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_43 | 0x2cc | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_44 | 0x2d0 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_45 | 0x2d4 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_46 | 0x2d8 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_47 | 0x2dc | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_48 | 0x2e0 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_49 | 0x2e4 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_50 | 0x2e8 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_51 | 0x2ec | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_52 | 0x2f0 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_53 | 0x2f4 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_54 | 0x2f8 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_55 | 0x2fc | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_56 | 0x300 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_57 | 0x304 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_58 | 0x308 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_59 | 0x30c | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_60 | 0x310 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_61 | 0x314 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_62 | 0x318 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_63 | 0x31c | 4 | Class assignment of alerts. |
alert_handler.ALERT_CLASS_SHADOWED_64 | 0x320 | 4 | Class assignment of alerts. |
alert_handler.ALERT_CAUSE_0 | 0x324 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_1 | 0x328 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_2 | 0x32c | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_3 | 0x330 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_4 | 0x334 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_5 | 0x338 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_6 | 0x33c | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_7 | 0x340 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_8 | 0x344 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_9 | 0x348 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_10 | 0x34c | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_11 | 0x350 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_12 | 0x354 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_13 | 0x358 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_14 | 0x35c | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_15 | 0x360 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_16 | 0x364 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_17 | 0x368 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_18 | 0x36c | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_19 | 0x370 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_20 | 0x374 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_21 | 0x378 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_22 | 0x37c | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_23 | 0x380 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_24 | 0x384 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_25 | 0x388 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_26 | 0x38c | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_27 | 0x390 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_28 | 0x394 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_29 | 0x398 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_30 | 0x39c | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_31 | 0x3a0 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_32 | 0x3a4 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_33 | 0x3a8 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_34 | 0x3ac | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_35 | 0x3b0 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_36 | 0x3b4 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_37 | 0x3b8 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_38 | 0x3bc | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_39 | 0x3c0 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_40 | 0x3c4 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_41 | 0x3c8 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_42 | 0x3cc | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_43 | 0x3d0 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_44 | 0x3d4 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_45 | 0x3d8 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_46 | 0x3dc | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_47 | 0x3e0 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_48 | 0x3e4 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_49 | 0x3e8 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_50 | 0x3ec | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_51 | 0x3f0 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_52 | 0x3f4 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_53 | 0x3f8 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_54 | 0x3fc | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_55 | 0x400 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_56 | 0x404 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_57 | 0x408 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_58 | 0x40c | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_59 | 0x410 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_60 | 0x414 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_61 | 0x418 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_62 | 0x41c | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_63 | 0x420 | 4 | Alert Cause Register |
alert_handler.ALERT_CAUSE_64 | 0x424 | 4 | Alert Cause Register |
alert_handler.LOC_ALERT_REGWEN_0 | 0x428 | 4 | Register write enable for alert enable bits. |
alert_handler.LOC_ALERT_REGWEN_1 | 0x42c | 4 | Register write enable for alert enable bits. |
alert_handler.LOC_ALERT_REGWEN_2 | 0x430 | 4 | Register write enable for alert enable bits. |
alert_handler.LOC_ALERT_REGWEN_3 | 0x434 | 4 | Register write enable for alert enable bits. |
alert_handler.LOC_ALERT_REGWEN_4 | 0x438 | 4 | Register write enable for alert enable bits. |
alert_handler.LOC_ALERT_REGWEN_5 | 0x43c | 4 | Register write enable for alert enable bits. |
alert_handler.LOC_ALERT_REGWEN_6 | 0x440 | 4 | Register write enable for alert enable bits. |
alert_handler.LOC_ALERT_EN_SHADOWED_0 | 0x444 | 4 | Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_EN_SHADOWED_1 | 0x448 | 4 | Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_EN_SHADOWED_2 | 0x44c | 4 | Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_EN_SHADOWED_3 | 0x450 | 4 | Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_EN_SHADOWED_4 | 0x454 | 4 | Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_EN_SHADOWED_5 | 0x458 | 4 | Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_EN_SHADOWED_6 | 0x45c | 4 | Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CLASS_SHADOWED_0 | 0x460 | 4 | Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CLASS_SHADOWED_1 | 0x464 | 4 | Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CLASS_SHADOWED_2 | 0x468 | 4 | Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CLASS_SHADOWED_3 | 0x46c | 4 | Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CLASS_SHADOWED_4 | 0x470 | 4 | Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CLASS_SHADOWED_5 | 0x474 | 4 | Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CLASS_SHADOWED_6 | 0x478 | 4 | Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CAUSE_0 | 0x47c | 4 | Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CAUSE_1 | 0x480 | 4 | Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CAUSE_2 | 0x484 | 4 | Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CAUSE_3 | 0x488 | 4 | Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CAUSE_4 | 0x48c | 4 | Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CAUSE_5 | 0x490 | 4 | Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.LOC_ALERT_CAUSE_6 | 0x494 | 4 | Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). |
alert_handler.CLASSA_REGWEN | 0x498 | 4 | Lock bit for Class A configuration. |
alert_handler.CLASSA_CTRL_SHADOWED | 0x49c | 4 | Escalation control register for alert Class A. Can not be modified if |
alert_handler.CLASSA_CLR_REGWEN | 0x4a0 | 4 | Clear enable for escalation protocol of Class A alerts. |
alert_handler.CLASSA_CLR_SHADOWED | 0x4a4 | 4 | Clear for escalation protocol of Class A. |
alert_handler.CLASSA_ACCUM_CNT | 0x4a8 | 4 | Current accumulation value for alert Class A. Software can clear this register
with a write to |
alert_handler.CLASSA_ACCUM_THRESH_SHADOWED | 0x4ac | 4 | Accumulation threshold value for alert Class A. |
alert_handler.CLASSA_TIMEOUT_CYC_SHADOWED | 0x4b0 | 4 | Interrupt timeout in cycles. |
alert_handler.CLASSA_CRASHDUMP_TRIGGER_SHADOWED | 0x4b4 | 4 | Crashdump trigger configuration for Class A. |
alert_handler.CLASSA_PHASE0_CYC_SHADOWED | 0x4b8 | 4 | Duration of escalation phase 0 for Class A. |
alert_handler.CLASSA_PHASE1_CYC_SHADOWED | 0x4bc | 4 | Duration of escalation phase 1 for Class A. |
alert_handler.CLASSA_PHASE2_CYC_SHADOWED | 0x4c0 | 4 | Duration of escalation phase 2 for Class A. |
alert_handler.CLASSA_PHASE3_CYC_SHADOWED | 0x4c4 | 4 | Duration of escalation phase 3 for Class A. |
alert_handler.CLASSA_ESC_CNT | 0x4c8 | 4 | Escalation counter in cycles for Class A. |
alert_handler.CLASSA_STATE | 0x4cc | 4 | Current escalation state of Class A. See also |
alert_handler.CLASSB_REGWEN | 0x4d0 | 4 | Lock bit for Class B configuration. |
alert_handler.CLASSB_CTRL_SHADOWED | 0x4d4 | 4 | Escalation control register for alert Class B. Can not be modified if |
alert_handler.CLASSB_CLR_REGWEN | 0x4d8 | 4 | Clear enable for escalation protocol of Class B alerts. |
alert_handler.CLASSB_CLR_SHADOWED | 0x4dc | 4 | Clear for escalation protocol of Class B. |
alert_handler.CLASSB_ACCUM_CNT | 0x4e0 | 4 | Current accumulation value for alert Class B. Software can clear this register
with a write to |
alert_handler.CLASSB_ACCUM_THRESH_SHADOWED | 0x4e4 | 4 | Accumulation threshold value for alert Class B. |
alert_handler.CLASSB_TIMEOUT_CYC_SHADOWED | 0x4e8 | 4 | Interrupt timeout in cycles. |
alert_handler.CLASSB_CRASHDUMP_TRIGGER_SHADOWED | 0x4ec | 4 | Crashdump trigger configuration for Class B. |
alert_handler.CLASSB_PHASE0_CYC_SHADOWED | 0x4f0 | 4 | Duration of escalation phase 0 for Class B. |
alert_handler.CLASSB_PHASE1_CYC_SHADOWED | 0x4f4 | 4 | Duration of escalation phase 1 for Class B. |
alert_handler.CLASSB_PHASE2_CYC_SHADOWED | 0x4f8 | 4 | Duration of escalation phase 2 for Class B. |
alert_handler.CLASSB_PHASE3_CYC_SHADOWED | 0x4fc | 4 | Duration of escalation phase 3 for Class B. |
alert_handler.CLASSB_ESC_CNT | 0x500 | 4 | Escalation counter in cycles for Class B. |
alert_handler.CLASSB_STATE | 0x504 | 4 | Current escalation state of Class B. See also |
alert_handler.CLASSC_REGWEN | 0x508 | 4 | Lock bit for Class C configuration. |
alert_handler.CLASSC_CTRL_SHADOWED | 0x50c | 4 | Escalation control register for alert Class C. Can not be modified if |
alert_handler.CLASSC_CLR_REGWEN | 0x510 | 4 | Clear enable for escalation protocol of Class C alerts. |
alert_handler.CLASSC_CLR_SHADOWED | 0x514 | 4 | Clear for escalation protocol of Class C. |
alert_handler.CLASSC_ACCUM_CNT | 0x518 | 4 | Current accumulation value for alert Class C. Software can clear this register
with a write to |
alert_handler.CLASSC_ACCUM_THRESH_SHADOWED | 0x51c | 4 | Accumulation threshold value for alert Class C. |
alert_handler.CLASSC_TIMEOUT_CYC_SHADOWED | 0x520 | 4 | Interrupt timeout in cycles. |
alert_handler.CLASSC_CRASHDUMP_TRIGGER_SHADOWED | 0x524 | 4 | Crashdump trigger configuration for Class C. |
alert_handler.CLASSC_PHASE0_CYC_SHADOWED | 0x528 | 4 | Duration of escalation phase 0 for Class C. |
alert_handler.CLASSC_PHASE1_CYC_SHADOWED | 0x52c | 4 | Duration of escalation phase 1 for Class C. |
alert_handler.CLASSC_PHASE2_CYC_SHADOWED | 0x530 | 4 | Duration of escalation phase 2 for Class C. |
alert_handler.CLASSC_PHASE3_CYC_SHADOWED | 0x534 | 4 | Duration of escalation phase 3 for Class C. |
alert_handler.CLASSC_ESC_CNT | 0x538 | 4 | Escalation counter in cycles for Class C. |
alert_handler.CLASSC_STATE | 0x53c | 4 | Current escalation state of Class C. See also |
alert_handler.CLASSD_REGWEN | 0x540 | 4 | Lock bit for Class D configuration. |
alert_handler.CLASSD_CTRL_SHADOWED | 0x544 | 4 | Escalation control register for alert Class D. Can not be modified if |
alert_handler.CLASSD_CLR_REGWEN | 0x548 | 4 | Clear enable for escalation protocol of Class D alerts. |
alert_handler.CLASSD_CLR_SHADOWED | 0x54c | 4 | Clear for escalation protocol of Class D. |
alert_handler.CLASSD_ACCUM_CNT | 0x550 | 4 | Current accumulation value for alert Class D. Software can clear this register
with a write to |
alert_handler.CLASSD_ACCUM_THRESH_SHADOWED | 0x554 | 4 | Accumulation threshold value for alert Class D. |
alert_handler.CLASSD_TIMEOUT_CYC_SHADOWED | 0x558 | 4 | Interrupt timeout in cycles. |
alert_handler.CLASSD_CRASHDUMP_TRIGGER_SHADOWED | 0x55c | 4 | Crashdump trigger configuration for Class D. |
alert_handler.CLASSD_PHASE0_CYC_SHADOWED | 0x560 | 4 | Duration of escalation phase 0 for Class D. |
alert_handler.CLASSD_PHASE1_CYC_SHADOWED | 0x564 | 4 | Duration of escalation phase 1 for Class D. |
alert_handler.CLASSD_PHASE2_CYC_SHADOWED | 0x568 | 4 | Duration of escalation phase 2 for Class D. |
alert_handler.CLASSD_PHASE3_CYC_SHADOWED | 0x56c | 4 | Duration of escalation phase 3 for Class D. |
alert_handler.CLASSD_ESC_CNT | 0x570 | 4 | Escalation counter in cycles for Class D. |
alert_handler.CLASSD_STATE | 0x574 | 4 | Current escalation state of Class D. See also |
alert_handler.INTR_STATE @ 0x0
Interrupt State Register Reset default = 0x0, mask 0xf
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | classa | Interrupt state bit of Class A. Set by HW in case an alert within this class triggered. Defaults true, write one to clear. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1 | rw1c | 0x0 | classb | Interrupt state bit of Class B. Set by HW in case an alert within this class triggered. Defaults true, write one to clear. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2 | rw1c | 0x0 | classc | Interrupt state bit of Class C. Set by HW in case an alert within this class triggered. Defaults true, write one to clear. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
3 | rw1c | 0x0 | classd | Interrupt state bit of Class D. Set by HW in case an alert within this class triggered. Defaults true, write one to clear. |
alert_handler.INTR_ENABLE @ 0x4
Interrupt Enable Register Reset default = 0x0, mask 0xf
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | classa | Enable interrupt when | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1 | rw | 0x0 | classb | Enable interrupt when | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2 | rw | 0x0 | classc | Enable interrupt when | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
3 | rw | 0x0 | classd | Enable interrupt when |
alert_handler.INTR_TEST @ 0x8
Interrupt Test Register Reset default = 0x0, mask 0xf
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | wo | 0x0 | classa | Write 1 to force | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1 | wo | 0x0 | classb | Write 1 to force | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2 | wo | 0x0 | classc | Write 1 to force | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
3 | wo | 0x0 | classd | Write 1 to force |
alert_handler.PING_TIMER_REGWEN @ 0xc
Register write enable for Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | PING_TIMER_REGWEN | When true, the |
alert_handler.PING_TIMEOUT_CYC_SHADOWED @ 0x10
Ping timeout cycle count. Reset default = 0x100, mask 0xffff
Register enable = PING_TIMER_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
15:0 | rw | 0x100 | PING_TIMEOUT_CYC_SHADOWED | Timeout value in cycles. If an alert receiver or an escalation sender does not respond to a ping within this timeout window, a pingfail alert will be raised. It is recommended to set this value to the equivalent of 256 cycles of the slowest alert sender clock domain in the system (or greater). |
alert_handler.PING_TIMER_EN_SHADOWED @ 0x14
Ping timer enable. Reset default = 0x0, mask 0x1
Register enable = PING_TIMER_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1s | 0x0 | PING_TIMER_EN_SHADOWED | Setting this to 1 enables the ping timer mechanism. This bit cannot be cleared to 0 once it has been set to 1. Note that the alert pinging mechanism will only ping alerts that have been enabled and locked. |
alert_handler.ALERT_REGWEN_0 @ 0x18
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_0 | Alert configuration write enable bit.
If this is cleared to 0, the corresponding Note that the alert pinging mechanism will only ping alerts that have been enabled and locked. |
alert_handler.ALERT_REGWEN_1 @ 0x1c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_1 | For alert1 |
alert_handler.ALERT_REGWEN_2 @ 0x20
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_2 | For alert2 |
alert_handler.ALERT_REGWEN_3 @ 0x24
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_3 | For alert3 |
alert_handler.ALERT_REGWEN_4 @ 0x28
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_4 | For alert4 |
alert_handler.ALERT_REGWEN_5 @ 0x2c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_5 | For alert5 |
alert_handler.ALERT_REGWEN_6 @ 0x30
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_6 | For alert6 |
alert_handler.ALERT_REGWEN_7 @ 0x34
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_7 | For alert7 |
alert_handler.ALERT_REGWEN_8 @ 0x38
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_8 | For alert8 |
alert_handler.ALERT_REGWEN_9 @ 0x3c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_9 | For alert9 |
alert_handler.ALERT_REGWEN_10 @ 0x40
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_10 | For alert10 |
alert_handler.ALERT_REGWEN_11 @ 0x44
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_11 | For alert11 |
alert_handler.ALERT_REGWEN_12 @ 0x48
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_12 | For alert12 |
alert_handler.ALERT_REGWEN_13 @ 0x4c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_13 | For alert13 |
alert_handler.ALERT_REGWEN_14 @ 0x50
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_14 | For alert14 |
alert_handler.ALERT_REGWEN_15 @ 0x54
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_15 | For alert15 |
alert_handler.ALERT_REGWEN_16 @ 0x58
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_16 | For alert16 |
alert_handler.ALERT_REGWEN_17 @ 0x5c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_17 | For alert17 |
alert_handler.ALERT_REGWEN_18 @ 0x60
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_18 | For alert18 |
alert_handler.ALERT_REGWEN_19 @ 0x64
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_19 | For alert19 |
alert_handler.ALERT_REGWEN_20 @ 0x68
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_20 | For alert20 |
alert_handler.ALERT_REGWEN_21 @ 0x6c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_21 | For alert21 |
alert_handler.ALERT_REGWEN_22 @ 0x70
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_22 | For alert22 |
alert_handler.ALERT_REGWEN_23 @ 0x74
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_23 | For alert23 |
alert_handler.ALERT_REGWEN_24 @ 0x78
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_24 | For alert24 |
alert_handler.ALERT_REGWEN_25 @ 0x7c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_25 | For alert25 |
alert_handler.ALERT_REGWEN_26 @ 0x80
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_26 | For alert26 |
alert_handler.ALERT_REGWEN_27 @ 0x84
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_27 | For alert27 |
alert_handler.ALERT_REGWEN_28 @ 0x88
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_28 | For alert28 |
alert_handler.ALERT_REGWEN_29 @ 0x8c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_29 | For alert29 |
alert_handler.ALERT_REGWEN_30 @ 0x90
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_30 | For alert30 |
alert_handler.ALERT_REGWEN_31 @ 0x94
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_31 | For alert31 |
alert_handler.ALERT_REGWEN_32 @ 0x98
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_32 | For alert32 |
alert_handler.ALERT_REGWEN_33 @ 0x9c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_33 | For alert33 |
alert_handler.ALERT_REGWEN_34 @ 0xa0
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_34 | For alert34 |
alert_handler.ALERT_REGWEN_35 @ 0xa4
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_35 | For alert35 |
alert_handler.ALERT_REGWEN_36 @ 0xa8
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_36 | For alert36 |
alert_handler.ALERT_REGWEN_37 @ 0xac
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_37 | For alert37 |
alert_handler.ALERT_REGWEN_38 @ 0xb0
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_38 | For alert38 |
alert_handler.ALERT_REGWEN_39 @ 0xb4
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_39 | For alert39 |
alert_handler.ALERT_REGWEN_40 @ 0xb8
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_40 | For alert40 |
alert_handler.ALERT_REGWEN_41 @ 0xbc
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_41 | For alert41 |
alert_handler.ALERT_REGWEN_42 @ 0xc0
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_42 | For alert42 |
alert_handler.ALERT_REGWEN_43 @ 0xc4
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_43 | For alert43 |
alert_handler.ALERT_REGWEN_44 @ 0xc8
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_44 | For alert44 |
alert_handler.ALERT_REGWEN_45 @ 0xcc
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_45 | For alert45 |
alert_handler.ALERT_REGWEN_46 @ 0xd0
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_46 | For alert46 |
alert_handler.ALERT_REGWEN_47 @ 0xd4
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_47 | For alert47 |
alert_handler.ALERT_REGWEN_48 @ 0xd8
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_48 | For alert48 |
alert_handler.ALERT_REGWEN_49 @ 0xdc
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_49 | For alert49 |
alert_handler.ALERT_REGWEN_50 @ 0xe0
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_50 | For alert50 |
alert_handler.ALERT_REGWEN_51 @ 0xe4
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_51 | For alert51 |
alert_handler.ALERT_REGWEN_52 @ 0xe8
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_52 | For alert52 |
alert_handler.ALERT_REGWEN_53 @ 0xec
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_53 | For alert53 |
alert_handler.ALERT_REGWEN_54 @ 0xf0
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_54 | For alert54 |
alert_handler.ALERT_REGWEN_55 @ 0xf4
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_55 | For alert55 |
alert_handler.ALERT_REGWEN_56 @ 0xf8
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_56 | For alert56 |
alert_handler.ALERT_REGWEN_57 @ 0xfc
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_57 | For alert57 |
alert_handler.ALERT_REGWEN_58 @ 0x100
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_58 | For alert58 |
alert_handler.ALERT_REGWEN_59 @ 0x104
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_59 | For alert59 |
alert_handler.ALERT_REGWEN_60 @ 0x108
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_60 | For alert60 |
alert_handler.ALERT_REGWEN_61 @ 0x10c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_61 | For alert61 |
alert_handler.ALERT_REGWEN_62 @ 0x110
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_62 | For alert62 |
alert_handler.ALERT_REGWEN_63 @ 0x114
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_63 | For alert63 |
alert_handler.ALERT_REGWEN_64 @ 0x118
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_64 | For alert64 |
alert_handler.ALERT_EN_SHADOWED_0 @ 0x11c
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_0 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_0 | Alert enable bit. Note that the alert pinging mechanism will only ping alerts that have been enabled and locked. |
alert_handler.ALERT_EN_SHADOWED_1 @ 0x120
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_1 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_1 | For alert1 |
alert_handler.ALERT_EN_SHADOWED_2 @ 0x124
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_2 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_2 | For alert2 |
alert_handler.ALERT_EN_SHADOWED_3 @ 0x128
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_3 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_3 | For alert3 |
alert_handler.ALERT_EN_SHADOWED_4 @ 0x12c
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_4 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_4 | For alert4 |
alert_handler.ALERT_EN_SHADOWED_5 @ 0x130
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_5 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_5 | For alert5 |
alert_handler.ALERT_EN_SHADOWED_6 @ 0x134
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_6 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_6 | For alert6 |
alert_handler.ALERT_EN_SHADOWED_7 @ 0x138
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_7 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_7 | For alert7 |
alert_handler.ALERT_EN_SHADOWED_8 @ 0x13c
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_8 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_8 | For alert8 |
alert_handler.ALERT_EN_SHADOWED_9 @ 0x140
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_9 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_9 | For alert9 |
alert_handler.ALERT_EN_SHADOWED_10 @ 0x144
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_10 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_10 | For alert10 |
alert_handler.ALERT_EN_SHADOWED_11 @ 0x148
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_11 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_11 | For alert11 |
alert_handler.ALERT_EN_SHADOWED_12 @ 0x14c
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_12 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_12 | For alert12 |
alert_handler.ALERT_EN_SHADOWED_13 @ 0x150
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_13 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_13 | For alert13 |
alert_handler.ALERT_EN_SHADOWED_14 @ 0x154
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_14 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_14 | For alert14 |
alert_handler.ALERT_EN_SHADOWED_15 @ 0x158
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_15 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_15 | For alert15 |
alert_handler.ALERT_EN_SHADOWED_16 @ 0x15c
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_16 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_16 | For alert16 |
alert_handler.ALERT_EN_SHADOWED_17 @ 0x160
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_17 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_17 | For alert17 |
alert_handler.ALERT_EN_SHADOWED_18 @ 0x164
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_18 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_18 | For alert18 |
alert_handler.ALERT_EN_SHADOWED_19 @ 0x168
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_19 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_19 | For alert19 |
alert_handler.ALERT_EN_SHADOWED_20 @ 0x16c
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_20 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_20 | For alert20 |
alert_handler.ALERT_EN_SHADOWED_21 @ 0x170
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_21 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_21 | For alert21 |
alert_handler.ALERT_EN_SHADOWED_22 @ 0x174
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_22 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_22 | For alert22 |
alert_handler.ALERT_EN_SHADOWED_23 @ 0x178
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_23 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_23 | For alert23 |
alert_handler.ALERT_EN_SHADOWED_24 @ 0x17c
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_24 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_24 | For alert24 |
alert_handler.ALERT_EN_SHADOWED_25 @ 0x180
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_25 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_25 | For alert25 |
alert_handler.ALERT_EN_SHADOWED_26 @ 0x184
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_26 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_26 | For alert26 |
alert_handler.ALERT_EN_SHADOWED_27 @ 0x188
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_27 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_27 | For alert27 |
alert_handler.ALERT_EN_SHADOWED_28 @ 0x18c
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_28 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_28 | For alert28 |
alert_handler.ALERT_EN_SHADOWED_29 @ 0x190
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_29 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_29 | For alert29 |
alert_handler.ALERT_EN_SHADOWED_30 @ 0x194
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_30 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_30 | For alert30 |
alert_handler.ALERT_EN_SHADOWED_31 @ 0x198
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_31 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_31 | For alert31 |
alert_handler.ALERT_EN_SHADOWED_32 @ 0x19c
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_32 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_32 | For alert32 |
alert_handler.ALERT_EN_SHADOWED_33 @ 0x1a0
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_33 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_33 | For alert33 |
alert_handler.ALERT_EN_SHADOWED_34 @ 0x1a4
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_34 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_34 | For alert34 |
alert_handler.ALERT_EN_SHADOWED_35 @ 0x1a8
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_35 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_35 | For alert35 |
alert_handler.ALERT_EN_SHADOWED_36 @ 0x1ac
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_36 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_36 | For alert36 |
alert_handler.ALERT_EN_SHADOWED_37 @ 0x1b0
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_37 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_37 | For alert37 |
alert_handler.ALERT_EN_SHADOWED_38 @ 0x1b4
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_38 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_38 | For alert38 |
alert_handler.ALERT_EN_SHADOWED_39 @ 0x1b8
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_39 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_39 | For alert39 |
alert_handler.ALERT_EN_SHADOWED_40 @ 0x1bc
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_40 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_40 | For alert40 |
alert_handler.ALERT_EN_SHADOWED_41 @ 0x1c0
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_41 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_41 | For alert41 |
alert_handler.ALERT_EN_SHADOWED_42 @ 0x1c4
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_42 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_42 | For alert42 |
alert_handler.ALERT_EN_SHADOWED_43 @ 0x1c8
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_43 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_43 | For alert43 |
alert_handler.ALERT_EN_SHADOWED_44 @ 0x1cc
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_44 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_44 | For alert44 |
alert_handler.ALERT_EN_SHADOWED_45 @ 0x1d0
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_45 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_45 | For alert45 |
alert_handler.ALERT_EN_SHADOWED_46 @ 0x1d4
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_46 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_46 | For alert46 |
alert_handler.ALERT_EN_SHADOWED_47 @ 0x1d8
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_47 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_47 | For alert47 |
alert_handler.ALERT_EN_SHADOWED_48 @ 0x1dc
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_48 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_48 | For alert48 |
alert_handler.ALERT_EN_SHADOWED_49 @ 0x1e0
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_49 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_49 | For alert49 |
alert_handler.ALERT_EN_SHADOWED_50 @ 0x1e4
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_50 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_50 | For alert50 |
alert_handler.ALERT_EN_SHADOWED_51 @ 0x1e8
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_51 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_51 | For alert51 |
alert_handler.ALERT_EN_SHADOWED_52 @ 0x1ec
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_52 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_52 | For alert52 |
alert_handler.ALERT_EN_SHADOWED_53 @ 0x1f0
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_53 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_53 | For alert53 |
alert_handler.ALERT_EN_SHADOWED_54 @ 0x1f4
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_54 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_54 | For alert54 |
alert_handler.ALERT_EN_SHADOWED_55 @ 0x1f8
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_55 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_55 | For alert55 |
alert_handler.ALERT_EN_SHADOWED_56 @ 0x1fc
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_56 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_56 | For alert56 |
alert_handler.ALERT_EN_SHADOWED_57 @ 0x200
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_57 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_57 | For alert57 |
alert_handler.ALERT_EN_SHADOWED_58 @ 0x204
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_58 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_58 | For alert58 |
alert_handler.ALERT_EN_SHADOWED_59 @ 0x208
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_59 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_59 | For alert59 |
alert_handler.ALERT_EN_SHADOWED_60 @ 0x20c
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_60 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_60 | For alert60 |
alert_handler.ALERT_EN_SHADOWED_61 @ 0x210
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_61 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_61 | For alert61 |
alert_handler.ALERT_EN_SHADOWED_62 @ 0x214
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_62 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_62 | For alert62 |
alert_handler.ALERT_EN_SHADOWED_63 @ 0x218
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_63 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_63 | For alert63 |
alert_handler.ALERT_EN_SHADOWED_64 @ 0x21c
Enable register for alerts. Reset default = 0x0, mask 0x1
Register enable = ALERT_REGWEN_64 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_A_64 | For alert64 |
alert_handler.ALERT_CLASS_SHADOWED_0 @ 0x220
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_0 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_0 | Classification
|
alert_handler.ALERT_CLASS_SHADOWED_1 @ 0x224
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_1 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_1 | For alert1 |
alert_handler.ALERT_CLASS_SHADOWED_2 @ 0x228
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_2 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_2 | For alert2 |
alert_handler.ALERT_CLASS_SHADOWED_3 @ 0x22c
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_3 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_3 | For alert3 |
alert_handler.ALERT_CLASS_SHADOWED_4 @ 0x230
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_4 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_4 | For alert4 |
alert_handler.ALERT_CLASS_SHADOWED_5 @ 0x234
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_5 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_5 | For alert5 |
alert_handler.ALERT_CLASS_SHADOWED_6 @ 0x238
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_6 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_6 | For alert6 |
alert_handler.ALERT_CLASS_SHADOWED_7 @ 0x23c
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_7 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_7 | For alert7 |
alert_handler.ALERT_CLASS_SHADOWED_8 @ 0x240
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_8 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_8 | For alert8 |
alert_handler.ALERT_CLASS_SHADOWED_9 @ 0x244
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_9 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_9 | For alert9 |
alert_handler.ALERT_CLASS_SHADOWED_10 @ 0x248
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_10 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_10 | For alert10 |
alert_handler.ALERT_CLASS_SHADOWED_11 @ 0x24c
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_11 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_11 | For alert11 |
alert_handler.ALERT_CLASS_SHADOWED_12 @ 0x250
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_12 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_12 | For alert12 |
alert_handler.ALERT_CLASS_SHADOWED_13 @ 0x254
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_13 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_13 | For alert13 |
alert_handler.ALERT_CLASS_SHADOWED_14 @ 0x258
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_14 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_14 | For alert14 |
alert_handler.ALERT_CLASS_SHADOWED_15 @ 0x25c
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_15 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_15 | For alert15 |
alert_handler.ALERT_CLASS_SHADOWED_16 @ 0x260
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_16 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_16 | For alert16 |
alert_handler.ALERT_CLASS_SHADOWED_17 @ 0x264
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_17 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_17 | For alert17 |
alert_handler.ALERT_CLASS_SHADOWED_18 @ 0x268
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_18 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_18 | For alert18 |
alert_handler.ALERT_CLASS_SHADOWED_19 @ 0x26c
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_19 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_19 | For alert19 |
alert_handler.ALERT_CLASS_SHADOWED_20 @ 0x270
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_20 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_20 | For alert20 |
alert_handler.ALERT_CLASS_SHADOWED_21 @ 0x274
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_21 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_21 | For alert21 |
alert_handler.ALERT_CLASS_SHADOWED_22 @ 0x278
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_22 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_22 | For alert22 |
alert_handler.ALERT_CLASS_SHADOWED_23 @ 0x27c
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_23 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_23 | For alert23 |
alert_handler.ALERT_CLASS_SHADOWED_24 @ 0x280
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_24 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_24 | For alert24 |
alert_handler.ALERT_CLASS_SHADOWED_25 @ 0x284
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_25 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_25 | For alert25 |
alert_handler.ALERT_CLASS_SHADOWED_26 @ 0x288
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_26 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_26 | For alert26 |
alert_handler.ALERT_CLASS_SHADOWED_27 @ 0x28c
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_27 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_27 | For alert27 |
alert_handler.ALERT_CLASS_SHADOWED_28 @ 0x290
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_28 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_28 | For alert28 |
alert_handler.ALERT_CLASS_SHADOWED_29 @ 0x294
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_29 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_29 | For alert29 |
alert_handler.ALERT_CLASS_SHADOWED_30 @ 0x298
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_30 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_30 | For alert30 |
alert_handler.ALERT_CLASS_SHADOWED_31 @ 0x29c
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_31 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_31 | For alert31 |
alert_handler.ALERT_CLASS_SHADOWED_32 @ 0x2a0
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_32 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_32 | For alert32 |
alert_handler.ALERT_CLASS_SHADOWED_33 @ 0x2a4
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_33 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_33 | For alert33 |
alert_handler.ALERT_CLASS_SHADOWED_34 @ 0x2a8
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_34 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_34 | For alert34 |
alert_handler.ALERT_CLASS_SHADOWED_35 @ 0x2ac
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_35 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_35 | For alert35 |
alert_handler.ALERT_CLASS_SHADOWED_36 @ 0x2b0
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_36 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_36 | For alert36 |
alert_handler.ALERT_CLASS_SHADOWED_37 @ 0x2b4
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_37 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_37 | For alert37 |
alert_handler.ALERT_CLASS_SHADOWED_38 @ 0x2b8
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_38 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_38 | For alert38 |
alert_handler.ALERT_CLASS_SHADOWED_39 @ 0x2bc
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_39 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_39 | For alert39 |
alert_handler.ALERT_CLASS_SHADOWED_40 @ 0x2c0
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_40 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_40 | For alert40 |
alert_handler.ALERT_CLASS_SHADOWED_41 @ 0x2c4
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_41 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_41 | For alert41 |
alert_handler.ALERT_CLASS_SHADOWED_42 @ 0x2c8
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_42 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_42 | For alert42 |
alert_handler.ALERT_CLASS_SHADOWED_43 @ 0x2cc
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_43 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_43 | For alert43 |
alert_handler.ALERT_CLASS_SHADOWED_44 @ 0x2d0
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_44 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_44 | For alert44 |
alert_handler.ALERT_CLASS_SHADOWED_45 @ 0x2d4
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_45 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_45 | For alert45 |
alert_handler.ALERT_CLASS_SHADOWED_46 @ 0x2d8
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_46 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_46 | For alert46 |
alert_handler.ALERT_CLASS_SHADOWED_47 @ 0x2dc
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_47 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_47 | For alert47 |
alert_handler.ALERT_CLASS_SHADOWED_48 @ 0x2e0
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_48 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_48 | For alert48 |
alert_handler.ALERT_CLASS_SHADOWED_49 @ 0x2e4
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_49 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_49 | For alert49 |
alert_handler.ALERT_CLASS_SHADOWED_50 @ 0x2e8
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_50 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_50 | For alert50 |
alert_handler.ALERT_CLASS_SHADOWED_51 @ 0x2ec
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_51 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_51 | For alert51 |
alert_handler.ALERT_CLASS_SHADOWED_52 @ 0x2f0
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_52 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_52 | For alert52 |
alert_handler.ALERT_CLASS_SHADOWED_53 @ 0x2f4
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_53 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_53 | For alert53 |
alert_handler.ALERT_CLASS_SHADOWED_54 @ 0x2f8
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_54 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_54 | For alert54 |
alert_handler.ALERT_CLASS_SHADOWED_55 @ 0x2fc
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_55 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_55 | For alert55 |
alert_handler.ALERT_CLASS_SHADOWED_56 @ 0x300
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_56 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_56 | For alert56 |
alert_handler.ALERT_CLASS_SHADOWED_57 @ 0x304
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_57 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_57 | For alert57 |
alert_handler.ALERT_CLASS_SHADOWED_58 @ 0x308
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_58 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_58 | For alert58 |
alert_handler.ALERT_CLASS_SHADOWED_59 @ 0x30c
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_59 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_59 | For alert59 |
alert_handler.ALERT_CLASS_SHADOWED_60 @ 0x310
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_60 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_60 | For alert60 |
alert_handler.ALERT_CLASS_SHADOWED_61 @ 0x314
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_61 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_61 | For alert61 |
alert_handler.ALERT_CLASS_SHADOWED_62 @ 0x318
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_62 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_62 | For alert62 |
alert_handler.ALERT_CLASS_SHADOWED_63 @ 0x31c
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_63 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_63 | For alert63 |
alert_handler.ALERT_CLASS_SHADOWED_64 @ 0x320
Class assignment of alerts. Reset default = 0x0, mask 0x3
Register enable = ALERT_REGWEN_64 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_A_64 | For alert64 |
alert_handler.ALERT_CAUSE_0 @ 0x324
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_0 | Cause bit |
alert_handler.ALERT_CAUSE_1 @ 0x328
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_1 | For ALERT1 |
alert_handler.ALERT_CAUSE_2 @ 0x32c
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_2 | For ALERT2 |
alert_handler.ALERT_CAUSE_3 @ 0x330
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_3 | For ALERT3 |
alert_handler.ALERT_CAUSE_4 @ 0x334
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_4 | For ALERT4 |
alert_handler.ALERT_CAUSE_5 @ 0x338
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_5 | For ALERT5 |
alert_handler.ALERT_CAUSE_6 @ 0x33c
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_6 | For ALERT6 |
alert_handler.ALERT_CAUSE_7 @ 0x340
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_7 | For ALERT7 |
alert_handler.ALERT_CAUSE_8 @ 0x344
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_8 | For ALERT8 |
alert_handler.ALERT_CAUSE_9 @ 0x348
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_9 | For ALERT9 |
alert_handler.ALERT_CAUSE_10 @ 0x34c
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_10 | For ALERT10 |
alert_handler.ALERT_CAUSE_11 @ 0x350
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_11 | For ALERT11 |
alert_handler.ALERT_CAUSE_12 @ 0x354
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_12 | For ALERT12 |
alert_handler.ALERT_CAUSE_13 @ 0x358
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_13 | For ALERT13 |
alert_handler.ALERT_CAUSE_14 @ 0x35c
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_14 | For ALERT14 |
alert_handler.ALERT_CAUSE_15 @ 0x360
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_15 | For ALERT15 |
alert_handler.ALERT_CAUSE_16 @ 0x364
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_16 | For ALERT16 |
alert_handler.ALERT_CAUSE_17 @ 0x368
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_17 | For ALERT17 |
alert_handler.ALERT_CAUSE_18 @ 0x36c
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_18 | For ALERT18 |
alert_handler.ALERT_CAUSE_19 @ 0x370
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_19 | For ALERT19 |
alert_handler.ALERT_CAUSE_20 @ 0x374
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_20 | For ALERT20 |
alert_handler.ALERT_CAUSE_21 @ 0x378
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_21 | For ALERT21 |
alert_handler.ALERT_CAUSE_22 @ 0x37c
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_22 | For ALERT22 |
alert_handler.ALERT_CAUSE_23 @ 0x380
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_23 | For ALERT23 |
alert_handler.ALERT_CAUSE_24 @ 0x384
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_24 | For ALERT24 |
alert_handler.ALERT_CAUSE_25 @ 0x388
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_25 | For ALERT25 |
alert_handler.ALERT_CAUSE_26 @ 0x38c
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_26 | For ALERT26 |
alert_handler.ALERT_CAUSE_27 @ 0x390
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_27 | For ALERT27 |
alert_handler.ALERT_CAUSE_28 @ 0x394
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_28 | For ALERT28 |
alert_handler.ALERT_CAUSE_29 @ 0x398
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_29 | For ALERT29 |
alert_handler.ALERT_CAUSE_30 @ 0x39c
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_30 | For ALERT30 |
alert_handler.ALERT_CAUSE_31 @ 0x3a0
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_31 | For ALERT31 |
alert_handler.ALERT_CAUSE_32 @ 0x3a4
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_32 | For ALERT32 |
alert_handler.ALERT_CAUSE_33 @ 0x3a8
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_33 | For ALERT33 |
alert_handler.ALERT_CAUSE_34 @ 0x3ac
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_34 | For ALERT34 |
alert_handler.ALERT_CAUSE_35 @ 0x3b0
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_35 | For ALERT35 |
alert_handler.ALERT_CAUSE_36 @ 0x3b4
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_36 | For ALERT36 |
alert_handler.ALERT_CAUSE_37 @ 0x3b8
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_37 | For ALERT37 |
alert_handler.ALERT_CAUSE_38 @ 0x3bc
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_38 | For ALERT38 |
alert_handler.ALERT_CAUSE_39 @ 0x3c0
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_39 | For ALERT39 |
alert_handler.ALERT_CAUSE_40 @ 0x3c4
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_40 | For ALERT40 |
alert_handler.ALERT_CAUSE_41 @ 0x3c8
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_41 | For ALERT41 |
alert_handler.ALERT_CAUSE_42 @ 0x3cc
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_42 | For ALERT42 |
alert_handler.ALERT_CAUSE_43 @ 0x3d0
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_43 | For ALERT43 |
alert_handler.ALERT_CAUSE_44 @ 0x3d4
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_44 | For ALERT44 |
alert_handler.ALERT_CAUSE_45 @ 0x3d8
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_45 | For ALERT45 |
alert_handler.ALERT_CAUSE_46 @ 0x3dc
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_46 | For ALERT46 |
alert_handler.ALERT_CAUSE_47 @ 0x3e0
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_47 | For ALERT47 |
alert_handler.ALERT_CAUSE_48 @ 0x3e4
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_48 | For ALERT48 |
alert_handler.ALERT_CAUSE_49 @ 0x3e8
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_49 | For ALERT49 |
alert_handler.ALERT_CAUSE_50 @ 0x3ec
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_50 | For ALERT50 |
alert_handler.ALERT_CAUSE_51 @ 0x3f0
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_51 | For ALERT51 |
alert_handler.ALERT_CAUSE_52 @ 0x3f4
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_52 | For ALERT52 |
alert_handler.ALERT_CAUSE_53 @ 0x3f8
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_53 | For ALERT53 |
alert_handler.ALERT_CAUSE_54 @ 0x3fc
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_54 | For ALERT54 |
alert_handler.ALERT_CAUSE_55 @ 0x400
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_55 | For ALERT55 |
alert_handler.ALERT_CAUSE_56 @ 0x404
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_56 | For ALERT56 |
alert_handler.ALERT_CAUSE_57 @ 0x408
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_57 | For ALERT57 |
alert_handler.ALERT_CAUSE_58 @ 0x40c
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_58 | For ALERT58 |
alert_handler.ALERT_CAUSE_59 @ 0x410
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_59 | For ALERT59 |
alert_handler.ALERT_CAUSE_60 @ 0x414
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_60 | For ALERT60 |
alert_handler.ALERT_CAUSE_61 @ 0x418
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_61 | For ALERT61 |
alert_handler.ALERT_CAUSE_62 @ 0x41c
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_62 | For ALERT62 |
alert_handler.ALERT_CAUSE_63 @ 0x420
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_63 | For ALERT63 |
alert_handler.ALERT_CAUSE_64 @ 0x424
Alert Cause Register Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | A_64 | For ALERT64 |
alert_handler.LOC_ALERT_REGWEN_0 @ 0x428
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_0 | Alert configuration write enable bit.
If this is cleared to 0, the corresponding Note that the alert pinging mechanism will only ping alerts that have been enabled and locked. |
alert_handler.LOC_ALERT_REGWEN_1 @ 0x42c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_1 | For LOC_ALERT1 |
alert_handler.LOC_ALERT_REGWEN_2 @ 0x430
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_2 | For LOC_ALERT2 |
alert_handler.LOC_ALERT_REGWEN_3 @ 0x434
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_3 | For LOC_ALERT3 |
alert_handler.LOC_ALERT_REGWEN_4 @ 0x438
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_4 | For LOC_ALERT4 |
alert_handler.LOC_ALERT_REGWEN_5 @ 0x43c
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_5 | For LOC_ALERT5 |
alert_handler.LOC_ALERT_REGWEN_6 @ 0x440
Register write enable for alert enable bits. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | EN_6 | For LOC_ALERT6 |
alert_handler.LOC_ALERT_EN_SHADOWED_0 @ 0x444
Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
Register enable = LOC_ALERT_REGWEN_0 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_LA_0 | Alert enable bit. Note that the alert pinging mechanism will only ping alerts that have been enabled and locked. |
alert_handler.LOC_ALERT_EN_SHADOWED_1 @ 0x448
Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
Register enable = LOC_ALERT_REGWEN_1 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_LA_1 | For LOC_ALERT1 |
alert_handler.LOC_ALERT_EN_SHADOWED_2 @ 0x44c
Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
Register enable = LOC_ALERT_REGWEN_2 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_LA_2 | For LOC_ALERT2 |
alert_handler.LOC_ALERT_EN_SHADOWED_3 @ 0x450
Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
Register enable = LOC_ALERT_REGWEN_3 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_LA_3 | For LOC_ALERT3 |
alert_handler.LOC_ALERT_EN_SHADOWED_4 @ 0x454
Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
Register enable = LOC_ALERT_REGWEN_4 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_LA_4 | For LOC_ALERT4 |
alert_handler.LOC_ALERT_EN_SHADOWED_5 @ 0x458
Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
Register enable = LOC_ALERT_REGWEN_5 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_LA_5 | For LOC_ALERT5 |
alert_handler.LOC_ALERT_EN_SHADOWED_6 @ 0x45c
Enable register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
Register enable = LOC_ALERT_REGWEN_6 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN_LA_6 | For LOC_ALERT6 |
alert_handler.LOC_ALERT_CLASS_SHADOWED_0 @ 0x460
Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x3
Register enable = LOC_ALERT_REGWEN_0 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_LA_0 | Classification
|
alert_handler.LOC_ALERT_CLASS_SHADOWED_1 @ 0x464
Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x3
Register enable = LOC_ALERT_REGWEN_1 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_LA_1 | For LOC_ALERT1 |
alert_handler.LOC_ALERT_CLASS_SHADOWED_2 @ 0x468
Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x3
Register enable = LOC_ALERT_REGWEN_2 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_LA_2 | For LOC_ALERT2 |
alert_handler.LOC_ALERT_CLASS_SHADOWED_3 @ 0x46c
Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x3
Register enable = LOC_ALERT_REGWEN_3 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_LA_3 | For LOC_ALERT3 |
alert_handler.LOC_ALERT_CLASS_SHADOWED_4 @ 0x470
Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x3
Register enable = LOC_ALERT_REGWEN_4 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_LA_4 | For LOC_ALERT4 |
alert_handler.LOC_ALERT_CLASS_SHADOWED_5 @ 0x474
Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x3
Register enable = LOC_ALERT_REGWEN_5 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_LA_5 | For LOC_ALERT5 |
alert_handler.LOC_ALERT_CLASS_SHADOWED_6 @ 0x478
Class assignment of the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x3
Register enable = LOC_ALERT_REGWEN_6 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASS_LA_6 | For LOC_ALERT6 |
alert_handler.LOC_ALERT_CAUSE_0 @ 0x47c
Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | LA_0 | Cause bit |
alert_handler.LOC_ALERT_CAUSE_1 @ 0x480
Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | LA_1 | For LOC_ALERT1 |
alert_handler.LOC_ALERT_CAUSE_2 @ 0x484
Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | LA_2 | For LOC_ALERT2 |
alert_handler.LOC_ALERT_CAUSE_3 @ 0x488
Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | LA_3 | For LOC_ALERT3 |
alert_handler.LOC_ALERT_CAUSE_4 @ 0x48c
Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | LA_4 | For LOC_ALERT4 |
alert_handler.LOC_ALERT_CAUSE_5 @ 0x490
Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | LA_5 | For LOC_ALERT5 |
alert_handler.LOC_ALERT_CAUSE_6 @ 0x494
Alert Cause Register for the local alerts "alert pingfail" (0), "escalation pingfail" (1), "alert integfail" (2), "escalation integfail" (3), "bus integrity failure" (4), "shadow reg update error" (5) and "shadow reg storage error" (6). Reset default = 0x0, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw1c | 0x0 | LA_6 | For LOC_ALERT6 |
alert_handler.CLASSA_REGWEN @ 0x498
Lock bit for Class A configuration. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | CLASSA_REGWEN | Class configuration enable bit. If this is cleared to 0, the corresponding class configuration registers cannot be written anymore. |
alert_handler.CLASSA_CTRL_SHADOWED @ 0x49c
Escalation control register for alert Class A. Can not be modified if Reset default = 0x393c, mask 0x3fff
Register enable = CLASSA_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN | Enable escalation mechanisms (accumulation and interrupt timeout) for Class A. Note that interrupts can fire regardless of whether the escalation mechanisms are enabled for this class or not. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1 | rw | 0x0 | LOCK | Enable automatic locking of escalation counter for class A. If true, there is no way to stop the escalation protocol for class A once it has been triggered. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2 | rw | 0x1 | EN_E0 | Enable escalation signal 0 for Class A | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
3 | rw | 0x1 | EN_E1 | Enable escalation signal 1 for Class A | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
4 | rw | 0x1 | EN_E2 | Enable escalation signal 2 for Class A | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
5 | rw | 0x1 | EN_E3 | Enable escalation signal 3 for Class A | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
7:6 | rw | 0x0 | MAP_E0 | Determines in which escalation phase escalation signal 0 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
9:8 | rw | 0x1 | MAP_E1 | Determines in which escalation phase escalation signal 1 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
11:10 | rw | 0x2 | MAP_E2 | Determines in which escalation phase escalation signal 2 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
13:12 | rw | 0x3 | MAP_E3 | Determines in which escalation phase escalation signal 3 shall be asserted. |
alert_handler.CLASSA_CLR_REGWEN @ 0x4a0
Clear enable for escalation protocol of Class A alerts. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | CLASSA_CLR_REGWEN | Register defaults to true, can only be cleared. This register is set
to false by the hardware if the escalation protocol has been triggered and the bit
|
alert_handler.CLASSA_CLR_SHADOWED @ 0x4a4
Clear for escalation protocol of Class A. Reset default = 0x0, mask 0x1
Register enable = CLASSA_CLR_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | CLASSA_CLR_SHADOWED | Writing 1 to this register clears the accumulator and aborts escalation
(if it has been triggered). This clear is disabled if |
alert_handler.CLASSA_ACCUM_CNT @ 0x4a8
Current accumulation value for alert Class A. Software can clear this register
with a write to Reset default = 0x0, mask 0xffff
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
15:0 | ro | x | CLASSA_ACCUM_CNT |
alert_handler.CLASSA_ACCUM_THRESH_SHADOWED @ 0x4ac
Accumulation threshold value for alert Class A. Reset default = 0x0, mask 0xffff
Register enable = CLASSA_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
15:0 | rw | 0x0 | CLASSA_ACCUM_THRESH_SHADOWED | Once the accumulation value register is equal to the threshold escalation will
be triggered on the next alert occurrence within this class A begins. Note that this
register can not be modified if |
alert_handler.CLASSA_TIMEOUT_CYC_SHADOWED @ 0x4b0
Interrupt timeout in cycles. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSA_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSA_TIMEOUT_CYC_SHADOWED | If the interrupt corresponding to this class is not
handled within the specified amount of cycles, escalation will be triggered.
Set to a positive value to enable the interrupt timeout for Class A. The timeout is set to zero
by default, which disables this feature. Note that this register can not be modified if
|
alert_handler.CLASSA_CRASHDUMP_TRIGGER_SHADOWED @ 0x4b4
Crashdump trigger configuration for Class A. Reset default = 0x0, mask 0x3
Register enable = CLASSA_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASSA_CRASHDUMP_TRIGGER_SHADOWED | Determine in which escalation phase to capture the crashdump containing all alert cause CSRs and escalation
timer states. It is recommended to capture the crashdump upon entering the first escalation phase
that activates a countermeasure with many side-effects (e.g. life cycle state scrapping) in order
to prevent spurious alert events from masking the original alert causes.
Note that this register can not be modified if |
alert_handler.CLASSA_PHASE0_CYC_SHADOWED @ 0x4b8
Duration of escalation phase 0 for Class A. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSA_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSA_PHASE0_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSA_PHASE1_CYC_SHADOWED @ 0x4bc
Duration of escalation phase 1 for Class A. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSA_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSA_PHASE1_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSA_PHASE2_CYC_SHADOWED @ 0x4c0
Duration of escalation phase 2 for Class A. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSA_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSA_PHASE2_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSA_PHASE3_CYC_SHADOWED @ 0x4c4
Duration of escalation phase 3 for Class A. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSA_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSA_PHASE3_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSA_ESC_CNT @ 0x4c8
Escalation counter in cycles for Class A. Reset default = 0x0, mask 0xffffffff
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | ro | x | CLASSA_ESC_CNT | Returns the current timeout or escalation count (depending on If the class is in the Timeout state, the timeout can be aborted by clearing the corresponding interrupt bit. If this class is in any of the escalation phases (e.g. Phase0), escalation protocol can be
aborted by writing to |
alert_handler.CLASSA_STATE @ 0x4cc
Current escalation state of Class A. See also Reset default = 0x0, mask 0x7
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2:0 | ro | x | CLASSA_STATE |
|
alert_handler.CLASSB_REGWEN @ 0x4d0
Lock bit for Class B configuration. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | CLASSB_REGWEN | Class configuration enable bit. If this is cleared to 0, the corresponding class configuration registers cannot be written anymore. |
alert_handler.CLASSB_CTRL_SHADOWED @ 0x4d4
Escalation control register for alert Class B. Can not be modified if Reset default = 0x393c, mask 0x3fff
Register enable = CLASSB_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN | Enable escalation mechanisms (accumulation and interrupt timeout) for Class B. Note that interrupts can fire regardless of whether the escalation mechanisms are enabled for this class or not. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1 | rw | 0x0 | LOCK | Enable automatic locking of escalation counter for class B. If true, there is no way to stop the escalation protocol for class B once it has been triggered. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2 | rw | 0x1 | EN_E0 | Enable escalation signal 0 for Class B | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
3 | rw | 0x1 | EN_E1 | Enable escalation signal 1 for Class B | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
4 | rw | 0x1 | EN_E2 | Enable escalation signal 2 for Class B | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
5 | rw | 0x1 | EN_E3 | Enable escalation signal 3 for Class B | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
7:6 | rw | 0x0 | MAP_E0 | Determines in which escalation phase escalation signal 0 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
9:8 | rw | 0x1 | MAP_E1 | Determines in which escalation phase escalation signal 1 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
11:10 | rw | 0x2 | MAP_E2 | Determines in which escalation phase escalation signal 2 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
13:12 | rw | 0x3 | MAP_E3 | Determines in which escalation phase escalation signal 3 shall be asserted. |
alert_handler.CLASSB_CLR_REGWEN @ 0x4d8
Clear enable for escalation protocol of Class B alerts. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | CLASSB_CLR_REGWEN | Register defaults to true, can only be cleared. This register is set
to false by the hardware if the escalation protocol has been triggered and the bit
|
alert_handler.CLASSB_CLR_SHADOWED @ 0x4dc
Clear for escalation protocol of Class B. Reset default = 0x0, mask 0x1
Register enable = CLASSB_CLR_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | CLASSB_CLR_SHADOWED | Writing 1 to this register clears the accumulator and aborts escalation
(if it has been triggered). This clear is disabled if |
alert_handler.CLASSB_ACCUM_CNT @ 0x4e0
Current accumulation value for alert Class B. Software can clear this register
with a write to Reset default = 0x0, mask 0xffff
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
15:0 | ro | x | CLASSB_ACCUM_CNT |
alert_handler.CLASSB_ACCUM_THRESH_SHADOWED @ 0x4e4
Accumulation threshold value for alert Class B. Reset default = 0x0, mask 0xffff
Register enable = CLASSB_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
15:0 | rw | 0x0 | CLASSB_ACCUM_THRESH_SHADOWED | Once the accumulation value register is equal to the threshold escalation will
be triggered on the next alert occurrence within this class B begins. Note that this
register can not be modified if |
alert_handler.CLASSB_TIMEOUT_CYC_SHADOWED @ 0x4e8
Interrupt timeout in cycles. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSB_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSB_TIMEOUT_CYC_SHADOWED | If the interrupt corresponding to this class is not
handled within the specified amount of cycles, escalation will be triggered.
Set to a positive value to enable the interrupt timeout for Class B. The timeout is set to zero
by default, which disables this feature. Note that this register can not be modified if
|
alert_handler.CLASSB_CRASHDUMP_TRIGGER_SHADOWED @ 0x4ec
Crashdump trigger configuration for Class B. Reset default = 0x0, mask 0x3
Register enable = CLASSB_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASSB_CRASHDUMP_TRIGGER_SHADOWED | Determine in which escalation phase to capture the crashdump containing all alert cause CSRs and escalation
timer states. It is recommended to capture the crashdump upon entering the first escalation phase
that activates a countermeasure with many side-effects (e.g. life cycle state scrapping) in order
to prevent spurious alert events from masking the original alert causes.
Note that this register can not be modified if |
alert_handler.CLASSB_PHASE0_CYC_SHADOWED @ 0x4f0
Duration of escalation phase 0 for Class B. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSB_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSB_PHASE0_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSB_PHASE1_CYC_SHADOWED @ 0x4f4
Duration of escalation phase 1 for Class B. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSB_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSB_PHASE1_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSB_PHASE2_CYC_SHADOWED @ 0x4f8
Duration of escalation phase 2 for Class B. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSB_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSB_PHASE2_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSB_PHASE3_CYC_SHADOWED @ 0x4fc
Duration of escalation phase 3 for Class B. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSB_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSB_PHASE3_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSB_ESC_CNT @ 0x500
Escalation counter in cycles for Class B. Reset default = 0x0, mask 0xffffffff
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | ro | x | CLASSB_ESC_CNT | Returns the current timeout or escalation count (depending on If the class is in the Timeout state, the timeout can be aborted by clearing the corresponding interrupt bit. If this class is in any of the escalation phases (e.g. Phase0), escalation protocol can be
aborted by writing to |
alert_handler.CLASSB_STATE @ 0x504
Current escalation state of Class B. See also Reset default = 0x0, mask 0x7
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2:0 | ro | x | CLASSB_STATE |
|
alert_handler.CLASSC_REGWEN @ 0x508
Lock bit for Class C configuration. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | CLASSC_REGWEN | Class configuration enable bit. If this is cleared to 0, the corresponding class configuration registers cannot be written anymore. |
alert_handler.CLASSC_CTRL_SHADOWED @ 0x50c
Escalation control register for alert Class C. Can not be modified if Reset default = 0x393c, mask 0x3fff
Register enable = CLASSC_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN | Enable escalation mechanisms (accumulation and interrupt timeout) for Class C. Note that interrupts can fire regardless of whether the escalation mechanisms are enabled for this class or not. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1 | rw | 0x0 | LOCK | Enable automatic locking of escalation counter for class C. If true, there is no way to stop the escalation protocol for class C once it has been triggered. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2 | rw | 0x1 | EN_E0 | Enable escalation signal 0 for Class C | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
3 | rw | 0x1 | EN_E1 | Enable escalation signal 1 for Class C | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
4 | rw | 0x1 | EN_E2 | Enable escalation signal 2 for Class C | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
5 | rw | 0x1 | EN_E3 | Enable escalation signal 3 for Class C | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
7:6 | rw | 0x0 | MAP_E0 | Determines in which escalation phase escalation signal 0 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
9:8 | rw | 0x1 | MAP_E1 | Determines in which escalation phase escalation signal 1 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
11:10 | rw | 0x2 | MAP_E2 | Determines in which escalation phase escalation signal 2 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
13:12 | rw | 0x3 | MAP_E3 | Determines in which escalation phase escalation signal 3 shall be asserted. |
alert_handler.CLASSC_CLR_REGWEN @ 0x510
Clear enable for escalation protocol of Class C alerts. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | CLASSC_CLR_REGWEN | Register defaults to true, can only be cleared. This register is set
to false by the hardware if the escalation protocol has been triggered and the bit
|
alert_handler.CLASSC_CLR_SHADOWED @ 0x514
Clear for escalation protocol of Class C. Reset default = 0x0, mask 0x1
Register enable = CLASSC_CLR_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | CLASSC_CLR_SHADOWED | Writing 1 to this register clears the accumulator and aborts escalation
(if it has been triggered). This clear is disabled if |
alert_handler.CLASSC_ACCUM_CNT @ 0x518
Current accumulation value for alert Class C. Software can clear this register
with a write to Reset default = 0x0, mask 0xffff
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
15:0 | ro | x | CLASSC_ACCUM_CNT |
alert_handler.CLASSC_ACCUM_THRESH_SHADOWED @ 0x51c
Accumulation threshold value for alert Class C. Reset default = 0x0, mask 0xffff
Register enable = CLASSC_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
15:0 | rw | 0x0 | CLASSC_ACCUM_THRESH_SHADOWED | Once the accumulation value register is equal to the threshold escalation will
be triggered on the next alert occurrence within this class C begins. Note that this
register can not be modified if |
alert_handler.CLASSC_TIMEOUT_CYC_SHADOWED @ 0x520
Interrupt timeout in cycles. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSC_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSC_TIMEOUT_CYC_SHADOWED | If the interrupt corresponding to this class is not
handled within the specified amount of cycles, escalation will be triggered.
Set to a positive value to enable the interrupt timeout for Class C. The timeout is set to zero
by default, which disables this feature. Note that this register can not be modified if
|
alert_handler.CLASSC_CRASHDUMP_TRIGGER_SHADOWED @ 0x524
Crashdump trigger configuration for Class C. Reset default = 0x0, mask 0x3
Register enable = CLASSC_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASSC_CRASHDUMP_TRIGGER_SHADOWED | Determine in which escalation phase to capture the crashdump containing all alert cause CSRs and escalation
timer states. It is recommended to capture the crashdump upon entering the first escalation phase
that activates a countermeasure with many side-effects (e.g. life cycle state scrapping) in order
to prevent spurious alert events from masking the original alert causes.
Note that this register can not be modified if |
alert_handler.CLASSC_PHASE0_CYC_SHADOWED @ 0x528
Duration of escalation phase 0 for Class C. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSC_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSC_PHASE0_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSC_PHASE1_CYC_SHADOWED @ 0x52c
Duration of escalation phase 1 for Class C. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSC_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSC_PHASE1_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSC_PHASE2_CYC_SHADOWED @ 0x530
Duration of escalation phase 2 for Class C. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSC_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSC_PHASE2_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSC_PHASE3_CYC_SHADOWED @ 0x534
Duration of escalation phase 3 for Class C. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSC_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSC_PHASE3_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSC_ESC_CNT @ 0x538
Escalation counter in cycles for Class C. Reset default = 0x0, mask 0xffffffff
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | ro | x | CLASSC_ESC_CNT | Returns the current timeout or escalation count (depending on If the class is in the Timeout state, the timeout can be aborted by clearing the corresponding interrupt bit. If this class is in any of the escalation phases (e.g. Phase0), escalation protocol can be
aborted by writing to |
alert_handler.CLASSC_STATE @ 0x53c
Current escalation state of Class C. See also Reset default = 0x0, mask 0x7
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2:0 | ro | x | CLASSC_STATE |
|
alert_handler.CLASSD_REGWEN @ 0x540
Lock bit for Class D configuration. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | CLASSD_REGWEN | Class configuration enable bit. If this is cleared to 0, the corresponding class configuration registers cannot be written anymore. |
alert_handler.CLASSD_CTRL_SHADOWED @ 0x544
Escalation control register for alert Class D. Can not be modified if Reset default = 0x393c, mask 0x3fff
Register enable = CLASSD_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | EN | Enable escalation mechanisms (accumulation and interrupt timeout) for Class D. Note that interrupts can fire regardless of whether the escalation mechanisms are enabled for this class or not. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1 | rw | 0x0 | LOCK | Enable automatic locking of escalation counter for class D. If true, there is no way to stop the escalation protocol for class D once it has been triggered. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2 | rw | 0x1 | EN_E0 | Enable escalation signal 0 for Class D | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
3 | rw | 0x1 | EN_E1 | Enable escalation signal 1 for Class D | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
4 | rw | 0x1 | EN_E2 | Enable escalation signal 2 for Class D | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
5 | rw | 0x1 | EN_E3 | Enable escalation signal 3 for Class D | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
7:6 | rw | 0x0 | MAP_E0 | Determines in which escalation phase escalation signal 0 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
9:8 | rw | 0x1 | MAP_E1 | Determines in which escalation phase escalation signal 1 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
11:10 | rw | 0x2 | MAP_E2 | Determines in which escalation phase escalation signal 2 shall be asserted. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
13:12 | rw | 0x3 | MAP_E3 | Determines in which escalation phase escalation signal 3 shall be asserted. |
alert_handler.CLASSD_CLR_REGWEN @ 0x548
Clear enable for escalation protocol of Class D alerts. Reset default = 0x1, mask 0x1
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw0c | 0x1 | CLASSD_CLR_REGWEN | Register defaults to true, can only be cleared. This register is set
to false by the hardware if the escalation protocol has been triggered and the bit
|
alert_handler.CLASSD_CLR_SHADOWED @ 0x54c
Clear for escalation protocol of Class D. Reset default = 0x0, mask 0x1
Register enable = CLASSD_CLR_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
0 | rw | 0x0 | CLASSD_CLR_SHADOWED | Writing 1 to this register clears the accumulator and aborts escalation
(if it has been triggered). This clear is disabled if |
alert_handler.CLASSD_ACCUM_CNT @ 0x550
Current accumulation value for alert Class D. Software can clear this register
with a write to Reset default = 0x0, mask 0xffff
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
15:0 | ro | x | CLASSD_ACCUM_CNT |
alert_handler.CLASSD_ACCUM_THRESH_SHADOWED @ 0x554
Accumulation threshold value for alert Class D. Reset default = 0x0, mask 0xffff
Register enable = CLASSD_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
15:0 | rw | 0x0 | CLASSD_ACCUM_THRESH_SHADOWED | Once the accumulation value register is equal to the threshold escalation will
be triggered on the next alert occurrence within this class D begins. Note that this
register can not be modified if |
alert_handler.CLASSD_TIMEOUT_CYC_SHADOWED @ 0x558
Interrupt timeout in cycles. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSD_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSD_TIMEOUT_CYC_SHADOWED | If the interrupt corresponding to this class is not
handled within the specified amount of cycles, escalation will be triggered.
Set to a positive value to enable the interrupt timeout for Class D. The timeout is set to zero
by default, which disables this feature. Note that this register can not be modified if
|
alert_handler.CLASSD_CRASHDUMP_TRIGGER_SHADOWED @ 0x55c
Crashdump trigger configuration for Class D. Reset default = 0x0, mask 0x3
Register enable = CLASSD_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1:0 | rw | 0x0 | CLASSD_CRASHDUMP_TRIGGER_SHADOWED | Determine in which escalation phase to capture the crashdump containing all alert cause CSRs and escalation
timer states. It is recommended to capture the crashdump upon entering the first escalation phase
that activates a countermeasure with many side-effects (e.g. life cycle state scrapping) in order
to prevent spurious alert events from masking the original alert causes.
Note that this register can not be modified if |
alert_handler.CLASSD_PHASE0_CYC_SHADOWED @ 0x560
Duration of escalation phase 0 for Class D. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSD_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSD_PHASE0_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSD_PHASE1_CYC_SHADOWED @ 0x564
Duration of escalation phase 1 for Class D. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSD_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSD_PHASE1_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSD_PHASE2_CYC_SHADOWED @ 0x568
Duration of escalation phase 2 for Class D. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSD_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSD_PHASE2_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSD_PHASE3_CYC_SHADOWED @ 0x56c
Duration of escalation phase 3 for Class D. Reset default = 0x0, mask 0xffffffff
Register enable = CLASSD_REGWEN |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | rw | 0x0 | CLASSD_PHASE3_CYC_SHADOWED | Escalation phase duration in cycles. Note that this register can not be
modified if |
alert_handler.CLASSD_ESC_CNT @ 0x570
Escalation counter in cycles for Class D. Reset default = 0x0, mask 0xffffffff
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
31:0 | ro | x | CLASSD_ESC_CNT | Returns the current timeout or escalation count (depending on If the class is in the Timeout state, the timeout can be aborted by clearing the corresponding interrupt bit. If this class is in any of the escalation phases (e.g. Phase0), escalation protocol can be
aborted by writing to |
alert_handler.CLASSD_STATE @ 0x574
Current escalation state of Class D. See also Reset default = 0x0, mask 0x7
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Bits | Type | Reset | Name | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2:0 | ro | x | CLASSD_STATE |
|
Additional Notes
Timing Constraints
The skew within all differential signal pairs must be constrained to be smaller than the period of the fastest clock operating the alert handler receivers. The maximum propagation delay of differential pair should also be constrained (although it may be longer than the clock periods involved).
Fast-track Alerts
Note that it is possible to program a certain class to provide a fast-track response for critical alerts by setting its accumulation trigger value to 1, and configuring the escalation protocol such that the appropriate escalation measure is triggered within escalation phase 0. This results in a minimal escalation latency of 4 clock cycles from alert sender input to escalation receiver output in the case where all involved signaling modules are completely synchronous with the alert handler. In case the alert sender is asynchronous w.r.t. to the alert handler, the actual latency depends on the clock periods involved. Assuming both clocks have the same frequency alert propagation takes at least 6-8 clock alert handler clock cycles.
For alerts that mandate an asynchronous response (i.e. without requiring a clock to be active), it is highly recommended to build a separate network at the top-level. That network should OR’ the critical sources together and route the asynchronous alert signal directly to the highest severity countermeasure device. Examples for alert conditions of this sort would be attacks on the secure clock.