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 <errno.h>
18 #include <fcntl.h>
19 #include <stdbool.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <unistd.h>
24 
25 #include <sys/cdefs.h>
26 #include <sys/mman.h>
27 
28 #include <adf/adf.h>
29 
30 #include "graphics.h"
31 
32 struct adf_surface_pdata {
33     GRSurface base;
34     int fd;
35     __u32 offset;
36     __u32 pitch;
37 };
38 
39 struct adf_pdata {
40     minui_backend base;
41     int intf_fd;
42     adf_id_t eng_id;
43     __u32 format;
44 
45     unsigned int current_surface;
46     unsigned int n_surfaces;
47     adf_surface_pdata surfaces[2];
48 };
49 
50 static GRSurface* adf_flip(minui_backend *backend);
51 static void adf_blank(minui_backend *backend, bool blank);
52 
adf_surface_init(adf_pdata * pdata,drm_mode_modeinfo * mode,adf_surface_pdata * surf)53 static int adf_surface_init(adf_pdata *pdata, drm_mode_modeinfo *mode, adf_surface_pdata *surf) {
54     memset(surf, 0, sizeof(*surf));
55 
56     surf->fd = adf_interface_simple_buffer_alloc(pdata->intf_fd, mode->hdisplay,
57             mode->vdisplay, pdata->format, &surf->offset, &surf->pitch);
58     if (surf->fd < 0)
59         return surf->fd;
60 
61     surf->base.width = mode->hdisplay;
62     surf->base.height = mode->vdisplay;
63     surf->base.row_bytes = surf->pitch;
64     surf->base.pixel_bytes = (pdata->format == DRM_FORMAT_RGB565) ? 2 : 4;
65 
66     surf->base.data = reinterpret_cast<uint8_t*>(mmap(NULL,
67                                                       surf->pitch * surf->base.height, PROT_WRITE,
68                                                       MAP_SHARED, surf->fd, surf->offset));
69     if (surf->base.data == MAP_FAILED) {
70         close(surf->fd);
71         return -errno;
72     }
73 
74     return 0;
75 }
76 
adf_interface_init(adf_pdata * pdata)77 static int adf_interface_init(adf_pdata *pdata)
78 {
79     adf_interface_data intf_data;
80     int ret = 0;
81     int err;
82 
83     err = adf_get_interface_data(pdata->intf_fd, &intf_data);
84     if (err < 0)
85         return err;
86 
87     err = adf_surface_init(pdata, &intf_data.current_mode, &pdata->surfaces[0]);
88     if (err < 0) {
89         fprintf(stderr, "allocating surface 0 failed: %s\n", strerror(-err));
90         ret = err;
91         goto done;
92     }
93 
94     err = adf_surface_init(pdata, &intf_data.current_mode,
95             &pdata->surfaces[1]);
96     if (err < 0) {
97         fprintf(stderr, "allocating surface 1 failed: %s\n", strerror(-err));
98         memset(&pdata->surfaces[1], 0, sizeof(pdata->surfaces[1]));
99         pdata->n_surfaces = 1;
100     } else {
101         pdata->n_surfaces = 2;
102     }
103 
104 done:
105     adf_free_interface_data(&intf_data);
106     return ret;
107 }
108 
adf_device_init(adf_pdata * pdata,adf_device * dev)109 static int adf_device_init(adf_pdata *pdata, adf_device *dev)
110 {
111     adf_id_t intf_id;
112     int intf_fd;
113     int err;
114 
115     err = adf_find_simple_post_configuration(dev, &pdata->format, 1, &intf_id,
116             &pdata->eng_id);
117     if (err < 0)
118         return err;
119 
120     err = adf_device_attach(dev, pdata->eng_id, intf_id);
121     if (err < 0 && err != -EALREADY)
122         return err;
123 
124     pdata->intf_fd = adf_interface_open(dev, intf_id, O_RDWR);
125     if (pdata->intf_fd < 0)
126         return pdata->intf_fd;
127 
128     err = adf_interface_init(pdata);
129     if (err < 0) {
130         close(pdata->intf_fd);
131         pdata->intf_fd = -1;
132     }
133 
134     return err;
135 }
136 
adf_init(minui_backend * backend)137 static GRSurface* adf_init(minui_backend *backend)
138 {
139     adf_pdata *pdata = (adf_pdata *)backend;
140     adf_id_t *dev_ids = NULL;
141     ssize_t n_dev_ids, i;
142     GRSurface* ret;
143 
144 #if defined(RECOVERY_ABGR)
145     pdata->format = DRM_FORMAT_ABGR8888;
146 #elif defined(RECOVERY_BGRA)
147     pdata->format = DRM_FORMAT_BGRA8888;
148 #elif defined(RECOVERY_RGBX)
149     pdata->format = DRM_FORMAT_RGBX8888;
150 #else
151     pdata->format = DRM_FORMAT_RGB565;
152 #endif
153 
154     n_dev_ids = adf_devices(&dev_ids);
155     if (n_dev_ids == 0) {
156         return NULL;
157     } else if (n_dev_ids < 0) {
158         fprintf(stderr, "enumerating adf devices failed: %s\n",
159                 strerror(-n_dev_ids));
160         return NULL;
161     }
162 
163     pdata->intf_fd = -1;
164 
165     for (i = 0; i < n_dev_ids && pdata->intf_fd < 0; i++) {
166         adf_device dev;
167 
168         int err = adf_device_open(dev_ids[i], O_RDWR, &dev);
169         if (err < 0) {
170             fprintf(stderr, "opening adf device %u failed: %s\n", dev_ids[i],
171                     strerror(-err));
172             continue;
173         }
174 
175         err = adf_device_init(pdata, &dev);
176         if (err < 0)
177             fprintf(stderr, "initializing adf device %u failed: %s\n",
178                     dev_ids[i], strerror(-err));
179 
180         adf_device_close(&dev);
181     }
182 
183     free(dev_ids);
184 
185     if (pdata->intf_fd < 0)
186         return NULL;
187 
188     ret = adf_flip(backend);
189 
190     adf_blank(backend, true);
191     adf_blank(backend, false);
192 
193     return ret;
194 }
195 
adf_flip(minui_backend * backend)196 static GRSurface* adf_flip(minui_backend *backend)
197 {
198     adf_pdata *pdata = (adf_pdata *)backend;
199     adf_surface_pdata *surf = &pdata->surfaces[pdata->current_surface];
200 
201     int fence_fd = adf_interface_simple_post(pdata->intf_fd, pdata->eng_id,
202             surf->base.width, surf->base.height, pdata->format, surf->fd,
203             surf->offset, surf->pitch, -1);
204     if (fence_fd >= 0)
205         close(fence_fd);
206 
207     pdata->current_surface = (pdata->current_surface + 1) % pdata->n_surfaces;
208     return &pdata->surfaces[pdata->current_surface].base;
209 }
210 
adf_blank(minui_backend * backend,bool blank)211 static void adf_blank(minui_backend *backend, bool blank)
212 {
213     adf_pdata *pdata = (adf_pdata *)backend;
214     adf_interface_blank(pdata->intf_fd,
215             blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON);
216 }
217 
adf_surface_destroy(adf_surface_pdata * surf)218 static void adf_surface_destroy(adf_surface_pdata *surf)
219 {
220     munmap(surf->base.data, surf->pitch * surf->base.height);
221     close(surf->fd);
222 }
223 
adf_exit(minui_backend * backend)224 static void adf_exit(minui_backend *backend)
225 {
226     adf_pdata *pdata = (adf_pdata *)backend;
227     unsigned int i;
228 
229     for (i = 0; i < pdata->n_surfaces; i++)
230         adf_surface_destroy(&pdata->surfaces[i]);
231     if (pdata->intf_fd >= 0)
232         close(pdata->intf_fd);
233     free(pdata);
234 }
235 
open_adf()236 minui_backend *open_adf()
237 {
238     adf_pdata* pdata = reinterpret_cast<adf_pdata*>(calloc(1, sizeof(*pdata)));
239     if (!pdata) {
240         perror("allocating adf backend failed");
241         return NULL;
242     }
243 
244     pdata->base.init = adf_init;
245     pdata->base.flip = adf_flip;
246     pdata->base.blank = adf_blank;
247     pdata->base.exit = adf_exit;
248     return &pdata->base;
249 }
250