mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-20 00:48:52 +09:00
![Tom Rini](/assets/img/avatar_default.png)
When U-Boot started using SPDX tags we were among the early adopters and there weren't a lot of other examples to borrow from. So we picked the area of the file that usually had a full license text and replaced it with an appropriate SPDX-License-Identifier: entry. Since then, the Linux Kernel has adopted SPDX tags and they place it as the very first line in a file (except where shebangs are used, then it's second line) and with slightly different comment styles than us. In part due to community overlap, in part due to better tag visibility and in part for other minor reasons, switch over to that style. This commit changes all instances where we have a single declared license in the tag as both the before and after are identical in tag contents. There's also a few places where I found we did not have a tag and have introduced one. Signed-off-by: Tom Rini <trini@konsulko.com>
311 lines
8.2 KiB
C
311 lines
8.2 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* efi_selftest_bitblt
|
|
*
|
|
* Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
|
|
*
|
|
* Test the block image transfer in the graphical output protocol.
|
|
* An animated submarine is shown.
|
|
*/
|
|
|
|
#include <efi_selftest.h>
|
|
|
|
#define WIDTH 200
|
|
#define HEIGHT 120
|
|
#define DEPTH 60
|
|
|
|
static const struct efi_gop_pixel BLACK = { 0, 0, 0, 0};
|
|
static const struct efi_gop_pixel RED = { 0, 0, 255, 0};
|
|
static const struct efi_gop_pixel ORANGE = { 0, 128, 255, 0};
|
|
static const struct efi_gop_pixel YELLOW = { 0, 255, 255, 0};
|
|
static const struct efi_gop_pixel GREEN = { 0, 255, 0, 0};
|
|
static const struct efi_gop_pixel DARK_BLUE = {128, 0, 0, 0};
|
|
static const struct efi_gop_pixel LIGHT_BLUE = {255, 192, 192, 0};
|
|
|
|
static struct efi_boot_services *boottime;
|
|
static efi_guid_t efi_gop_guid = EFI_GOP_GUID;
|
|
static struct efi_gop *gop;
|
|
static struct efi_gop_pixel *bitmap;
|
|
static struct efi_event *event;
|
|
static efi_uintn_t xpos;
|
|
|
|
static void ellipse(efi_uintn_t x, efi_uintn_t y,
|
|
efi_uintn_t x0, efi_uintn_t y0,
|
|
efi_uintn_t x1, efi_uintn_t y1,
|
|
const struct efi_gop_pixel col, struct efi_gop_pixel *pix)
|
|
{
|
|
efi_uintn_t xm = x0 + x1;
|
|
efi_uintn_t ym = y0 + y1;
|
|
efi_uintn_t dx = x1 - x0 + 1;
|
|
efi_uintn_t dy = y1 - y0 + 1;
|
|
|
|
if (dy * dy * (2 * x - xm) * (2 * x - xm) +
|
|
dx * dx * (2 * y - ym) * (2 * y - ym) <= dx * dx * dy * dy)
|
|
*pix = col;
|
|
}
|
|
|
|
static void rectangle(efi_uintn_t x, efi_uintn_t y,
|
|
efi_uintn_t x0, efi_uintn_t y0,
|
|
efi_uintn_t x1, efi_uintn_t y1,
|
|
const struct efi_gop_pixel col, struct efi_gop_pixel *pix)
|
|
{
|
|
if (x >= x0 && y >= y0 && x <= x1 && y <= y1)
|
|
*pix = col;
|
|
}
|
|
|
|
/*
|
|
* Notification function, copies image to video.
|
|
* The position is incremented in each call.
|
|
*
|
|
* @event notified event
|
|
* @context pointer to the notification count
|
|
*/
|
|
static void EFIAPI notify(struct efi_event *event, void *context)
|
|
{
|
|
efi_uintn_t *pos = context;
|
|
efi_uintn_t dx, sx, width;
|
|
|
|
if (!pos)
|
|
return;
|
|
|
|
/* Increment position */
|
|
*pos += 5;
|
|
if (*pos >= WIDTH + gop->mode->info->width)
|
|
*pos = 0;
|
|
|
|
width = WIDTH;
|
|
dx = *pos - WIDTH;
|
|
sx = 0;
|
|
if (*pos >= gop->mode->info->width) {
|
|
width = WIDTH + gop->mode->info->width - *pos;
|
|
} else if (*pos < WIDTH) {
|
|
dx = 0;
|
|
sx = WIDTH - *pos;
|
|
width = *pos;
|
|
}
|
|
|
|
/* Copy image to video */
|
|
gop->blt(gop, bitmap, EFI_BLT_BUFFER_TO_VIDEO, sx, 0, dx, DEPTH,
|
|
width, HEIGHT, WIDTH * sizeof(struct efi_gop_pixel));
|
|
}
|
|
|
|
/*
|
|
* Setup unit test.
|
|
*
|
|
* @handle: handle of the loaded image
|
|
* @systable: system table
|
|
* @return: EFI_ST_SUCCESS for success
|
|
*/
|
|
static int setup(const efi_handle_t handle,
|
|
const struct efi_system_table *systable)
|
|
{
|
|
efi_status_t ret;
|
|
struct efi_gop_pixel pix;
|
|
efi_uintn_t x, y;
|
|
|
|
boottime = systable->boottime;
|
|
|
|
/* Create event */
|
|
ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL,
|
|
TPL_CALLBACK, notify, (void *)&xpos,
|
|
&event);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("could not create event\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
|
|
/* Get graphical output protocol */
|
|
ret = boottime->locate_protocol(&efi_gop_guid, NULL, (void **)&gop);
|
|
if (ret != EFI_SUCCESS) {
|
|
gop = NULL;
|
|
efi_st_printf("Graphical output protocol is not available.\n");
|
|
return EFI_ST_SUCCESS;
|
|
}
|
|
|
|
/* Prepare image of submarine */
|
|
ret = boottime->allocate_pool(EFI_LOADER_DATA,
|
|
sizeof(struct efi_gop_pixel) *
|
|
WIDTH * HEIGHT, (void **)&bitmap);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("Out of memory\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
for (y = 0; y < HEIGHT; ++y) {
|
|
for (x = 0; x < WIDTH; ++x) {
|
|
pix = DARK_BLUE;
|
|
|
|
/* Propeller */
|
|
ellipse(x, y, 35, 55, 43, 75, BLACK, &pix);
|
|
ellipse(x, y, 36, 56, 42, 74, LIGHT_BLUE, &pix);
|
|
|
|
ellipse(x, y, 35, 75, 43, 95, BLACK, &pix);
|
|
ellipse(x, y, 36, 76, 42, 94, LIGHT_BLUE, &pix);
|
|
|
|
/* Shaft */
|
|
rectangle(x, y, 35, 73, 100, 77, BLACK, &pix);
|
|
|
|
/* Periscope */
|
|
ellipse(x, y, 120, 10, 160, 50, BLACK, &pix);
|
|
ellipse(x, y, 121, 11, 159, 59, YELLOW, &pix);
|
|
ellipse(x, y, 130, 20, 150, 40, BLACK, &pix);
|
|
ellipse(x, y, 131, 21, 149, 49, DARK_BLUE, &pix);
|
|
rectangle(x, y, 135, 10, 160, 50, DARK_BLUE, &pix);
|
|
ellipse(x, y, 132, 10, 138, 20, BLACK, &pix);
|
|
ellipse(x, y, 133, 11, 139, 19, RED, &pix);
|
|
|
|
/* Rudder */
|
|
ellipse(x, y, 45, 40, 75, 70, BLACK, &pix);
|
|
ellipse(x, y, 46, 41, 74, 69, ORANGE, &pix);
|
|
ellipse(x, y, 45, 80, 75, 109, BLACK, &pix);
|
|
ellipse(x, y, 46, 81, 74, 108, RED, &pix);
|
|
|
|
/* Bridge */
|
|
ellipse(x, y, 100, 30, 120, 50, BLACK, &pix);
|
|
ellipse(x, y, 101, 31, 119, 49, GREEN, &pix);
|
|
ellipse(x, y, 140, 30, 160, 50, BLACK, &pix);
|
|
ellipse(x, y, 141, 31, 159, 49, GREEN, &pix);
|
|
rectangle(x, y, 110, 30, 150, 50, BLACK, &pix);
|
|
rectangle(x, y, 110, 31, 150, 50, GREEN, &pix);
|
|
|
|
/* Hull */
|
|
ellipse(x, y, 50, 40, 199, 109, BLACK, &pix);
|
|
ellipse(x, y, 51, 41, 198, 108, LIGHT_BLUE, &pix);
|
|
|
|
/* Port holes */
|
|
ellipse(x, y, 79, 57, 109, 82, BLACK, &pix);
|
|
ellipse(x, y, 80, 58, 108, 81, LIGHT_BLUE, &pix);
|
|
ellipse(x, y, 83, 61, 105, 78, BLACK, &pix);
|
|
ellipse(x, y, 84, 62, 104, 77, YELLOW, &pix);
|
|
/*
|
|
* This port hole is created by copying
|
|
* ellipse(x, y, 119, 57, 149, 82, BLACK, &pix);
|
|
* ellipse(x, y, 120, 58, 148, 81, LIGHT_BLUE, &pix);
|
|
* ellipse(x, y, 123, 61, 145, 78, BLACK, &pix);
|
|
* ellipse(x, y, 124, 62, 144, 77, YELLOW, &pix);
|
|
*/
|
|
ellipse(x, y, 159, 57, 189, 82, BLACK, &pix);
|
|
ellipse(x, y, 160, 58, 188, 81, LIGHT_BLUE, &pix);
|
|
ellipse(x, y, 163, 61, 185, 78, BLACK, &pix);
|
|
ellipse(x, y, 164, 62, 184, 77, YELLOW, &pix);
|
|
|
|
bitmap[WIDTH * y + x] = pix;
|
|
}
|
|
}
|
|
|
|
return EFI_ST_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* Tear down unit test.
|
|
*
|
|
* @return: EFI_ST_SUCCESS for success
|
|
*/
|
|
static int teardown(void)
|
|
{
|
|
efi_status_t ret;
|
|
|
|
if (bitmap) {
|
|
ret = boottime->free_pool(bitmap);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("FreePool failed\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
}
|
|
if (event) {
|
|
ret = boottime->close_event(event);
|
|
event = NULL;
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("could not close event\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
}
|
|
return EFI_ST_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* Execute unit test.
|
|
*
|
|
* @return: EFI_ST_SUCCESS for success
|
|
*/
|
|
static int execute(void)
|
|
{
|
|
u32 max_mode;
|
|
efi_status_t ret;
|
|
struct efi_gop_mode_info *info;
|
|
|
|
if (!gop)
|
|
return EFI_ST_SUCCESS;
|
|
|
|
if (!gop->mode) {
|
|
efi_st_error("EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE missing\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
info = gop->mode->info;
|
|
max_mode = gop->mode->max_mode;
|
|
if (!max_mode) {
|
|
efi_st_error("No graphical mode available\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
|
|
/* Fill background */
|
|
ret = gop->blt(gop, bitmap, EFI_BLT_VIDEO_FILL, 0, 0, 0, 0,
|
|
info->width, info->height, 0);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("EFI_BLT_VIDEO_FILL failed\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
|
|
/* Copy image to video */
|
|
ret = gop->blt(gop, bitmap, EFI_BLT_BUFFER_TO_VIDEO, 0, 0, 0, DEPTH,
|
|
WIDTH, HEIGHT, 0);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("EFI_BLT_BUFFER_TO_VIDEO failed\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
|
|
/* Copy left port hole */
|
|
ret = gop->blt(gop, bitmap, EFI_BLT_VIDEO_TO_VIDEO,
|
|
79, 57 + DEPTH, 119, 57 + DEPTH,
|
|
31, 26, 0);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("EFI_BLT_VIDEO_TO_VIDEO failed\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
|
|
/* Copy port holes back to buffer */
|
|
ret = gop->blt(gop, bitmap, EFI_BLT_VIDEO_TO_BLT_BUFFER,
|
|
94, 57 + DEPTH, 94, 57,
|
|
90, 26, WIDTH * sizeof(struct efi_gop_pixel));
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("EFI_BLT_VIDEO_TO_BLT_BUFFER failed\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
|
|
/* Set 250ms timer */
|
|
xpos = WIDTH;
|
|
ret = boottime->set_timer(event, EFI_TIMER_PERIODIC, 250000);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("Could not set timer\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
|
|
con_out->set_cursor_position(con_out, 0, 0);
|
|
con_out->set_attribute(con_out, EFI_WHITE | EFI_BACKGROUND_BLUE);
|
|
efi_st_printf("The submarine should have three yellow port holes.\n");
|
|
efi_st_printf("Press any key to continue");
|
|
efi_st_get_key();
|
|
con_out->set_attribute(con_out, EFI_LIGHTGRAY);
|
|
efi_st_printf("\n");
|
|
|
|
return EFI_ST_SUCCESS;
|
|
}
|
|
|
|
EFI_UNIT_TEST(bitblt) = {
|
|
.name = "block image transfer",
|
|
.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
|
|
.setup = setup,
|
|
.execute = execute,
|
|
.teardown = teardown,
|
|
.on_request = true,
|
|
};
|