1 /*
2 * Copyright (c) 2022 HiSilicon (Shanghai) Technologies CO., LIMITED.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #ifndef __HIFB_H__
17 #define __HIFB_H__
18
19 #ifdef __HuaweiLite__
20 #include <fb.h>
21 #include <linux/wait.h>
22 #include "stdlib.h"
23 #include <linux/workqueue.h>
24 #include <linux/kernel.h>
25 #include <linux/device.h>
26 #include "liteos/fb.h"
27 #else
28 #include <linux/fb.h>
29 #endif
30
31 #include "hi_type.h"
32 #include "hi_common.h"
33
34 #ifdef __cplusplus
35 #if __cplusplus
36 extern "C" {
37 #endif
38 #endif /* __cplusplus */
39
40 #define IOC_TYPE_HIFB 'F'
41 /* To obtain the colorkey of an overlay layer */
42 #define FBIOGET_COLORKEY_HIFB _IOR(IOC_TYPE_HIFB, 90, HIFB_COLORKEY_S)
43 /* To set the colorkey of an overlay layer */
44 #define FBIOPUT_COLORKEY_HIFB _IOW(IOC_TYPE_HIFB, 91, HIFB_COLORKEY_S)
45 /* To get the alpha of an overlay layer */
46 #define FBIOGET_ALPHA_HIFB _IOR(IOC_TYPE_HIFB, 92, HIFB_ALPHA_S)
47 /* To set the alpha of an overlay layer */
48 #define FBIOPUT_ALPHA_HIFB _IOW(IOC_TYPE_HIFB, 93, HIFB_ALPHA_S)
49 /* To get the origin of an overlay layer on the screen */
50 #define FBIOGET_SCREEN_ORIGIN_HIFB _IOR(IOC_TYPE_HIFB, 94, HIFB_POINT_S)
51 /* To set the origin of an overlay layer on the screen */
52 #define FBIOPUT_SCREEN_ORIGIN_HIFB _IOW(IOC_TYPE_HIFB, 95, HIFB_POINT_S)
53 /* To obtain the anti-flicker setting of an overlay layer */
54 #define FBIOGET_DEFLICKER_HIFB _IOR(IOC_TYPE_HIFB, 98, HIFB_DEFLICKER_S)
55 /* To set the anti-flicker setting of an overlay layer */
56 #define FBIOPUT_DEFLICKER_HIFB _IOW(IOC_TYPE_HIFB, 99, HIFB_DEFLICKER_S)
57 /* To wait for the vertical blanking region of an overlay layer */
58 #define FBIOGET_VBLANK_HIFB _IO(IOC_TYPE_HIFB, 100)
59 /* To set the display state of an overlay layer */
60 #define FBIOPUT_SHOW_HIFB _IOW(IOC_TYPE_HIFB, 101, HI_BOOL)
61 /* To obtain the display state of an overlay layer */
62 #define FBIOGET_SHOW_HIFB _IOR(IOC_TYPE_HIFB, 102, HI_BOOL)
63 /* to obtain the capability of an overlay layer */
64 #define FBIOGET_CAPABILITY_HIFB _IOR(IOC_TYPE_HIFB, 103, HIFB_CAPABILITY_S)
65 /* set the screen output size */
66 #define FBIOPUT_SCREENSIZE _IOW(IOC_TYPE_HIFB, 130, HIFB_SIZE_S)
67 /* get the screen output size */
68 #define FBIOGET_SCREENSIZE _IOR(IOC_TYPE_HIFB, 131, HIFB_SIZE_S)
69
70 /* To display multiple surfaces in turn and set the alpha and colorkey attributes */
71 #define FBIOFLIP_SURFACE _IOW(IOC_TYPE_HIFB, 132, HIFB_SURFACEEX_S)
72
73 /* To set the compression function status of an overlay layer */
74 #define FBIOPUT_COMPRESSION_HIFB _IOW(IOC_TYPE_HIFB, 133, HI_BOOL)
75 /* To obtain the compression function status of an overlay layer */
76 #define FBIOGET_COMPRESSION_HIFB _IOR(IOC_TYPE_HIFB, 134, HI_BOOL)
77
78 /* To set the hdr function status of an overlay layer */
79 #define FBIOPUT_DYNAMIC_RANGE_HIFB _IOW(IOC_TYPE_HIFB, 139, HIFB_DYNAMIC_RANGE_E)
80 /* To get the hdr function status of an overlay layer */
81 #define FBIOGET_DYNAMIC_RANGE_HIFB _IOR(IOC_TYPE_HIFB, 140, HIFB_DYNAMIC_RANGE_E)
82
83 /* To create the layer */
84 #define FBIO_CREATE_LAYER _IO(IOC_TYPE_HIFB, 149)
85 /* To destroy the layer */
86 #define FBIO_DESTROY_LAYER _IO(IOC_TYPE_HIFB, 150)
87
88 typedef struct {
89 HI_U32 u32Width;
90 HI_U32 u32Height;
91 } HIFB_SIZE_S;
92
93 #ifndef __HuaweiLite__
hifb_rgb(const struct fb_bitfield * pBit,HI_S32 color)94 static inline HI_U8 hifb_rgb(const struct fb_bitfield *pBit, HI_S32 color)
95 {
96 return ((HI_U8)((((HI_U32)color) >> pBit->offset) << (8 - pBit->length)) + /* 8 Digits to flip */
97 ((HI_U8)(((HI_U32)(color) >> pBit->offset) << (8 - pBit->length)) >> pBit->length)); /* 8 Digits to flip */
98 }
99
hifb_color2key(const struct fb_var_screeninfo * pVar,HI_S32 color)100 static inline HI_S32 hifb_color2key(const struct fb_var_screeninfo *pVar, HI_S32 color)
101 {
102 if (pVar->bits_per_pixel <= 8) { /* 8 left shift */
103 return color;
104 } else {
105 HI_U8 r, g, b;
106 r = hifb_rgb(&pVar->red, color);
107 g = hifb_rgb(&pVar->green, color);
108 b = hifb_rgb(&pVar->blue, color);
109 return (r << 16) + (g << 8) + b; /* left shift altitude 16 8 */
110 }
111 }
112 #endif
113
114 typedef enum {
115 HIFB_DYNAMIC_RANGE_SDR8 = 0,
116 HIFB_DYNAMIC_RANGE_SDR10,
117 HIFB_DYNAMIC_RANGE_HDR10,
118 HIFB_DYNAMIC_RANGE_HLG,
119 HIFB_DYNAMIC_RANGE_SLF,
120 HIFB_DYNAMIC_RANGE_BUTT
121 } HIFB_DYNAMIC_RANGE_E;
122
123 typedef struct {
124 HI_BOOL bKeyEnable; /* colorkey enable flag */
125 HI_U32 u32Key; /* colorkey value, maybe contains alpha */
126 } HIFB_COLORKEY_S;
127
128 typedef struct {
129 HI_S32 x;
130 HI_S32 y;
131 HI_S32 w;
132 HI_S32 h;
133 } HIFB_RECT;
134
135 typedef struct {
136 HI_S32 s32XPos; /* horizontal position */
137 HI_S32 s32YPos; /* vertical position */
138 } HIFB_POINT_S;
139
140 typedef struct {
141 HI_U32 u32HDfLevel; /* horizontal deflicker level */
142 HI_U32 u32VDfLevel; /* vertical deflicker level */
143 HI_U8 ATTRIBUTE *pu8HDfCoef; /* horizontal deflicker coefficient */
144 HI_U8 ATTRIBUTE *pu8VDfCoef; /* vertical deflicker coefficient */
145 } HIFB_DEFLICKER_S;
146
147 /* Alpha info */
148 typedef struct {
149 HI_BOOL bAlphaEnable; /* alpha enable flag */
150 HI_BOOL bAlphaChannel; /* alpha channel enable flag */
151 HI_U8 u8Alpha0; /* alpha0 value, used in ARGB1555 */
152 HI_U8 u8Alpha1; /* alpha1 value, used in ARGB1555 */
153 HI_U8 u8GlobalAlpha; /* global alpha value */
154 HI_U8 u8Reserved;
155 } HIFB_ALPHA_S;
156
157 typedef enum {
158 HIFB_FMT_RGB565 = 0,
159 HIFB_FMT_RGB888, /* RGB888 24bpp */
160
161 HIFB_FMT_KRGB444, /* RGB444 16bpp */
162 HIFB_FMT_KRGB555, /* RGB555 16bpp */
163 HIFB_FMT_KRGB888, /* RGB888 32bpp */
164
165 HIFB_FMT_ARGB4444, /* ARGB4444 */
166 HIFB_FMT_ARGB1555, /* ARGB1555 */
167 HIFB_FMT_ARGB8888, /* ARGB8888 */
168 HIFB_FMT_ARGB8565, /* ARGB8565 */
169
170 HIFB_FMT_RGBA4444, /* ARGB4444 */
171 HIFB_FMT_RGBA5551, /* RGBA5551 */
172 HIFB_FMT_RGBA5658, /* RGBA5658 */
173 HIFB_FMT_RGBA8888, /* RGBA8888 */
174
175 HIFB_FMT_BGR565, /* BGR565 */
176 HIFB_FMT_BGR888, /* BGR888 */
177 HIFB_FMT_ABGR4444, /* ABGR4444 */
178 HIFB_FMT_ABGR1555, /* ABGR1555 */
179 HIFB_FMT_ABGR8888, /* ABGR8888 */
180 HIFB_FMT_ABGR8565, /* ABGR8565 */
181 HIFB_FMT_KBGR444, /* BGR444 16bpp */
182 HIFB_FMT_KBGR555, /* BGR555 16bpp */
183 HIFB_FMT_KBGR888, /* BGR888 32bpp */
184
185 HIFB_FMT_1BPP, /* clut1 */
186 HIFB_FMT_2BPP, /* clut2 */
187 HIFB_FMT_4BPP, /* clut4 */
188 HIFB_FMT_8BPP, /* clut8 */
189 HIFB_FMT_ACLUT44, /* AClUT44 */
190 HIFB_FMT_ACLUT88, /* ACLUT88 */
191 HIFB_FMT_PUYVY, /* UYVY */
192 HIFB_FMT_PYUYV, /* YUYV */
193 HIFB_FMT_PYVYU, /* YVYU */
194 HIFB_FMT_YUV888, /* YUV888 */
195 HIFB_FMT_AYUV8888, /* AYUV8888 */
196 HIFB_FMT_YUVA8888, /* YUVA8888 */
197 HIFB_FMT_BUTT
198 } HIFB_COLOR_FMT_E;
199
200 typedef struct {
201 HI_BOOL bKeyRgb;
202 HI_BOOL bKeyAlpha; /* whether support colorkey alpha */
203 HI_BOOL bGlobalAlpha; /* whether support global alpha */
204 HI_BOOL bCmap; /* whether support color map */
205 HI_BOOL bHasCmapReg; /* whether has color map register */
206 HI_BOOL bColFmt[HIFB_FMT_BUTT]; /* support which color format */
207 HI_BOOL bVoScale; /* support vo scale */
208 /* whether support a certain layer, for example:x5 HD support HIFB_SD_0 not support HIFB_SD_1 */
209 HI_BOOL bLayerSupported;
210 HI_U32 u32MaxWidth; /* the max pixels per line */
211 HI_U32 u32MaxHeight; /* the max lines */
212 HI_U32 u32MinWidth; /* the min pixels per line */
213 HI_U32 u32MinHeight; /* the min lines */
214 HI_U32 u32VDefLevel; /* vertical deflicker level, 0 means vertical deflicker is unsupported */
215 HI_U32 u32HDefLevel; /* horizontal deflicker level, 0 means horizontal deflicker is unsupported */
216 HI_BOOL bDcmp;
217 HI_BOOL bPreMul;
218 HI_BOOL bGHDR; /* NEW Feature. Is GHDR supported. */
219 } HIFB_CAPABILITY_S;
220
221 /* refresh mode */
222 typedef enum {
223 HIFB_LAYER_BUF_DOUBLE = 0x0, /* 2 display buf in fb */
224 HIFB_LAYER_BUF_ONE = 0x1, /* 1 display buf in fb */
225 HIFB_LAYER_BUF_NONE = 0x2, /* no display buf in fb,the buf user refreshed will be directly set to VO */
226 HIFB_LAYER_BUF_DOUBLE_IMMEDIATE = 0x3, /* 2 display buf in fb, each refresh will be displayed */
227 HIFB_LAYER_BUF_FENCE = 0x4, /* 2 display buf in fb with fence */
228 HIFB_LAYER_BUF_BUTT
229 } HIFB_LAYER_BUF_E;
230
231 /* surface info */
232 typedef struct {
233 HI_U64 u64PhyAddr; /* start physical address */
234 HI_U64 u64GBPhyAddr;
235 HI_U32 u32Width; /* width pixels */
236 HI_U32 u32Height; /* height pixels */
237 HI_U32 u32Pitch; /* line pixels */
238 HIFB_COLOR_FMT_E enFmt; /* color format */
239 HIFB_DYNAMIC_RANGE_E enDynamicRange; /* NEW dynamic range. */
240 } HIFB_SURFACE_S;
241
242 typedef struct {
243 HI_U64 u64PhyAddr;
244 HIFB_ALPHA_S stAlpha;
245 HIFB_COLORKEY_S stColorkey;
246 } HIFB_SURFACEEX_S;
247
248 /* refresh surface info */
249 typedef struct {
250 HIFB_SURFACE_S stCanvas;
251 HIFB_RECT UpdateRect; /* refresh region */
252 } HIFB_BUFFER_S;
253
254 /* cursor info */
255 typedef struct {
256 HIFB_SURFACE_S stCursor;
257 HIFB_POINT_S stHotPos;
258 } HIFB_CURSOR_S;
259
260 /* DDR detect zone info */
261 typedef struct {
262 HI_U32 u32StartSection;
263 HI_U32 u32ZoneNums;
264 } HIFB_DDRZONE_S;
265
266 /* cursor handle */
267 /* Attention:surface in cursor will be released by user */
268 #define FBIOPUT_CURSOR_INFO _IOW(IOC_TYPE_HIFB, 104, HIFB_CURSOR_S)
269 #define FBIOGET_CURSOR_INFO _IOW(IOC_TYPE_HIFB, 105, HIFB_CURSOR_S)
270
271 #define FBIOPUT_CURSOR_STATE _IOW(IOC_TYPE_HIFB, 106, HI_BOOL)
272 #define FBIOGET_CURSOR_STATE _IOW(IOC_TYPE_HIFB, 107, HI_BOOL)
273
274 #define FBIOPUT_CURSOR_POS _IOW(IOC_TYPE_HIFB, 108, HIFB_POINT_S)
275 #define FBIOGET_CURSOR_POS _IOR(IOC_TYPE_HIFB, 109, HIFB_POINT_S)
276
277 #define FBIOPUT_CURSOR_COLORKEY _IOR(IOC_TYPE_HIFB, 110, HIFB_COLORKEY_S)
278 #define FBIOGET_CURSOR_COLORKEY _IOW(IOC_TYPE_HIFB, 111, HIFB_COLORKEY_S)
279 #define FBIOPUT_CURSOR_ALPHA _IOR(IOC_TYPE_HIFB, 112, HIFB_ALPHA_S)
280 #define FBIOGET_CURSOR_ALPHA _IOW(IOC_TYPE_HIFB, 113, HIFB_ALPHA_S)
281
282 /*
283 * cursor will be separated from attached layer automatically if you attach cursor to another layer,that means
284 * cursor can be attached to only one layer at any time
285 */
286 #define FBIOPUT_CURSOR_ATTCHCURSOR _IOW(IOC_TYPE_HIFB, 114, HI_U32)
287 #define FBIOPUT_CURSOR_DETACHCURSOR _IOW(IOC_TYPE_HIFB, 115, HI_U32)
288
289 /* Auto means fb will choose a appropriate antiflicker level automatically according to the color info of map */
290 typedef enum {
291 HIFB_LAYER_ANTIFLICKER_NONE = 0x0, /* no antiflicker */
292 HIFB_LAYER_ANTIFLICKER_LOW = 0x1, /* low level */
293 HIFB_LAYER_ANTIFLICKER_MIDDLE = 0x2, /* middle level */
294 HIFB_LAYER_ANTIFLICKER_HIGH = 0x3, /* high level */
295 HIFB_LAYER_ANTIFLICKER_AUTO = 0x4, /* auto */
296 HIFB_LAYER_ANTIFLICKER_BUTT
297 } HIFB_LAYER_ANTIFLICKER_LEVEL_E;
298
299 /* MIRROR mode */
300 typedef enum {
301 HIFB_MIRROR_NONE = 0x0,
302 HIFB_MIRROR_HORIZONTAL = 0x1,
303 HIFB_MIRROR_VERTICAL = 0x2,
304 HIFB_MIRROR_BOTH = 0x3,
305 HIFB_MIRROR_BUTT
306 } HIFB_MIRROR_MODE_E;
307
308 /* ROTATE mode */
309 typedef enum {
310 HIFB_ROTATE_NONE = 0x0,
311 HIFB_ROTATE_90 = 0x1,
312 HIFB_ROTATE_180 = 0x2,
313 HIFB_ROTATE_270 = 0x3,
314 HIFB_ROTATE_BUTT
315 } HIFB_ROTATE_MODE_E;
316
317 /* layer info maskbit */
318 typedef enum {
319 HIFB_LAYERMASK_BUFMODE = 0x1, /* BUFMODE bitmask */
320 HIFB_LAYERMASK_ANTIFLICKER_MODE = 0x2, /* ANTIFLICKER_MODE bitmask */
321 HIFB_LAYERMASK_POS = 0x4, /* the position bitmask */
322 HIFB_LAYERMASK_CANVASSIZE = 0x8, /* canvassize bitmask */
323 HIFB_LAYERMASK_DISPSIZE = 0x10, /* displaysize bitmask */
324 HIFB_LAYERMASK_SCREENSIZE = 0x20, /* screensize bitmask */
325 HIFB_LAYERMASK_BMUL = 0x40, /* pre-mult bitmask */
326 HIFB_LAYERMASK_BUTT
327 } HIFB_LAYER_INFO_MASKBIT;
328
329 /* layer info */
330 typedef struct {
331 HIFB_LAYER_BUF_E BufMode;
332 HIFB_LAYER_ANTIFLICKER_LEVEL_E eAntiflickerLevel;
333 HI_S32 s32XPos; /* the x pos of origin point in screen */
334 HI_S32 s32YPos; /* the y pos of origin point in screen */
335 HI_U32 u32CanvasWidth; /* the width of canvas buffer */
336 HI_U32 u32CanvasHeight; /* the height of canvas buffer */
337 /* the width of display buf in fb.for 0 buf ,there is no display buf in fb, so it's effectless */
338 HI_U32 u32DisplayWidth;
339 HI_U32 u32DisplayHeight; /* the height of display buf in fb. */
340 HI_U32 u32ScreenWidth; /* the width of screen */
341 HI_U32 u32ScreenHeight; /* the height of screen */
342 HI_BOOL bPreMul; /* The data drawn in buf is premul data or not */
343 HI_U32 u32Mask; /* param modify mask bit */
344 } HIFB_LAYER_INFO_S;
345
346 /* To set the layer information */
347 #define FBIOPUT_LAYER_INFO _IOW(IOC_TYPE_HIFB, 120, HIFB_LAYER_INFO_S)
348 /* To get the layer information */
349 #define FBIOGET_LAYER_INFO _IOR(IOC_TYPE_HIFB, 121, HIFB_LAYER_INFO_S)
350 /* To get canvas buf */
351 #define FBIOGET_CANVAS_BUFFER _IOR(IOC_TYPE_HIFB, 123, HIFB_BUFFER_S)
352 /* To refresh the displayed contents in extended mode */
353 #define FBIO_REFRESH _IOW(IOC_TYPE_HIFB, 124, HIFB_BUFFER_S)
354
355 /* sync refresh */
356 #define FBIO_WAITFOR_FREFRESH_DONE _IO(IOC_TYPE_HIFB, 125)
357
358 /* To set the mirror mode */
359 #define FBIOPUT_MIRROR_MODE _IOW(IOC_TYPE_HIFB, 126, HIFB_MIRROR_MODE_E)
360 /* To get the mirror mode */
361 #define FBIOGET_MIRROR_MODE _IOW(IOC_TYPE_HIFB, 127, HIFB_MIRROR_MODE_E)
362
363 /* To set the rotate mode */
364 #define FBIOPUT_ROTATE_MODE _IOW(IOC_TYPE_HIFB, 128, HIFB_ROTATE_MODE_E)
365 /* To get the rotate mode */
366 #define FBIOGET_ROTATE_MODE _IOW(IOC_TYPE_HIFB, 129, HIFB_ROTATE_MODE_E)
367
368 /* To set the DDR detect zone of an overlay layer */
369 #define FBIOPUT_MDDRDETECT_HIFB _IOW(IOC_TYPE_HIFB, 135, HIFB_DDRZONE_S)
370 /* To get the DDR detect zone of an overlay layer */
371 #define FBIOGET_MDDRDETECT_HIFB _IOW(IOC_TYPE_HIFB, 136, HIFB_DDRZONE_S)
372
373 #ifdef __HuaweiLite__
374 #define FBIOGET_SCREENINFO_HIFB 0x4600
375 #define FBIOPUT_SCREENINFO_HIFB 0x4601
376 #define FBIOPAN_DISPLAY_HIFB 0x4606
377
378 struct hifb_info {
379 struct fb_vtable_s vtable; /* FB interfaces */
380 struct fb_videoinfo_s vinfo; /* This structure descrides the overall video controller */
381 struct fb_overlayinfo_s oinfo; /* This structure descrides one overlay */
382 #ifdef CONFIG_FB_CMAP
383 struct fb_cmap_s cmap; /* Current camp */
384 #endif
385 int activate;
386 void *par; /* Private data */
387 };
388
389 HI_S32 hifb_init(hi_void *pArgs);
390 #endif
391
392 #ifdef __cplusplus
393 #if __cplusplus
394 }
395 #endif
396 #endif /* __cplusplus */
397
398 #endif /* __HIFB_H__ */
399