Files
kmscon/src/uterm_video_fbdev.c
T
David Herrmann 10cb9fdee0 uterm: video_fbdev: fix debug statements
Remove blitting debug statements as it is working fine now.

Signed-off-by: David Herrmann <dh.herrmann@googlemail.com>
2012-06-24 01:09:40 +02:00

491 lines
12 KiB
C

/*
* uterm - Linux User-Space Terminal
*
* Copyright (c) 2011-2012 David Herrmann <dh.herrmann@googlemail.com>
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* 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.
*/
/*
* FBDEV Video backend
*/
#include <errno.h>
#include <fcntl.h>
#include <libudev.h>
#include <linux/fb.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <unistd.h>
#include "log.h"
#include "misc.h"
#include "uterm.h"
#include "uterm_internal.h"
#define LOG_SUBSYSTEM "video_fbdev"
static const char *mode_get_name(const struct uterm_mode *mode)
{
return "<default>";
}
static unsigned int mode_get_width(const struct uterm_mode *mode)
{
return mode->fbdev.width;
}
static unsigned int mode_get_height(const struct uterm_mode *mode)
{
return mode->fbdev.height;
}
static int refresh_info(struct uterm_display *disp)
{
int ret;
ret = ioctl(disp->fbdev.fd, FBIOGET_FSCREENINFO, &disp->fbdev.finfo);
if (ret) {
log_err("cannot get finfo (%d): %m", errno);
return -EFAULT;
}
ret = ioctl(disp->fbdev.fd, FBIOGET_VSCREENINFO, &disp->fbdev.vinfo);
if (ret) {
log_err("cannot get vinfo (%d): %m", errno);
return -EFAULT;
}
return 0;
}
static int display_activate_force(struct uterm_display *disp,
struct uterm_mode *mode,
bool force)
{
static const char depths[] = { 32, 24, 16, 0 };
struct fb_var_screeninfo *vinfo;
struct fb_fix_screeninfo *finfo;
int ret, i;
uint64_t quot;
size_t len;
if (!disp->video || !video_is_awake(disp->video))
return -EINVAL;
if (!force && (disp->flags & DISPLAY_ONLINE))
return 0;
/* TODO: We do not support explicit modesetting in fbdev, so we require
* @mode to be NULL. You can still switch modes via "fbset" on the
* console and then restart the app. It will automatically adapt to the
* new mode. The only values changed here are bpp and color mode. */
if (mode)
return -EINVAL;
ret = refresh_info(disp);
if (ret)
return ret;
finfo = &disp->fbdev.finfo;
vinfo = &disp->fbdev.vinfo;
vinfo->xoffset = 0;
vinfo->yoffset = 0;
vinfo->activate = FB_ACTIVATE_NOW | FB_ACTIVATE_FORCE;
vinfo->xres_virtual = vinfo->xres;
vinfo->yres_virtual = vinfo->yres * 2;
vinfo->bits_per_pixel = 32;
log_info("activating display %s to %ux%u %u bpp", disp->fbdev.node,
vinfo->xres, vinfo->yres, vinfo->bits_per_pixel);
ret = ioctl(disp->fbdev.fd, FBIOPUT_VSCREENINFO, vinfo);
if (ret) {
disp->flags &= ~DISPLAY_DBUF;
vinfo->yres_virtual = vinfo->yres;
ret = ioctl(disp->fbdev.fd, FBIOPUT_VSCREENINFO, vinfo);
if (ret) {
log_err("cannot set vinfo (%d): %m",
errno);
return -EFAULT;
}
log_debug("disabling double buffering");
} else {
disp->flags |= DISPLAY_DBUF;
log_debug("enabling double buffering");
}
ret = refresh_info(disp);
if (ret)
return ret;
/* We require TRUECOLOR mode here. That is, each pixel has a color value
* that is split into rgba values that we can set directly. Other visual
* modes like pseudocolor or direct-color do not provide this. As I have
* never seen a device that does not support TRUECOLOR, I think we can
* ignore them here. */
if (finfo->visual != FB_VISUAL_TRUECOLOR) {
for (i = 0; depths[i]; ++i) {
vinfo->bits_per_pixel = depths[i];
vinfo->activate = FB_ACTIVATE_NOW | FB_ACTIVATE_FORCE;
ret = ioctl(disp->fbdev.fd, FBIOPUT_VSCREENINFO,
vinfo);
if (ret < 0)
continue;
ret = refresh_info(disp);
if (ret)
return ret;
if (finfo->visual == FB_VISUAL_TRUECOLOR)
break;
}
}
if (vinfo->xres_virtual < vinfo->xres ||
(disp->flags & DISPLAY_DBUF &&
vinfo->yres_virtual < vinfo->yres * 2) ||
vinfo->yres_virtual < vinfo->yres) {
log_error("device %s does not support out buffer sizes",
disp->fbdev.node);
return -EFAULT;
}
if (vinfo->bits_per_pixel % 8) {
log_error("device %s uses no power of 8 bpp: %u",
disp->fbdev.node, vinfo->bits_per_pixel);
return -EFAULT;
}
if (finfo->visual != FB_VISUAL_TRUECOLOR ||
vinfo->bits_per_pixel < 16) {
log_error("device %s does not support true-color bpp >= 16",
disp->fbdev.node);
return -EFAULT;
}
/* TODO: remove this check and correctly provide conversions for the
* blitting functions. In fact, the for-loop above is totally useless
* while using this restriction here but lets be optimistic and say that
* this will be replaced soon. */
if (vinfo->red.offset != 16 || vinfo->red.length != 8 ||
vinfo->green.offset != 8 || vinfo->green.length != 8 ||
vinfo->blue.offset != 0 || vinfo->green.length != 8 ||
vinfo->bits_per_pixel != 32) {
log_error("device %s does not support xrgb32",
disp->fbdev.node);
return -EFAULT;
}
/* calculate monitor rate, default is 60 Hz */
quot = (vinfo->upper_margin + vinfo->lower_margin + vinfo->yres);
quot *= (vinfo->left_margin + vinfo->right_margin + vinfo->xres);
quot *= vinfo->pixclock;
if (quot)
disp->fbdev.rate = 1000000000000000LLU / quot;
else
disp->fbdev.rate = 60 * 1000;
len = finfo->line_length * vinfo->yres;
if (disp->flags & DISPLAY_DBUF)
len *= 2;
disp->fbdev.map = mmap(0, len, PROT_WRITE, MAP_SHARED,
disp->fbdev.fd, 0);
if (disp->fbdev.map == MAP_FAILED) {
log_error("cannot mmap device %s (%d): %m", disp->fbdev.node,
errno);
return -EFAULT;
}
memset(disp->fbdev.map, 0, len);
disp->fbdev.xres = vinfo->xres;
disp->fbdev.yres = vinfo->yres;
disp->fbdev.len = len;
disp->fbdev.bpp = vinfo->bits_per_pixel / 8;
disp->fbdev.stride = finfo->line_length;
disp->fbdev.bufid = 0;
ret = mode_new(&disp->modes, &fbdev_mode_ops);
if (ret) {
munmap(disp->fbdev.map, disp->fbdev.len);
return ret;
}
disp->modes->fbdev.width = disp->fbdev.xres;
disp->modes->fbdev.height = disp->fbdev.yres;
disp->current_mode = disp->modes;
disp->flags |= DISPLAY_ONLINE;
return 0;
}
static int display_activate(struct uterm_display *disp, struct uterm_mode *mode)
{
return display_activate_force(disp, mode, false);
}
static void display_deactivate_force(struct uterm_display *disp, bool force)
{
if (!disp->video || !(disp->flags & DISPLAY_ONLINE))
return;
log_info("deactivating device %s", disp->fbdev.node);
uterm_mode_unref(disp->modes);
disp->modes = NULL;
disp->current_mode = NULL;
munmap(disp->fbdev.map, disp->fbdev.len);
if (!force)
disp->flags &= ~DISPLAY_ONLINE;
}
static void display_deactivate(struct uterm_display *disp)
{
return display_deactivate_force(disp, false);
}
static int display_set_dpms(struct uterm_display *disp, int state)
{
int set, ret;
if (!disp->video || !(disp->flags & DISPLAY_ONLINE))
return -EINVAL;
switch (state) {
case UTERM_DPMS_ON:
set = FB_BLANK_UNBLANK;
break;
case UTERM_DPMS_STANDBY:
set = FB_BLANK_NORMAL;
break;
case UTERM_DPMS_SUSPEND:
set = FB_BLANK_NORMAL;
break;
case UTERM_DPMS_OFF:
set = FB_BLANK_POWERDOWN;
break;
default:
return -EINVAL;
}
log_info("setting DPMS of device %p to %s", disp->fbdev.node,
uterm_dpms_to_name(state));
ret = ioctl(disp->fbdev.fd, FBIOBLANK, set);
if (ret) {
log_error("cannot set DPMS on %s (%d): %m", disp->fbdev.node,
errno);
return -EFAULT;
}
disp->dpms = state;
return 0;
}
void *fbdev_display_map(struct uterm_display *disp)
{
if (!disp->video || !video_is_awake(disp->video))
return NULL;
if (!(disp->flags & DISPLAY_ONLINE))
return NULL;
/* TODO: temporary function to obtain a pointer to the frambuffer from
* the calling application. Stuff like bpp, size, etc. must be
* published, too, otherwise, no-one will be able to use it. */
return disp->fbdev.map;
}
static int display_swap(struct uterm_display *disp)
{
struct fb_var_screeninfo *vinfo;
int ret;
if (!disp->video || !video_is_awake(disp->video))
return -EINVAL;
if (!(disp->flags & DISPLAY_ONLINE))
return -EINVAL;
if (!(disp->flags & DISPLAY_DBUF))
return 0;
vinfo = &disp->fbdev.vinfo;
vinfo->activate = FB_ACTIVATE_VBL;
if (!disp->fbdev.bufid)
vinfo->yoffset = disp->fbdev.yres;
else
vinfo->yoffset = 0;
ret = ioctl(disp->fbdev.fd, FBIOPUT_VSCREENINFO, vinfo);
if (ret) {
log_warning("cannot swap buffers on %s (%d): %m",
disp->fbdev.node, errno);
return -EFAULT;
}
disp->fbdev.bufid ^= 1;
return 0;
}
static int display_blit(struct uterm_display *disp,
const struct uterm_video_buffer *buf,
unsigned int x, unsigned int y,
unsigned int width, unsigned int height)
{
unsigned int tmp;
uint8_t *dst, *src;
if (!disp->video || !(disp->flags & DISPLAY_ONLINE))
return -EINVAL;
if (!buf || !video_is_awake(disp->video))
return -EINVAL;
if (buf->bpp != disp->fbdev.bpp)
return -EINVAL;
tmp = x + width;
if (tmp < x || x >= buf->width)
return -EINVAL;
if (tmp > buf->width)
width = buf->width - x;
tmp = y + height;
if (tmp < y || y >= buf->height)
return -EINVAL;
if (tmp > buf->height)
height = buf->height - y;
if (!(disp->flags & DISPLAY_DBUF) || disp->fbdev.bufid)
dst = disp->fbdev.map;
else
dst = &disp->fbdev.map[disp->fbdev.yres * disp->fbdev.stride];
dst = &dst[y * disp->fbdev.stride + x * disp->fbdev.bpp];
src = &buf->data[y * buf->stride + x * buf->bpp];
while (--height) {
memcpy(dst, src, buf->bpp * width);
dst += disp->fbdev.stride;
src += buf->stride;
}
return 0;
}
static int video_init(struct uterm_video *video, const char *node)
{
int ret;
struct uterm_display *disp;
ret = display_new(&disp, &fbdev_display_ops);
if (ret)
return ret;
disp->fbdev.node = strdup(node);
if (!disp->fbdev.node) {
log_err("cannot dup node name");
ret = -ENOMEM;
goto err_free;
}
disp->fbdev.fd = open(node, O_RDWR | O_CLOEXEC);
if (disp->fbdev.fd < 0) {
log_err("cannot open %s (%d): %m", node, errno);
ret = -EFAULT;
goto err_node;
}
disp->video = video;
disp->dpms = UTERM_DPMS_UNKNOWN;
video->displays = disp;
log_info("new device on %s", disp->fbdev.node);
return 0;
err_node:
free(disp->fbdev.node);
err_free:
uterm_display_unref(disp);
return ret;
}
static void video_destroy(struct uterm_video *video)
{
log_info("free device %p", video);
}
static void video_sleep(struct uterm_video *video)
{
if (!(video->flags & VIDEO_AWAKE))
return;
display_deactivate_force(video->displays, true);
video->flags &= ~VIDEO_AWAKE;
}
static int video_wake_up(struct uterm_video *video)
{
int ret;
if (video->flags & VIDEO_AWAKE)
return 0;
video->flags |= VIDEO_AWAKE;
if (video->displays->flags & DISPLAY_ONLINE) {
ret = display_activate_force(video->displays, NULL, true);
if (ret) {
video->flags &= ~VIDEO_AWAKE;
return ret;
}
}
return 0;
}
const struct mode_ops fbdev_mode_ops = {
.init = NULL,
.destroy = NULL,
.get_name = mode_get_name,
.get_width = mode_get_width,
.get_height = mode_get_height,
};
const struct display_ops fbdev_display_ops = {
.init = NULL,
.destroy = NULL,
.activate = display_activate,
.deactivate = display_deactivate,
.set_dpms = display_set_dpms,
.use = NULL,
.swap = display_swap,
.blit = display_blit,
};
const struct video_ops fbdev_video_ops = {
.init = video_init,
.destroy = video_destroy,
.segfault = NULL, /* TODO */
.use = NULL,
.poll = NULL,
.sleep = video_sleep,
.wake_up = video_wake_up,
};