| /* |
| * Copyright (c) 2012-2017 Etnaviv Project |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sub license, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| * DEALINGS IN THE SOFTWARE. |
| */ |
| #define _POSIX_C_SOURCE 200112L |
| #include "etna_fb.h" |
| #include "etna_util.h" |
| |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <stdlib.h> |
| #include <stdbool.h> |
| #include <fcntl.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <sys/mman.h> |
| #include <sys/ioctl.h> |
| #include <stdarg.h> |
| #include <string.h> |
| #include <linux/videodev2.h> |
| #include <errno.h> |
| |
| #include "hw/state_3d.xml.h" |
| |
| #ifdef ANDROID |
| #define FBDEV_DEV "/dev/graphics/fb%i" |
| #else |
| #define FBDEV_DEV "/dev/fb%i" |
| #endif |
| |
| /* Structure to convert framebuffer format to RS destination conf */ |
| struct etna_fb_format_desc |
| { |
| unsigned bits_per_pixel; |
| unsigned red_offset; |
| unsigned red_length; |
| unsigned green_offset; |
| unsigned green_length; |
| unsigned blue_offset; |
| unsigned blue_length; |
| unsigned alpha_offset; |
| unsigned alpha_length; |
| unsigned grayscale; |
| unsigned rs_format; |
| bool swap_rb; |
| }; |
| |
| static const struct etna_fb_format_desc etna_fb_formats[] = { |
| /* bpp ro rl go gl bo bl ao al gs rs_format swap_rb */ |
| {32, 16, 8, 8, 8, 0 , 8, 0, 0, 0, RS_FORMAT_X8R8G8B8, false}, |
| {32, 0 , 8, 8, 8, 16, 8, 0, 0, 0, RS_FORMAT_X8R8G8B8, true}, |
| {32, 16, 8, 8, 8, 0 , 8, 24, 8, 0, RS_FORMAT_A8R8G8B8, false}, |
| {32, 16, 8, 8, 8, 0 , 8, 24, 8, V4L2_PIX_FMT_ARGB32, RS_FORMAT_A8R8G8B8, false}, |
| {32, 0 , 8, 8, 8, 16, 8, 24, 8, 0, RS_FORMAT_A8R8G8B8, true}, |
| {16, 8 , 4, 4, 4, 0, 4, 0, 0, 0, RS_FORMAT_X4R4G4B4, false}, |
| {16, 0 , 4, 4, 4, 8, 4, 0, 0, 0, RS_FORMAT_X4R4G4B4, true}, |
| {16, 8 , 4, 4, 4, 0, 4, 12, 4, 0, RS_FORMAT_A4R4G4B4, false}, |
| {16, 0 , 4, 4, 4, 8, 4, 12, 4, 0, RS_FORMAT_A4R4G4B4, true}, |
| {16, 10, 5, 5, 5, 0, 5, 0, 0, 0, RS_FORMAT_X1R5G5B5, false}, |
| {16, 0, 5, 5, 5, 10, 5, 0, 0, 0, RS_FORMAT_X1R5G5B5, true}, |
| {16, 10, 5, 5, 5, 0, 5, 15, 1, 0, RS_FORMAT_A1R5G5B5, false}, |
| {16, 0, 5, 5, 5, 10, 5, 15, 1, 0, RS_FORMAT_A1R5G5B5, true}, |
| {16, 11, 5, 5, 6, 0, 5, 0, 0, 0, RS_FORMAT_R5G6B5, false}, |
| {16, 0, 5, 5, 6, 11, 5, 0, 0, 0, RS_FORMAT_R5G6B5, true}, |
| {16, 0, 0, 0, 0, 0 , 0, 0, 0, V4L2_PIX_FMT_YUYV, RS_FORMAT_YUY2, false}, |
| }; |
| |
| #define NUM_FB_FORMATS (sizeof(etna_fb_formats) / sizeof(etna_fb_formats[0])) |
| |
| // Align height to 8 to make sure we can use the buffer as target |
| // for resolve even on GPUs with two pixel pipes |
| #define ETNA_FB_HEIGHT_ALIGN (8) |
| |
| /* Get resolve format and swap red/blue format based on report on red/green/blue |
| * bit positions from kernel. |
| */ |
| static bool etna_fb_get_format(const struct fb_var_screeninfo *fb_var, unsigned *rs_format, bool *swap_rb) |
| { |
| unsigned fmt_idx=0; |
| /* linear scan of table to find matching format */ |
| for(fmt_idx=0; fmt_idx<NUM_FB_FORMATS; ++fmt_idx) |
| { |
| const struct etna_fb_format_desc *desc = &etna_fb_formats[fmt_idx]; |
| if(desc->red_offset == fb_var->red.offset && |
| desc->red_length == fb_var->red.length && |
| desc->green_offset == fb_var->green.offset && |
| desc->green_length == fb_var->green.length && |
| desc->blue_offset == fb_var->blue.offset && |
| desc->blue_length == fb_var->blue.length && |
| (desc->alpha_offset == fb_var->transp.offset || desc->alpha_length == 0) && |
| desc->alpha_length == fb_var->transp.length && |
| desc->grayscale == fb_var->grayscale) |
| { |
| break; |
| } |
| } |
| if(fmt_idx == NUM_FB_FORMATS) |
| { |
| printf("Unsupported framebuffer format: red_offset=%i red_length=%i green_offset=%i green_length=%i blue_offset=%i blue_length=%i trans_offset=%i transp_length=%i grayscale=%08x\n", |
| (int)fb_var->red.offset, (int)fb_var->red.length, |
| (int)fb_var->green.offset, (int)fb_var->green.length, |
| (int)fb_var->blue.offset, (int)fb_var->blue.length, |
| (int)fb_var->transp.offset, (int)fb_var->transp.length, |
| (int)fb_var->grayscale); |
| return false; |
| } else { |
| printf("Framebuffer format: %i, flip_rb=%i\n", |
| etna_fb_formats[fmt_idx].rs_format, |
| etna_fb_formats[fmt_idx].swap_rb); |
| *rs_format = etna_fb_formats[fmt_idx].rs_format; |
| *swap_rb = etna_fb_formats[fmt_idx].swap_rb; |
| return true; |
| } |
| } |
| |
| /* Open framebuffer and get information */ |
| int fb_open(struct etna_device *conn, int num, struct fb_info **out_p) |
| { |
| #ifndef LIBETNAVIV_BO_EXTENSIONS |
| printf("Error: fb_open needs libetnaviv extensions\n"); |
| return -1; |
| #else |
| char devname[256]; |
| struct fb_info *out = ETNA_CALLOC_STRUCT(fb_info); |
| snprintf(devname, 256, FBDEV_DEV, num); |
| |
| int fd = open(devname, O_RDWR); |
| if (fd == -1) { |
| printf("Error: failed to open %s: %s\n", |
| devname, strerror(errno)); |
| return errno; |
| } |
| |
| if (ioctl(fd, FBIOGET_VSCREENINFO, &out->fb_var) || |
| ioctl(fd, FBIOGET_FSCREENINFO, &out->fb_fix)) { |
| printf("Error: failed to run ioctl on %s: %s\n", |
| devname, strerror(errno)); |
| close(fd); |
| return errno; |
| } |
| |
| printf("fix smem_start %08x\n", (unsigned)out->fb_fix.smem_start); |
| printf(" smem_len %08x\n", (unsigned)out->fb_fix.smem_len); |
| printf(" line_length %08x\n", (unsigned)out->fb_fix.line_length); |
| printf("\n"); |
| printf("var x_res %i\n", (unsigned)out->fb_var.xres); |
| printf(" y_res %i\n", (unsigned)out->fb_var.yres); |
| printf(" x_res_virtual %i\n", (unsigned)out->fb_var.xres_virtual); |
| printf(" y_res_virtual %i\n", (unsigned)out->fb_var.yres_virtual); |
| printf(" bits_per_pixel %i\n", (unsigned)out->fb_var.bits_per_pixel); |
| printf(" red.offset %i\n", (unsigned)out->fb_var.red.offset); |
| printf(" red.length %i\n", (unsigned)out->fb_var.red.length); |
| printf(" green.offset %i\n", (unsigned)out->fb_var.green.offset); |
| printf(" green.length %i\n", (unsigned)out->fb_var.green.length); |
| printf(" blue.offset %i\n", (unsigned)out->fb_var.blue.offset); |
| printf(" blue.length %i\n", (unsigned)out->fb_var.blue.length); |
| printf(" transp.offset %i\n", (unsigned)out->fb_var.transp.offset); |
| printf(" transp.length %i\n", (unsigned)out->fb_var.transp.length); |
| printf(" grayscale 0x%08x\n", (unsigned)out->fb_var.grayscale); |
| |
| out->fd = fd; |
| out->stride = out->fb_fix.line_length; |
| out->width = out->fb_var.xres; |
| out->height = out->fb_var.yres; |
| // Align height to make sure we can use the buffer as target |
| // for resolve even on GPUs with two pixel pipes |
| out->padded_height = etna_align_up(out->fb_var.yres, ETNA_FB_HEIGHT_ALIGN); |
| out->buffer_stride = out->stride * out->padded_height; |
| out->num_buffers = out->fb_fix.smem_len / out->buffer_stride; |
| |
| if(out->num_buffers > ETNA_FB_MAX_BUFFERS) |
| out->num_buffers = ETNA_FB_MAX_BUFFERS; |
| char *num_buffers_str = getenv("EGL_FBDEV_BUFFERS"); |
| if(num_buffers_str != NULL) |
| { |
| int num_buffers_env = atoi(num_buffers_str); |
| if(num_buffers_env >= 1 && out->num_buffers > num_buffers_env) |
| out->num_buffers = num_buffers_env; |
| } |
| printf("number of fb buffers: %i\n", out->num_buffers); |
| |
| int req_virth = (out->num_buffers * out->padded_height); |
| if(out->fb_var.yres_virtual < (unsigned)req_virth) |
| { |
| printf("required virtual h is %i, current virtual h is %i: requesting change\n", |
| req_virth, out->fb_var.yres_virtual); |
| out->fb_var.yres_virtual = req_virth; |
| if (ioctl(out->fd, FBIOPUT_VSCREENINFO, &out->fb_var)) |
| { |
| printf("Error: failed to run ioctl to change virtual height for buffering: %s. Rendering may fail.\n", strerror(errno)); |
| return -1; |
| } |
| } |
| |
| out->bo = etna_bo_from_fbdev(conn, fd, 0, out->fb_fix.smem_len); |
| if(!out->bo) |
| { |
| printf("Error: Unable to map framebuffer to GPU\n"); |
| return -1; |
| } |
| |
| for(int idx=0; idx<out->num_buffers; ++idx) |
| { |
| out->buffer[idx].bo = out->bo; |
| out->buffer[idx].offset = idx * out->buffer_stride; |
| out->buffer[idx].flags = ETNA_RELOC_READ|ETNA_RELOC_WRITE; |
| } |
| |
| /* determine resolve format */ |
| if(!etna_fb_get_format(&out->fb_var, (unsigned*)&out->rs_format, &out->swap_rb)) |
| { |
| /* no match */ |
| printf("Error: No matching framebuffer format\n"); |
| out->rs_format = -1; |
| out->swap_rb = false; |
| return -1; |
| } |
| |
| *out_p = out; |
| return 0; |
| #endif |
| } |
| |
| /* Set currently visible buffer id */ |
| int fb_set_buffer(struct fb_info *fb, int buffer) |
| { |
| fb->fb_var.yoffset = buffer * fb->fb_var.yres; |
| /* Android uses FBIOPUT_VSCREENINFO for this; however on some hardware this does a |
| * reconfiguration of the DC every time it is called which causes flicker and slowness. |
| * On the other hand, FBIOPAN_DISPLAY causes a smooth scroll on some hardware, |
| * according to the Android rationale. Choose the least of both evils. |
| */ |
| if (ioctl(fb->fd, FBIOPAN_DISPLAY, &fb->fb_var)) |
| { |
| printf("Error: failed to run ioctl to pan display: %s\n", strerror(errno)); |
| return errno; |
| } |
| return 0; |
| } |
| |
| int fb_close(struct fb_info *fb) |
| { |
| etna_bo_del(fb->bo); |
| close(fb->fd); |
| return 0; |
| } |
