1/*
2 * Copyright (C) 2016 ARM Limited. All rights reserved.
3 *
4 * Copyright (C) 2008 The Android Open Source Project
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 *      http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19#ifndef MALI_GRALLOC_FORMATS_H_
20#define MALI_GRALLOC_FORMATS_H_
21
22#include <system/graphics.h>
23
24/* Internal formats are represented in gralloc as a 64bit identifier
25 * where the 32 lower bits are a base format and the 32 upper bits are modifiers.
26 *
27 * Modifier bits are divided into mutually exclusive ones and those that are not.
28 */
29/* Internal format type */
30typedef uint64_t mali_gralloc_internal_format;
31
32/* Internal format masks */
33#define    MALI_GRALLOC_INTFMT_FMT_MASK             0x00000000ffffffffULL
34#define    MALI_GRALLOC_INTFMT_EXT_MASK             0xffffffff00000000ULL
35#define    MALI_GRALLOC_INTFMT_ME_EXT_MASK          0x0000ffff00000000ULL
36#define    MALI_GRALLOC_INTFMT_REG_EXT_MASK         0xffff000000000000ULL
37
38/* Internal base formats */
39
40/* Base formats that do not have an identical HAL match
41 * are defined starting at the Android private range
42 */
43#define MALI_GRALLOC_FORMAT_INTERNAL_RANGE_BASE 0x100
44
45typedef enum
46{
47    /* Internal definitions for HAL formats. */
48    MALI_GRALLOC_FORMAT_INTERNAL_RGBA_8888 = HAL_PIXEL_FORMAT_RGBA_8888,
49    MALI_GRALLOC_FORMAT_INTERNAL_RGBX_8888 = HAL_PIXEL_FORMAT_RGBX_8888,
50    MALI_GRALLOC_FORMAT_INTERNAL_RGB_888 = HAL_PIXEL_FORMAT_RGB_888,
51    MALI_GRALLOC_FORMAT_INTERNAL_RGB_565 = HAL_PIXEL_FORMAT_RGB_565 ,
52    MALI_GRALLOC_FORMAT_INTERNAL_BGRA_8888 = HAL_PIXEL_FORMAT_BGRA_8888,
53    MALI_GRALLOC_FORMAT_INTERNAL_YV12 = HAL_PIXEL_FORMAT_YV12 ,
54    MALI_GRALLOC_FORMAT_INTERNAL_Y8 = HAL_PIXEL_FORMAT_Y8,
55    MALI_GRALLOC_FORMAT_INTERNAL_Y16 = HAL_PIXEL_FORMAT_Y16,
56    MALI_GRALLOC_FORMAT_INTERNAL_YUV420_888 = HAL_PIXEL_FORMAT_YCbCr_420_888,
57
58    /* Camera specific HAL formats */
59    MALI_GRALLOC_FORMAT_INTERNAL_RAW16 = HAL_PIXEL_FORMAT_RAW16,
60    MALI_GRALLOC_FORMAT_INTERNAL_RAW12 = HAL_PIXEL_FORMAT_RAW12,
61    MALI_GRALLOC_FORMAT_INTERNAL_RAW10 = HAL_PIXEL_FORMAT_RAW10,
62    MALI_GRALLOC_FORMAT_INTERNAL_BLOB = HAL_PIXEL_FORMAT_BLOB,
63
64    /* Flexible YUV formats would be parsed but not have any representation as
65     * internal format itself but one of the ones below
66     */
67
68    /* The internal private formats that have no HAL equivivalent are defined
69     * afterwards starting at a specific base range */
70    MALI_GRALLOC_FORMAT_INTERNAL_NV12 = MALI_GRALLOC_FORMAT_INTERNAL_RANGE_BASE,
71    MALI_GRALLOC_FORMAT_INTERNAL_NV21,
72    MALI_GRALLOC_FORMAT_INTERNAL_YUV422_8BIT,
73
74    /* Extended YUV formats
75     *
76     * NOTE: P010, P210, and Y410 are only supported uncompressed.
77     */
78    MALI_GRALLOC_FORMAT_INTERNAL_Y0L2,
79    MALI_GRALLOC_FORMAT_INTERNAL_P010,
80    MALI_GRALLOC_FORMAT_INTERNAL_P210,
81    MALI_GRALLOC_FORMAT_INTERNAL_Y210,
82    MALI_GRALLOC_FORMAT_INTERNAL_Y410,
83
84    /* Add more internal formats here. Make sure decode_internal_format() is updated. */
85
86    /* These are legacy 0.3 gralloc formats used only by the wrap/unwrap macros. */
87    MALI_GRALLOC_FORMAT_INTERNAL_YV12_WRAP,
88    MALI_GRALLOC_FORMAT_INTERNAL_Y8_WRAP,
89    MALI_GRALLOC_FORMAT_INTERNAL_Y16_WRAP,
90
91	MALI_GRALLOC_FORMAT_INTERNAL_RANGE_LAST,
92} mali_gralloc_pixel_format;
93
94
95/* Format Modifier Bits Locations */
96#define MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START             32
97#define MALI_GRALLOC_INTFMT_EXTENSION_BIT_START                (MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START+16)
98
99/* Mutually Exclusive Modifier Bits */
100
101/* This format will use AFBC */
102#define    MALI_GRALLOC_INTFMT_AFBC_BASIC                 (1ULL << (MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START+0))
103
104/* This format uses AFBC split block mode */
105#define    MALI_GRALLOC_INTFMT_AFBC_SPLITBLK        (1ULL << (MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START+1))
106
107#define    MALI_GRALLOC_INTFMT_UNUSED               (1ULL << (MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START+2))
108
109/* This format uses AFBC wide block mode */
110#define    MALI_GRALLOC_INTFMT_AFBC_WIDEBLK         (1ULL << (MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START+3))
111
112
113/* Regular Modifier Bits */
114#define    MALI_GRALLOC_INTFMT_AFBC_TILED_HEADERS   (1ULL << (MALI_GRALLOC_INTFMT_EXTENSION_BIT_START+0))
115
116
117/* This mask should be used to check or clear support for AFBC for an internal format
118 * These bits are mutually exclusive so this mask should not be used to enable support
119 */
120#define    MALI_GRALLOC_INTFMT_AFBCENABLE_MASK                   ((uint64_t) (MALI_GRALLOC_INTFMT_AFBC_BASIC | \
121                                                                   MALI_GRALLOC_INTFMT_AFBC_SPLITBLK | \
122                                                                   MALI_GRALLOC_INTFMT_AFBC_WIDEBLK))
123
124/* Prototypes */
125uint64_t mali_gralloc_select_format(int req_format,int usage, int buffer_size);
126
127/* These are legacy Gralloc 0.3 support macros for passing private formats through the 0.3 alloc interface.
128 * It packs modifier bits together with base format into a 32 bit format identifier.
129 * Gralloc 1.0 interface should use private functions to set private buffer format in the buffer descriptor.
130 *
131 * Packing:
132 *
133 * Bits 15-0:    mali_gralloc_pixel_format format
134 * Bits 23-16:   mutually exclusive modifier bits
135 * Bits 31-24:   regular modifier bits
136 */
137static inline int mali_gralloc_format_wrapper(int format, int modifiers)
138{
139    /* Internal formats that are identical to HAL formats
140     * have the same definition. This is convenient for
141     * client parsing code to not have to parse them separately.
142     *
143     * For 3 of the HAL YUV formats that have very large definitions
144     * this causes problems for packing in modifier bits.
145     * Because of this reason we redefine these three formats
146     * while packing/unpacking them.
147     */
148    if(format == MALI_GRALLOC_FORMAT_INTERNAL_YV12)
149    {
150        format = MALI_GRALLOC_FORMAT_INTERNAL_YV12_WRAP;
151    }
152    else if(format == MALI_GRALLOC_FORMAT_INTERNAL_Y8)
153    {
154        format = MALI_GRALLOC_FORMAT_INTERNAL_Y8_WRAP;
155    }
156    else if(format == MALI_GRALLOC_FORMAT_INTERNAL_Y16)
157    {
158        format = MALI_GRALLOC_FORMAT_INTERNAL_Y16_WRAP;
159    }
160    return (modifiers | format);
161}
162
163static inline uint64_t mali_gralloc_format_unwrap(int x)
164{
165    uint64_t internal_format = (uint64_t) (    ((((uint64_t)(x)) & 0xff000000) << 24) | // Regular modifier bits
166                                               ((((uint64_t)(x)) & 0x00ff0000) << 16) | // Mutually exclusive modifier bits
167                                                (((uint64_t)(x)) & 0x0000ffff)   );     // Private format
168
169    uint64_t base_format = internal_format & MALI_GRALLOC_INTFMT_FMT_MASK;
170    uint64_t modifiers = internal_format & MALI_GRALLOC_INTFMT_EXT_MASK;
171
172    if(base_format == MALI_GRALLOC_FORMAT_INTERNAL_YV12_WRAP)
173    {
174        base_format = MALI_GRALLOC_FORMAT_INTERNAL_YV12;
175    }
176    else if(base_format == MALI_GRALLOC_FORMAT_INTERNAL_Y8_WRAP)
177    {
178        base_format = MALI_GRALLOC_FORMAT_INTERNAL_Y8;
179    }
180    else if(base_format == MALI_GRALLOC_FORMAT_INTERNAL_Y16_WRAP)
181    {
182        base_format = MALI_GRALLOC_FORMAT_INTERNAL_Y16;
183    }
184    return (modifiers | base_format);
185}
186
187#define    GRALLOC_PRIVATE_FORMAT_WRAPPER(x)                           ( mali_gralloc_format_wrapper(x, 0) )
188#define    GRALLOC_PRIVATE_FORMAT_WRAPPER_AFBC(x)                      ( mali_gralloc_format_wrapper(x, (MALI_GRALLOC_INTFMT_AFBC_BASIC >> 16)) )
189#define    GRALLOC_PRIVATE_FORMAT_WRAPPER_AFBC_SPLITBLK(x)             ( mali_gralloc_format_wrapper(x, (MALI_GRALLOC_INTFMT_AFBC_SPLITBLK >> 16)) )
190#define    GRALLOC_PRIVATE_FORMAT_WRAPPER_AFBC_WIDEBLK(x)              ( mali_gralloc_format_wrapper(x, (MALI_GRALLOC_INTFMT_AFBC_WIDEBLK >> 16)) )
191#define    GRALLOC_PRIVATE_FORMAT_WRAPPER_AFBC_TILED_HEADERS_BASIC(x)  ( mali_gralloc_format_wrapper(x, (MALI_GRALLOC_INTFMT_AFBC_TILED_HEADERS >> 24) | \
192                                                                                                        (MALI_GRALLOC_INTFMT_AFBC_BASIC >> 16)))
193#define    GRALLOC_PRIVATE_FORMAT_WRAPPER_AFBC_TILED_HEADERS_WIDE(x)   ( mali_gralloc_format_wrapper(x, (MALI_GRALLOC_INTFMT_AFBC_TILED_HEADERS >> 24) | \
194                                                                                                        (MALI_GRALLOC_INTFMT_AFBC_WIDEBLK >> 16)))
195#define    GRALLOC_PRIVATE_FORMAT_UNWRAP(x)                            mali_gralloc_format_unwrap(x)
196
197/* IP block capability masks */
198#define MALI_GRALLOC_FORMAT_CAPABILITY_OPTIONS_PRESENT            ((uint64_t) (1 << 0))
199#define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_BASIC                 ((uint64_t) (1 << 1))
200#define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_SPLITBLK              ((uint64_t) (1 << 2))
201#define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_WIDEBLK               ((uint64_t) (1 << 3))
202#define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_WIDEBLK_YUV_DISABLE   ((uint64_t) (1 << 4))
203#define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_YUV_NOREAD            ((uint64_t) (1 << 5))
204#define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_YUV_NOWRITE           ((uint64_t) (1 << 6))
205#define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_TILED_HEADERS         ((uint64_t) (1 << 7))
206
207#define MALI_GRALLOC_FORMAT_CAPABILITY_AFBCENABLE_MASK ((uint64_t) (MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_BASIC | \
208                                                                    MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_SPLITBLK | \
209                                                                    MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_WIDEBLK | \
210                                                                    MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_TILED_HEADERS))
211
212struct mali_gralloc_format_caps
213{
214	uint64_t caps_mask;
215};
216typedef struct mali_gralloc_format_caps mali_gralloc_format_caps;
217
218#define MALI_GRALLOC_FORMATCAPS_SYM_NAME        mali_gralloc_format_capabilities
219#define MALI_GRALLOC_FORMATCAPS_SYM_NAME_STR    "mali_gralloc_format_capabilities"
220
221/* Producer and Consumer definitions */
222typedef enum
223{
224	MALI_GRALLOC_PRODUCER_VIDEO_DECODER,
225	MALI_GRALLOC_PRODUCER_GPU,
226	MALI_GRALLOC_PRODUCER_CAMERA,
227} mali_gralloc_producer_type;
228
229typedef enum
230{
231
232    /* For surface composition in SurfaceFlinger a producer
233     * will not know what consumer will process a buffer.
234     *
235     * MALI_GRALLOC_CONSUMER_GPU_OR_DISPLAY means the GPU
236     * MUST support the given format but it should be allocated
237     * with preference to the DPU.
238     */
239    MALI_GRALLOC_CONSUMER_GPU_OR_DISPLAY,
240    MALI_GRALLOC_CONSUMER_VIDEO_ENCODER,
241
242
243    /* This is used when no known "premium" dpu is configured.
244     * For example, HDLCD/CLCD would be such a dpu.
245     */
246    MALI_GRALLOC_CONSUMER_GPU_EXCL,
247} mali_gralloc_consumer_type;
248
249
250/*
251 * Below usage types overlap, this is intentional.
252 * The reason is that for Gralloc 0.3 there are very
253 * few usage flags we have at our disposal.
254 *
255 * The overlapping is handled by processing the definitions
256 * in a specific order.
257 *
258 * MALI_GRALLOC_USAGE_PRIVATE_FORMAT and MALI_GRALLOC_USAGE_NO_AFBC
259 * don't overlap and are processed first.
260 *
261 * MALI_GRALLOC_USAGE_YUV_CONF are only for YUV formats and clients
262 * using MALI_GRALLOC_USAGE_NO_AFBC must never allocate YUV formats.
263 * The latter is strictly enforced and allocations will fail.
264 *
265 * MALI_GRALLOC_USAGE_AFBC_PADDING is only valid if MALI_GRALLOC_USAGE_NO_AFBC
266 * is not present.
267 */
268typedef enum
269{
270	/* The client has specified a private format in the format parameter */
271	MALI_GRALLOC_USAGE_PRIVATE_FORMAT = (int) GRALLOC_USAGE_PRIVATE_3,
272
273	/* Buffer won't be allocated as AFBC */
274	MALI_GRALLOC_USAGE_NO_AFBC = (int) (GRALLOC_USAGE_PRIVATE_1 | GRALLOC_USAGE_PRIVATE_2),
275
276	/* Valid only for YUV allocations */
277	MALI_GRALLOC_USAGE_YUV_CONF_0 = 0,
278	MALI_GRALLOC_USAGE_YUV_CONF_1 = (int) GRALLOC_USAGE_PRIVATE_1,
279	MALI_GRALLOC_USAGE_YUV_CONF_2 = (int) GRALLOC_USAGE_PRIVATE_0,
280	MALI_GRALLOC_USAGE_YUV_CONF_3 = (int) (GRALLOC_USAGE_PRIVATE_0 | GRALLOC_USAGE_PRIVATE_1),
281	MALI_GRALLOC_USAGE_YUV_CONF_MASK = MALI_GRALLOC_USAGE_YUV_CONF_3,
282
283	/* A very specific alignment is requested on some buffers */
284	MALI_GRALLOC_USAGE_AFBC_PADDING = GRALLOC_USAGE_PRIVATE_2,
285
286} mali_gralloc_usage_type;
287
288/* Prototypes */
289uint64_t mali_gralloc_select_format(int req_format,int usage, int buffer_size);
290
291#ifdef __cplusplus
292extern "C"
293{
294#endif
295
296void mali_gralloc_get_gpu_caps(struct mali_gralloc_format_caps *gpu_caps);
297
298#ifdef __cplusplus
299}
300#endif
301
302#endif /* MALI_GRALLOC_FORMATS_H_ */
303