Merge branch 'rmobile' of git://git.denx.de/u-boot-sh
[oweals/u-boot.git] / lib / efi_selftest / efi_selftest_tpl.c
1 /*
2  * efi_selftest_events
3  *
4  * Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
5  *
6  * SPDX-License-Identifier:     GPL-2.0+
7  *
8  * This unit test uses timer events to check the handling of
9  * task priority levels.
10  */
11
12 #include <efi_selftest.h>
13
14 static struct efi_event *event_notify;
15 static struct efi_event *event_wait;
16 static unsigned int counter;
17 static struct efi_boot_services *boottime;
18
19 /*
20  * Notification function, increments a counter.
21  *
22  * @event       notified event
23  * @context     pointer to the counter
24  */
25 static void EFIAPI notify(struct efi_event *event, void *context)
26 {
27         if (!context)
28                 return;
29         ++*(unsigned int *)context;
30 }
31
32 /*
33  * Setup unit test.
34  *
35  * Create two timer events.
36  * One with EVT_NOTIFY_SIGNAL, the other with EVT_NOTIFY_WAIT.
37  *
38  * @handle:     handle of the loaded image
39  * @systable:   system table
40  */
41 static int setup(const efi_handle_t handle,
42                  const struct efi_system_table *systable)
43 {
44         efi_status_t ret;
45
46         boottime = systable->boottime;
47
48         ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL,
49                                      TPL_CALLBACK, notify, (void *)&counter,
50                                      &event_notify);
51         if (ret != EFI_SUCCESS) {
52                 efi_st_error("could not create event\n");
53                 return 1;
54         }
55         ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_WAIT,
56                                      TPL_HIGH_LEVEL, notify, NULL, &event_wait);
57         if (ret != EFI_SUCCESS) {
58                 efi_st_error("could not create event\n");
59                 return 1;
60         }
61         return 0;
62 }
63
64 /*
65  * Tear down unit test.
66  *
67  * Close the events created in setup.
68  */
69 static int teardown(void)
70 {
71         efi_status_t ret;
72
73         if (event_notify) {
74                 ret = boottime->close_event(event_notify);
75                 event_notify = NULL;
76                 if (ret != EFI_SUCCESS) {
77                         efi_st_error("could not close event\n");
78                         return 1;
79                 }
80         }
81         if (event_wait) {
82                 ret = boottime->close_event(event_wait);
83                 event_wait = NULL;
84                 if (ret != EFI_SUCCESS) {
85                         efi_st_error("could not close event\n");
86                         return 1;
87                 }
88         }
89         boottime->restore_tpl(TPL_APPLICATION);
90         return 0;
91 }
92
93 /*
94  * Execute unit test.
95  *
96  * Run a 10 ms periodic timer and check that it is called 10 times
97  * while waiting for 100 ms single shot timer.
98  *
99  * Raise the TPL level to the level of the 10 ms timer and observe
100  * that the notification function is not called again.
101  *
102  * Lower the TPL level and check that the queued notification
103  * function is called.
104  */
105 static int execute(void)
106 {
107         unsigned long index;
108         efi_status_t ret;
109         UINTN old_tpl;
110
111         /* Set 10 ms timer */
112         counter = 0;
113         ret = boottime->set_timer(event_notify, EFI_TIMER_PERIODIC, 100000);
114         if (ret != EFI_SUCCESS) {
115                 efi_st_error("Could not set timer\n");
116                 return 1;
117         }
118         /* Set 100 ms timer */
119         ret = boottime->set_timer(event_wait, EFI_TIMER_RELATIVE, 1000000);
120         if (ret != EFI_SUCCESS) {
121                 efi_st_error("Could not set timer\n");
122                 return 1;
123         }
124         index = 5;
125         ret = boottime->wait_for_event(1, &event_wait, &index);
126         if (ret != EFI_SUCCESS) {
127                 efi_st_error("Could not wait for event\n");
128                 return 1;
129         }
130         ret = boottime->check_event(event_wait);
131         if (ret != EFI_NOT_READY) {
132                 efi_st_error("Signaled state was not cleared.\n");
133                 efi_st_printf("ret = %u\n", (unsigned int)ret);
134                 return 1;
135         }
136         if (index != 0) {
137                 efi_st_error("WaitForEvent returned wrong index\n");
138                 return 1;
139         }
140         efi_st_printf("Counter with TPL level TPL_APPLICATION: %u\n", counter);
141         if (counter < 8 || counter > 12) {
142                 efi_st_error("Incorrect timing of events\n");
143                 return 1;
144         }
145         ret = boottime->set_timer(event_notify, EFI_TIMER_STOP, 0);
146         if (index != 0) {
147                 efi_st_error("Could not cancel timer\n");
148                 return 1;
149         }
150         /* Raise TPL level */
151         old_tpl = boottime->raise_tpl(TPL_CALLBACK);
152         if (old_tpl != TPL_APPLICATION) {
153                 efi_st_error("Initial TPL level was not TPL_APPLICATION");
154                 return 1;
155         }
156         /* Set 10 ms timer */
157         counter = 0;
158         ret = boottime->set_timer(event_notify, EFI_TIMER_PERIODIC, 100000);
159         if (index != 0) {
160                 efi_st_error("Could not set timer\n");
161                 return 1;
162         }
163         /* Set 100 ms timer */
164         ret = boottime->set_timer(event_wait, EFI_TIMER_RELATIVE, 1000000);
165         if (ret != EFI_SUCCESS) {
166                 efi_st_error("Could not set timer\n");
167                 return 1;
168         }
169         do {
170                 ret = boottime->check_event(event_wait);
171         } while (ret == EFI_NOT_READY);
172         if (ret != EFI_SUCCESS) {
173                 efi_st_error("Could not check event\n");
174                 return 1;
175         }
176         efi_st_printf("Counter with TPL level TPL_CALLBACK: %u\n", counter);
177         if (counter != 0) {
178                 efi_st_error("Suppressed timer fired\n");
179                 return 1;
180         }
181         /* Set 1 ms timer */
182         ret = boottime->set_timer(event_wait, EFI_TIMER_RELATIVE, 1000);
183         if (ret != EFI_SUCCESS) {
184                 efi_st_error("Could not set timer\n");
185                 return 1;
186         }
187         /* Restore the old TPL level */
188         boottime->restore_tpl(TPL_APPLICATION);
189         ret = boottime->wait_for_event(1, &event_wait, &index);
190         if (ret != EFI_SUCCESS) {
191                 efi_st_error("Could not wait for event\n");
192                 return 1;
193         }
194         efi_st_printf("Counter with TPL level TPL_APPLICATION: %u\n", counter);
195         if (counter < 1) {
196                 efi_st_error("Queued timer event did not fire\n");
197                 return 1;
198         }
199         ret = boottime->set_timer(event_wait, EFI_TIMER_STOP, 0);
200         if (index != 0) {
201                 efi_st_error("Could not cancel timer\n");
202                 return 1;
203         }
204
205         return 0;
206 }
207
208 EFI_UNIT_TEST(tpl) = {
209         .name = "task priority levels",
210         .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
211         .setup = setup,
212         .execute = execute,
213         .teardown = teardown,
214 };