drv_lcd.c 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247
  1. /*
  2. * Copyright (c) 2021-2024 HPMicro
  3. *
  4. * SPDX-License-Identifier: BSD-3-Clause
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2024-02-20 HPMicro First version
  9. */
  10. #include <rtthread.h>
  11. #ifdef BSP_USING_RTT_LCD_DRIVER
  12. #include "board.h"
  13. #include "hpm_l1c_drv.h"
  14. #include "hpm_lcdc_drv.h"
  15. #include "hpm_pdma_drv.h"
  16. #include "hpm_panel.h"
  17. #define LCD_BITS_PER_PIXEL 16
  18. #define LCD_PIXEL_FORMAT RTGRAPHIC_PIXEL_FORMAT_RGB565
  19. #define LCD_LAYER_INDEX (0)
  20. #define LCD_LAYER_DONE_MASK (1U << LCD_LAYER_INDEX)
  21. struct hpm_lcd
  22. {
  23. LCDC_Type *lcd_base;
  24. rt_uint8_t lcd_irq;
  25. struct rt_semaphore lcd_lock;
  26. char *bus_name;
  27. struct rt_device parent;
  28. struct rt_device_graphic_info lcd_info;
  29. uint32_t lcd_buffer_size;
  30. };
  31. static rt_err_t hpm_lcd_init(struct rt_device *device);
  32. static rt_err_t hpm_lcd_control(struct rt_device *device, int cmd, void *args);
  33. static int hpm_lcdc_init(struct hpm_lcd *lcd, struct rt_device_graphic_info *info);
  34. static uint8_t __attribute__((section(".framebuffer"), aligned(HPM_L1C_CACHELINE_SIZE))) lcdc_framebuffer[PANEL_SIZE_WIDTH * PANEL_SIZE_HEIGHT * LCD_BITS_PER_PIXEL / 8];
  35. #ifdef RT_USING_DEVICE_OPS
  36. const struct rt_device_ops hpm_lcd_ops = {
  37. .init = hpm_lcd_init,
  38. .open = RT_NULL,
  39. .close = RT_NULL,
  40. .read = RT_NULL,
  41. .write = RT_NULL,
  42. .control = hpm_lcd_control,
  43. };
  44. #endif
  45. static struct hpm_lcd hpm_lcds[] =
  46. {
  47. {
  48. .bus_name = "lcd0",
  49. .lcd_buffer_size = (PANEL_SIZE_WIDTH * PANEL_SIZE_HEIGHT * LCD_BITS_PER_PIXEL / 8),
  50. .lcd_base = HPM_LCDC,
  51. .lcd_irq = BOARD_LCD_IRQ,
  52. .parent.type = RT_Device_Class_Graphic,
  53. #ifdef RT_USING_DEVICE_OPS
  54. .parent.ops = &hpm_lcd_ops,
  55. #else
  56. .parent.init = hpm_lcd_init,
  57. .parent.open = RT_NULL,
  58. .parent.close = RT_NULL,
  59. .parent.read = RT_NULL,
  60. .parent.write = RT_NULL,
  61. .parent.control = hpm_lcd_control,
  62. #endif
  63. },
  64. };
  65. void isr_lcd_d0(void)
  66. {
  67. lcdc_disable_interrupt(hpm_lcds[0].lcd_base, LCDC_INT_EN_VSYNC_MASK);
  68. rt_sem_release(&hpm_lcds[0].lcd_lock);
  69. lcdc_clear_status(hpm_lcds[0].lcd_base, LCDC_ST_VSYNC_MASK);
  70. }
  71. SDK_DECLARE_EXT_ISR_M(BOARD_LCD_IRQ, isr_lcd_d0)
  72. static rt_err_t hpm_lcd_init(struct rt_device *device)
  73. {
  74. /* nothing, right now */
  75. (void *)device;
  76. return RT_EOK;
  77. }
  78. static rt_err_t hpm_lcd_control(struct rt_device *device, int cmd, void *args)
  79. {
  80. uint32_t aligned_start, aligned_end, aligned_size;
  81. struct hpm_lcd *lcd = (struct hpm_lcd *)device->user_data;
  82. hpm_panel_t *panel = hpm_panel_find_device_default();
  83. struct rt_device_graphic_info *info = RT_NULL;
  84. uint32_t buffer;
  85. switch (cmd)
  86. {
  87. case RTGRAPHIC_CTRL_SET_MODE:
  88. info = (struct rt_device_graphic_info *)args;
  89. rt_sem_trytake(&lcd->lcd_lock);
  90. lcdc_disable_interrupt(lcd->lcd_base, LCDC_INT_EN_VSYNC_MASK);
  91. rt_thread_delay(10);
  92. hpm_lcdc_init(lcd, info);
  93. break;
  94. case RTGRAPHIC_CTRL_RECT_UPDATE:
  95. if (args != RT_NULL)
  96. {
  97. buffer = (uint32_t)args;
  98. }
  99. else
  100. {
  101. buffer = (uint32_t)lcd->lcd_info.framebuffer;
  102. }
  103. if (l1c_dc_is_enabled())
  104. {
  105. aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(buffer);
  106. aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(buffer + lcd->lcd_buffer_size);
  107. aligned_size = aligned_end - aligned_start;
  108. l1c_dc_writeback(aligned_start, aligned_size);
  109. }
  110. if (lcdc_layer_control_shadow_loaded(lcd->lcd_base, 0))
  111. {
  112. lcdc_layer_set_next_buffer(lcd->lcd_base, 0, (rt_uint32_t)buffer);
  113. }
  114. break;
  115. case RTGRAPHIC_CTRL_WAIT_VSYNC:
  116. rt_sem_trytake(&lcd->lcd_lock);
  117. lcdc_enable_interrupt(lcd->lcd_base, LCDC_INT_EN_VSYNC_MASK);
  118. rt_sem_take(&lcd->lcd_lock, RT_WAITING_FOREVER);
  119. break;
  120. case RTGRAPHIC_CTRL_POWERON:
  121. hpm_panel_set_backlight(panel, true);
  122. break;
  123. case RTGRAPHIC_CTRL_POWEROFF:
  124. hpm_panel_set_backlight(panel, false);
  125. break;
  126. case RTGRAPHIC_CTRL_GET_INFO:
  127. info = (struct rt_device_graphic_info *)args;
  128. RT_ASSERT(info != RT_NULL);
  129. info->pixel_format = lcd->lcd_info.pixel_format;
  130. info->bits_per_pixel = 16;
  131. info->width = lcd->lcd_info.width;
  132. info->height = lcd->lcd_info.height;
  133. info->framebuffer = lcd->lcd_info.framebuffer;
  134. break;
  135. default:
  136. break;
  137. }
  138. }
  139. static int hpm_lcdc_init(struct hpm_lcd *lcd, struct rt_device_graphic_info *info)
  140. {
  141. lcdc_config_t config = {0};
  142. display_pixel_format_t pixel_format;
  143. lcdc_get_default_config(lcd->lcd_base, &config);
  144. board_panel_para_to_lcdc(&config);
  145. if (info->framebuffer == RT_NULL)
  146. {
  147. return -RT_ERROR;
  148. }
  149. rt_memcpy(&lcd->lcd_info, info, sizeof(struct rt_device_graphic_info));
  150. lcd->lcd_info.framebuffer = lcdc_framebuffer;
  151. if (info->pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB565)
  152. {
  153. pixel_format = display_pixel_format_rgb565;
  154. }
  155. else if (info->pixel_format == RTGRAPHIC_PIXEL_FORMAT_ARGB888)
  156. {
  157. pixel_format = display_pixel_format_rgb565;
  158. }
  159. else {
  160. return -RT_ERROR;
  161. }
  162. lcdc_init(lcd->lcd_base, &config);
  163. memset(lcd->lcd_info.framebuffer, 0, info->width * info->height * info->bits_per_pixel / 8);
  164. lcdc_layer_config_t layer;
  165. lcdc_get_default_layer_config(lcd->lcd_base, &layer, pixel_format, LCD_LAYER_INDEX);
  166. layer.position_x = 0;
  167. layer.position_y = 0;
  168. layer.width = info->width;
  169. layer.height = info->height;
  170. layer.buffer = (rt_uint32_t)lcd->lcd_info.framebuffer;
  171. layer.background.u = 0;
  172. if (status_success != lcdc_config_layer(lcd->lcd_base, LCD_LAYER_INDEX, &layer, true)) {
  173. return -RT_ERROR;
  174. }
  175. lcdc_turn_on_display(lcd->lcd_base);
  176. lcdc_enable_interrupt(lcd->lcd_base, LCDC_INT_EN_VSYNC_MASK);
  177. intc_m_enable_irq_with_priority(lcd->lcd_irq, 7);
  178. return 0;
  179. }
  180. int drv_lcd_hw_init(void)
  181. {
  182. rt_err_t result = RT_EOK;
  183. struct rt_device_graphic_info lcd_info;
  184. for (uint32_t i = 0; i < sizeof(hpm_lcds) / sizeof(hpm_lcds[0]); i++)
  185. {
  186. struct hpm_lcd *lcd = &hpm_lcds[i];
  187. struct rt_device *device = &lcd->parent;
  188. lcd->parent.user_data = lcd;
  189. /* init lcd_lock semaphore */
  190. result = rt_sem_init(&hpm_lcds[0].lcd_lock, "lcd_lock", 0, RT_IPC_FLAG_FIFO);
  191. if (result != RT_EOK)
  192. {
  193. result = -RT_ENOMEM;
  194. goto __exit;
  195. }
  196. /* config LCD dev info */
  197. lcd_info.height = PANEL_SIZE_HEIGHT;
  198. lcd_info.width = PANEL_SIZE_WIDTH;
  199. lcd_info.bits_per_pixel = LCD_BITS_PER_PIXEL;
  200. lcd_info.pixel_format = LCD_PIXEL_FORMAT;
  201. lcd_info.framebuffer = lcdc_framebuffer;
  202. /* register lcd device */
  203. rt_device_register(device, hpm_lcds[i].bus_name, RT_DEVICE_FLAG_RDWR);
  204. board_init_lcd();
  205. if (hpm_lcdc_init(&hpm_lcds[i], &lcd_info) != RT_EOK)
  206. {
  207. result = -RT_ERROR;
  208. goto __exit;
  209. }
  210. __exit:
  211. if (result != RT_EOK)
  212. {
  213. rt_sem_delete(&hpm_lcds[i].lcd_lock);
  214. }
  215. return result;
  216. }
  217. }
  218. INIT_BOARD_EXPORT(drv_lcd_hw_init);
  219. #endif /* BSP_USING_RTT_LCD_DRIVER */