arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2025-02-16 01:22:02 +00:00
Code Issues Releases Wiki Activity

refactor(core): improve dma2d driver init/deinit

Browse Source 
[no changelog]
This commit is contained in:
cepetr 2025-02-11 08:43:02 +01:00 committed by cepetr
parent 8b12a77a3b
commit 08d55ea3f4
2 changed files with 278 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

454
core/embed/gfx/bitblt/stm32/dma2d_bitblt.c
View File

@ -24,8 +24,27 @@
#include "../dma2d_bitblt.h" #include "../dma2d_bitblt.h"
static DMA2D_HandleTypeDef dma2d_handle = { // Number of DMA2D layers - background (0) and foreground (1)
.Instance = (DMA2D_TypeDef*)DMA2D_BASE, #define DMA2D_LAYER_COUNT 2
typedef struct {
// Set if the driver is initialized
bool initialized;
// ST DMA2D driver handle
DMA2D_HandleTypeDef handle;
// CLUT cache
struct {
gfx_color32_t c_fg;
gfx_color32_t c_bg;
} cache[DMA2D_LAYER_COUNT];
// CLUT is configured according to the cache
bool clut_valid;
} dma2d_driver_t;
static dma2d_driver_t g_dma2d_driver = {
.initialized = false,
}; };
// Returns `true` if the specified address is accessible by DMA2D // Returns `true` if the specified address is accessible by DMA2D
@ -41,25 +60,50 @@ static inline bool dma2d_accessible(const void* ptr) {
} }
void dma2d_init(void) { void dma2d_init(void) {
dma2d_driver_t* drv = &g_dma2d_driver;
if (drv->initialized) {
return;
}
memset(drv, 0, sizeof(dma2d_driver_t));
drv->handle.Instance = DMA2D;
#ifdef KERNEL_MODE
__HAL_RCC_DMA2D_FORCE_RESET(); __HAL_RCC_DMA2D_FORCE_RESET();
__HAL_RCC_DMA2D_RELEASE_RESET(); __HAL_RCC_DMA2D_RELEASE_RESET();
__HAL_RCC_DMA2D_CLK_ENABLE(); __HAL_RCC_DMA2D_CLK_ENABLE();
#endif
drv->initialized = true;
} }
void dma2d_deinit(void) { void dma2d_deinit(void) {
__HAL_RCC_DMA2D_CLK_DISABLE(); dma2d_driver_t* drv = &g_dma2d_driver;
#ifdef KERNEL_MODE
__HAL_RCC_DMA2D_CLK_DISABLE();
__HAL_RCC_DMA2D_FORCE_RESET(); __HAL_RCC_DMA2D_FORCE_RESET();
__HAL_RCC_DMA2D_RELEASE_RESET(); __HAL_RCC_DMA2D_RELEASE_RESET();
#endif
memset(drv, 0, sizeof(dma2d_driver_t));
} }
void dma2d_wait(void) { void dma2d_wait(void) {
while (HAL_DMA2D_PollForTransfer(&dma2d_handle, 10) != HAL_OK) dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return;
}
while (HAL_DMA2D_PollForTransfer(&drv->handle, 10) != HAL_OK)
; ;
} }
bool dma2d_rgb565_fill(const gfx_bitblt_t* bb) { bool dma2d_rgb565_fill(const gfx_bitblt_t* bb) {
dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return false;
}
dma2d_wait(); dma2d_wait();
if (!dma2d_accessible(bb->dst_row)) { if (!dma2d_accessible(bb->dst_row)) {
@ -67,38 +111,38 @@ bool dma2d_rgb565_fill(const gfx_bitblt_t* bb) {
} }
if (bb->src_alpha == 255) { if (bb->src_alpha == 255) {
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_RGB565; drv->handle.Init.ColorMode = DMA2D_OUTPUT_RGB565;
dma2d_handle.Init.Mode = DMA2D_R2M; drv->handle.Init.Mode = DMA2D_R2M;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset =
bb->dst_stride / sizeof(uint16_t) - bb->width; bb->dst_stride / sizeof(uint16_t) - bb->width;
HAL_DMA2D_Init(&dma2d_handle); HAL_DMA2D_Init(&drv->handle);
HAL_DMA2D_Start(&dma2d_handle, gfx_color_to_color32(bb->src_fg), HAL_DMA2D_Start(&drv->handle, gfx_color_to_color32(bb->src_fg),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t),
bb->width, bb->height); bb->width, bb->height);
} else { } else {
#ifdef STM32U5 #ifdef STM32U5
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_RGB565; drv->handle.Init.ColorMode = DMA2D_OUTPUT_RGB565;
dma2d_handle.Init.Mode = DMA2D_M2M_BLEND_FG; drv->handle.Init.Mode = DMA2D_M2M_BLEND_FG;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset =
bb->dst_stride / sizeof(uint16_t) - bb->width; bb->dst_stride / sizeof(uint16_t) - bb->width;
HAL_DMA2D_Init(&dma2d_handle); HAL_DMA2D_Init(&drv->handle);
dma2d_handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB565; drv->handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB565;
dma2d_handle.LayerCfg[1].InputOffset = 0; drv->handle.LayerCfg[1].InputOffset = 0;
dma2d_handle.LayerCfg[1].AlphaMode = DMA2D_REPLACE_ALPHA; drv->handle.LayerCfg[1].AlphaMode = DMA2D_REPLACE_ALPHA;
dma2d_handle.LayerCfg[1].InputAlpha = bb->src_alpha; drv->handle.LayerCfg[1].InputAlpha = bb->src_alpha;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 1); HAL_DMA2D_ConfigLayer(&drv->handle, 1);
dma2d_handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_RGB565; drv->handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_RGB565;
dma2d_handle.LayerCfg[0].InputOffset = drv->handle.LayerCfg[0].InputOffset =
bb->dst_stride / sizeof(uint16_t) - bb->width; bb->dst_stride / sizeof(uint16_t) - bb->width;
dma2d_handle.LayerCfg[0].AlphaMode = 0; drv->handle.LayerCfg[0].AlphaMode = 0;
dma2d_handle.LayerCfg[0].InputAlpha = 0; drv->handle.LayerCfg[0].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 0); HAL_DMA2D_ConfigLayer(&drv->handle, 0);
HAL_DMA2D_BlendingStart( HAL_DMA2D_BlendingStart(
&dma2d_handle, gfx_color_to_color32(bb->src_fg), &drv->handle, gfx_color_to_color32(bb->src_fg),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t), bb->width, (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t), bb->width,
bb->height); bb->height);
@ -113,24 +157,22 @@ bool dma2d_rgb565_fill(const gfx_bitblt_t* bb) {
static void dma2d_config_clut(uint32_t layer, gfx_color32_t fg, static void dma2d_config_clut(uint32_t layer, gfx_color32_t fg,
gfx_color32_t bg) { gfx_color32_t bg) {
#define LAYER_COUNT 2 dma2d_driver_t* drv = &g_dma2d_driver;
#define GRADIENT_STEPS 16 #define GRADIENT_STEPS 16
static struct { if (layer >= ARRAY_LENGTH(drv->cache)) {
gfx_color32_t c_fg;
gfx_color32_t c_bg;
} cache[LAYER_COUNT] = {0};
if (layer >= LAYER_COUNT) {
return; return;
} }
volatile uint32_t* clut = volatile uint32_t* clut =
layer ? dma2d_handle.Instance->FGCLUT : dma2d_handle.Instance->BGCLUT; layer ? drv->handle.Instance->FGCLUT : drv->handle.Instance->BGCLUT;
if (fg != cache[layer].c_fg || bg != cache[layer].c_bg) { if (fg != drv->cache[layer].c_fg || bg != drv->cache[layer].c_bg ||
cache[layer].c_fg = fg; !drv->clut_valid) {
cache[layer].c_bg = bg; drv->cache[layer].c_fg = fg;
drv->cache[layer].c_bg = bg;
drv->clut_valid = true;
for (int step = 0; step < GRADIENT_STEPS; step++) { for (int step = 0; step < GRADIENT_STEPS; step++) {
clut[step] = gfx_color32_rgba( clut[step] = gfx_color32_rgba(
@ -145,7 +187,7 @@ static void dma2d_config_clut(uint32_t layer, gfx_color32_t fg,
clut_def.Size = GRADIENT_STEPS - 1; clut_def.Size = GRADIENT_STEPS - 1;
clut_def.pCLUT = 0; // ??? clut_def.pCLUT = 0; // ???
HAL_DMA2D_ConfigCLUT(&dma2d_handle, clut_def, layer); HAL_DMA2D_ConfigCLUT(&drv->handle, clut_def, layer);
} }
} }
@ -180,6 +222,12 @@ static void dma2d_rgb565_copy_mono4_last_col(gfx_bitblt_t* bb,
} }
bool dma2d_rgb565_copy_mono4(const gfx_bitblt_t* params) { bool dma2d_rgb565_copy_mono4(const gfx_bitblt_t* params) {
dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return false;
}
const gfx_color16_t* src_gradient = NULL; const gfx_color16_t* src_gradient = NULL;
gfx_bitblt_t bb_copy = *params; gfx_bitblt_t bb_copy = *params;
@ -211,48 +259,52 @@ bool dma2d_rgb565_copy_mono4(const gfx_bitblt_t* params) {
bb->width -= 1; bb->width -= 1;
} }
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_RGB565; drv->handle.Init.ColorMode = DMA2D_OUTPUT_RGB565;
dma2d_handle.Init.Mode = DMA2D_M2M_PFC; drv->handle.Init.Mode = DMA2D_M2M_PFC;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset = bb->dst_stride / sizeof(uint16_t) - bb->width;
bb->dst_stride / sizeof(uint16_t) - bb->width; HAL_DMA2D_Init(&drv->handle);
HAL_DMA2D_Init(&dma2d_handle);
dma2d_handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_L4; drv->handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_L4;
dma2d_handle.LayerCfg[1].InputOffset = bb->src_stride * 2 - bb->width; drv->handle.LayerCfg[1].InputOffset = bb->src_stride * 2 - bb->width;
dma2d_handle.LayerCfg[1].AlphaMode = 0; drv->handle.LayerCfg[1].AlphaMode = 0;
dma2d_handle.LayerCfg[1].InputAlpha = 0; drv->handle.LayerCfg[1].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 1); HAL_DMA2D_ConfigLayer(&drv->handle, 1);
dma2d_config_clut(1, gfx_color_to_color32(bb->src_fg), dma2d_config_clut(1, gfx_color_to_color32(bb->src_fg),
gfx_color_to_color32(bb->src_bg)); gfx_color_to_color32(bb->src_bg));
HAL_DMA2D_Start(&dma2d_handle, (uint32_t)bb->src_row + bb->src_x / 2, HAL_DMA2D_Start(&drv->handle, (uint32_t)bb->src_row + bb->src_x / 2,
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t),
bb->width, bb->height); bb->width, bb->height);
return true; return true;
} }
bool dma2d_rgb565_copy_rgb565(const gfx_bitblt_t* bb) { bool dma2d_rgb565_copy_rgb565(const gfx_bitblt_t* bb) {
dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return false;
}
dma2d_wait(); dma2d_wait();
if (!dma2d_accessible(bb->dst_row) || !dma2d_accessible(bb->src_row)) { if (!dma2d_accessible(bb->dst_row) || !dma2d_accessible(bb->src_row)) {
return false; return false;
} }
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_RGB565; drv->handle.Init.ColorMode = DMA2D_OUTPUT_RGB565;
dma2d_handle.Init.Mode = DMA2D_M2M_PFC; drv->handle.Init.Mode = DMA2D_M2M_PFC;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset = bb->dst_stride / sizeof(uint16_t) - bb->width;
bb->dst_stride / sizeof(uint16_t) - bb->width; HAL_DMA2D_Init(&drv->handle);
HAL_DMA2D_Init(&dma2d_handle);
dma2d_handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB565; drv->handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB565;
dma2d_handle.LayerCfg[1].InputOffset = drv->handle.LayerCfg[1].InputOffset =
bb->src_stride / sizeof(uint16_t) - bb->width; bb->src_stride / sizeof(uint16_t) - bb->width;
dma2d_handle.LayerCfg[1].AlphaMode = 0; drv->handle.LayerCfg[1].AlphaMode = 0;
dma2d_handle.LayerCfg[1].InputAlpha = 0; drv->handle.LayerCfg[1].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 1); HAL_DMA2D_ConfigLayer(&drv->handle, 1);
HAL_DMA2D_Start(&dma2d_handle, HAL_DMA2D_Start(&drv->handle,
(uint32_t)bb->src_row + bb->src_x * sizeof(uint16_t), (uint32_t)bb->src_row + bb->src_x * sizeof(uint16_t),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t),
bb->width, bb->height); bb->width, bb->height);
@ -292,6 +344,12 @@ static void dma2d_rgb565_blend_mono4_last_col(const gfx_bitblt_t* bb) {
} }
bool dma2d_rgb565_blend_mono4(const gfx_bitblt_t* params) { bool dma2d_rgb565_blend_mono4(const gfx_bitblt_t* params) {
dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return false;
}
dma2d_wait(); dma2d_wait();
gfx_bitblt_t bb_copy = *params; gfx_bitblt_t bb_copy = *params;
@ -318,31 +376,31 @@ bool dma2d_rgb565_blend_mono4(const gfx_bitblt_t* params) {
} }
if (bb->width > 0) { if (bb->width > 0) {
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_RGB565; drv->handle.Init.ColorMode = DMA2D_OUTPUT_RGB565;
dma2d_handle.Init.Mode = DMA2D_M2M_BLEND; drv->handle.Init.Mode = DMA2D_M2M_BLEND;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset =
bb->dst_stride / sizeof(uint16_t) - bb->width; bb->dst_stride / sizeof(uint16_t) - bb->width;
HAL_DMA2D_Init(&dma2d_handle); HAL_DMA2D_Init(&drv->handle);
dma2d_handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_L4; drv->handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_L4;
dma2d_handle.LayerCfg[1].InputOffset = bb->src_stride * 2 - bb->width; drv->handle.LayerCfg[1].InputOffset = bb->src_stride * 2 - bb->width;
dma2d_handle.LayerCfg[1].AlphaMode = DMA2D_COMBINE_ALPHA; drv->handle.LayerCfg[1].AlphaMode = DMA2D_COMBINE_ALPHA;
dma2d_handle.LayerCfg[1].InputAlpha = bb->src_alpha; drv->handle.LayerCfg[1].InputAlpha = bb->src_alpha;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 1); HAL_DMA2D_ConfigLayer(&drv->handle, 1);
dma2d_config_clut( dma2d_config_clut(
1, gfx_color_to_color32(bb->src_fg), 1, gfx_color_to_color32(bb->src_fg),
gfx_color32_set_alpha(gfx_color_to_color32(bb->src_fg), 0)); gfx_color32_set_alpha(gfx_color_to_color32(bb->src_fg), 0));
dma2d_handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_RGB565; drv->handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_RGB565;
dma2d_handle.LayerCfg[0].InputOffset = drv->handle.LayerCfg[0].InputOffset =
bb->dst_stride / sizeof(uint16_t) - bb->width; bb->dst_stride / sizeof(uint16_t) - bb->width;
dma2d_handle.LayerCfg[0].AlphaMode = 0; drv->handle.LayerCfg[0].AlphaMode = 0;
dma2d_handle.LayerCfg[0].InputAlpha = 0; drv->handle.LayerCfg[0].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 0); HAL_DMA2D_ConfigLayer(&drv->handle, 0);
HAL_DMA2D_BlendingStart( HAL_DMA2D_BlendingStart(
&dma2d_handle, (uint32_t)bb->src_row + bb->src_x / 2, &drv->handle, (uint32_t)bb->src_row + bb->src_x / 2,
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t), bb->width, (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t), bb->width,
bb->height); bb->height);
@ -352,32 +410,37 @@ bool dma2d_rgb565_blend_mono4(const gfx_bitblt_t* params) {
} }
bool dma2d_rgb565_blend_mono8(const gfx_bitblt_t* bb) { bool dma2d_rgb565_blend_mono8(const gfx_bitblt_t* bb) {
dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return false;
}
dma2d_wait(); dma2d_wait();
if (!dma2d_accessible(bb->dst_row) || !dma2d_accessible(bb->src_row)) { if (!dma2d_accessible(bb->dst_row) || !dma2d_accessible(bb->src_row)) {
return false; return false;
} }
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_RGB565; drv->handle.Init.ColorMode = DMA2D_OUTPUT_RGB565;
dma2d_handle.Init.Mode = DMA2D_M2M_BLEND; drv->handle.Init.Mode = DMA2D_M2M_BLEND;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset = bb->dst_stride / sizeof(uint16_t) - bb->width;
HAL_DMA2D_Init(&drv->handle);
drv->handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_A8;
drv->handle.LayerCfg[1].InputOffset = bb->src_stride - bb->width;
drv->handle.LayerCfg[1].AlphaMode = 0;
drv->handle.LayerCfg[1].InputAlpha = gfx_color_to_color32(bb->src_fg);
HAL_DMA2D_ConfigLayer(&drv->handle, 1);
drv->handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_RGB565;
drv->handle.LayerCfg[0].InputOffset =
bb->dst_stride / sizeof(uint16_t) - bb->width; bb->dst_stride / sizeof(uint16_t) - bb->width;
HAL_DMA2D_Init(&dma2d_handle); drv->handle.LayerCfg[0].AlphaMode = 0;
drv->handle.LayerCfg[0].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&drv->handle, 0);
dma2d_handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_A8; HAL_DMA2D_BlendingStart(&drv->handle, (uint32_t)bb->src_row + bb->src_x,
dma2d_handle.LayerCfg[1].InputOffset = bb->src_stride - bb->width;
dma2d_handle.LayerCfg[1].AlphaMode = 0;
dma2d_handle.LayerCfg[1].InputAlpha = gfx_color_to_color32(bb->src_fg);
HAL_DMA2D_ConfigLayer(&dma2d_handle, 1);
dma2d_handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_RGB565;
dma2d_handle.LayerCfg[0].InputOffset =
bb->dst_stride / sizeof(uint16_t) - bb->width;
dma2d_handle.LayerCfg[0].AlphaMode = 0;
dma2d_handle.LayerCfg[0].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 0);
HAL_DMA2D_BlendingStart(&dma2d_handle, (uint32_t)bb->src_row + bb->src_x,
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint16_t),
bb->width, bb->height); bb->width, bb->height);
@ -386,6 +449,12 @@ bool dma2d_rgb565_blend_mono8(const gfx_bitblt_t* bb) {
} }
bool dma2d_rgba8888_fill(const gfx_bitblt_t* bb) { bool dma2d_rgba8888_fill(const gfx_bitblt_t* bb) {
dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return false;
}
dma2d_wait(); dma2d_wait();
if (!dma2d_accessible(bb->dst_row)) { if (!dma2d_accessible(bb->dst_row)) {
@ -393,38 +462,38 @@ bool dma2d_rgba8888_fill(const gfx_bitblt_t* bb) {
} }
if (bb->src_alpha == 255) { if (bb->src_alpha == 255) {
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888; drv->handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888;
dma2d_handle.Init.Mode = DMA2D_R2M; drv->handle.Init.Mode = DMA2D_R2M;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset =
bb->dst_stride / sizeof(uint32_t) - bb->width; bb->dst_stride / sizeof(uint32_t) - bb->width;
HAL_DMA2D_Init(&dma2d_handle); HAL_DMA2D_Init(&drv->handle);
HAL_DMA2D_Start(&dma2d_handle, gfx_color_to_color32(bb->src_fg), HAL_DMA2D_Start(&drv->handle, gfx_color_to_color32(bb->src_fg),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t),
bb->width, bb->height); bb->width, bb->height);
} else { } else {
#ifdef STM32U5 #ifdef STM32U5
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888; drv->handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888;
dma2d_handle.Init.Mode = DMA2D_M2M_BLEND_FG; drv->handle.Init.Mode = DMA2D_M2M_BLEND_FG;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset =
bb->dst_stride / sizeof(uint32_t) - bb->width; bb->dst_stride / sizeof(uint32_t) - bb->width;
HAL_DMA2D_Init(&dma2d_handle); HAL_DMA2D_Init(&drv->handle);
dma2d_handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_ARGB8888; drv->handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_ARGB8888;
dma2d_handle.LayerCfg[1].InputOffset = 0; drv->handle.LayerCfg[1].InputOffset = 0;
dma2d_handle.LayerCfg[1].AlphaMode = DMA2D_REPLACE_ALPHA; drv->handle.LayerCfg[1].AlphaMode = DMA2D_REPLACE_ALPHA;
dma2d_handle.LayerCfg[1].InputAlpha = bb->src_alpha; drv->handle.LayerCfg[1].InputAlpha = bb->src_alpha;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 1); HAL_DMA2D_ConfigLayer(&drv->handle, 1);
dma2d_handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_ARGB8888; drv->handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_ARGB8888;
dma2d_handle.LayerCfg[0].InputOffset = drv->handle.LayerCfg[0].InputOffset =
bb->dst_stride / sizeof(uint32_t) - bb->width; bb->dst_stride / sizeof(uint32_t) - bb->width;
dma2d_handle.LayerCfg[0].AlphaMode = 0; drv->handle.LayerCfg[0].AlphaMode = 0;
dma2d_handle.LayerCfg[0].InputAlpha = 0; drv->handle.LayerCfg[0].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 0); HAL_DMA2D_ConfigLayer(&drv->handle, 0);
HAL_DMA2D_BlendingStart( HAL_DMA2D_BlendingStart(
&dma2d_handle, gfx_color_to_color32(bb->src_fg), &drv->handle, gfx_color_to_color32(bb->src_fg),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), bb->width, (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), bb->width,
bb->height); bb->height);
@ -467,8 +536,15 @@ static void dma2d_rgba8888_copy_mono4_last_col(gfx_bitblt_t* bb,
} }
bool dma2d_rgba8888_copy_mono4(const gfx_bitblt_t* params) { bool dma2d_rgba8888_copy_mono4(const gfx_bitblt_t* params) {
const gfx_color32_t* src_gradient = NULL; dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return false;
}
dma2d_wait();
const gfx_color32_t* src_gradient = NULL;
gfx_bitblt_t bb_copy = *params; gfx_bitblt_t bb_copy = *params;
gfx_bitblt_t* bb = &bb_copy; gfx_bitblt_t* bb = &bb_copy;
@ -498,48 +574,52 @@ bool dma2d_rgba8888_copy_mono4(const gfx_bitblt_t* params) {
bb->width -= 1; bb->width -= 1;
} }
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888; drv->handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888;
dma2d_handle.Init.Mode = DMA2D_M2M_PFC; drv->handle.Init.Mode = DMA2D_M2M_PFC;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset = bb->dst_stride / sizeof(uint32_t) - bb->width;
bb->dst_stride / sizeof(uint32_t) - bb->width; HAL_DMA2D_Init(&drv->handle);
HAL_DMA2D_Init(&dma2d_handle);
dma2d_handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_L4; drv->handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_L4;
dma2d_handle.LayerCfg[1].InputOffset = bb->src_stride * 2 - bb->width; drv->handle.LayerCfg[1].InputOffset = bb->src_stride * 2 - bb->width;
dma2d_handle.LayerCfg[1].AlphaMode = 0; drv->handle.LayerCfg[1].AlphaMode = 0;
dma2d_handle.LayerCfg[1].InputAlpha = 0; drv->handle.LayerCfg[1].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 1); HAL_DMA2D_ConfigLayer(&drv->handle, 1);
dma2d_config_clut(1, gfx_color_to_color32(bb->src_fg), dma2d_config_clut(1, gfx_color_to_color32(bb->src_fg),
gfx_color_to_color32(bb->src_bg)); gfx_color_to_color32(bb->src_bg));
HAL_DMA2D_Start(&dma2d_handle, (uint32_t)bb->src_row + bb->src_x / 2, HAL_DMA2D_Start(&drv->handle, (uint32_t)bb->src_row + bb->src_x / 2,
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t),
bb->width, bb->height); bb->width, bb->height);
return true; return true;
} }
bool dma2d_rgba8888_copy_rgb565(const gfx_bitblt_t* bb) { bool dma2d_rgba8888_copy_rgb565(const gfx_bitblt_t* bb) {
dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return false;
}
dma2d_wait(); dma2d_wait();
if (!dma2d_accessible(bb->dst_row) || !dma2d_accessible(bb->src_row)) { if (!dma2d_accessible(bb->dst_row) || !dma2d_accessible(bb->src_row)) {
return false; return false;
} }
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888; drv->handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888;
dma2d_handle.Init.Mode = DMA2D_M2M_PFC; drv->handle.Init.Mode = DMA2D_M2M_PFC;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset = bb->dst_stride / sizeof(uint32_t) - bb->width;
bb->dst_stride / sizeof(uint32_t) - bb->width; HAL_DMA2D_Init(&drv->handle);
HAL_DMA2D_Init(&dma2d_handle);
dma2d_handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB565; drv->handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB565;
dma2d_handle.LayerCfg[1].InputOffset = drv->handle.LayerCfg[1].InputOffset =
bb->src_stride / sizeof(uint16_t) - bb->width; bb->src_stride / sizeof(uint16_t) - bb->width;
dma2d_handle.LayerCfg[1].AlphaMode = 0; drv->handle.LayerCfg[1].AlphaMode = 0;
dma2d_handle.LayerCfg[1].InputAlpha = 0; drv->handle.LayerCfg[1].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 1); HAL_DMA2D_ConfigLayer(&drv->handle, 1);
HAL_DMA2D_Start(&dma2d_handle, HAL_DMA2D_Start(&drv->handle,
(uint32_t)bb->src_row + bb->src_x * sizeof(uint16_t), (uint32_t)bb->src_row + bb->src_x * sizeof(uint16_t),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t),
bb->width, bb->height); bb->width, bb->height);
@ -579,6 +659,12 @@ static void dma2d_rgba8888_blend_mono4_last_col(const gfx_bitblt_t* bb) {
} }
bool dma2d_rgba8888_blend_mono4(const gfx_bitblt_t* params) { bool dma2d_rgba8888_blend_mono4(const gfx_bitblt_t* params) {
dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return false;
}
dma2d_wait(); dma2d_wait();
gfx_bitblt_t bb_copy = *params; gfx_bitblt_t bb_copy = *params;
@ -605,31 +691,31 @@ bool dma2d_rgba8888_blend_mono4(const gfx_bitblt_t* params) {
} }
if (bb->width > 0) { if (bb->width > 0) {
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888; drv->handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888;
dma2d_handle.Init.Mode = DMA2D_M2M_BLEND; drv->handle.Init.Mode = DMA2D_M2M_BLEND;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset =
bb->dst_stride / sizeof(uint32_t) - bb->width; bb->dst_stride / sizeof(uint32_t) - bb->width;
HAL_DMA2D_Init(&dma2d_handle); HAL_DMA2D_Init(&drv->handle);
dma2d_handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_L4; drv->handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_L4;
dma2d_handle.LayerCfg[1].InputOffset = bb->src_stride * 2 - bb->width; drv->handle.LayerCfg[1].InputOffset = bb->src_stride * 2 - bb->width;
dma2d_handle.LayerCfg[1].AlphaMode = DMA2D_COMBINE_ALPHA; drv->handle.LayerCfg[1].AlphaMode = DMA2D_COMBINE_ALPHA;
dma2d_handle.LayerCfg[1].InputAlpha = bb->src_alpha; drv->handle.LayerCfg[1].InputAlpha = bb->src_alpha;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 1); HAL_DMA2D_ConfigLayer(&drv->handle, 1);
dma2d_config_clut( dma2d_config_clut(
1, gfx_color_to_color32(bb->src_fg), 1, gfx_color_to_color32(bb->src_fg),
gfx_color32_set_alpha(gfx_color_to_color32(bb->src_fg), 0)); gfx_color32_set_alpha(gfx_color_to_color32(bb->src_fg), 0));
dma2d_handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_ARGB8888; drv->handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_ARGB8888;
dma2d_handle.LayerCfg[0].InputOffset = drv->handle.LayerCfg[0].InputOffset =
bb->dst_stride / sizeof(uint32_t) - bb->width; bb->dst_stride / sizeof(uint32_t) - bb->width;
dma2d_handle.LayerCfg[0].AlphaMode = 0; drv->handle.LayerCfg[0].AlphaMode = 0;
dma2d_handle.LayerCfg[0].InputAlpha = 0; drv->handle.LayerCfg[0].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 0); HAL_DMA2D_ConfigLayer(&drv->handle, 0);
HAL_DMA2D_BlendingStart( HAL_DMA2D_BlendingStart(
&dma2d_handle, (uint32_t)bb->src_row + bb->src_x / 2, &drv->handle, (uint32_t)bb->src_row + bb->src_x / 2,
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), bb->width, (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), bb->width,
bb->height); bb->height);
@ -639,32 +725,37 @@ bool dma2d_rgba8888_blend_mono4(const gfx_bitblt_t* params) {
} }
bool dma2d_rgba8888_blend_mono8(const gfx_bitblt_t* bb) { bool dma2d_rgba8888_blend_mono8(const gfx_bitblt_t* bb) {
dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return false;
}
dma2d_wait(); dma2d_wait();
if (!dma2d_accessible(bb->dst_row) || !dma2d_accessible(bb->src_row)) { if (!dma2d_accessible(bb->dst_row) || !dma2d_accessible(bb->src_row)) {
return false; return false;
} }
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888; drv->handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888;
dma2d_handle.Init.Mode = DMA2D_M2M_BLEND; drv->handle.Init.Mode = DMA2D_M2M_BLEND;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset = bb->dst_stride / sizeof(uint32_t) - bb->width;
HAL_DMA2D_Init(&drv->handle);
drv->handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_A8;
drv->handle.LayerCfg[1].InputOffset = bb->src_stride - bb->width;
drv->handle.LayerCfg[1].AlphaMode = 0;
drv->handle.LayerCfg[1].InputAlpha = gfx_color_to_color32(bb->src_fg);
HAL_DMA2D_ConfigLayer(&drv->handle, 1);
drv->handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_ARGB8888;
drv->handle.LayerCfg[0].InputOffset =
bb->dst_stride / sizeof(uint32_t) - bb->width; bb->dst_stride / sizeof(uint32_t) - bb->width;
HAL_DMA2D_Init(&dma2d_handle); drv->handle.LayerCfg[0].AlphaMode = 0;
drv->handle.LayerCfg[0].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&drv->handle, 0);
dma2d_handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_A8; HAL_DMA2D_BlendingStart(&drv->handle, (uint32_t)bb->src_row + bb->src_x,
dma2d_handle.LayerCfg[1].InputOffset = bb->src_stride - bb->width;
dma2d_handle.LayerCfg[1].AlphaMode = 0;
dma2d_handle.LayerCfg[1].InputAlpha = gfx_color_to_color32(bb->src_fg);
HAL_DMA2D_ConfigLayer(&dma2d_handle, 1);
dma2d_handle.LayerCfg[0].InputColorMode = DMA2D_INPUT_ARGB8888;
dma2d_handle.LayerCfg[0].InputOffset =
bb->dst_stride / sizeof(uint32_t) - bb->width;
dma2d_handle.LayerCfg[0].AlphaMode = 0;
dma2d_handle.LayerCfg[0].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 0);
HAL_DMA2D_BlendingStart(&dma2d_handle, (uint32_t)bb->src_row + bb->src_x,
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t),
bb->width, bb->height); bb->width, bb->height);
@ -673,26 +764,31 @@ bool dma2d_rgba8888_blend_mono8(const gfx_bitblt_t* bb) {
} }
bool dma2d_rgba8888_copy_rgba8888(const gfx_bitblt_t* bb) { bool dma2d_rgba8888_copy_rgba8888(const gfx_bitblt_t* bb) {
dma2d_driver_t* drv = &g_dma2d_driver;
if (!drv->initialized) {
return false;
}
dma2d_wait(); dma2d_wait();
if (!dma2d_accessible(bb->dst_row) || !dma2d_accessible(bb->src_row)) { if (!dma2d_accessible(bb->dst_row) || !dma2d_accessible(bb->src_row)) {
return false; return false;
} }
dma2d_handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888; drv->handle.Init.ColorMode = DMA2D_OUTPUT_ARGB8888;
dma2d_handle.Init.Mode = DMA2D_M2M_PFC; drv->handle.Init.Mode = DMA2D_M2M_PFC;
dma2d_handle.Init.OutputOffset = drv->handle.Init.OutputOffset = bb->dst_stride / sizeof(uint32_t) - bb->width;
bb->dst_stride / sizeof(uint32_t) - bb->width; HAL_DMA2D_Init(&drv->handle);
HAL_DMA2D_Init(&dma2d_handle);
dma2d_handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_ARGB8888; drv->handle.LayerCfg[1].InputColorMode = DMA2D_INPUT_ARGB8888;
dma2d_handle.LayerCfg[1].InputOffset = drv->handle.LayerCfg[1].InputOffset =
bb->src_stride / sizeof(uint32_t) - bb->width; bb->src_stride / sizeof(uint32_t) - bb->width;
dma2d_handle.LayerCfg[1].AlphaMode = 0; drv->handle.LayerCfg[1].AlphaMode = 0;
dma2d_handle.LayerCfg[1].InputAlpha = 0; drv->handle.LayerCfg[1].InputAlpha = 0;
HAL_DMA2D_ConfigLayer(&dma2d_handle, 1); HAL_DMA2D_ConfigLayer(&drv->handle, 1);
HAL_DMA2D_Start(&dma2d_handle, HAL_DMA2D_Start(&drv->handle,
(uint32_t)bb->src_row + bb->src_x * sizeof(uint32_t), (uint32_t)bb->src_row + bb->src_x * sizeof(uint32_t),
(uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t), (uint32_t)bb->dst_row + bb->dst_x * sizeof(uint32_t),
bb->width, bb->height); bb->width, bb->height);

3
core/embed/projects/firmware/main.c
View File

@ -45,6 +45,9 @@
#endif #endif
int main(uint32_t cmd, void *arg) { int main(uint32_t cmd, void *arg) {
// This call will be removed in the future with DMA2D syscalls.
gfx_bitblt_init();
if (cmd == 1) { if (cmd == 1) {
systask_postmortem_t *info = (systask_postmortem_t *)arg; systask_postmortem_t *info = (systask_postmortem_t *)arg;
rsod_gui(info); rsod_gui(info);