-
Notifications
You must be signed in to change notification settings - Fork 45
/
lvgl.c
373 lines (306 loc) · 9.32 KB
/
lvgl.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
/*
* Copyright (c) 2018-2019 Jan Van Winkel <jan.van_winkel@dxplore.eu>
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <init.h>
#include <zephyr.h>
#include <lvgl.h>
#include "lvgl_display.h"
#ifdef CONFIG_LV_Z_USE_FILESYSTEM
#include "lvgl_fs.h"
#endif
#ifdef CONFIG_LV_Z_POINTER_KSCAN
#include <drivers/kscan.h>
#endif
#include LV_MEM_CUSTOM_INCLUDE
#define LOG_LEVEL CONFIG_LV_LOG_LEVEL
#include <logging/log.h>
LOG_MODULE_REGISTER(lvgl);
static lv_disp_drv_t disp_drv;
#ifdef CONFIG_LV_Z_POINTER_KSCAN
static lv_indev_drv_t indev_drv;
#endif /* CONFIG_LV_Z_POINTER_KSCAN */
#ifdef CONFIG_LV_Z_BUFFER_ALLOC_STATIC
static lv_disp_draw_buf_t disp_buf;
#define BUFFER_SIZE (CONFIG_LV_Z_BITS_PER_PIXEL * ((CONFIG_LV_Z_VDB_SIZE * \
CONFIG_LV_Z_HOR_RES_MAX * CONFIG_LV_Z_VER_RES_MAX) / 100) / 8)
#define NBR_PIXELS_IN_BUFFER (BUFFER_SIZE * 8 / CONFIG_LV_Z_BITS_PER_PIXEL)
/* NOTE: depending on chosen color depth buffer may be accessed using uint8_t *,
* uint16_t * or uint32_t *, therefore buffer needs to be aligned accordingly to
* prevent unaligned memory accesses.
*/
static uint8_t buf0[BUFFER_SIZE] __aligned(4);
#ifdef CONFIG_LV_Z_DOUBLE_VDB
static uint8_t buf1[BUFFER_SIZE] __aligned(4);
#endif
#endif /* CONFIG_LV_Z_BUFFER_ALLOC_STATIC */
#if CONFIG_LV_LOG_LEVEL != 0
/*
* In LVGLv8 the signature of the logging callback has changes and it no longer
* takes the log level as an integer argument. Instead, the log level is now
* already part of the buffer passed to the logging callback. It's not optimal
* but we need to live with it and parse the buffer manually to determine the
* level and then truncate the string we actually pass to the logging framework.
*/
static void lvgl_log(const char *buf)
{
/*
* This is ugly and should be done in a loop or something but as it
* turned out, Z_LOG()'s first argument (that specifies the log level)
* cannot be an l-value...
*
* We also assume lvgl is sane and always supplies the level string.
*/
switch (buf[1]) {
case 'E':
LOG_ERR("%s", log_strdup(buf + strlen("[Error] ")));
break;
case 'W':
LOG_WRN("%s", log_strdup(buf + strlen("Warn] ")));
break;
case 'I':
LOG_INF("%s", log_strdup(buf + strlen("[Info] ")));
break;
case 'T':
LOG_DBG("%s", log_strdup(buf + strlen("[Trace] ")));
break;
}
}
#endif
#ifdef CONFIG_LV_Z_BUFFER_ALLOC_STATIC
static int lvgl_allocate_rendering_buffers(lv_disp_drv_t *disp_drv)
{
struct display_capabilities cap;
const struct device *display_dev = (const struct device *)disp_drv->user_data;
int err = 0;
display_get_capabilities(display_dev, &cap);
if (cap.x_resolution <= CONFIG_LV_Z_HOR_RES_MAX) {
disp_drv->hor_res = cap.x_resolution;
} else {
LOG_ERR("Horizontal resolution is larger than maximum");
err = -ENOTSUP;
}
if (cap.y_resolution <= CONFIG_LV_Z_VER_RES_MAX) {
disp_drv->ver_res = cap.y_resolution;
} else {
LOG_ERR("Vertical resolution is larger than maximum");
err = -ENOTSUP;
}
disp_drv->draw_buf = &disp_buf;
#ifdef CONFIG_LV_Z_DOUBLE_VDB
lv_disp_draw_buf_init(disp_drv->draw_buf, &buf0, &buf1, NBR_PIXELS_IN_BUFFER);
#else
lv_disp_draw_buf_init(disp_drv->draw_buf, &buf0, NULL, NBR_PIXELS_IN_BUFFER);
#endif /* CONFIG_LV_Z_DOUBLE_VDB */
return err;
}
#else
static int lvgl_allocate_rendering_buffers(lv_disp_drv_t *disp_drv)
{
void *buf0 = NULL;
void *buf1 = NULL;
uint16_t buf_nbr_pixels;
uint32_t buf_size;
struct display_capabilities cap;
const struct device *display_dev = (const struct device *)disp_drv->user_data;
display_get_capabilities(display_dev, &cap);
disp_drv->hor_res = cap.x_resolution;
disp_drv->ver_res = cap.y_resolution;
buf_nbr_pixels = (CONFIG_LV_Z_VDB_SIZE * disp_drv->hor_res *
disp_drv->ver_res) / 100;
/* one horizontal line is the minimum buffer requirement for lvgl */
if (buf_nbr_pixels < disp_drv->hor_res) {
buf_nbr_pixels = disp_drv->hor_res;
}
switch (cap.current_pixel_format) {
case PIXEL_FORMAT_ARGB_8888:
buf_size = 4 * buf_nbr_pixels;
break;
case PIXEL_FORMAT_RGB_888:
buf_size = 3 * buf_nbr_pixels;
break;
case PIXEL_FORMAT_RGB_565:
buf_size = 2 * buf_nbr_pixels;
break;
case PIXEL_FORMAT_MONO01:
case PIXEL_FORMAT_MONO10:
buf_size = buf_nbr_pixels / 8;
buf_size += (buf_nbr_pixels % 8) == 0 ? 0 : 1;
break;
default:
return -ENOTSUP;
}
buf0 = LV_MEM_CUSTOM_ALLOC(buf_size);
if (buf0 == NULL) {
LOG_ERR("Failed to allocate memory for rendering buffer");
return -ENOMEM;
}
#ifdef CONFIG_LV_Z_DOUBLE_VDB
buf1 = LV_MEM_CUSTOM_ALLOC(buf_size);
if (buf1 == NULL) {
LV_MEM_CUSTOM_FREE(buf0);
LOG_ERR("Failed to allocate memory for rendering buffer");
return -ENOMEM;
}
#endif
disp_drv->draw_buf = LV_MEM_CUSTOM_ALLOC(sizeof(lv_disp_draw_buf_t));
if (disp_drv->draw_buf == NULL) {
LV_MEM_CUSTOM_FREE(buf0);
LV_MEM_CUSTOM_FREE(buf1);
LOG_ERR("Failed to allocate memory to store rendering buffers");
return -ENOMEM;
}
lv_disp_draw_buf_init(disp_drv->draw_buf, buf0, buf1, buf_nbr_pixels);
return 0;
}
#endif /* CONFIG_LV_Z_BUFFER_ALLOC_STATIC */
#ifdef CONFIG_LV_Z_POINTER_KSCAN
K_MSGQ_DEFINE(kscan_msgq, sizeof(lv_indev_data_t),
CONFIG_LV_Z_POINTER_KSCAN_MSGQ_COUNT, 4);
static void lvgl_pointer_kscan_callback(const struct device *dev,
uint32_t row,
uint32_t col, bool pressed)
{
lv_indev_data_t data = {
.point.x = col,
.point.y = row,
.state = pressed ? LV_INDEV_STATE_PR : LV_INDEV_STATE_REL,
};
if (k_msgq_put(&kscan_msgq, &data, K_NO_WAIT) != 0) {
LOG_DBG("Could not put input data into queue");
}
}
static void lvgl_pointer_kscan_read(lv_indev_drv_t *drv, lv_indev_data_t *data)
{
lv_disp_t *disp;
const struct device *disp_dev;
struct display_capabilities cap;
lv_indev_data_t curr;
static lv_indev_data_t prev = {
.point.x = 0,
.point.y = 0,
.state = LV_INDEV_STATE_REL,
};
if (k_msgq_get(&kscan_msgq, &curr, K_NO_WAIT) != 0) {
goto set_and_release;
}
prev = curr;
disp = lv_disp_get_default();
disp_dev = disp->driver->user_data;
display_get_capabilities(disp_dev, &cap);
/* adjust kscan coordinates */
if (IS_ENABLED(CONFIG_LV_Z_POINTER_KSCAN_SWAP_XY)) {
lv_coord_t x;
x = prev.point.x;
prev.point.x = prev.point.y;
prev.point.y = x;
}
if (IS_ENABLED(CONFIG_LV_Z_POINTER_KSCAN_INVERT_X)) {
if (cap.current_orientation == DISPLAY_ORIENTATION_NORMAL ||
cap.current_orientation == DISPLAY_ORIENTATION_ROTATED_180) {
prev.point.x = cap.x_resolution - prev.point.x;
} else {
prev.point.x = cap.y_resolution - prev.point.x;
}
}
if (IS_ENABLED(CONFIG_LV_Z_POINTER_KSCAN_INVERT_Y)) {
if (cap.current_orientation == DISPLAY_ORIENTATION_NORMAL ||
cap.current_orientation == DISPLAY_ORIENTATION_ROTATED_180) {
prev.point.y = cap.y_resolution - prev.point.y;
} else {
prev.point.y = cap.x_resolution - prev.point.y;
}
}
/* rotate touch point to match display rotation */
if (cap.current_orientation == DISPLAY_ORIENTATION_ROTATED_90) {
lv_coord_t x;
x = prev.point.x;
prev.point.x = prev.point.y;
prev.point.y = cap.y_resolution - x;
} else if (cap.current_orientation == DISPLAY_ORIENTATION_ROTATED_180) {
prev.point.x = cap.x_resolution - prev.point.x;
prev.point.y = cap.y_resolution - prev.point.y;
} else if (cap.current_orientation == DISPLAY_ORIENTATION_ROTATED_270) {
lv_coord_t x;
x = prev.point.x;
prev.point.x = cap.x_resolution - prev.point.y;
prev.point.y = x;
}
/* filter readings within display */
if (prev.point.x <= 0) {
prev.point.x = 0;
}
else if (prev.point.x >= cap.x_resolution) {
prev.point.x = cap.x_resolution - 1;
}
if (prev.point.y <= 0) {
prev.point.y = 0;
}
else if (prev.point.y >= cap.y_resolution) {
prev.point.y = cap.y_resolution - 1;
}
set_and_release:
*data = prev;
k_msgq_num_used_get(&kscan_msgq);
}
static int lvgl_pointer_kscan_init(void)
{
const struct device *kscan_dev =
device_get_binding(CONFIG_LV_Z_POINTER_KSCAN_DEV_NAME);
if (kscan_dev == NULL) {
LOG_ERR("Keyboard scan device not found.");
return -ENODEV;
}
if (kscan_config(kscan_dev, lvgl_pointer_kscan_callback) < 0) {
LOG_ERR("Could not configure keyboard scan device.");
return -ENODEV;
}
lv_indev_drv_init(&indev_drv);
indev_drv.type = LV_INDEV_TYPE_POINTER;
indev_drv.read_cb = lvgl_pointer_kscan_read;
if (lv_indev_drv_register(&indev_drv) == NULL) {
LOG_ERR("Failed to register input device.");
return -EPERM;
}
kscan_enable_callback(kscan_dev);
return 0;
}
#endif /* CONFIG_LV_Z_POINTER_KSCAN */
static int lvgl_init(const struct device *dev)
{
ARG_UNUSED(dev);
const struct device *display_dev =
device_get_binding(CONFIG_LV_Z_DISPLAY_DEV_NAME);
int err = 0;
if (display_dev == NULL) {
LOG_ERR("Display device not found.");
return -ENODEV;
}
#if CONFIG_LV_LOG_LEVEL != 0
lv_log_register_print_cb(lvgl_log);
#endif
lv_init();
#ifdef CONFIG_LV_Z_USE_FILESYSTEM
lvgl_fs_init();
#endif
lv_disp_drv_init(&disp_drv);
disp_drv.user_data = (void *) display_dev;
err = lvgl_allocate_rendering_buffers(&disp_drv);
if (err != 0) {
return err;
}
if (set_lvgl_rendering_cb(&disp_drv) != 0) {
LOG_ERR("Display not supported.");
return -ENOTSUP;
}
if (lv_disp_drv_register(&disp_drv) == NULL) {
LOG_ERR("Failed to register display device.");
return -EPERM;
}
#ifdef CONFIG_LV_Z_POINTER_KSCAN
lvgl_pointer_kscan_init();
#endif /* CONFIG_LV_Z_POINTER_KSCAN */
return 0;
}
SYS_INIT(lvgl_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);