1 /* 2 * Copyright (C) 2008 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 <sys/mman.h> 18 19 #include <dlfcn.h> 20 21 #include <cutils/ashmem.h> 22 #include <cutils/log.h> 23 24 #include <hardware/hardware.h> 25 #include <hardware/gralloc.h> 26 27 #include <fcntl.h> 28 #include <errno.h> 29 #include <sys/ioctl.h> 30 #include <string.h> 31 #include <stdlib.h> 32 33 #include <utils/Vector.h> 34 35 #include <cutils/log.h> 36 #include <cutils/atomic.h> 37 38 #if HAVE_ANDROID_OS 39 #include <linux/fb.h> 40 #endif 41 42 #include "gralloc_priv.h" 43 44 /*****************************************************************************/ 45 46 // numbers of buffers for page flipping 47 #define NUM_BUFFERS 2 48 49 struct hwc_callback_entry 50 { 51 void (*callback)(void *, private_handle_t *); 52 void *data; 53 }; 54 55 typedef android::Vector<struct hwc_callback_entry> hwc_callback_queue_t; 56 57 struct fb_context_t { 58 framebuffer_device_t device; 59 }; 60 61 /*****************************************************************************/ 62 63 static int fb_setSwapInterval(struct framebuffer_device_t* dev, 64 int interval) 65 { 66 fb_context_t* ctx = (fb_context_t*)dev; 67 if (interval < dev->minSwapInterval || interval > dev->maxSwapInterval) 68 return -EINVAL; 69 // FIXME: implement fb_setSwapInterval 70 return 0; 71 } 72 73 static int fb_post(struct framebuffer_device_t* dev, buffer_handle_t buffer) 74 { 75 if (private_handle_t::validate(buffer) < 0) 76 return -EINVAL; 77 78 private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(buffer); 79 private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module); 80 81 hwc_callback_queue_t *queue = reinterpret_cast<hwc_callback_queue_t *>(m->queue); 82 pthread_mutex_lock(&m->queue_lock); 83 if(queue->isEmpty()) 84 pthread_mutex_unlock(&m->queue_lock); 85 else { 86 private_handle_t *hnd = private_handle_t::dynamicCast(buffer); 87 struct hwc_callback_entry entry = queue->top(); 88 queue->pop(); 89 pthread_mutex_unlock(&m->queue_lock); 90 entry.callback(entry.data, hnd); 91 } 92 93 return 0; 94 } 95 96 /*****************************************************************************/ 97 98 static int fb_close(struct hw_device_t *dev) 99 { 100 fb_context_t* ctx = (fb_context_t*)dev; 101 if (ctx) { 102 free(ctx); 103 } 104 return 0; 105 } 106 107 static void get_screen_res(const char *fbname, int32_t *xres, int32_t *yres, 108 int32_t *refresh) 109 { 110 char *path; 111 int fd; 112 char buf[128]; 113 int ret; 114 unsigned int _x, _y, _r; 115 116 asprintf(&path, "/sys/class/graphics/%s/modes", fbname); 117 if (!path) 118 goto err_asprintf; 119 fd = open(path, O_RDONLY); 120 if (fd < 0) 121 goto err_open; 122 ret = read(fd, buf, sizeof(buf)); 123 if (ret <= 0) 124 goto err_read; 125 buf[sizeof(buf)-1] = '\0'; 126 127 ret = sscanf(buf, "U:%ux%up-%u", &_x, &_y, &_r); 128 if (ret != 3) 129 goto err_sscanf; 130 131 ALOGI("Using %ux%u %uHz resolution for '%s' from modes list\n", 132 _x, _y, _r, fbname); 133 134 *xres = (int32_t)_x; 135 *yres = (int32_t)_y; 136 *refresh = (int32_t)_r; 137 138 close(fd); 139 free(path); 140 return; 141 142 err_sscanf: 143 err_read: 144 close(fd); 145 err_open: 146 free(path); 147 err_asprintf: 148 *xres = 2560; 149 *yres = 1600; 150 *refresh = 60; 151 } 152 153 int init_fb(struct private_module_t* module) 154 { 155 char const * const device_template[] = { 156 "/dev/graphics/fb%u", 157 "/dev/fb%u", 158 NULL 159 }; 160 161 int fd = -1; 162 int i = 0; 163 char name[64]; 164 165 fd = open("/dev/graphics/fb0", O_RDWR); 166 if (fd < 0) { 167 ALOGE("/dev/graphics/fb0 Open fail"); 168 return -errno; 169 } 170 171 struct fb_fix_screeninfo finfo; 172 if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1) { 173 ALOGE("Fail to get FB Screen Info"); 174 return -errno; 175 } 176 177 struct fb_var_screeninfo info; 178 if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1) { 179 ALOGE("First, Fail to get FB VScreen Info"); 180 return -errno; 181 } 182 183 int32_t refreshRate; 184 get_screen_res("fb0", &module->xres, &module->yres, &refreshRate); 185 if (refreshRate == 0) 186 refreshRate = 60; /* 60 Hz */ 187 188 float xdpi = (module->xres * 25.4f) / info.width; 189 float ydpi = (module->yres * 25.4f) / info.height; 190 191 ALOGI("using (id=%s)\n" 192 "xres = %d px\n" 193 "yres = %d px\n" 194 "width = %d mm (%f dpi)\n" 195 "height = %d mm (%f dpi)\n" 196 "refresh rate = %.2f Hz\n", 197 finfo.id, module->xres, module->yres, info.width, xdpi, info.height, 198 ydpi, (float)refreshRate); 199 200 module->line_length = module->xres * 4; 201 module->xdpi = xdpi; 202 module->ydpi = ydpi; 203 module->fps = (float)refreshRate; 204 205 return 0; 206 } 207 208 int fb_device_open(hw_module_t const* module, const char* name, 209 hw_device_t** device) 210 { 211 int status = -EINVAL; 212 #ifdef GRALLOC_16_BITS 213 int bits_per_pixel = 16; 214 int format = HAL_PIXEL_FORMAT_RGB_565; 215 #else 216 int bits_per_pixel = 32; 217 int format = HAL_PIXEL_FORMAT_RGBA_8888; 218 #endif 219 220 alloc_device_t* gralloc_device; 221 status = gralloc_open(module, &gralloc_device); 222 if (status < 0) { 223 ALOGE("Fail to Open gralloc device"); 224 return status; 225 } 226 227 framebuffer_device_t *dev = (framebuffer_device_t *)malloc(sizeof(framebuffer_device_t)); 228 if (dev == NULL) { 229 ALOGE("Failed to allocate memory for dev"); 230 gralloc_close(gralloc_device); 231 return status; 232 } 233 234 private_module_t* m = (private_module_t*)module; 235 status = init_fb(m); 236 if (status < 0) { 237 ALOGE("Fail to init framebuffer"); 238 free(dev); 239 gralloc_close(gralloc_device); 240 return status; 241 } 242 243 /* initialize our state here */ 244 memset(dev, 0, sizeof(*dev)); 245 246 /* initialize the procs */ 247 dev->common.tag = HARDWARE_DEVICE_TAG; 248 dev->common.version = 0; 249 dev->common.module = const_cast<hw_module_t*>(module); 250 dev->common.close = fb_close; 251 dev->setSwapInterval = 0; 252 dev->post = fb_post; 253 dev->setUpdateRect = 0; 254 dev->compositionComplete = 0; 255 m->queue = new hwc_callback_queue_t; 256 pthread_mutex_init(&m->queue_lock, NULL); 257 258 int stride = m->line_length / (bits_per_pixel >> 3); 259 const_cast<uint32_t&>(dev->flags) = 0; 260 const_cast<uint32_t&>(dev->width) = m->xres; 261 const_cast<uint32_t&>(dev->height) = m->yres; 262 const_cast<int&>(dev->stride) = stride; 263 const_cast<int&>(dev->format) = format; 264 const_cast<float&>(dev->xdpi) = m->xdpi; 265 const_cast<float&>(dev->ydpi) = m->ydpi; 266 const_cast<float&>(dev->fps) = m->fps; 267 const_cast<int&>(dev->minSwapInterval) = 1; 268 const_cast<int&>(dev->maxSwapInterval) = 1; 269 *device = &dev->common; 270 status = 0; 271 272 return status; 273 } 274
