378 lines
11 KiB
C
378 lines
11 KiB
C
/**
|
||
* @file lv_port_disp.c
|
||
*
|
||
*/
|
||
|
||
#if 1
|
||
|
||
/*********************
|
||
* INCLUDES
|
||
*********************/
|
||
#include "lv_port_disp.h"
|
||
#include "lisa_display.h"
|
||
#include <stdlib.h>
|
||
/*********************
|
||
* DEFINES
|
||
*********************/
|
||
|
||
/**********************
|
||
* TYPEDEFS
|
||
**********************/
|
||
|
||
/**********************
|
||
* STATIC PROTOTYPES
|
||
**********************/
|
||
static void disp_flush(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p);
|
||
|
||
/**********************
|
||
* STATIC VARIABLES
|
||
**********************/
|
||
lisa_device_t *lv_display_device = NULL;
|
||
|
||
/* Display buffers */
|
||
static lv_disp_draw_buf_t disp_buf;
|
||
static lv_color_t *buf_1;
|
||
|
||
#if CONFIG_LV_DOUBLE_VDB
|
||
#include "FreeRTOS.h"
|
||
#include "task.h"
|
||
#include "queue.h"
|
||
#include "semphr.h"
|
||
|
||
static lv_color_t *buf_2;
|
||
static QueueHandle_t flush_queue;
|
||
static TaskHandle_t flush_task_handle;
|
||
static SemaphoreHandle_t flush_sem; // Add semaphore handle
|
||
|
||
typedef struct {
|
||
lv_area_t area;
|
||
lv_color_t *color_p;
|
||
lv_disp_drv_t *disp_drv;
|
||
} flush_msg_t;
|
||
|
||
static void flush_thread(void *arg)
|
||
{
|
||
flush_msg_t msg;
|
||
lisa_display_buffer_desc_t desc;
|
||
|
||
while (1) {
|
||
if (xQueueReceive(flush_queue, &msg, portMAX_DELAY) == pdTRUE) {
|
||
desc.width = msg.area.x2 - msg.area.x1 + 1;
|
||
desc.height = msg.area.y2 - msg.area.y1 + 1;
|
||
desc.pitch = desc.width * sizeof(lv_color_t);
|
||
desc.buf_size = desc.height * desc.width * sizeof(lv_color_t);
|
||
|
||
lisa_display_write(lv_display_device, msg.area.x1, msg.area.y1, &desc, msg.color_p);
|
||
|
||
xSemaphoreGive(flush_sem);
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if CONFIG_LV_CUSTOM_MONITOR
|
||
#include "lisa_log.h"
|
||
#include "csk_monitor_lv.h"
|
||
|
||
volatile uint64_t g_draw_letter_time;
|
||
volatile uint32_t g_draw_letter_call_cnt;
|
||
|
||
volatile uint64_t g_draw_image_time;
|
||
volatile uint32_t g_draw_image_call_cnt;
|
||
|
||
volatile uint64_t g_draw_rect_time;
|
||
volatile uint32_t g_draw_rect_call_cnt;
|
||
|
||
static void monitor_cb(lv_disp_drv_t * drv, uint32_t time, uint32_t px)
|
||
{
|
||
LOGI("[%s] time:%dms px:%d", __func__, time, px);
|
||
|
||
LOGI("draw letter: cnt = %d, time = %dus", g_draw_letter_call_cnt, clk_2_us(g_draw_letter_time));
|
||
g_draw_letter_time = 0;
|
||
g_draw_letter_call_cnt = 0;
|
||
|
||
LOGI("draw image: cnt = %d, time = %dus", g_draw_image_call_cnt, clk_2_us(g_draw_image_time));
|
||
g_draw_image_time = 0;
|
||
g_draw_image_call_cnt = 0;
|
||
|
||
LOGI("draw rect: cnt = %d, time = %dus", g_draw_rect_call_cnt, clk_2_us(g_draw_rect_time));
|
||
g_draw_rect_time = 0;
|
||
g_draw_rect_call_cnt = 0;
|
||
|
||
#ifdef CONFIG_LV_USE_GPU_CSK_DMA2D
|
||
LOGI("dam2d fill: cnt = %d, time = %dus, dma_time = %dus", g_dma2d_fill_call_cnt, clk_2_us(g_dma2d_fill_total_time), clk_2_us(g_dma2d_fill_dma_time));
|
||
g_dma2d_fill_total_time = 0;
|
||
g_dma2d_fill_dma_time = 0;
|
||
g_dma2d_fill_call_cnt = 0;
|
||
|
||
LOGI("dam2d copy: cnt = %d, time = %dus, dma_time = %dus", g_dma2d_copy_call_cnt, clk_2_us(g_dma2d_copy_total_time), clk_2_us(g_dma2d_copy_dma_time));
|
||
g_dma2d_copy_total_time = 0;
|
||
g_dma2d_copy_dma_time = 0;
|
||
g_dma2d_copy_call_cnt = 0;
|
||
#endif
|
||
|
||
#ifdef CONFIG_LV_USE_RPC
|
||
LOGI("rpc fill normal : cnt = %d, time = %dus, proxy_time = %dus", g_rpc_fill_normal_call_cnt, clk_2_us(g_rpc_fill_normal_total_time), clk_2_us(g_rpc_fill_normal_proxy_time));
|
||
g_rpc_fill_normal_total_time = 0;
|
||
g_rpc_fill_normal_proxy_time = 0;
|
||
g_rpc_fill_normal_call_cnt = 0;
|
||
|
||
LOGI("rpc map normal: cnt = %d, time = %dus, proxy_time = %dus", g_rpc_map_normal_call_cnt, clk_2_us(g_rpc_map_normal_total_time), clk_2_us(g_rpc_map_normal_proxy_time));
|
||
g_rpc_map_normal_total_time = 0;
|
||
g_rpc_map_normal_proxy_time = 0;
|
||
g_rpc_map_normal_call_cnt = 0;
|
||
|
||
LOGI("rpc fill blended: cnt = %d, time = %dus, proxy_time = %dus", g_rpc_fill_blended_call_cnt, clk_2_us(g_rpc_fill_blended_total_time), clk_2_us(g_rpc_fill_blended_proxy_time));
|
||
g_rpc_fill_blended_total_time = 0;
|
||
g_rpc_fill_blended_proxy_time = 0;
|
||
g_rpc_fill_blended_call_cnt = 0;
|
||
|
||
LOGI("rpc map blended: cnt = %d, time = %dus, proxy_time = %dus", g_rpc_map_blended_call_cnt, clk_2_us(g_rpc_map_blended_total_time), clk_2_us(g_rpc_map_blended_proxy_time));
|
||
g_rpc_map_blended_total_time = 0;
|
||
g_rpc_map_blended_proxy_time = 0;
|
||
g_rpc_map_blended_call_cnt = 0;
|
||
#endif
|
||
}
|
||
#endif
|
||
|
||
#if CONFIG_LV_DRIVER_PIXEL_ALIGN_SIZE > 1
|
||
static void disp_rounder(lv_disp_drv_t *disp_drv, lv_area_t *area)
|
||
{
|
||
area->y1 &= ~(CONFIG_LV_DRIVER_PIXEL_ALIGN_SIZE - 1);
|
||
area->y2 |= (CONFIG_LV_DRIVER_PIXEL_ALIGN_SIZE - 1);
|
||
area->x1 &= ~(CONFIG_LV_DRIVER_PIXEL_ALIGN_SIZE - 1);
|
||
area->x2 |= (CONFIG_LV_DRIVER_PIXEL_ALIGN_SIZE - 1);
|
||
|
||
/* Clamp to screen boundaries to prevent overflow */
|
||
lv_coord_t max_x, max_y;
|
||
if(disp_drv->rotated == LV_DISP_ROT_90 || disp_drv->rotated == LV_DISP_ROT_270) {
|
||
max_x = disp_drv->ver_res - 1;
|
||
max_y = disp_drv->hor_res - 1;
|
||
} else {
|
||
max_x = disp_drv->hor_res - 1;
|
||
max_y = disp_drv->ver_res - 1;
|
||
}
|
||
|
||
if(area->x2 > max_x) area->x2 = max_x;
|
||
if(area->y2 > max_y) area->y2 = max_y;
|
||
}
|
||
#endif
|
||
lisa_device_t *lv_port_get_display_device(void)
|
||
{
|
||
return lv_display_device;
|
||
}
|
||
|
||
void lv_port_disp_init(lisa_device_t *display_dev)
|
||
{
|
||
lisa_display_capabilities_t caps = {0};
|
||
|
||
/*-------------------------
|
||
* Initialize your display
|
||
* -----------------------*/
|
||
lv_display_device = display_dev;
|
||
if (lv_display_device == NULL) {
|
||
LV_LOG_ERROR("[%s] display device create faild", __FUNCTION__);
|
||
return;
|
||
}
|
||
|
||
lisa_display_get_capabilities(lv_display_device, &caps);
|
||
lisa_display_blanking_on(lv_display_device);
|
||
|
||
/*-----------------------------
|
||
* Create a buffer for drawing
|
||
*----------------------------*/
|
||
uint32_t size = caps.width * caps.height * sizeof(lv_color_t);
|
||
buf_1 = (lv_color_t *)lv_mem_alloc(size);
|
||
if (buf_1 == NULL) {
|
||
LV_LOG_ERROR("[%s] buf_1 malloc faild", __FUNCTION__);
|
||
return;
|
||
}
|
||
|
||
#if CONFIG_LV_DOUBLE_VDB
|
||
buf_2 = lv_mem_alloc(size);
|
||
if(buf_2 == NULL) {
|
||
LV_LOG_ERROR("[%s] lv_mem malloc faild", __FUNCTION__);
|
||
lv_mem_free(buf_1);
|
||
return;
|
||
}
|
||
|
||
/* Create message queue for flush commands */
|
||
flush_queue = xQueueCreate(2, sizeof(flush_msg_t));
|
||
if (flush_queue == NULL) {
|
||
LV_LOG_ERROR("[%s] Failed to create flush queue", __FUNCTION__);
|
||
lv_mem_free(buf_1);
|
||
lv_mem_free(buf_2);
|
||
return;
|
||
}
|
||
|
||
/* Create semaphore for flush synchronization */
|
||
flush_sem = xSemaphoreCreateBinary();
|
||
if (flush_sem == NULL) {
|
||
LV_LOG_ERROR("[%s] Failed to create flush semaphore", __FUNCTION__);
|
||
vQueueDelete(flush_queue);
|
||
lv_mem_free(buf_1);
|
||
lv_mem_free(buf_2);
|
||
return;
|
||
}
|
||
/* Initialize semaphore as available */
|
||
xSemaphoreGive(flush_sem);
|
||
|
||
/* Create flush thread */
|
||
BaseType_t ret = xTaskCreate(flush_thread, "lvgl_flush", 2048, NULL,
|
||
configMAX_PRIORITIES - 1, &flush_task_handle);
|
||
if (ret != pdPASS) {
|
||
LV_LOG_ERROR("[%s] Failed to create flush thread", __FUNCTION__);
|
||
vQueueDelete(flush_queue);
|
||
vSemaphoreDelete(flush_sem);
|
||
lv_mem_free(buf_1);
|
||
lv_mem_free(buf_2);
|
||
return;
|
||
}
|
||
|
||
lv_disp_draw_buf_init(&disp_buf, buf_1, buf_2, size / sizeof(lv_color_t));
|
||
#else
|
||
lv_disp_draw_buf_init(&disp_buf, buf_1, NULL, size / sizeof(lv_color_t));
|
||
#endif
|
||
|
||
#if 1
|
||
/*-----------------------------------
|
||
* Register the display in LVGL
|
||
*----------------------------------*/
|
||
static lv_disp_drv_t disp_drv;
|
||
lv_disp_drv_init(&disp_drv);
|
||
|
||
/*Set up the functions to access to your display*/
|
||
disp_drv.flush_cb = disp_flush;
|
||
|
||
#if CONFIG_LV_DRIVER_PIXEL_ALIGN_SIZE > 1
|
||
disp_drv.rounder_cb = disp_rounder;
|
||
#endif
|
||
|
||
#if CONFIG_LV_DRIVER_ROTATE_NORMAL
|
||
disp_drv.rotated = LV_DISP_ROT_NONE;
|
||
lisa_display_set_orientation(lv_display_device, LISA_DISPLAY_ORIENTATION_0);
|
||
#elif CONFIG_LV_DRIVER_ROTATE_90
|
||
disp_drv.rotated = LV_DISP_ROT_90;
|
||
lisa_display_set_orientation(lv_display_device, LISA_DISPLAY_ORIENTATION_90);
|
||
#elif CONFIG_LV_DRIVER_ROTATE_270
|
||
disp_drv.rotated = LV_DISP_ROT_270;
|
||
lisa_display_set_orientation(lv_display_device, LISA_DISPLAY_ORIENTATION_270);
|
||
#endif
|
||
|
||
#if CONFIG_LV_DRIVER_FULL_REFRESH
|
||
disp_drv.full_refresh = 1;
|
||
#endif
|
||
|
||
#if CONFIG_LV_CUSTOM_MONITOR
|
||
disp_drv.monitor_cb = monitor_cb;
|
||
#endif
|
||
|
||
/*Set the resolution of the display*/
|
||
disp_drv.hor_res = caps.width;
|
||
disp_drv.ver_res = caps.height;
|
||
|
||
/*Used to copy the buffer's content to the display*/
|
||
disp_drv.draw_buf = &disp_buf;
|
||
#if CONFIG_LV_COLOR_DEPTH_1
|
||
uint8_t *fb_buffer_mono = lv_mem_alloc(caps.width * caps.height / 8);
|
||
if (fb_buffer_mono == NULL) {
|
||
LV_LOG_ERROR("[%s] lv_mem malloc faild", __FUNCTION__);
|
||
} else {
|
||
disp_drv.user_data = fb_buffer_mono;
|
||
}
|
||
#endif
|
||
|
||
/*Finally register the driver*/
|
||
lv_disp_drv_register(&disp_drv);
|
||
#endif
|
||
}
|
||
|
||
#if CONFIG_LV_COLOR_DEPTH_1
|
||
|
||
int framebuffer_convert_to_mono(const void *src, void *dst, uint32_t width, uint32_t height)
|
||
{
|
||
const uint8_t *src_buf = (const uint8_t *)src;
|
||
uint8_t *dst_buf = (uint8_t *)dst;
|
||
|
||
if (src == NULL || dst == NULL || width == 0 || height == 0) {
|
||
return -1;
|
||
}
|
||
|
||
uint32_t src_pitch = width * sizeof(lv_color_t);
|
||
uint32_t dst_pitch = (width + 7) / 8; // 1bpp: 8个像素占1字节，向上取整
|
||
|
||
for (uint32_t y = 0; y < height; y++) {
|
||
for (uint32_t x = 0; x < width; x++) {
|
||
uint32_t src_idx = y * src_pitch + x * sizeof(lv_color_t);
|
||
uint32_t dst_idx = y * dst_pitch + x / 8;
|
||
uint8_t bit_pos = 7 - (x % 8);
|
||
|
||
lv_color_t color = *((lv_color_t *)(src_buf + src_idx));
|
||
if (lv_color_to1(color) == 0) {
|
||
dst_buf[dst_idx] &= ~(1 << bit_pos);
|
||
} else {
|
||
dst_buf[dst_idx] |= (1 << bit_pos);
|
||
}
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
#endif
|
||
|
||
/*Flush the content of the internal buffer the specific area on the display
|
||
*You can use DMA or any hardware acceleration to do this operation in the background but
|
||
*'lv_disp_flush_ready()' has to be called when finished.*/
|
||
static void disp_flush(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p)
|
||
{
|
||
#if CONFIG_LV_DOUBLE_VDB
|
||
flush_msg_t msg;
|
||
msg.area.x1 = area->x1;
|
||
msg.area.y1 = area->y1;
|
||
msg.area.x2 = area->x2;
|
||
msg.area.y2 = area->y2;
|
||
msg.disp_drv = disp_drv;
|
||
msg.color_p = color_p;
|
||
|
||
if (xSemaphoreTake(flush_sem, portMAX_DELAY) != pdTRUE) {
|
||
LV_LOG_ERROR("[%s] Failed to take flush semaphore", __FUNCTION__);
|
||
}
|
||
|
||
if (xQueueSend(flush_queue, &msg, portMAX_DELAY) != pdPASS) {
|
||
LV_LOG_ERROR("[%s] Failed to send flush message", __FUNCTION__);
|
||
}
|
||
|
||
lv_disp_flush_ready(msg.disp_drv);
|
||
#else
|
||
lisa_display_buffer_desc_t desc = {0};
|
||
/* Update descriptor for the current area */
|
||
desc.width = area->x2 - area->x1 + 1;
|
||
desc.height = area->y2 - area->y1 + 1;
|
||
desc.pitch = desc.width * sizeof(lv_color_t);
|
||
desc.buf_size = desc.height * desc.width * sizeof(lv_color_t);
|
||
|
||
#if CONFIG_LV_COLOR_DEPTH_1
|
||
uint8_t *fb_buffer_mono = (uint8_t *)disp_drv->user_data;
|
||
if (fb_buffer_mono == NULL) {
|
||
LV_LOG_ERROR("[%s] fb_buffer_mono is NULL", __FUNCTION__);
|
||
lv_disp_flush_ready(disp_drv);
|
||
return;
|
||
}
|
||
if (framebuffer_convert_to_mono(color_p, fb_buffer_mono, desc.width, desc.height) != 0) {
|
||
LV_LOG_ERROR("[%s] framebuffer_convert_to_mono faild", __FUNCTION__);
|
||
lv_disp_flush_ready(disp_drv);
|
||
return;
|
||
}
|
||
color_p = (lv_color_t *)fb_buffer_mono;
|
||
#endif
|
||
/* Write data to display */
|
||
lisa_display_write(lv_display_device, area->x1, area->y1, &desc, color_p);
|
||
|
||
/* IMPORTANT!!!
|
||
* Inform the graphics library that you are ready with the flushing*/
|
||
lv_disp_flush_ready(disp_drv);
|
||
#endif
|
||
}
|
||
#endif
|