Home | History | Annotate | Download | only in libgralloc
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  * Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
      4  *
      5  * Licensed under the Apache License, Version 2.0 (the "License");
      6  * you may not use this file except in compliance with the License.
      7  * You may obtain a copy of the License at
      8  *
      9  *      http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  * Unless required by applicable law or agreed to in writing, software
     12  * distributed under the License is distributed on an "AS IS" BASIS,
     13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  * See the License for the specific language governing permissions and
     15  * limitations under the License.
     16  */
     17 
     18 #ifndef GRALLOC_PRIV_H_
     19 #define GRALLOC_PRIV_H_
     20 
     21 #include <stdint.h>
     22 #include <limits.h>
     23 #include <sys/cdefs.h>
     24 #include <hardware/gralloc.h>
     25 #include <pthread.h>
     26 #include <errno.h>
     27 #include <unistd.h>
     28 
     29 #include <cutils/native_handle.h>
     30 
     31 #include <cutils/log.h>
     32 
     33 #define ROUND_UP_PAGESIZE(x) ( (((unsigned long)(x)) + PAGE_SIZE-1)  & \
     34                                (~(PAGE_SIZE-1)) )
     35 
     36 enum {
     37     /* gralloc usage bits indicating the type
     38      * of allocation that should be used */
     39 
     40     /* SYSTEM heap comes from kernel vmalloc,
     41      * can never be uncached, is not secured*/
     42     GRALLOC_USAGE_PRIVATE_SYSTEM_HEAP     =       GRALLOC_USAGE_PRIVATE_0,
     43     /* SF heap is used for application buffers, is not secured */
     44     GRALLOC_USAGE_PRIVATE_UI_CONTIG_HEAP  =       GRALLOC_USAGE_PRIVATE_1,
     45     /* IOMMU heap comes from manually allocated pages,
     46      * can be cached/uncached, is not secured */
     47     GRALLOC_USAGE_PRIVATE_IOMMU_HEAP      =       GRALLOC_USAGE_PRIVATE_2,
     48     /* MM heap is a carveout heap for video, can be secured*/
     49     GRALLOC_USAGE_PRIVATE_MM_HEAP         =       GRALLOC_USAGE_PRIVATE_3,
     50     /* ADSP heap is a carveout heap, is not secured*/
     51     GRALLOC_USAGE_PRIVATE_ADSP_HEAP       =       0x01000000,
     52 
     53     /* Set this for allocating uncached memory (using O_DSYNC)
     54      * cannot be used with noncontiguous heaps */
     55     GRALLOC_USAGE_PRIVATE_UNCACHED        =       0x02000000,
     56 
     57     /* Buffer content should be displayed on an external display only */
     58     GRALLOC_USAGE_PRIVATE_EXTERNAL_ONLY   =       0x08000000,
     59 
     60     /* Only this buffer content should be displayed on external, even if
     61      * other EXTERNAL_ONLY buffers are available. Used during suspend.
     62      */
     63     GRALLOC_USAGE_PRIVATE_EXTERNAL_BLOCK  =       0x00100000,
     64 
     65     /* Close Caption displayed on an external display only */
     66     GRALLOC_USAGE_PRIVATE_EXTERNAL_CC     =       0x00200000,
     67 
     68     /* CAMERA heap is a carveout heap for camera, is not secured*/
     69     GRALLOC_USAGE_PRIVATE_CAMERA_HEAP     =       0x00400000,
     70 };
     71 
     72 enum {
     73     /* Gralloc perform enums
     74     */
     75     GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER = 1,
     76     GRALLOC_MODULE_PERFORM_GET_STRIDE,
     77     GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_FROM_HANDLE,
     78 };
     79 
     80 #define GRALLOC_HEAP_MASK   (GRALLOC_USAGE_PRIVATE_UI_CONTIG_HEAP |\
     81                              GRALLOC_USAGE_PRIVATE_SYSTEM_HEAP    |\
     82                              GRALLOC_USAGE_PRIVATE_IOMMU_HEAP     |\
     83                              GRALLOC_USAGE_PRIVATE_MM_HEAP        |\
     84                              GRALLOC_USAGE_PRIVATE_ADSP_HEAP)
     85 
     86 #define INTERLACE_MASK 0x80
     87 #define S3D_FORMAT_MASK 0xFF000
     88 /*****************************************************************************/
     89 enum {
     90     /* OEM specific HAL formats */
     91     HAL_PIXEL_FORMAT_NV12_ENCODEABLE        = 0x102,
     92     HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS     = 0x7FA30C04,
     93     HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED     = 0x7FA30C03,
     94     HAL_PIXEL_FORMAT_YCbCr_420_SP           = 0x109,
     95     HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO    = 0x7FA30C01,
     96     HAL_PIXEL_FORMAT_YCrCb_422_SP           = 0x10B,
     97     HAL_PIXEL_FORMAT_R_8                    = 0x10D,
     98     HAL_PIXEL_FORMAT_RG_88                  = 0x10E,
     99     HAL_PIXEL_FORMAT_YCbCr_444_SP           = 0x10F,
    100     HAL_PIXEL_FORMAT_YCrCb_444_SP           = 0x110,
    101     HAL_PIXEL_FORMAT_NV21_ZSL               = 0x111,
    102     HAL_PIXEL_FORMAT_INTERLACE              = 0x180,
    103 
    104 };
    105 
    106 /* possible formats for 3D content*/
    107 enum {
    108     HAL_NO_3D                         = 0x0000,
    109     HAL_3D_IN_SIDE_BY_SIDE_L_R        = 0x10000,
    110     HAL_3D_IN_TOP_BOTTOM              = 0x20000,
    111     HAL_3D_IN_INTERLEAVE              = 0x40000,
    112     HAL_3D_IN_SIDE_BY_SIDE_R_L        = 0x80000,
    113     HAL_3D_OUT_SIDE_BY_SIDE           = 0x1000,
    114     HAL_3D_OUT_TOP_BOTTOM             = 0x2000,
    115     HAL_3D_OUT_INTERLEAVE             = 0x4000,
    116     HAL_3D_OUT_MONOSCOPIC             = 0x8000
    117 };
    118 
    119 enum {
    120     BUFFER_TYPE_UI = 0,
    121     BUFFER_TYPE_VIDEO
    122 };
    123 
    124 /*****************************************************************************/
    125 
    126 #ifdef __cplusplus
    127 struct private_handle_t : public native_handle {
    128 #else
    129     struct private_handle_t {
    130         native_handle_t nativeHandle;
    131 #endif
    132         enum {
    133             PRIV_FLAGS_FRAMEBUFFER        = 0x00000001,
    134             PRIV_FLAGS_USES_PMEM          = 0x00000002,
    135             PRIV_FLAGS_USES_PMEM_ADSP     = 0x00000004,
    136             PRIV_FLAGS_USES_ION           = 0x00000008,
    137             PRIV_FLAGS_USES_ASHMEM        = 0x00000010,
    138             PRIV_FLAGS_NEEDS_FLUSH        = 0x00000020,
    139             PRIV_FLAGS_DO_NOT_FLUSH       = 0x00000040,
    140             PRIV_FLAGS_SW_LOCK            = 0x00000080,
    141             PRIV_FLAGS_NONCONTIGUOUS_MEM  = 0x00000100,
    142             // Set by HWC when storing the handle
    143             PRIV_FLAGS_HWC_LOCK           = 0x00000200,
    144             PRIV_FLAGS_SECURE_BUFFER      = 0x00000400,
    145             // For explicit synchronization
    146             PRIV_FLAGS_UNSYNCHRONIZED     = 0x00000800,
    147             // Not mapped in userspace
    148             PRIV_FLAGS_NOT_MAPPED         = 0x00001000,
    149             // Display on external only
    150             PRIV_FLAGS_EXTERNAL_ONLY      = 0x00002000,
    151             // Display only this buffer on external
    152             PRIV_FLAGS_EXTERNAL_BLOCK     = 0x00004000,
    153             // Display this buffer on external as close caption
    154             PRIV_FLAGS_EXTERNAL_CC        = 0x00008000,
    155             PRIV_FLAGS_VIDEO_ENCODER      = 0x00010000,
    156             PRIV_FLAGS_CAMERA_WRITE       = 0x00020000,
    157             PRIV_FLAGS_CAMERA_READ        = 0x00040000,
    158             PRIV_FLAGS_HW_COMPOSER        = 0x00080000,
    159             PRIV_FLAGS_HW_TEXTURE         = 0x00100000,
    160             PRIV_FLAGS_ITU_R_601          = 0x00200000,
    161             PRIV_FLAGS_ITU_R_601_FR       = 0x00400000,
    162             PRIV_FLAGS_ITU_R_709          = 0x00800000,
    163             PRIV_FLAGS_L3_SECURE_BUFFER   = 0x01000000,
    164         };
    165 
    166         // file-descriptors
    167         int     fd;
    168         int     fd_metadata;          // fd for the meta-data
    169         // ints
    170         int     magic;
    171         int     flags;
    172         int     size;
    173         int     offset;
    174         int     bufferType;
    175         int     base;
    176         int     offset_metadata;
    177         // The gpu address mapped into the mmu.
    178         int     gpuaddr;
    179         int     format;
    180         int     width;
    181         int     height;
    182         int     base_metadata;
    183 
    184 #ifdef __cplusplus
    185         static const int sNumInts = 12;
    186         static const int sNumFds = 2;
    187         static const int sMagic = 'gmsm';
    188 
    189         private_handle_t(int fd, int size, int flags, int bufferType,
    190                          int format,int width, int height, int eFd = -1,
    191                          int eOffset = 0, int eBase = 0) :
    192             fd(fd), fd_metadata(eFd), magic(sMagic),
    193             flags(flags), size(size), offset(0), bufferType(bufferType),
    194             base(0), offset_metadata(eOffset), gpuaddr(0),
    195             format(format), width(width), height(height),
    196             base_metadata(eBase)
    197         {
    198             version = sizeof(native_handle);
    199             numInts = sNumInts;
    200             numFds = sNumFds;
    201         }
    202         ~private_handle_t() {
    203             magic = 0;
    204         }
    205 
    206         bool usesPhysicallyContiguousMemory() {
    207             return (flags & PRIV_FLAGS_USES_PMEM) != 0;
    208         }
    209 
    210         static int validate(const native_handle* h) {
    211             const private_handle_t* hnd = (const private_handle_t*)h;
    212             if (!h || h->version != sizeof(native_handle) ||
    213                 h->numInts != sNumInts || h->numFds != sNumFds ||
    214                 hnd->magic != sMagic)
    215             {
    216                 ALOGD("Invalid gralloc handle (at %p): "
    217                       "ver(%d/%d) ints(%d/%d) fds(%d/%d) magic(%c%c%c%c/%c%c%c%c)",
    218                       h,
    219                       h ? h->version : -1, sizeof(native_handle),
    220                       h ? h->numInts : -1, sNumInts,
    221                       h ? h->numFds : -1, sNumFds,
    222                       hnd ? (((hnd->magic >> 24) & 0xFF)?
    223                              ((hnd->magic >> 24) & 0xFF) : '-') : '?',
    224                       hnd ? (((hnd->magic >> 16) & 0xFF)?
    225                              ((hnd->magic >> 16) & 0xFF) : '-') : '?',
    226                       hnd ? (((hnd->magic >> 8) & 0xFF)?
    227                              ((hnd->magic >> 8) & 0xFF) : '-') : '?',
    228                       hnd ? (((hnd->magic >> 0) & 0xFF)?
    229                              ((hnd->magic >> 0) & 0xFF) : '-') : '?',
    230                       (sMagic >> 24) & 0xFF,
    231                       (sMagic >> 16) & 0xFF,
    232                       (sMagic >> 8) & 0xFF,
    233                       (sMagic >> 0) & 0xFF);
    234                 return -EINVAL;
    235             }
    236             return 0;
    237         }
    238 
    239         static private_handle_t* dynamicCast(const native_handle* in) {
    240             if (validate(in) == 0) {
    241                 return (private_handle_t*) in;
    242             }
    243             return NULL;
    244         }
    245 #endif
    246     };
    247 
    248 #endif /* GRALLOC_PRIV_H_ */
    249