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 <unistd.h>
23
24#include <sys/cdefs.h>
25#include <sys/mman.h>
26
27#include <adf/adf.h>
28
29#include "graphics.h"
30
31struct adf_surface_pdata {
32    GRSurface base;
33    int fd;
34    __u32 offset;
35    __u32 pitch;
36};
37
38struct adf_pdata {
39    minui_backend base;
40    int intf_fd;
41    adf_id_t eng_id;
42    __u32 format;
43
44    unsigned int current_surface;
45    unsigned int n_surfaces;
46    struct adf_surface_pdata surfaces[2];
47};
48
49static gr_surface adf_flip(struct minui_backend *backend);
50static void adf_blank(struct minui_backend *backend, bool blank);
51
52static int adf_surface_init(struct adf_pdata *pdata,
53        struct drm_mode_modeinfo *mode, struct adf_surface_pdata *surf)
54{
55    memset(surf, 0, sizeof(*surf));
56
57    surf->fd = adf_interface_simple_buffer_alloc(pdata->intf_fd, mode->hdisplay,
58            mode->vdisplay, pdata->format, &surf->offset, &surf->pitch);
59    if (surf->fd < 0)
60        return surf->fd;
61
62    surf->base.width = mode->hdisplay;
63    surf->base.height = mode->vdisplay;
64    surf->base.row_bytes = surf->pitch;
65    surf->base.pixel_bytes = (pdata->format == DRM_FORMAT_RGB565) ? 2 : 4;
66
67    surf->base.data = mmap(NULL, 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
77static int adf_interface_init(struct adf_pdata *pdata)
78{
79    struct 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
104done:
105    adf_free_interface_data(&intf_data);
106    return ret;
107}
108
109static int adf_device_init(struct adf_pdata *pdata, struct 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
137static gr_surface adf_init(minui_backend *backend)
138{
139    struct adf_pdata *pdata = (struct adf_pdata *)backend;
140    adf_id_t *dev_ids = NULL;
141    ssize_t n_dev_ids, i;
142    gr_surface ret;
143
144#if defined(RECOVERY_BGRA)
145    pdata->format = DRM_FORMAT_BGRA8888;
146#elif defined(RECOVERY_RGBX)
147    pdata->format = DRM_FORMAT_RGBX8888;
148#else
149    pdata->format = DRM_FORMAT_RGB565;
150#endif
151
152    n_dev_ids = adf_devices(&dev_ids);
153    if (n_dev_ids == 0) {
154        return NULL;
155    } else if (n_dev_ids < 0) {
156        fprintf(stderr, "enumerating adf devices failed: %s\n",
157                strerror(-n_dev_ids));
158        return NULL;
159    }
160
161    pdata->intf_fd = -1;
162
163    for (i = 0; i < n_dev_ids && pdata->intf_fd < 0; i++) {
164        struct adf_device dev;
165
166        int err = adf_device_open(dev_ids[i], O_RDWR, &dev);
167        if (err < 0) {
168            fprintf(stderr, "opening adf device %u failed: %s\n", dev_ids[i],
169                    strerror(-err));
170            continue;
171        }
172
173        err = adf_device_init(pdata, &dev);
174        if (err < 0)
175            fprintf(stderr, "initializing adf device %u failed: %s\n",
176                    dev_ids[i], strerror(-err));
177
178        adf_device_close(&dev);
179    }
180
181    free(dev_ids);
182
183    if (pdata->intf_fd < 0)
184        return NULL;
185
186    ret = adf_flip(backend);
187
188    adf_blank(backend, true);
189    adf_blank(backend, false);
190
191    return ret;
192}
193
194static gr_surface adf_flip(struct minui_backend *backend)
195{
196    struct adf_pdata *pdata = (struct adf_pdata *)backend;
197    struct adf_surface_pdata *surf = &pdata->surfaces[pdata->current_surface];
198
199    int fence_fd = adf_interface_simple_post(pdata->intf_fd, pdata->eng_id,
200            surf->base.width, surf->base.height, pdata->format, surf->fd,
201            surf->offset, surf->pitch, -1);
202    if (fence_fd >= 0)
203        close(fence_fd);
204
205    pdata->current_surface = (pdata->current_surface + 1) % pdata->n_surfaces;
206    return &pdata->surfaces[pdata->current_surface].base;
207}
208
209static void adf_blank(struct minui_backend *backend, bool blank)
210{
211    struct adf_pdata *pdata = (struct adf_pdata *)backend;
212    adf_interface_blank(pdata->intf_fd,
213            blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON);
214}
215
216static void adf_surface_destroy(struct adf_surface_pdata *surf)
217{
218    munmap(surf->base.data, surf->pitch * surf->base.height);
219    close(surf->fd);
220}
221
222static void adf_exit(struct minui_backend *backend)
223{
224    struct adf_pdata *pdata = (struct adf_pdata *)backend;
225    unsigned int i;
226
227    for (i = 0; i < pdata->n_surfaces; i++)
228        adf_surface_destroy(&pdata->surfaces[i]);
229    if (pdata->intf_fd >= 0)
230        close(pdata->intf_fd);
231    free(pdata);
232}
233
234minui_backend *open_adf()
235{
236    struct adf_pdata *pdata = calloc(1, sizeof(*pdata));
237    if (!pdata) {
238        perror("allocating adf backend failed");
239        return NULL;
240    }
241
242    pdata->base.init = adf_init;
243    pdata->base.flip = adf_flip;
244    pdata->base.blank = adf_blank;
245    pdata->base.exit = adf_exit;
246    return &pdata->base;
247}
248