Software APIs
dif_sensor_ctrl_unittest.cc
1 // Copyright lowRISC contributors (OpenTitan project).
2 // Licensed under the Apache License, Version 2.0, see LICENSE for details.
3 // SPDX-License-Identifier: Apache-2.0
4 
5 #include "sw/device/lib/dif/dif_sensor_ctrl.h"
6 
7 #include "gtest/gtest.h"
8 #include "sw/device/lib/base/mmio.h"
9 #include "sw/device/lib/base/mock_mmio.h"
10 #include "sw/device/lib/base/multibits.h"
11 #include "sw/device/lib/dif/dif_base.h"
12 #include "sw/device/lib/dif/dif_test_base.h"
13 
14 #include "sensor_ctrl_regs.h" // Generated.
15 
16 namespace dif_sensor_ctrl_unittest {
17 namespace {
18 using mock_mmio::MmioTest;
19 using mock_mmio::MockDevice;
20 using testing::Test;
21 
22 class SensorCtrlTest : public Test, public MmioTest {
23  protected:
24  void SetUp() {
25  ASSERT_DIF_OK(dif_sensor_ctrl_init(dev().region(), &sensor_ctrl));
26  }
27 
28  dif_sensor_ctrl_t sensor_ctrl;
29 };
30 
31 TEST_F(SensorCtrlTest, BadArgs) {
32  uint32_t good_idx = 0;
33  uint32_t bad_idx = SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS;
34  dif_toggle_t toggle_arg{};
35  dif_sensor_ctrl_events_t events_arg{};
36  dif_sensor_ctrl_io_power_status_t power_arg{};
37 
38  EXPECT_DIF_BADARG(dif_sensor_ctrl_lock_cfg(nullptr));
39 
40  EXPECT_DIF_BADARG(
41  dif_sensor_ctrl_get_ast_event_trigger(nullptr, good_idx, &toggle_arg));
42  EXPECT_DIF_BADARG(dif_sensor_ctrl_get_ast_event_trigger(&sensor_ctrl, bad_idx,
43  &toggle_arg));
44  EXPECT_DIF_BADARG(
45  dif_sensor_ctrl_get_ast_event_trigger(&sensor_ctrl, good_idx, nullptr));
46 
47  EXPECT_DIF_BADARG(
48  dif_sensor_ctrl_set_ast_event_trigger(nullptr, good_idx, toggle_arg));
49  EXPECT_DIF_BADARG(
50  dif_sensor_ctrl_set_ast_event_trigger(&sensor_ctrl, bad_idx, toggle_arg));
51 
52  EXPECT_DIF_BADARG(
53  dif_sensor_ctrl_set_alert_en(nullptr, good_idx, toggle_arg));
54  EXPECT_DIF_BADARG(
55  dif_sensor_ctrl_set_alert_en(&sensor_ctrl, bad_idx, toggle_arg));
56 
57  EXPECT_DIF_BADARG(
58  dif_sensor_ctrl_set_alert_fatal(nullptr, good_idx, toggle_arg));
59  EXPECT_DIF_BADARG(
60  dif_sensor_ctrl_set_alert_fatal(&sensor_ctrl, bad_idx, toggle_arg));
61 
62  EXPECT_DIF_BADARG(dif_sensor_ctrl_get_recov_events(nullptr, &events_arg));
63  EXPECT_DIF_BADARG(dif_sensor_ctrl_get_recov_events(&sensor_ctrl, nullptr));
64 
65  EXPECT_DIF_BADARG(dif_sensor_ctrl_clear_recov_event(nullptr, good_idx));
66  EXPECT_DIF_BADARG(dif_sensor_ctrl_clear_recov_event(&sensor_ctrl, bad_idx));
67 
68  EXPECT_DIF_BADARG(dif_sensor_ctrl_get_fatal_events(nullptr, &events_arg));
69  EXPECT_DIF_BADARG(dif_sensor_ctrl_get_fatal_events(&sensor_ctrl, nullptr));
70 
71  EXPECT_DIF_BADARG(
72  dif_sensor_ctrl_get_ast_init_done_status(nullptr, &toggle_arg));
73  EXPECT_DIF_BADARG(
74  dif_sensor_ctrl_get_ast_init_done_status(&sensor_ctrl, nullptr));
75 
76  EXPECT_DIF_BADARG(dif_sensor_ctrl_get_io_power_status(nullptr, &power_arg));
77  EXPECT_DIF_BADARG(dif_sensor_ctrl_get_io_power_status(&sensor_ctrl, nullptr));
78 }
79 
80 TEST_F(SensorCtrlTest, TriggerEvents) {
81  for (size_t i = 0; i < SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS; i++) {
82  EXPECT_READ32(SENSOR_CTRL_ALERT_TRIG_REG_OFFSET, 0);
83  EXPECT_WRITE32(SENSOR_CTRL_ALERT_TRIG_REG_OFFSET, 1 << i);
84  EXPECT_DIF_OK(dif_sensor_ctrl_set_ast_event_trigger(&sensor_ctrl, i,
85  kDifToggleEnabled));
86  }
87 
88  for (size_t i = 0; i < SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS; i++) {
89  EXPECT_READ32(SENSOR_CTRL_ALERT_TRIG_REG_OFFSET, -1);
90  EXPECT_WRITE32(SENSOR_CTRL_ALERT_TRIG_REG_OFFSET, ~(1 << i));
91  EXPECT_DIF_OK(dif_sensor_ctrl_set_ast_event_trigger(&sensor_ctrl, i,
92  kDifToggleDisabled));
93  }
94 
95  for (size_t i = 0; i < SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS; i++) {
96  dif_toggle_t enable = kDifToggleDisabled;
97  EXPECT_READ32(SENSOR_CTRL_ALERT_TRIG_REG_OFFSET, 1 << i);
98  EXPECT_DIF_OK(
99  dif_sensor_ctrl_get_ast_event_trigger(&sensor_ctrl, i, &enable));
100  EXPECT_EQ(enable, kDifToggleEnabled);
101  }
102 
103  for (size_t i = 0; i < SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS; i++) {
104  dif_toggle_t enable = kDifToggleEnabled;
105  EXPECT_READ32(SENSOR_CTRL_ALERT_TRIG_REG_OFFSET, ~(1 << i));
106  EXPECT_DIF_OK(
107  dif_sensor_ctrl_get_ast_event_trigger(&sensor_ctrl, i, &enable));
108  EXPECT_EQ(enable, kDifToggleDisabled);
109  }
110 }
111 
112 TEST_F(SensorCtrlTest, AlertEnable) {
113  for (size_t i = 0; i < SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS; i++) {
114  EXPECT_READ32(SENSOR_CTRL_CFG_REGWEN_REG_OFFSET, 1);
115  EXPECT_WRITE32(SENSOR_CTRL_ALERT_EN_0_REG_OFFSET + i * 4,
116  kMultiBitBool4True);
117  EXPECT_DIF_OK(
118  dif_sensor_ctrl_set_alert_en(&sensor_ctrl, i, kDifToggleEnabled));
119  }
120 
121  for (size_t i = 0; i < SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS; i++) {
122  EXPECT_READ32(SENSOR_CTRL_CFG_REGWEN_REG_OFFSET, 1);
123  EXPECT_WRITE32(SENSOR_CTRL_ALERT_EN_0_REG_OFFSET + i * 4,
124  kMultiBitBool4False);
125  EXPECT_DIF_OK(
126  dif_sensor_ctrl_set_alert_en(&sensor_ctrl, i, kDifToggleDisabled));
127  }
128 
129  EXPECT_READ32(SENSOR_CTRL_CFG_REGWEN_REG_OFFSET, 0);
130  EXPECT_EQ(dif_sensor_ctrl_set_alert_en(&sensor_ctrl, 0, kDifToggleDisabled),
131  kDifLocked);
132 
133  EXPECT_READ32(SENSOR_CTRL_CFG_REGWEN_REG_OFFSET, 0);
134  EXPECT_EQ(dif_sensor_ctrl_set_alert_en(&sensor_ctrl, 0, kDifToggleEnabled),
135  kDifLocked);
136 }
137 
138 TEST_F(SensorCtrlTest, AlertFatality) {
139  for (size_t i = 0; i < SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS; i++) {
140  EXPECT_READ32(SENSOR_CTRL_CFG_REGWEN_REG_OFFSET, 1);
141  EXPECT_READ32(SENSOR_CTRL_FATAL_ALERT_EN_REG_OFFSET, 0);
142  EXPECT_WRITE32(SENSOR_CTRL_FATAL_ALERT_EN_REG_OFFSET, 1 << i);
143  EXPECT_DIF_OK(
144  dif_sensor_ctrl_set_alert_fatal(&sensor_ctrl, i, kDifToggleEnabled));
145  }
146 
147  for (size_t i = 0; i < SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS; i++) {
148  EXPECT_READ32(SENSOR_CTRL_CFG_REGWEN_REG_OFFSET, 1);
149  EXPECT_READ32(SENSOR_CTRL_FATAL_ALERT_EN_REG_OFFSET, -1);
150  EXPECT_WRITE32(SENSOR_CTRL_FATAL_ALERT_EN_REG_OFFSET, ~(1 << i));
151  EXPECT_DIF_OK(
152  dif_sensor_ctrl_set_alert_fatal(&sensor_ctrl, i, kDifToggleDisabled));
153  }
154 
155  EXPECT_READ32(SENSOR_CTRL_CFG_REGWEN_REG_OFFSET, 0);
156  EXPECT_EQ(
157  dif_sensor_ctrl_set_alert_fatal(&sensor_ctrl, 0, kDifToggleDisabled),
158  kDifLocked);
159 
160  EXPECT_READ32(SENSOR_CTRL_CFG_REGWEN_REG_OFFSET, 0);
161  EXPECT_EQ(dif_sensor_ctrl_set_alert_fatal(&sensor_ctrl, 0, kDifToggleEnabled),
162  kDifLocked);
163 }
164 
165 TEST_F(SensorCtrlTest, GetRecovEvents) {
166  uint32_t events_mask = (1 << SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS) - 1;
167 
168  dif_sensor_ctrl_events_t exp_events = 0x987542 & events_mask;
169  dif_sensor_ctrl_events_t rcv_events;
170  EXPECT_READ32(SENSOR_CTRL_RECOV_ALERT_REG_OFFSET, exp_events);
171  EXPECT_DIF_OK(dif_sensor_ctrl_get_recov_events(&sensor_ctrl, &rcv_events));
172  EXPECT_EQ(exp_events, rcv_events);
173 
174  exp_events = 0xdc5a8492 & events_mask;
175  EXPECT_READ32(SENSOR_CTRL_RECOV_ALERT_REG_OFFSET, exp_events);
176  EXPECT_DIF_OK(dif_sensor_ctrl_get_recov_events(&sensor_ctrl, &rcv_events));
177  EXPECT_EQ(exp_events, rcv_events);
178 }
179 
180 TEST_F(SensorCtrlTest, ClearRecovEvent) {
181  for (size_t i = 0; i < SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS; i++) {
182  EXPECT_WRITE32(SENSOR_CTRL_RECOV_ALERT_REG_OFFSET, (1 << i));
183  EXPECT_DIF_OK(dif_sensor_ctrl_clear_recov_event(&sensor_ctrl, i));
184  }
185 }
186 
187 TEST_F(SensorCtrlTest, GetFatalEvents) {
188  uint32_t events_mask = (1 << SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS) - 1;
189 
190  dif_sensor_ctrl_events_t exp_events = 0x1987451 & events_mask;
191  dif_sensor_ctrl_events_t rcv_events;
192  EXPECT_READ32(SENSOR_CTRL_FATAL_ALERT_REG_OFFSET, exp_events);
193  EXPECT_DIF_OK(dif_sensor_ctrl_get_fatal_events(&sensor_ctrl, &rcv_events));
194  EXPECT_EQ(exp_events, rcv_events);
195 
196  exp_events = 0x9874bac & events_mask;
197  EXPECT_READ32(SENSOR_CTRL_FATAL_ALERT_REG_OFFSET, exp_events);
198  EXPECT_DIF_OK(dif_sensor_ctrl_get_fatal_events(&sensor_ctrl, &rcv_events));
199  EXPECT_EQ(exp_events, rcv_events);
200 }
201 
202 TEST_F(SensorCtrlTest, GetAstInitStatus) {
203  dif_toggle_t init_done;
204  uint32_t exp[4] = {0xa7, 0xa6, 0xbc, 0xf1};
205  for (size_t i = 0; i < sizeof(exp) / sizeof(uint32_t); i++) {
206  EXPECT_READ32(SENSOR_CTRL_STATUS_REG_OFFSET, exp[i]);
207  EXPECT_DIF_OK(
208  dif_sensor_ctrl_get_ast_init_done_status(&sensor_ctrl, &init_done));
209  EXPECT_EQ(bitfield_bit32_read(exp[i], SENSOR_CTRL_STATUS_AST_INIT_DONE_BIT),
210  init_done);
211  }
212 }
213 
214 TEST_F(SensorCtrlTest, GetIoPowerStatus) {
215  dif_sensor_ctrl_io_power_status_t io_power_status;
216  uint32_t exp[4] = {0xa7, 0xa0, 0xa3, 0xa5};
217 
218  for (size_t i = 0; i < sizeof(exp) / sizeof(uint32_t); i++) {
219  EXPECT_READ32(SENSOR_CTRL_STATUS_REG_OFFSET, exp[i]);
220  EXPECT_DIF_OK(
221  dif_sensor_ctrl_get_io_power_status(&sensor_ctrl, &io_power_status));
222  EXPECT_EQ(bitfield_field32_read(exp[i], SENSOR_CTRL_STATUS_IO_POK_FIELD),
223  io_power_status);
224  }
225 }
226 
227 } // namespace
228 } // namespace dif_sensor_ctrl_unittest
Return to OpenTitan Documentation