Greg Hackmann | 41909dd | 2014-04-25 10:39:50 -0700 | [diff] [blame^] | 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 | |
| 31 | struct adf_surface_pdata { |
| 32 | GRSurface base; |
| 33 | int fd; |
| 34 | __u32 offset; |
| 35 | __u32 pitch; |
| 36 | }; |
| 37 | |
| 38 | struct 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 | |
| 49 | static gr_surface adf_flip(struct minui_backend *backend); |
| 50 | static void adf_blank(struct minui_backend *backend, bool blank); |
| 51 | |
| 52 | static 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 | |
| 77 | static 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 | |
| 104 | done: |
| 105 | adf_free_interface_data(&intf_data); |
| 106 | return ret; |
| 107 | } |
| 108 | |
| 109 | static 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 | |
| 137 | static 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 | |
| 194 | static 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 | |
| 209 | static 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 | |
| 216 | static 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 | |
| 222 | static 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 | |
| 234 | minui_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 | } |