4 * Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
6 * SPDX-License-Identifier: GPL-2.0+
8 * Test the block image transfer in the graphical output protocol.
9 * An animated submarine is shown.
12 #include <efi_selftest.h>
18 static const struct efi_gop_pixel BLACK = { 0, 0, 0, 0};
19 static const struct efi_gop_pixel RED = { 0, 0, 255, 0};
20 static const struct efi_gop_pixel ORANGE = { 0, 128, 255, 0};
21 static const struct efi_gop_pixel YELLOW = { 0, 255, 255, 0};
22 static const struct efi_gop_pixel GREEN = { 0, 255, 0, 0};
23 static const struct efi_gop_pixel DARK_BLUE = {128, 0, 0, 0};
24 static const struct efi_gop_pixel LIGHT_BLUE = {255, 192, 192, 0};
26 static struct efi_boot_services *boottime;
27 static efi_guid_t efi_gop_guid = EFI_GOP_GUID;
28 static struct efi_gop *gop;
29 static struct efi_gop_pixel *bitmap;
30 static struct efi_event *event;
31 static efi_uintn_t xpos;
33 static void ellipse(efi_uintn_t x, efi_uintn_t y,
34 efi_uintn_t x0, efi_uintn_t y0,
35 efi_uintn_t x1, efi_uintn_t y1,
36 const struct efi_gop_pixel col, struct efi_gop_pixel *pix)
38 efi_uintn_t xm = x0 + x1;
39 efi_uintn_t ym = y0 + y1;
40 efi_uintn_t dx = x1 - x0 + 1;
41 efi_uintn_t dy = y1 - y0 + 1;
43 if (dy * dy * (2 * x - xm) * (2 * x - xm) +
44 dx * dx * (2 * y - ym) * (2 * y - ym) <= dx * dx * dy * dy)
48 static void rectangle(efi_uintn_t x, efi_uintn_t y,
49 efi_uintn_t x0, efi_uintn_t y0,
50 efi_uintn_t x1, efi_uintn_t y1,
51 const struct efi_gop_pixel col, struct efi_gop_pixel *pix)
53 if (x >= x0 && y >= y0 && x <= x1 && y <= y1)
58 * Notification function, copies image to video.
59 * The position is incremented in each call.
61 * @event notified event
62 * @context pointer to the notification count
64 static void EFIAPI notify(struct efi_event *event, void *context)
66 efi_uintn_t *pos = context;
67 efi_uintn_t dx, sx, width;
72 /* Increment position */
74 if (*pos >= WIDTH + gop->mode->info->width)
80 if (*pos >= gop->mode->info->width) {
81 width = WIDTH + gop->mode->info->width - *pos;
82 } else if (*pos < WIDTH) {
88 /* Copy image to video */
89 gop->blt(gop, bitmap, EFI_BLT_BUFFER_TO_VIDEO, sx, 0, dx, DEPTH,
90 width, HEIGHT, WIDTH);
96 * @handle: handle of the loaded image
97 * @systable: system table
98 * @return: EFI_ST_SUCCESS for success
100 static int setup(const efi_handle_t handle,
101 const struct efi_system_table *systable)
104 struct efi_gop_pixel pix;
107 boottime = systable->boottime;
110 ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL,
111 TPL_CALLBACK, notify, (void *)&xpos,
113 if (ret != EFI_SUCCESS) {
114 efi_st_error("could not create event\n");
115 return EFI_ST_FAILURE;
118 /* Get graphical output protocol */
119 ret = boottime->locate_protocol(&efi_gop_guid, NULL, (void **)&gop);
120 if (ret != EFI_SUCCESS) {
122 efi_st_printf("Graphical output protocol is not available.\n");
123 return EFI_ST_SUCCESS;
126 /* Prepare image of submarine */
127 ret = boottime->allocate_pool(EFI_LOADER_DATA,
128 sizeof(struct efi_gop_pixel) *
129 WIDTH * HEIGHT, (void **)&bitmap);
130 if (ret != EFI_SUCCESS) {
131 efi_st_error("Out of memory\n");
132 return EFI_ST_FAILURE;
134 for (y = 0; y < HEIGHT; ++y) {
135 for (x = 0; x < WIDTH; ++x) {
139 ellipse(x, y, 35, 55, 43, 75, BLACK, &pix);
140 ellipse(x, y, 36, 56, 42, 74, LIGHT_BLUE, &pix);
142 ellipse(x, y, 35, 75, 43, 95, BLACK, &pix);
143 ellipse(x, y, 36, 76, 42, 94, LIGHT_BLUE, &pix);
146 rectangle(x, y, 35, 73, 100, 77, BLACK, &pix);
149 ellipse(x, y, 120, 10, 160, 50, BLACK, &pix);
150 ellipse(x, y, 121, 11, 159, 59, YELLOW, &pix);
151 ellipse(x, y, 130, 20, 150, 40, BLACK, &pix);
152 ellipse(x, y, 131, 21, 149, 49, DARK_BLUE, &pix);
153 rectangle(x, y, 135, 10, 160, 50, DARK_BLUE, &pix);
154 ellipse(x, y, 132, 10, 138, 20, BLACK, &pix);
155 ellipse(x, y, 133, 11, 139, 19, RED, &pix);
158 ellipse(x, y, 45, 40, 75, 70, BLACK, &pix);
159 ellipse(x, y, 46, 41, 74, 69, ORANGE, &pix);
160 ellipse(x, y, 45, 80, 75, 109, BLACK, &pix);
161 ellipse(x, y, 46, 81, 74, 108, RED, &pix);
164 ellipse(x, y, 100, 30, 120, 50, BLACK, &pix);
165 ellipse(x, y, 101, 31, 119, 49, GREEN, &pix);
166 ellipse(x, y, 140, 30, 160, 50, BLACK, &pix);
167 ellipse(x, y, 141, 31, 159, 49, GREEN, &pix);
168 rectangle(x, y, 110, 30, 150, 50, BLACK, &pix);
169 rectangle(x, y, 110, 31, 150, 50, GREEN, &pix);
172 ellipse(x, y, 50, 40, 199, 109, BLACK, &pix);
173 ellipse(x, y, 51, 41, 198, 108, LIGHT_BLUE, &pix);
176 ellipse(x, y, 79, 57, 109, 82, BLACK, &pix);
177 ellipse(x, y, 80, 58, 108, 81, LIGHT_BLUE, &pix);
178 ellipse(x, y, 83, 61, 105, 78, BLACK, &pix);
179 ellipse(x, y, 84, 62, 104, 77, YELLOW, &pix);
181 * This port hole is created by copying
182 * ellipse(x, y, 119, 57, 149, 82, BLACK, &pix);
183 * ellipse(x, y, 120, 58, 148, 81, LIGHT_BLUE, &pix);
184 * ellipse(x, y, 123, 61, 145, 78, BLACK, &pix);
185 * ellipse(x, y, 124, 62, 144, 77, YELLOW, &pix);
187 ellipse(x, y, 159, 57, 189, 82, BLACK, &pix);
188 ellipse(x, y, 160, 58, 188, 81, LIGHT_BLUE, &pix);
189 ellipse(x, y, 163, 61, 185, 78, BLACK, &pix);
190 ellipse(x, y, 164, 62, 184, 77, YELLOW, &pix);
192 bitmap[WIDTH * y + x] = pix;
196 return EFI_ST_SUCCESS;
200 * Tear down unit test.
202 * @return: EFI_ST_SUCCESS for success
204 static int teardown(void)
209 ret = boottime->free_pool(bitmap);
210 if (ret != EFI_SUCCESS) {
211 efi_st_error("FreePool failed\n");
212 return EFI_ST_FAILURE;
216 ret = boottime->close_event(event);
218 if (ret != EFI_SUCCESS) {
219 efi_st_error("could not close event\n");
220 return EFI_ST_FAILURE;
223 return EFI_ST_SUCCESS;
229 * @return: EFI_ST_SUCCESS for success
231 static int execute(void)
235 struct efi_gop_mode_info *info;
238 return EFI_ST_SUCCESS;
241 efi_st_error("EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE missing\n");
242 return EFI_ST_FAILURE;
244 info = gop->mode->info;
245 max_mode = gop->mode->max_mode;
247 efi_st_error("No graphical mode available\n");
248 return EFI_ST_FAILURE;
251 /* Fill background */
252 ret = gop->blt(gop, bitmap, EFI_BLT_VIDEO_FILL, 0, 0, 0, 0,
253 info->width, info->height, 0);
254 if (ret != EFI_SUCCESS) {
255 efi_st_error("EFI_BLT_VIDEO_FILL failed\n");
256 return EFI_ST_FAILURE;
259 /* Copy image to video */
260 ret = gop->blt(gop, bitmap, EFI_BLT_BUFFER_TO_VIDEO, 0, 0, 0, DEPTH,
262 if (ret != EFI_SUCCESS) {
263 efi_st_error("EFI_BLT_BUFFER_TO_VIDEO failed\n");
264 return EFI_ST_FAILURE;
267 /* Copy left port hole */
268 ret = gop->blt(gop, bitmap, EFI_BLT_VIDEO_TO_VIDEO,
269 79, 57 + DEPTH, 119, 57 + DEPTH,
271 if (ret != EFI_SUCCESS) {
272 efi_st_error("EFI_BLT_VIDEO_TO_VIDEO failed\n");
273 return EFI_ST_FAILURE;
276 /* Copy port holes back to buffer */
277 ret = gop->blt(gop, bitmap, EFI_BLT_VIDEO_TO_BLT_BUFFER,
278 94, 57 + DEPTH, 94, 57,
280 if (ret != EFI_SUCCESS) {
281 efi_st_error("EFI_BLT_VIDEO_TO_BLT_BUFFER failed\n");
282 return EFI_ST_FAILURE;
285 /* Set 250ms timer */
287 ret = boottime->set_timer(event, EFI_TIMER_PERIODIC, 250000);
288 if (ret != EFI_SUCCESS) {
289 efi_st_error("Could not set timer\n");
290 return EFI_ST_FAILURE;
293 con_out->set_cursor_position(con_out, 0, 0);
294 con_out->set_attribute(con_out, EFI_WHITE | EFI_BACKGROUND_BLUE);
295 efi_st_printf("The submarine should have three yellow port holes.\n");
296 efi_st_printf("Press any key to continue");
298 con_out->set_attribute(con_out, EFI_LIGHTGRAY);
301 return EFI_ST_SUCCESS;
304 EFI_UNIT_TEST(bitblt) = {
305 .name = "block image transfer",
306 .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
309 .teardown = teardown,