1/* Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
2 * Use of this source code is governed by a BSD-style license that can be
3 * found in the LICENSE file.
4 *
5 * Tests for vboot_api_firmware
6 */
7
8#include <stddef.h>
9#include <stdint.h>
10#include <stdio.h>
11#include <stdlib.h>
12
13#include "crc32.h"
14#include "gbb_header.h"
15#include "host_common.h"
16#include "load_kernel_fw.h"
17#include "rollback_index.h"
18#include "test_common.h"
19#include "vboot_common.h"
20#include "vboot_display.h"
21#include "vboot_nvstorage.h"
22#include "vboot_struct.h"
23
24
25/* Expected results */
26
27#define MAX_NOTE_EVENTS 10
28#define TICKS_PER_MSEC 1900ULL
29#define TIME_FUZZ 500
30#define KBD_READ_TIME 60
31
32typedef struct {
33  uint16_t msec;
34  uint16_t freq;
35  int time;
36} note_event_t;
37
38typedef struct {
39  char *name;
40  uint32_t gbb_flags;
41  VbError_t beep_return;
42  uint32_t keypress_key;
43  int keypress_at_count;
44  int num_events;
45  note_event_t notes[MAX_NOTE_EVENTS];
46} test_case_t;
47
48test_case_t test[] = {
49
50  { "VbBootDeveloperSoundTest( fast, background )",
51    0x00000001, VBERROR_SUCCESS,
52    0, 0,
53    2,
54    {
55      {0, 0, 0},                        // probing for capability
56      {0, 0, 2000},                     // off and return at 2 seconds
57    }},
58
59  { "VbBootDeveloperSoundTest( normal, background )",
60    0x00000000, VBERROR_SUCCESS,
61    0, 0,
62    6,
63    {
64      {0, 0, 0},                        // probing for capability
65      {0, 400, 20000},                  // starts first beep at 20 seconds
66      {0, 0, 20250},                    // stops 250ms later
67      {0, 400, 20500},                  // starts second beep
68      {0, 0, 20750},                    // stops 250ms later
69      {0, 0, 30000},                    // off and return at 30 seconds
70    }},
71
72  { "VbBootDeveloperSoundTest( fast, no background )",
73    0x00000001, VBERROR_NO_BACKGROUND_SOUND,
74    0, 0,
75    2,
76    {
77      {0, 0, 0},                        // probing for capability
78      {0, 0, 2000},                     // off and return at 2 seconds
79    }},
80
81  { "VbBootDeveloperSoundTest( normal, no background )",
82    0x00000000, VBERROR_NO_BACKGROUND_SOUND,
83    0, 0,
84    4,
85    {
86      {0, 0, 0},                        // probing for capability
87      {250, 400, 20000},                // first beep at 20 seconds
88      {250, 400, 20510},                // second beep shortly after
89      {0, 0, 30020},                    // off and return at 30 seconds
90    }},
91
92  // Now with some keypresses
93
94  { "VbBootDeveloperSoundTest( normal, background, Ctrl-D )",
95    0x00000000, VBERROR_SUCCESS,
96    4, 10000,                           // Ctrl-D at 10 seconds
97    2,
98    {
99      {0, 0, 0},                        // probing for capability
100      {0, 0, 10000},                    // sees Ctrl-D, sound off, return
101    }},
102
103  { "VbBootDeveloperSoundTest( normal, no background, Ctrl-D )",
104    0x00000000, VBERROR_NO_BACKGROUND_SOUND,
105    4, 20400,                           // Ctrl-D between beeps
106    3,
107    {
108      {0, 0, 0},                        // probing for capability
109      {250, 400, 20000},                // first beep at 20 seconds
110      {0, 0, 20400},                    // sees Ctrl-D, sound off, return
111    }},
112
113  { "VbBootDeveloperSoundTest( normal, background, Ctrl-U not allowed )",
114    0x00000000, VBERROR_SUCCESS,
115    21, 10000,                          // Ctrl-U at 10 seconds
116    8,
117    {
118      {0, 0, 0},                        // probing for capability
119      {120, 400, 10000},                // complains about Ctrl-U (one beep)
120                                        // waits 120ms...
121      {120, 400, 10240},                // complains about Ctrl-U (two beeps)
122                                        // original sequence is now shifted...
123      {0, 400, 20360},                  // starts first beep at 20 seconds
124      {0, 0, 20610},                    // stops 250ms later
125      {0, 400, 20860},                  // starts second beep
126      {0, 0, 21110},                    // stops 250ms later
127      {0, 0, 30360},                    // returns at 30 seconds + 360ms
128    }},
129
130};
131
132/* Mock data */
133static VbCommonParams cparams;
134static LoadKernelParams lkparams;
135static VbNvContext vnc;
136static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
137static VbSharedDataHeader* shared = (VbSharedDataHeader*)shared_data;
138static GoogleBinaryBlockHeader gbb;
139static int current_time;
140static uint64_t current_ticks;
141static int current_event;
142static int max_events;
143static int matched_events;
144static int kbd_fire_at;
145static uint32_t kbd_fire_key;
146static VbError_t beep_return;
147static note_event_t *expected_event;
148
149/* Reset mock data (for use before each test) */
150static void ResetMocks(void) {
151
152  Memset(&cparams, 0, sizeof(cparams));
153  cparams.shared_data_size = sizeof(shared_data);
154  cparams.shared_data_blob = shared_data;
155  cparams.gbb_data = &gbb;
156  cparams.gbb = &gbb;
157
158  Memset(&lkparams, 0, sizeof(lkparams));
159
160  Memset(&vnc, 0, sizeof(vnc));
161  VbNvSetup(&vnc);
162  VbNvTeardown(&vnc);  /* So CRC gets generated */
163
164  Memset(&shared_data, 0, sizeof(shared_data));
165  VbSharedDataInit(shared, sizeof(shared_data));
166  shared->fw_keyblock_flags = 0xABCDE0;
167
168  Memset(&gbb, 0, sizeof(gbb));
169  gbb.major_version = GBB_MAJOR_VER;
170  gbb.minor_version = GBB_MINOR_VER;
171  gbb.flags = 0;
172
173  current_ticks = 0;
174  current_time = 0;
175
176  current_event = 0;
177  kbd_fire_at = 0;
178  kbd_fire_key = 0;
179
180  beep_return = VBERROR_SUCCESS;
181
182  matched_events = 0;
183  max_events = 0;
184}
185
186/****************************************************************************/
187/* Mocked verification functions */
188
189VbError_t VbExNvStorageRead(uint8_t* buf) {
190  Memcpy(buf, vnc.raw, sizeof(vnc.raw));
191  return VBERROR_SUCCESS;
192}
193
194VbError_t VbExNvStorageWrite(const uint8_t* buf) {
195  Memcpy(vnc.raw, buf, sizeof(vnc.raw));
196  return VBERROR_SUCCESS;
197}
198
199VbError_t VbExDiskGetInfo(VbDiskInfo** infos_ptr, uint32_t* count,
200                          uint32_t disk_flags) {
201  return VBERROR_UNKNOWN;
202}
203
204VbError_t VbExDiskFreeInfo(VbDiskInfo* infos,
205                           VbExDiskHandle_t preserve_handle) {
206  return VBERROR_SUCCESS;
207}
208
209VbError_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
210                       uint64_t lba_count, void* buffer) {
211  return VBERROR_UNKNOWN;
212}
213
214VbError_t VbExDiskWrite(VbExDiskHandle_t handle, uint64_t lba_start,
215                        uint64_t lba_count, const void* buffer) {
216  return VBERROR_UNKNOWN;
217}
218
219uint32_t VbExIsShutdownRequested(void) {
220  return 0;
221}
222
223uint32_t VbExKeyboardRead(void) {
224  uint32_t tmp;
225  uint32_t now;
226
227  VbExSleepMs(KBD_READ_TIME);
228  now = current_time;
229
230  if (kbd_fire_key && now >= kbd_fire_at) {
231    VBDEBUG(("  VbExKeyboardRead() - returning %d at %d msec\n",
232             kbd_fire_key, now));
233    tmp = kbd_fire_key;
234    kbd_fire_key = 0;
235    return tmp;
236  }
237  VBDEBUG(("  VbExKeyboardRead() - returning %d at %d msec\n",
238           0, now));
239  return 0;
240}
241
242void VbExSleepMs(uint32_t msec) {
243  current_ticks += (uint64_t)msec * TICKS_PER_MSEC;
244  current_time = current_ticks / TICKS_PER_MSEC;
245  VBDEBUG(("VbExSleepMs(%d) -> %d\n", msec, current_time));
246}
247
248uint64_t VbExGetTimer(void) {
249  return current_ticks;
250}
251
252VbError_t VbExBeep(uint32_t msec, uint32_t frequency) {
253  VBDEBUG(("VbExBeep(%d, %d) at %d msec\n", msec, frequency, current_time));
254
255  if (current_event < max_events &&
256      msec == expected_event[current_event].msec &&
257      frequency == expected_event[current_event].freq &&
258      abs(current_time - expected_event[current_event].time) < TIME_FUZZ ) {
259    matched_events++;
260  }
261
262  if (msec)
263    VbExSleepMs(msec);
264  current_event++;
265  return beep_return;
266}
267
268VbError_t VbExDisplayScreen(uint32_t screen_type) {
269  switch(screen_type) {
270  case VB_SCREEN_BLANK:
271    VBDEBUG(("VbExDisplayScreen(BLANK)\n"));
272    break;
273  case VB_SCREEN_DEVELOPER_WARNING:
274    VBDEBUG(("VbExDisplayScreen(DEV)\n"));
275    break;
276  case VB_SCREEN_DEVELOPER_EGG:
277    VBDEBUG(("VbExDisplayScreen(EGG)\n"));
278    break;
279  case VB_SCREEN_RECOVERY_REMOVE:
280    VBDEBUG(("VbExDisplayScreen(REMOVE)\n"));
281    break;
282  case VB_SCREEN_RECOVERY_INSERT:
283    VBDEBUG(("VbExDisplayScreen(INSERT)\n"));
284    break;
285  case VB_SCREEN_RECOVERY_NO_GOOD:
286    VBDEBUG(("VbExDisplayScreen(NO_GOOD)\n"));
287    break;
288  default:
289    VBDEBUG(("VbExDisplayScreen(%d)\n", screen_type));
290  }
291
292  VBDEBUG(("  current_time is %d msec\n", current_time));
293
294  return VBERROR_SUCCESS;
295}
296
297/****************************************************************************/
298
299VbError_t VbBootDeveloper(VbCommonParams* cparams, LoadKernelParams* p);
300
301
302static void VbBootDeveloperSoundTest(void) {
303  int i;
304  int num_tests =  sizeof(test) / sizeof(test_case_t);
305
306  for (i=0; i<num_tests; i++) {
307    VBDEBUG(("STARTING %s ...\n", test[i].name));
308    ResetMocks();
309    gbb.flags = test[i].gbb_flags;
310    beep_return = test[i].beep_return;
311    kbd_fire_key = test[i].keypress_key;
312    kbd_fire_at = test[i].keypress_at_count;
313    max_events = test[i].num_events;
314    expected_event = test[i].notes;
315    (void) VbBootDeveloper(&cparams, &lkparams);
316    VBDEBUG(("INFO: matched %d total %d expected %d\n",
317             matched_events, current_event, test[i].num_events));
318    TEST_TRUE(matched_events == test[i].num_events &&
319              current_event == test[i].num_events, test[i].name);
320  }
321}
322
323
324int main(int argc, char* argv[]) {
325  int error_code = 0;
326
327  VbBootDeveloperSoundTest();
328
329  if (!gTestSuccess)
330    error_code = 255;
331  if (vboot_api_stub_check_memory())
332    error_code = 255;
333
334  return error_code;
335}
336