1 /*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "graphics_adf.h"
18
19 #include <errno.h>
20 #include <fcntl.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <sys/mman.h>
24 #include <unistd.h>
25
26 #include <adf/adf.h>
27 #include <sync/sync.h>
28
29 #include "minui/minui.h"
30
MinuiBackendAdf()31 MinuiBackendAdf::MinuiBackendAdf()
32 : intf_fd(-1), dev(), current_surface(0), n_surfaces(0), surfaces() {}
33
SurfaceInit(const drm_mode_modeinfo * mode,GRSurfaceAdf * surf)34 int MinuiBackendAdf::SurfaceInit(const drm_mode_modeinfo* mode, GRSurfaceAdf* surf) {
35 *surf = {};
36 surf->fence_fd = -1;
37 surf->fd = adf_interface_simple_buffer_alloc(intf_fd, mode->hdisplay, mode->vdisplay, format,
38 &surf->offset, &surf->pitch);
39 if (surf->fd < 0) {
40 return surf->fd;
41 }
42
43 surf->width = mode->hdisplay;
44 surf->height = mode->vdisplay;
45 surf->row_bytes = surf->pitch;
46 surf->pixel_bytes = (format == DRM_FORMAT_RGB565) ? 2 : 4;
47
48 surf->data = static_cast<uint8_t*>(
49 mmap(nullptr, surf->pitch * surf->height, PROT_WRITE, MAP_SHARED, surf->fd, surf->offset));
50 if (surf->data == MAP_FAILED) {
51 int saved_errno = errno;
52 close(surf->fd);
53 return -saved_errno;
54 }
55
56 return 0;
57 }
58
InterfaceInit()59 int MinuiBackendAdf::InterfaceInit() {
60 adf_interface_data intf_data;
61 int err = adf_get_interface_data(intf_fd, &intf_data);
62 if (err < 0) return err;
63
64 int ret = 0;
65 err = SurfaceInit(&intf_data.current_mode, &surfaces[0]);
66 if (err < 0) {
67 fprintf(stderr, "allocating surface 0 failed: %s\n", strerror(-err));
68 ret = err;
69 goto done;
70 }
71
72 err = SurfaceInit(&intf_data.current_mode, &surfaces[1]);
73 if (err < 0) {
74 fprintf(stderr, "allocating surface 1 failed: %s\n", strerror(-err));
75 surfaces[1] = {};
76 n_surfaces = 1;
77 } else {
78 n_surfaces = 2;
79 }
80
81 done:
82 adf_free_interface_data(&intf_data);
83 return ret;
84 }
85
DeviceInit(adf_device * dev)86 int MinuiBackendAdf::DeviceInit(adf_device* dev) {
87 adf_id_t intf_id;
88 int err = adf_find_simple_post_configuration(dev, &format, 1, &intf_id, &eng_id);
89 if (err < 0) return err;
90
91 err = adf_device_attach(dev, eng_id, intf_id);
92 if (err < 0 && err != -EALREADY) return err;
93
94 intf_fd = adf_interface_open(dev, intf_id, O_RDWR);
95 if (intf_fd < 0) return intf_fd;
96
97 err = InterfaceInit();
98 if (err < 0) {
99 close(intf_fd);
100 intf_fd = -1;
101 }
102
103 return err;
104 }
105
Init()106 GRSurface* MinuiBackendAdf::Init() {
107 #if defined(RECOVERY_ABGR)
108 format = DRM_FORMAT_ABGR8888;
109 #elif defined(RECOVERY_BGRA)
110 format = DRM_FORMAT_BGRA8888;
111 #elif defined(RECOVERY_RGBX)
112 format = DRM_FORMAT_RGBX8888;
113 #else
114 format = DRM_FORMAT_RGB565;
115 #endif
116
117 adf_id_t* dev_ids = nullptr;
118 ssize_t n_dev_ids = adf_devices(&dev_ids);
119 if (n_dev_ids == 0) {
120 return nullptr;
121 } else if (n_dev_ids < 0) {
122 fprintf(stderr, "enumerating adf devices failed: %s\n", strerror(-n_dev_ids));
123 return nullptr;
124 }
125
126 intf_fd = -1;
127
128 for (ssize_t i = 0; i < n_dev_ids && intf_fd < 0; i++) {
129 int err = adf_device_open(dev_ids[i], O_RDWR, &dev);
130 if (err < 0) {
131 fprintf(stderr, "opening adf device %u failed: %s\n", dev_ids[i], strerror(-err));
132 continue;
133 }
134
135 err = DeviceInit(&dev);
136 if (err < 0) {
137 fprintf(stderr, "initializing adf device %u failed: %s\n", dev_ids[i], strerror(-err));
138 adf_device_close(&dev);
139 }
140 }
141
142 free(dev_ids);
143
144 if (intf_fd < 0) return nullptr;
145
146 GRSurface* ret = Flip();
147
148 Blank(true);
149 Blank(false);
150
151 return ret;
152 }
153
Sync(GRSurfaceAdf * surf)154 void MinuiBackendAdf::Sync(GRSurfaceAdf* surf) {
155 static constexpr unsigned int warningTimeout = 3000;
156
157 if (surf == nullptr) return;
158
159 if (surf->fence_fd >= 0) {
160 int err = sync_wait(surf->fence_fd, warningTimeout);
161 if (err < 0) {
162 perror("adf sync fence wait error\n");
163 }
164
165 close(surf->fence_fd);
166 surf->fence_fd = -1;
167 }
168 }
169
Flip()170 GRSurface* MinuiBackendAdf::Flip() {
171 GRSurfaceAdf* surf = &surfaces[current_surface];
172
173 int fence_fd = adf_interface_simple_post(intf_fd, eng_id, surf->width, surf->height, format,
174 surf->fd, surf->offset, surf->pitch, -1);
175 if (fence_fd >= 0) surf->fence_fd = fence_fd;
176
177 current_surface = (current_surface + 1) % n_surfaces;
178 Sync(&surfaces[current_surface]);
179 return &surfaces[current_surface];
180 }
181
Blank(bool blank)182 void MinuiBackendAdf::Blank(bool blank) {
183 adf_interface_blank(intf_fd, blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON);
184 }
185
SurfaceDestroy(GRSurfaceAdf * surf)186 void MinuiBackendAdf::SurfaceDestroy(GRSurfaceAdf* surf) {
187 munmap(surf->data, surf->pitch * surf->height);
188 close(surf->fence_fd);
189 close(surf->fd);
190 }
191
~MinuiBackendAdf()192 MinuiBackendAdf::~MinuiBackendAdf() {
193 adf_device_close(&dev);
194 for (unsigned int i = 0; i < n_surfaces; i++) {
195 SurfaceDestroy(&surfaces[i]);
196 }
197 if (intf_fd >= 0) close(intf_fd);
198 }
199