1/*
2 * Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
3 * Not a Contribution
4 *
5 * Copyright (C) 2008 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *      http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
20#ifndef __GR_PRIV_HANDLE_H__
21#define __GR_PRIV_HANDLE_H__
22
23#include <cutils/log.h>
24#include <hardware/gralloc1.h>
25#include <hardware/gralloc.h>
26#include <cinttypes>
27
28#define GRALLOC1_FUNCTION_PERFORM 0x00001000
29
30#define DBG_HANDLE false
31
32typedef gralloc1_error_t (*GRALLOC1_PFN_PERFORM)(gralloc1_device_t *device, int operation, ...);
33
34#define PRIV_HANDLE_CONST(exp) static_cast<const private_handle_t *>(exp)
35
36struct private_handle_t : public native_handle_t {
37  enum {
38    PRIV_FLAGS_FRAMEBUFFER = 0x00000001,
39    PRIV_FLAGS_USES_ION = 0x00000008,
40    PRIV_FLAGS_NEEDS_FLUSH = 0x00000020,
41    PRIV_FLAGS_INTERNAL_ONLY = 0x00000040,
42    PRIV_FLAGS_NON_CPU_WRITER = 0x00000080,
43    PRIV_FLAGS_CACHED = 0x00000200,
44    PRIV_FLAGS_SECURE_BUFFER = 0x00000400,
45    PRIV_FLAGS_EXTERNAL_ONLY = 0x00002000,
46    PRIV_FLAGS_PROTECTED_BUFFER = 0x00004000,
47    PRIV_FLAGS_VIDEO_ENCODER = 0x00010000,
48    PRIV_FLAGS_CAMERA_WRITE = 0x00020000,
49    PRIV_FLAGS_CAMERA_READ = 0x00040000,
50    PRIV_FLAGS_HW_COMPOSER = 0x00080000,
51    PRIV_FLAGS_HW_TEXTURE = 0x00100000,
52    PRIV_FLAGS_ITU_R_601 = 0x00200000,     // Unused from display
53    PRIV_FLAGS_ITU_R_601_FR = 0x00400000,  // Unused from display
54    PRIV_FLAGS_ITU_R_709 = 0x00800000,     // Unused from display
55    PRIV_FLAGS_SECURE_DISPLAY = 0x01000000,
56    PRIV_FLAGS_TILE_RENDERED = 0x02000000,
57    PRIV_FLAGS_CPU_RENDERED = 0x04000000,
58    PRIV_FLAGS_UBWC_ALIGNED = 0x08000000,
59    PRIV_FLAGS_DISP_CONSUMER = 0x10000000,
60    PRIV_FLAGS_CLIENT_ALLOCATED = 0x20000000,   // Ion buffer allocated outside of gralloc
61  };
62
63  // file-descriptors dup'd over IPC
64  int fd;
65  int fd_metadata;
66
67  // values sent over IPC
68  int magic;
69  int flags;
70  int width;        // holds width of the actual buffer allocated
71  int height;       // holds height of the  actual buffer allocated
72  int unaligned_width;   // holds width client asked to allocate
73  int unaligned_height;  // holds height client asked to allocate
74  int format;
75  int buffer_type;
76  unsigned int size;
77  unsigned int offset;
78  unsigned int offset_metadata;
79  uint64_t base                            __attribute__((aligned(8)));
80  uint64_t base_metadata                   __attribute__((aligned(8)));
81  uint64_t gpuaddr                         __attribute__((aligned(8)));
82  uint64_t id                              __attribute__((aligned(8)));
83  gralloc1_producer_usage_t producer_usage __attribute__((aligned(8)));
84  gralloc1_consumer_usage_t consumer_usage __attribute__((aligned(8)));
85  unsigned int layer_count;
86
87  static const int kNumFds = 2;
88  static const int kMagic = 'gmsm';
89
90  static inline int NumInts() {
91    return ((sizeof(private_handle_t) - sizeof(native_handle_t)) / sizeof(int))
92        - kNumFds;
93  }
94
95  private_handle_t(int fd,
96                   int meta_fd,
97                   int flags,
98                   int width,
99                   int height,
100                   int uw,
101                   int uh,
102                   int format,
103                   int buf_type,
104                   unsigned int size,
105                   gralloc1_producer_usage_t prod_usage = GRALLOC1_PRODUCER_USAGE_NONE,
106                   gralloc1_consumer_usage_t cons_usage = GRALLOC1_CONSUMER_USAGE_NONE)
107      : fd(fd),
108        fd_metadata(meta_fd),
109        magic(kMagic),
110        flags(flags),
111        width(width),
112        height(height),
113        unaligned_width(uw),
114        unaligned_height(uh),
115        format(format),
116        buffer_type(buf_type),
117        size(size),
118        offset(0),
119        offset_metadata(0),
120        base(0),
121        base_metadata(0),
122        gpuaddr(0),
123        id(0),
124        producer_usage(prod_usage),
125        consumer_usage(cons_usage),
126        layer_count(1) {
127    version = static_cast<int>(sizeof(native_handle));
128    numInts = NumInts();
129    numFds = kNumFds;
130  }
131
132// Legacy constructor used by some clients
133  private_handle_t(int fd, unsigned int size, int usage, int buf_type, int format, int w, int h)
134  : private_handle_t(fd, -1, PRIV_FLAGS_CLIENT_ALLOCATED, w, h, 0, 0, format, buf_type, size,
135                     static_cast<gralloc1_producer_usage_t>(usage),
136                     static_cast<gralloc1_consumer_usage_t>(usage)) {
137  }
138
139  ~private_handle_t() {
140    magic = 0;
141    ALOGE_IF(DBG_HANDLE, "Deleting buffer handle %p", this);
142  }
143
144  static int validate(const native_handle *h) {
145    const private_handle_t *hnd = (const private_handle_t *)h;
146    if (!h || h->version != sizeof(native_handle) || h->numInts != NumInts() ||
147        h->numFds != kNumFds || hnd->magic != kMagic) {
148      ALOGE(
149          "Invalid gralloc handle (at %p): ver(%d/%zu) ints(%d/%d) fds(%d/%d) "
150          "magic(%c%c%c%c/%c%c%c%c)",
151          h, h ? h->version : -1, sizeof(native_handle), h ? h->numInts : -1, NumInts(),
152          h ? h->numFds : -1, kNumFds,
153          hnd ? (((hnd->magic >> 24) & 0xFF) ? ((hnd->magic >> 24) & 0xFF) : '-') : '?',
154          hnd ? (((hnd->magic >> 16) & 0xFF) ? ((hnd->magic >> 16) & 0xFF) : '-') : '?',
155          hnd ? (((hnd->magic >> 8) & 0xFF) ? ((hnd->magic >> 8) & 0xFF) : '-') : '?',
156          hnd ? (((hnd->magic >> 0) & 0xFF) ? ((hnd->magic >> 0) & 0xFF) : '-') : '?',
157          (kMagic >> 24) & 0xFF, (kMagic >> 16) & 0xFF, (kMagic >> 8) & 0xFF, (kMagic >> 0) & 0xFF);
158      return -EINVAL;
159    }
160
161    return 0;
162  }
163
164  static void Dump(const private_handle_t *hnd) {
165    ALOGD("handle id:%" PRIu64 " wxh:%dx%d uwxuh:%dx%d size: %d fd:%d fd_meta:%d flags:0x%x "
166          "prod_usage:0x%" PRIx64" cons_usage:0x%" PRIx64 " format:0x%x layer_count: %d",
167          hnd->id, hnd->width, hnd->height, hnd->unaligned_width, hnd->unaligned_height, hnd->size,
168          hnd->fd, hnd->fd_metadata, hnd->flags, hnd->producer_usage, hnd->consumer_usage,
169          hnd->format, hnd->layer_count);
170  }
171
172  int GetUnalignedWidth() const { return unaligned_width; }
173
174  int GetUnalignedHeight() const { return unaligned_height; }
175
176  int GetColorFormat() const { return format; }
177
178  unsigned int GetLayerCount() const { return layer_count; }
179
180  int GetStride() const {
181    // In handle we currently store aligned width after allocation.
182    return width;
183  }
184
185  gralloc1_consumer_usage_t GetConsumerUsage() const { return consumer_usage; }
186
187  gralloc1_producer_usage_t GetProducerUsage() const { return producer_usage; }
188
189  uint64_t GetBackingstore() const { return id; }
190};
191
192#endif  // __GR_PRIV_HANDLE_H__
193