drv_lcd.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298
  1. /*
  2. * Copyright (c) 2006-2021, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2021-10-14 spaceman first version
  9. */
  10. #include <board.h>
  11. #ifdef BSP_USING_LCD
  12. #include <lcd_port.h>
  13. #include "lcd.h"
  14. #include "drv_gpio.h"
  15. #define DRV_DEBUG
  16. #define LOG_TAG "drv.lcd"
  17. #include <drv_log.h>
  18. #define LCD_DEVICE(dev) (struct drv_lcd_device*)(dev)
  19. static __align(256) volatile rt_uint32_t LTDC_Buf1[LCD_WIDTH * LCD_HEIGHT] = {0x00};
  20. static __align(256) volatile rt_uint32_t LTDC_Buf2[LCD_WIDTH * LCD_HEIGHT] = {0x00};
  21. struct drv_lcd_device
  22. {
  23. struct rt_device parent;
  24. struct rt_device_graphic_info lcd_info;
  25. struct rt_semaphore lcd_lock;
  26. /* 0:front_buf is being used 1: back_buf is being used*/
  27. rt_uint8_t cur_buf;
  28. rt_uint8_t *front_buf;
  29. rt_uint8_t *back_buf;
  30. };
  31. struct drv_lcd_device _lcd;
  32. static rt_err_t drv_lcd_init(struct rt_device *device)
  33. {
  34. struct drv_lcd_device *lcd = LCD_DEVICE(device);
  35. /* nothing, right now */
  36. lcd = lcd;
  37. return RT_EOK;
  38. }
  39. static rt_err_t drv_lcd_control(struct rt_device *device, int cmd, void *args)
  40. {
  41. struct drv_lcd_device *lcd = LCD_DEVICE(device);
  42. switch (cmd)
  43. {
  44. case RTGRAPHIC_CTRL_RECT_UPDATE:
  45. {
  46. /* update */
  47. if (_lcd.cur_buf)
  48. {
  49. /* back_buf is being used */
  50. _lcd.lcd_info.framebuffer = _lcd.back_buf;
  51. /* Configure the color frame buffer start address */
  52. LTDC->DP_SWT = 0;
  53. _lcd.cur_buf = 0;
  54. }
  55. else
  56. {
  57. /* front_buf is being used */
  58. _lcd.lcd_info.framebuffer = _lcd.front_buf;
  59. /* Configure the color frame buffer start address */
  60. LTDC->DP_SWT = 1;
  61. _lcd.cur_buf = 1;
  62. }
  63. rt_sem_take(&_lcd.lcd_lock, RT_TICK_PER_SECOND / 20);
  64. }
  65. break;
  66. case RTGRAPHIC_CTRL_GET_INFO:
  67. {
  68. struct rt_device_graphic_info *info = (struct rt_device_graphic_info *)args;
  69. RT_ASSERT(info != RT_NULL);
  70. info->pixel_format = lcd->lcd_info.pixel_format;
  71. info->bits_per_pixel = LCD_BITS_PER_PIXEL;
  72. info->width = lcd->lcd_info.width;
  73. info->height = lcd->lcd_info.height;
  74. info->framebuffer = lcd->lcd_info.framebuffer;
  75. }
  76. break;
  77. }
  78. return RT_EOK;
  79. }
  80. rt_err_t stm32_lcd_init(struct drv_lcd_device *lcd)
  81. {
  82. LCD_Initial((rt_uint32_t)lcd->front_buf, (rt_uint32_t)lcd->back_buf);
  83. return RT_EOK;
  84. }
  85. #if defined(LCD_BACKLIGHT_USING_PWM)
  86. void turn_on_lcd_backlight(void)
  87. {
  88. struct rt_device_pwm *pwm_dev;
  89. /* turn on the LCD backlight */
  90. pwm_dev = (struct rt_device_pwm *)rt_device_find(LCD_PWM_DEV_NAME);
  91. /* pwm frequency:100K = 10000ns */
  92. rt_pwm_set(pwm_dev, LCD_PWM_DEV_CHANNEL, 10000, 10000);
  93. rt_pwm_enable(pwm_dev, LCD_PWM_DEV_CHANNEL);
  94. }
  95. #elif defined(LCD_BACKLIGHT_USING_GPIO)
  96. void turn_on_lcd_backlight(void)
  97. {
  98. rt_pin_mode(LCD_BL_GPIO_NUM, PIN_MODE_OUTPUT);
  99. rt_pin_mode(LCD_DISP_GPIO_NUM, PIN_MODE_OUTPUT);
  100. rt_pin_write(LCD_DISP_GPIO_NUM, PIN_HIGH);
  101. rt_pin_write(LCD_BL_GPIO_NUM, PIN_HIGH);
  102. }
  103. #else
  104. void turn_on_lcd_backlight(void)
  105. {
  106. }
  107. #endif
  108. #ifdef RT_USING_DEVICE_OPS
  109. const static struct rt_device_ops lcd_ops =
  110. {
  111. drv_lcd_init,
  112. RT_NULL,
  113. RT_NULL,
  114. RT_NULL,
  115. RT_NULL,
  116. drv_lcd_control
  117. };
  118. #endif
  119. void Lcd_ColorBox(struct drv_lcd_device *lcd, rt_uint16_t xStart, rt_uint16_t yStart, rt_uint16_t xLong, rt_uint16_t yLong, rt_uint32_t Color)
  120. {
  121. rt_uint16_t i, j;
  122. rt_uint32_t temp;
  123. rt_uint32_t *LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
  124. temp = lcd->lcd_info.height * xStart;
  125. for (i = 0; i < yLong; i++)
  126. {
  127. for (j = 0; j < xLong; j++)
  128. LTDC_Buf[yStart + i + lcd->lcd_info.height * j + temp] = Color;
  129. }
  130. lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
  131. }
  132. void LCD_Fill_Pic(struct drv_lcd_device *lcd, rt_uint16_t x, rt_uint16_t y, rt_uint16_t pic_H, rt_uint16_t pic_V, rt_uint32_t *pic)
  133. {
  134. rt_uint32_t *LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
  135. rt_uint16_t i, j;
  136. rt_uint32_t Xstart, k = 0;
  137. Xstart = lcd->lcd_info.height * x;
  138. for (i = 0; i < pic_V; i++)
  139. {
  140. for (j = 0; j < pic_H; j++)
  141. LTDC_Buf[Xstart + i + lcd->lcd_info.height * j + y] = pic[k++];
  142. }
  143. }
  144. void DrawPixel(struct drv_lcd_device *lcd, rt_uint16_t x, rt_uint16_t y, int Color)
  145. {
  146. rt_uint32_t *LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
  147. LTDC_Buf[y + lcd->lcd_info.height * x] = Color;
  148. }
  149. int drv_lcd_hw_init(void)
  150. {
  151. rt_err_t result = RT_EOK;
  152. struct rt_device *device = &_lcd.parent;
  153. /* memset _lcd to zero */
  154. rt_memset(&_lcd, 0x00, sizeof(_lcd));
  155. /* init lcd_lock semaphore */
  156. result = rt_sem_init(&_lcd.lcd_lock, "lcd_lock", 0, RT_IPC_FLAG_FIFO);
  157. if (result != RT_EOK)
  158. {
  159. LOG_E("init semaphore failed!\n");
  160. result = -RT_ENOMEM;
  161. goto __exit;
  162. }
  163. /* config LCD dev info */
  164. _lcd.lcd_info.height = LCD_HEIGHT;
  165. _lcd.lcd_info.width = LCD_WIDTH;
  166. _lcd.lcd_info.bits_per_pixel = LCD_BITS_PER_PIXEL;
  167. _lcd.lcd_info.pixel_format = LCD_PIXEL_FORMAT;
  168. /* malloc memory for Triple Buffering */
  169. _lcd.back_buf = (rt_uint8_t *)LTDC_Buf1;
  170. _lcd.front_buf = (rt_uint8_t *)LTDC_Buf2;
  171. _lcd.lcd_info.framebuffer = _lcd.back_buf;
  172. if (_lcd.lcd_info.framebuffer == RT_NULL || _lcd.back_buf == RT_NULL || _lcd.front_buf == RT_NULL)
  173. {
  174. LOG_E("init frame buffer failed!\n");
  175. result = -RT_ENOMEM;
  176. goto __exit;
  177. }
  178. /* memset buff to 0xFF */
  179. rt_memset(_lcd.back_buf, 0xFF, LCD_BUF_SIZE);
  180. rt_memset(_lcd.front_buf, 0xFF, LCD_BUF_SIZE);
  181. device->type = RT_Device_Class_Graphic;
  182. #ifdef RT_USING_DEVICE_OPS
  183. device->ops = &lcd_ops;
  184. #else
  185. device->init = drv_lcd_init;
  186. device->control = drv_lcd_control;
  187. #endif
  188. /* register lcd device */
  189. rt_device_register(device, "lcd", RT_DEVICE_FLAG_RDWR);
  190. /* init stm32 LTDC */
  191. if (stm32_lcd_init(&_lcd) != RT_EOK)
  192. {
  193. result = -RT_ERROR;
  194. goto __exit;
  195. }
  196. else
  197. {
  198. turn_on_lcd_backlight();
  199. }
  200. LOG_D("lcd register successful!");
  201. __exit:
  202. if (result != RT_EOK)
  203. {
  204. rt_sem_detach(&_lcd.lcd_lock);
  205. }
  206. return result;
  207. }
  208. INIT_DEVICE_EXPORT(drv_lcd_hw_init);
  209. #ifdef DRV_DEBUG
  210. #ifdef FINSH_USING_MSH
  211. int lcd_test()
  212. {
  213. struct drv_lcd_device *lcd;
  214. lcd = (struct drv_lcd_device *)rt_device_find("lcd");
  215. if(lcd == RT_NULL)
  216. {
  217. LOG_E("find lcd device failed!\n");
  218. return -1;
  219. }
  220. rt_uint32_t *LTDC_Buf = RT_NULL;
  221. LOG_D("red");
  222. /* red */
  223. LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
  224. for (int i = 0; i < LCD_BUF_SIZE / 4; i++)
  225. LTDC_Buf[i] = Red;
  226. lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
  227. rt_thread_mdelay(1000);
  228. LOG_D("green");
  229. /* green */
  230. LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
  231. for (int i = 0; i < LCD_BUF_SIZE / 4; i++)
  232. LTDC_Buf[i] = Green;
  233. lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
  234. rt_thread_mdelay(1000);
  235. LOG_D("blue");
  236. /* blue */
  237. LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
  238. for (int i = 0; i < LCD_BUF_SIZE / 4; i++)
  239. LTDC_Buf[i] = Blue;
  240. lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
  241. return 0;
  242. }
  243. MSH_CMD_EXPORT(lcd_test, lcd_test);
  244. #endif /* FINSH_USING_MSH */
  245. #endif /* DRV_DEBUG */
  246. #endif /* BSP_USING_LCD */