libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/hpmicro/libraries/drivers/drv_lcd.c

248 lines
7.2 KiB
C
Raw Blame History

/*
* Copyright (c) 2021-2024 HPMicro
*
* SPDX-License-Identifier: BSD-3-Clause
*
* Change Logs:
* Date Author Notes
* 2024-02-20 HPMicro First version
*/
#include <rtthread.h>
#ifdef BSP_USING_RTT_LCD_DRIVER
#include "board.h"
#include "hpm_l1c_drv.h"
#include "hpm_lcdc_drv.h"
#include "hpm_pdma_drv.h"
#include "hpm_panel.h"
#define LCD_BITS_PER_PIXEL 16
#define LCD_PIXEL_FORMAT RTGRAPHIC_PIXEL_FORMAT_RGB565
#define LCD_LAYER_INDEX (0)
#define LCD_LAYER_DONE_MASK (1U << LCD_LAYER_INDEX)
struct hpm_lcd
{
LCDC_Type *lcd_base;
rt_uint8_t lcd_irq;
struct rt_semaphore lcd_lock;
char *bus_name;
struct rt_device parent;
struct rt_device_graphic_info lcd_info;
uint32_t lcd_buffer_size;
};
static rt_err_t hpm_lcd_init(struct rt_device *device);
static rt_err_t hpm_lcd_control(struct rt_device *device, int cmd, void *args);
static int hpm_lcdc_init(struct hpm_lcd *lcd, struct rt_device_graphic_info *info);
static uint8_t __attribute__((section(".framebuffer"), aligned(HPM_L1C_CACHELINE_SIZE))) lcdc_framebuffer[PANEL_SIZE_WIDTH * PANEL_SIZE_HEIGHT * LCD_BITS_PER_PIXEL / 8];
#ifdef RT_USING_DEVICE_OPS
const struct rt_device_ops hpm_lcd_ops = {
.init = hpm_lcd_init,
.open = RT_NULL,
.close = RT_NULL,
.read = RT_NULL,
.write = RT_NULL,
.control = hpm_lcd_control,
};
#endif
static struct hpm_lcd hpm_lcds[] =
{
{
.bus_name = "lcd0",
.lcd_buffer_size = (PANEL_SIZE_WIDTH * PANEL_SIZE_HEIGHT * LCD_BITS_PER_PIXEL / 8),
.lcd_base = HPM_LCDC,
.lcd_irq = BOARD_LCD_IRQ,
.parent.type = RT_Device_Class_Graphic,
#ifdef RT_USING_DEVICE_OPS
.parent.ops = &hpm_lcd_ops,
#else
.parent.init = hpm_lcd_init,
.parent.open = RT_NULL,
.parent.close = RT_NULL,
.parent.read = RT_NULL,
.parent.write = RT_NULL,
.parent.control = hpm_lcd_control,
#endif
},
};
void isr_lcd_d0(void)
{
lcdc_disable_interrupt(hpm_lcds[0].lcd_base, LCDC_INT_EN_VSYNC_MASK);
rt_sem_release(&hpm_lcds[0].lcd_lock);
lcdc_clear_status(hpm_lcds[0].lcd_base, LCDC_ST_VSYNC_MASK);
}
SDK_DECLARE_EXT_ISR_M(BOARD_LCD_IRQ, isr_lcd_d0)
static rt_err_t hpm_lcd_init(struct rt_device *device)
{
/* nothing, right now */
(void *)device;
return RT_EOK;
}
static rt_err_t hpm_lcd_control(struct rt_device *device, int cmd, void *args)
{
uint32_t aligned_start, aligned_end, aligned_size;
struct hpm_lcd *lcd = (struct hpm_lcd *)device->user_data;
hpm_panel_t *panel = hpm_panel_find_device_default();
struct rt_device_graphic_info *info = RT_NULL;
uint32_t buffer;
switch (cmd)
{
case RTGRAPHIC_CTRL_SET_MODE:
info = (struct rt_device_graphic_info *)args;
rt_sem_trytake(&lcd->lcd_lock);
lcdc_disable_interrupt(lcd->lcd_base, LCDC_INT_EN_VSYNC_MASK);
rt_thread_delay(10);
hpm_lcdc_init(lcd, info);
break;
case RTGRAPHIC_CTRL_RECT_UPDATE:
if (args != RT_NULL)
{
buffer = (uint32_t)args;
}
else
{
buffer = (uint32_t)lcd->lcd_info.framebuffer;
}
if (l1c_dc_is_enabled())
{
aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(buffer);
aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(buffer + lcd->lcd_buffer_size);
aligned_size = aligned_end - aligned_start;
l1c_dc_writeback(aligned_start, aligned_size);
}
if (lcdc_layer_control_shadow_loaded(lcd->lcd_base, 0))
{
lcdc_layer_set_next_buffer(lcd->lcd_base, 0, (rt_uint32_t)buffer);
}
break;
case RTGRAPHIC_CTRL_WAIT_VSYNC:
rt_sem_trytake(&lcd->lcd_lock);
lcdc_enable_interrupt(lcd->lcd_base, LCDC_INT_EN_VSYNC_MASK);
rt_sem_take(&lcd->lcd_lock, RT_WAITING_FOREVER);
break;
case RTGRAPHIC_CTRL_POWERON:
hpm_panel_set_backlight(panel, true);
break;
case RTGRAPHIC_CTRL_POWEROFF:
hpm_panel_set_backlight(panel, false);
break;
case RTGRAPHIC_CTRL_GET_INFO:
info = (struct rt_device_graphic_info *)args;
RT_ASSERT(info != RT_NULL);
info->pixel_format = lcd->lcd_info.pixel_format;
info->bits_per_pixel = 16;
info->width = lcd->lcd_info.width;
info->height = lcd->lcd_info.height;
info->framebuffer = lcd->lcd_info.framebuffer;
break;
default:
break;
}
}
static int hpm_lcdc_init(struct hpm_lcd *lcd, struct rt_device_graphic_info *info)
{
lcdc_config_t config = {0};
display_pixel_format_t pixel_format;
lcdc_get_default_config(lcd->lcd_base, &config);
board_panel_para_to_lcdc(&config);
if (info->framebuffer == RT_NULL)
{
return -RT_ERROR;
}
rt_memcpy(&lcd->lcd_info, info, sizeof(struct rt_device_graphic_info));
lcd->lcd_info.framebuffer = lcdc_framebuffer;
if (info->pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB565)
{
pixel_format = display_pixel_format_rgb565;
}
else if (info->pixel_format == RTGRAPHIC_PIXEL_FORMAT_ARGB888)
{
pixel_format = display_pixel_format_rgb565;
}
else {
return -RT_ERROR;
}
lcdc_init(lcd->lcd_base, &config);
memset(lcd->lcd_info.framebuffer, 0, info->width * info->height * info->bits_per_pixel / 8);
lcdc_layer_config_t layer;
lcdc_get_default_layer_config(lcd->lcd_base, &layer, pixel_format, LCD_LAYER_INDEX);
layer.position_x = 0;
layer.position_y = 0;
layer.width = info->width;
layer.height = info->height;
layer.buffer = (rt_uint32_t)lcd->lcd_info.framebuffer;
layer.background.u = 0;
if (status_success != lcdc_config_layer(lcd->lcd_base, LCD_LAYER_INDEX, &layer, true)) {
return -RT_ERROR;
}
lcdc_turn_on_display(lcd->lcd_base);
lcdc_enable_interrupt(lcd->lcd_base, LCDC_INT_EN_VSYNC_MASK);
intc_m_enable_irq_with_priority(lcd->lcd_irq, 7);
return 0;
}
int drv_lcd_hw_init(void)
{
rt_err_t result = RT_EOK;
struct rt_device_graphic_info lcd_info;
for (uint32_t i = 0; i < sizeof(hpm_lcds) / sizeof(hpm_lcds[0]); i++)
{
struct hpm_lcd *lcd = &hpm_lcds[i];
struct rt_device *device = &lcd->parent;
lcd->parent.user_data = lcd;
/* init lcd_lock semaphore */
result = rt_sem_init(&hpm_lcds[0].lcd_lock, "lcd_lock", 0, RT_IPC_FLAG_FIFO);
if (result != RT_EOK)
{
result = -RT_ENOMEM;
goto __exit;
}
/* config LCD dev info */
lcd_info.height = PANEL_SIZE_HEIGHT;
lcd_info.width = PANEL_SIZE_WIDTH;
lcd_info.bits_per_pixel = LCD_BITS_PER_PIXEL;
lcd_info.pixel_format = LCD_PIXEL_FORMAT;
lcd_info.framebuffer = lcdc_framebuffer;
/* register lcd device */
rt_device_register(device, hpm_lcds[i].bus_name, RT_DEVICE_FLAG_RDWR);
board_init_lcd();
if (hpm_lcdc_init(&hpm_lcds[i], &lcd_info) != RT_EOK)
{
result = -RT_ERROR;
goto __exit;
}
__exit:
if (result != RT_EOK)
{
rt_sem_delete(&hpm_lcds[i].lcd_lock);
}
return result;
}
}
INIT_BOARD_EXPORT(drv_lcd_hw_init);
#endif /* BSP_USING_RTT_LCD_DRIVER */
View Git Blame Copy Permalink