[sdl_omap.git] / src / video / omapdss / osdl_video.c

/*
 * (C) Gražvydas "notaz" Ignotas, 2010-2012
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING file in the top-level directory.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <linux/fb.h>

#include "osdl.h"
#include "omapfb.h"
#include "linux/fbdev.h"
#include "linux/xenv.h"

struct omapfb_state {
	struct omapfb_plane_info pi;
	struct omapfb_mem_info mi;
	struct omapfb_plane_info pi_old;
	struct omapfb_mem_info mi_old;
};

static const char *get_fb_device(void)
{
	const char *fbname = getenv("SDL_FBDEV");
	if (fbname == NULL)
		fbname = "/dev/fb1";

	return fbname;
}

static int osdl_setup_omapfb(struct omapfb_state *ostate, int fd, int enabled,
	int x, int y, int w, int h, int mem, int *buffer_count)
{
	struct omapfb_plane_info pi;
	struct omapfb_mem_info mi;
	int mem_blocks = *buffer_count;
	int ret;

	memset(&pi, 0, sizeof(pi));
	memset(&mi, 0, sizeof(mi));

	ret = ioctl(fd, OMAPFB_QUERY_PLANE, &pi);
	if (ret != 0) {
		err_perror("QUERY_PLANE");
		return -1;
	}

	ret = ioctl(fd, OMAPFB_QUERY_MEM, &mi);
	if (ret != 0) {
		err_perror("QUERY_MEM");
		return -1;
	}

	/* must disable when changing stuff */
	if (pi.enabled) {
		pi.enabled = 0;
		ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
		if (ret != 0)
			err_perror("SETUP_PLANE");
	}

	if (mi.size < mem * mem_blocks) {
		for (; mem_blocks > 0; mem_blocks--) {
			mi.size = mem * mem_blocks;
			ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi);
			if (ret == 0)
				break;
		}
		if (ret != 0 || mem_blocks <= 0) {
			err("failed to allocate at least %d bytes of vram:\n", mem);
			err_perror("SETUP_MEM");
			return -1;
		}
	}
	*buffer_count = mem_blocks;

	pi.pos_x = x;
	pi.pos_y = y;
	pi.out_width = w;
	pi.out_height = h;
	pi.enabled = enabled;

	ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
	if (ret != 0) {
		err_perror("SETUP_PLANE");
		err("(%d %d %d %d)\n", x, y, w, h);
		return -1;
	}

	ostate->pi = pi;
	ostate->mi = mi;
	return 0;
}

static int read_sysfs(const char *fname, char *buff, size_t size)
{
	FILE *f;
	int ret;

	f = fopen(fname, "r");
	if (f == NULL) {
		err_perror("open %s: ", fname);
		return -1;
	}

	ret = fread(buff, 1, size - 1, f);
	fclose(f);
	if (ret <= 0) {
		err_perror("read %s: ", fname);
		return -1;
	}

	buff[ret] = 0;
	for (ret--; ret >= 0 && isspace(buff[ret]); ret--)
		buff[ret] = 0;

	return 0;
}

int read_vscreeninfo(const char *fbname, int *w, int *h)
{
	struct fb_var_screeninfo fbvar;
	int ret, fd;

	fd = open(fbname, O_RDWR);
	if (fd == -1) {
		err_perror("open %s", fbname);
		return -1;
	}

	ret = ioctl(fd, FBIOGET_VSCREENINFO, &fbvar);
	close(fd);

	if (ret == -1) {
		err_perror("ioctl %s", fbname);
		return -1;
	}

	if (fbvar.xres == 0 || fbvar.yres == 0)
		return -1;

	*w = fbvar.xres;
	*h = fbvar.yres;
	return 0;
}

int osdl_video_detect_screen(struct SDL_PrivateVideoData *pdata)
{
	int fb_id, overlay_id = -1, screen_id = -1;
	char buff[64], screen_name[64];
	const char *fbname;
	struct stat status;
	int fd, i, ret;
	int w, h;
	FILE *f;

	pdata->phys_w = pdata->phys_h = 0;

	fbname = get_fb_device();

	/* Figure out screen resolution, we need to know default resolution
	 * to report to SDL and for centering stuff.
	 * The only way to achieve this seems to be walking some sysfs files.. */
	ret = stat(fbname, &status);
	if (ret != 0) {
		err_perror("can't stat %s", fbname);
		goto skip_screen;
	}
	fb_id = minor(status.st_rdev);

	snprintf(buff, sizeof(buff), "/sys/class/graphics/fb%d/overlays", fb_id);
	f = fopen(buff, "r");
	if (f == NULL) {
		err("can't open %s, skip screen detection", buff);
		goto skip_screen;
	}

	ret = fscanf(f, "%d", &overlay_id);
	fclose(f);
	if (ret != 1) {
		err("can't parse %s, skip screen detection", buff);
		goto skip_screen;
	}

	snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/overlay%d/manager", overlay_id);
	ret = read_sysfs(buff, screen_name, sizeof(screen_name));
	if (ret < 0) {
		err("skip screen detection");
		goto skip_screen;
	}

	for (i = 0; ; i++) {
		snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/display%d/name", i);
		ret = read_sysfs(buff, buff, sizeof(buff));
		if (ret < 0)
			break;

		if (strcmp(screen_name, buff) == 0) {
			screen_id = i;
			break;
		}
	}

	if (screen_id < 0) {
		err("could not find screen");
		goto skip_screen;
	}

	snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/display%d/timings", screen_id);
	f = fopen(buff, "r");
	if (f == NULL) {
		err("can't open %s, skip screen detection", buff);
		goto skip_screen;
	}

	ret = fscanf(f, "%*d,%d/%*d/%*d/%*d,%d/%*d/%*d/%*d", &w, &h);
	fclose(f);
	if (ret != 2) {
		err("can't parse %s (%d), skip screen detection", buff, ret);
		goto skip_screen;
	}

	log("detected %dx%d '%s' (%d) screen attached to fb %d and overlay %d",
		w, h, screen_name, screen_id, fb_id, overlay_id);

	pdata->phys_w = w;
	pdata->phys_h = h;
	return 0;

skip_screen:
	/* attempt to extract this from FB then */
	ret = read_vscreeninfo(fbname, &pdata->phys_w, &pdata->phys_h);
	if (ret != 0 && strcmp(fbname, "/dev/fb0") != 0) {
		/* last resort */
		ret = read_vscreeninfo("/dev/fb0", &pdata->phys_w, &pdata->phys_h);
	}

	if (ret != 0) {
		err("VSCREENINFO has nothing meaningful");
		return -1;
	}

	return 0;
}

static int osdl_setup_omap_layer(struct SDL_PrivateVideoData *pdata,
		const char *fbname, int width, int height, int bpp, int *buffer_count)
{
	int x = 0, y = 0, w = width, h = height; /* layer size and pos */
	int screen_w = w, screen_h = h;
	int tmp_w, tmp_h;
	const char *tmp;
	int retval = -1;
	int ret, fd;

	pdata->layer_x = pdata->layer_y = pdata->layer_w = pdata->layer_h = 0;

	if (pdata->phys_w != 0)
		screen_w = pdata->phys_w;
	if (pdata->phys_h != 0)
		screen_h = pdata->phys_h;

	fd = open(fbname, O_RDWR);
	if (fd == -1) {
		err_perror("open %s", fbname);
		return -1;
	}

	/* FIXME: assuming layer doesn't change here */
	if (pdata->saved_layer == NULL) {
		struct omapfb_state *slayer;
		slayer = calloc(1, sizeof(*slayer));
		if (slayer == NULL)
			goto out;

		ret = ioctl(fd, OMAPFB_QUERY_PLANE, &slayer->pi_old);
		if (ret != 0) {
			err_perror("QUERY_PLANE");
			goto out;
		}

		ret = ioctl(fd, OMAPFB_QUERY_MEM, &slayer->mi_old);
		if (ret != 0) {
			err_perror("QUERY_MEM");
			goto out;
		}

		pdata->saved_layer = slayer;
	}

	tmp = getenv("SDL_OMAP_LAYER_SIZE");
	if (tmp != NULL) {
		if (strcasecmp(tmp, "fullscreen") == 0)
			w = screen_w, h = screen_h;
		else if (sscanf(tmp, "%dx%d", &tmp_w, &tmp_h) == 2)
			w = tmp_w, h = tmp_h;
		else
			err("layer size specified incorrectly, "
				"should be like 800x480");
	}

	/* the layer can't be set larger than screen */
	tmp_w = w, tmp_h = h;
	if (w > screen_w)
		w = screen_w;
	if (h > screen_h)
		h = screen_h;
	if (w != tmp_w || h != tmp_h)
		log("layer resized %dx%d -> %dx%d to fit screen", tmp_w, tmp_h, w, h);

	x = screen_w / 2 - w / 2;
	y = screen_h / 2 - h / 2;
	ret = osdl_setup_omapfb(pdata->saved_layer, fd, 1, x, y, w, h,
				width * height * ((bpp + 7) / 8), buffer_count);
	if (ret == 0) {
		pdata->layer_x = x;
		pdata->layer_y = y;
		pdata->layer_w = w;
		pdata->layer_h = h;
	}

	retval = ret;
out:
	close(fd);
	return retval;
}

void *osdl_video_set_mode(struct SDL_PrivateVideoData *pdata,
			  int border_l, int border_r, int border_t, int border_b,
			  int width, int height, int bpp, int *doublebuf,
			  const char *wm_title)
{
	int buffers_try, buffers_set;
	const char *fbname;
	void *result;
	int ret;

	fbname = get_fb_device();

	if (pdata->fbdev != NULL) {
		vout_fbdev_finish(pdata->fbdev);
		pdata->fbdev = NULL;
	}

	buffers_try = buffers_set = 1;
	if (*doublebuf)
		/* actually try tripple buffering for reduced chance of tearing */
		buffers_try = buffers_set = 3;

	ret = osdl_setup_omap_layer(pdata, fbname, width, height, bpp, &buffers_set);
	if (ret < 0)
		goto fail;

	pdata->fbdev = vout_fbdev_init(fbname, &width, &height, bpp, buffers_set);
	if (pdata->fbdev == NULL)
		goto fail;

	if (border_l | border_r | border_t | border_b) {
		width -= border_l + border_r;
		height -= border_t + border_b;
		result = vout_fbdev_resize(pdata->fbdev, width, height, bpp,
				border_l, border_r, border_t, border_b, buffers_set);
	}
	else {
		result = osdl_video_flip(pdata);
	}
	if (result == NULL)
		goto fail;

	if (!pdata->xenv_up) {
		int xenv_flags = XENV_CAP_KEYS | XENV_CAP_MOUSE;
		ret = xenv_init(&xenv_flags, wm_title);
		if (ret == 0) {
			pdata->xenv_up = 1;
			pdata->xenv_mouse = (xenv_flags & XENV_CAP_MOUSE) ? 1 : 0;
		}
	}

	if (buffers_try != buffers_set) {
		log("only %d/%d buffers available, expect tearing\n",
			buffers_set, buffers_try);
		*doublebuf = buffers_set > 1;
	}

	return result;

fail:
	osdl_video_finish(pdata);
	return NULL;
}

void *osdl_video_flip(struct SDL_PrivateVideoData *pdata)
{
	void *ret;

	if (pdata->fbdev == NULL)
		return NULL;

	ret = vout_fbdev_flip(pdata->fbdev);

	if (pdata->cfg_force_vsync)
		vout_fbdev_wait_vsync(pdata->fbdev);

	return ret;
}

int osdl_video_pause(struct SDL_PrivateVideoData *pdata, int is_pause)
{
	struct omapfb_state *state = pdata->saved_layer;
	struct omapfb_plane_info pi;
	struct omapfb_mem_info mi;
	int enabled;
	int fd = -1;
	int ret;

	if (pdata->fbdev != NULL)
		fd = vout_fbdev_get_fd(pdata->fbdev);
	if (fd == -1) {
		err("bad fd %d", fd);
		return -1;
	}
	if (state == NULL) {
		err("missing layer state\n");
		return -1;
	}

	if (is_pause) {
		ret = vout_fbdev_save(pdata->fbdev);
		if (ret != 0)
			return ret;
		pi = state->pi_old;
		mi = state->mi_old;
		enabled = pi.enabled;
	} else {
		pi = state->pi;
		mi = state->mi;
		enabled = 1;
	}
	pi.enabled = 0;
	ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
	if (ret != 0) {
		err_perror("SETUP_PLANE");
		return -1;
	}

	ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi);
	if (ret != 0)
		err_perror("SETUP_MEM");

	if (!is_pause) {
		ret = vout_fbdev_restore(pdata->fbdev);
		if (ret != 0) {
			err("fbdev_restore failed\n");
			return ret;
		}
	}

	if (enabled) {
		pi.enabled = 1;
		ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
		if (ret != 0) {
			err_perror("SETUP_PLANE");
			return -1;
		}
	}

	return 0;
}

void osdl_video_finish(struct SDL_PrivateVideoData *pdata)
{
	static const char *fbname;

	fbname = get_fb_device();
	if (pdata->fbdev != NULL) {
		vout_fbdev_finish(pdata->fbdev);
		pdata->fbdev = NULL;
	}

	/* restore the OMAP layer */
	if (pdata->saved_layer != NULL) {
		struct omapfb_state *slayer = pdata->saved_layer;
		int fd;

		fd = open(fbname, O_RDWR);
		if (fd != -1) {
			int enabled = slayer->pi_old.enabled;

			/* be sure to disable while setting up */
			slayer->pi_old.enabled = 0;
			ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi_old);
			ioctl(fd, OMAPFB_SETUP_MEM, &slayer->mi_old);
			if (enabled) {
				slayer->pi_old.enabled = enabled;
				ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi_old);
			}
			close(fd);
		}
		free(slayer);
		pdata->saved_layer = NULL;
	}

	if (pdata->xenv_up) {
		xenv_finish();
		pdata->xenv_up = 0;
	}
}
Commit	Line	Data
	1	/*
	2	* (C) Gražvydas "notaz" Ignotas, 2010-2012
	3	*
	4	* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
	5	* See the COPYING file in the top-level directory.
	6	*/
	7
	8	#include <stdio.h>
	9	#include <stdlib.h>
	10	#include <string.h>
	11	#include <strings.h>
	12	#include <ctype.h>
	13	#include <sys/types.h>
	14	#include <sys/stat.h>
	15	#include <fcntl.h>
	16	#include <sys/ioctl.h>
	17	#include <unistd.h>
	18	#include <linux/fb.h>
	19
	20	#include "osdl.h"
	21	#include "omapfb.h"
	22	#include "linux/fbdev.h"
	23	#include "linux/xenv.h"
	24
	25	struct omapfb_state {
	26	struct omapfb_plane_info pi;
	27	struct omapfb_mem_info mi;
	28	struct omapfb_plane_info pi_old;
	29	struct omapfb_mem_info mi_old;
	30	};
	31
	32	static const char *get_fb_device(void)
	33	{
	34	const char *fbname = getenv("SDL_FBDEV");
	35	if (fbname == NULL)
	36	fbname = "/dev/fb1";
	37
	38	return fbname;
	39	}
	40
	41	static int osdl_setup_omapfb(struct omapfb_state *ostate, int fd, int enabled,
	42	int x, int y, int w, int h, int mem, int *buffer_count)
	43	{
	44	struct omapfb_plane_info pi;
	45	struct omapfb_mem_info mi;
	46	int mem_blocks = *buffer_count;
	47	int ret;
	48
	49	memset(&pi, 0, sizeof(pi));
	50	memset(&mi, 0, sizeof(mi));
	51
	52	ret = ioctl(fd, OMAPFB_QUERY_PLANE, &pi);
	53	if (ret != 0) {
	54	err_perror("QUERY_PLANE");
	55	return -1;
	56	}
	57
	58	ret = ioctl(fd, OMAPFB_QUERY_MEM, &mi);
	59	if (ret != 0) {
	60	err_perror("QUERY_MEM");
	61	return -1;
	62	}
	63
	64	/* must disable when changing stuff */
	65	if (pi.enabled) {
	66	pi.enabled = 0;
	67	ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
	68	if (ret != 0)
	69	err_perror("SETUP_PLANE");
	70	}
	71
	72	if (mi.size < mem * mem_blocks) {
	73	for (; mem_blocks > 0; mem_blocks--) {
	74	mi.size = mem * mem_blocks;
	75	ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi);
	76	if (ret == 0)
	77	break;
	78	}
	79	if (ret != 0 \|\| mem_blocks <= 0) {
	80	err("failed to allocate at least %d bytes of vram:\n", mem);
	81	err_perror("SETUP_MEM");
	82	return -1;
	83	}
	84	}
	85	*buffer_count = mem_blocks;
	86
	87	pi.pos_x = x;
	88	pi.pos_y = y;
	89	pi.out_width = w;
	90	pi.out_height = h;
	91	pi.enabled = enabled;
	92
	93	ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
	94	if (ret != 0) {
	95	err_perror("SETUP_PLANE");
	96	err("(%d %d %d %d)\n", x, y, w, h);
	97	return -1;
	98	}
	99
	100	ostate->pi = pi;
	101	ostate->mi = mi;
	102	return 0;
	103	}
	104
	105	static int read_sysfs(const char fname, char buff, size_t size)
	106	{
	107	FILE *f;
	108	int ret;
	109
	110	f = fopen(fname, "r");
	111	if (f == NULL) {
	112	err_perror("open %s: ", fname);
	113	return -1;
	114	}
	115
	116	ret = fread(buff, 1, size - 1, f);
	117	fclose(f);
	118	if (ret <= 0) {
	119	err_perror("read %s: ", fname);
	120	return -1;
	121	}
	122
	123	buff[ret] = 0;
	124	for (ret--; ret >= 0 && isspace(buff[ret]); ret--)
	125	buff[ret] = 0;
	126
	127	return 0;
	128	}
	129
	130	int read_vscreeninfo(const char fbname, int w, int *h)
	131	{
	132	struct fb_var_screeninfo fbvar;
	133	int ret, fd;
	134
	135	fd = open(fbname, O_RDWR);
	136	if (fd == -1) {
	137	err_perror("open %s", fbname);
	138	return -1;
	139	}
	140
	141	ret = ioctl(fd, FBIOGET_VSCREENINFO, &fbvar);
	142	close(fd);
	143
	144	if (ret == -1) {
	145	err_perror("ioctl %s", fbname);
	146	return -1;
	147	}
	148
	149	if (fbvar.xres == 0 \|\| fbvar.yres == 0)
	150	return -1;
	151
	152	*w = fbvar.xres;
	153	*h = fbvar.yres;
	154	return 0;
	155	}
	156
	157	int osdl_video_detect_screen(struct SDL_PrivateVideoData *pdata)
	158	{
	159	int fb_id, overlay_id = -1, screen_id = -1;
	160	char buff[64], screen_name[64];
	161	const char *fbname;
	162	struct stat status;
	163	int fd, i, ret;
	164	int w, h;
	165	FILE *f;
	166
	167	pdata->phys_w = pdata->phys_h = 0;
	168
	169	fbname = get_fb_device();
	170
	171	/* Figure out screen resolution, we need to know default resolution
	172	* to report to SDL and for centering stuff.
	173	* The only way to achieve this seems to be walking some sysfs files.. */
	174	ret = stat(fbname, &status);
	175	if (ret != 0) {
	176	err_perror("can't stat %s", fbname);
	177	goto skip_screen;
	178	}
	179	fb_id = minor(status.st_rdev);
	180
	181	snprintf(buff, sizeof(buff), "/sys/class/graphics/fb%d/overlays", fb_id);
	182	f = fopen(buff, "r");
	183	if (f == NULL) {
	184	err("can't open %s, skip screen detection", buff);
	185	goto skip_screen;
	186	}
	187
	188	ret = fscanf(f, "%d", &overlay_id);
	189	fclose(f);
	190	if (ret != 1) {
	191	err("can't parse %s, skip screen detection", buff);
	192	goto skip_screen;
	193	}
	194
	195	snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/overlay%d/manager", overlay_id);
	196	ret = read_sysfs(buff, screen_name, sizeof(screen_name));
	197	if (ret < 0) {
	198	err("skip screen detection");
	199	goto skip_screen;
	200	}
	201
	202	for (i = 0; ; i++) {
	203	snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/display%d/name", i);
	204	ret = read_sysfs(buff, buff, sizeof(buff));
	205	if (ret < 0)
	206	break;
	207
	208	if (strcmp(screen_name, buff) == 0) {
	209	screen_id = i;
	210	break;
	211	}
	212	}
	213
	214	if (screen_id < 0) {
	215	err("could not find screen");
	216	goto skip_screen;
	217	}
	218
	219	snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/display%d/timings", screen_id);
	220	f = fopen(buff, "r");
	221	if (f == NULL) {
	222	err("can't open %s, skip screen detection", buff);
	223	goto skip_screen;
	224	}
	225
	226	ret = fscanf(f, "%d,%d/%d/%d/%d,%d/%d/%d/%*d", &w, &h);
	227	fclose(f);
	228	if (ret != 2) {
	229	err("can't parse %s (%d), skip screen detection", buff, ret);
	230	goto skip_screen;
	231	}
	232
	233	log("detected %dx%d '%s' (%d) screen attached to fb %d and overlay %d",
	234	w, h, screen_name, screen_id, fb_id, overlay_id);
	235
	236	pdata->phys_w = w;
	237	pdata->phys_h = h;
	238	return 0;
	239
	240	skip_screen:
	241	/* attempt to extract this from FB then */
	242	ret = read_vscreeninfo(fbname, &pdata->phys_w, &pdata->phys_h);
	243	if (ret != 0 && strcmp(fbname, "/dev/fb0") != 0) {
	244	/* last resort */
	245	ret = read_vscreeninfo("/dev/fb0", &pdata->phys_w, &pdata->phys_h);
	246	}
	247
	248	if (ret != 0) {
	249	err("VSCREENINFO has nothing meaningful");
	250	return -1;
	251	}
	252
	253	return 0;
	254	}
	255
	256	static int osdl_setup_omap_layer(struct SDL_PrivateVideoData *pdata,
	257	const char fbname, int width, int height, int bpp, int buffer_count)
	258	{
	259	int x = 0, y = 0, w = width, h = height; /* layer size and pos */
	260	int screen_w = w, screen_h = h;
	261	int tmp_w, tmp_h;
	262	const char *tmp;
	263	int retval = -1;
	264	int ret, fd;
	265
	266	pdata->layer_x = pdata->layer_y = pdata->layer_w = pdata->layer_h = 0;
	267
	268	if (pdata->phys_w != 0)
	269	screen_w = pdata->phys_w;
	270	if (pdata->phys_h != 0)
	271	screen_h = pdata->phys_h;
	272
	273	fd = open(fbname, O_RDWR);
	274	if (fd == -1) {
	275	err_perror("open %s", fbname);
	276	return -1;
	277	}
	278
	279	/* FIXME: assuming layer doesn't change here */
	280	if (pdata->saved_layer == NULL) {
	281	struct omapfb_state *slayer;
	282	slayer = calloc(1, sizeof(*slayer));
	283	if (slayer == NULL)
	284	goto out;
	285
	286	ret = ioctl(fd, OMAPFB_QUERY_PLANE, &slayer->pi_old);
	287	if (ret != 0) {
	288	err_perror("QUERY_PLANE");
	289	goto out;
	290	}
	291
	292	ret = ioctl(fd, OMAPFB_QUERY_MEM, &slayer->mi_old);
	293	if (ret != 0) {
	294	err_perror("QUERY_MEM");
	295	goto out;
	296	}
	297
	298	pdata->saved_layer = slayer;
	299	}
	300
	301	tmp = getenv("SDL_OMAP_LAYER_SIZE");
	302	if (tmp != NULL) {
	303	if (strcasecmp(tmp, "fullscreen") == 0)
	304	w = screen_w, h = screen_h;
	305	else if (sscanf(tmp, "%dx%d", &tmp_w, &tmp_h) == 2)
	306	w = tmp_w, h = tmp_h;
	307	else
	308	err("layer size specified incorrectly, "
	309	"should be like 800x480");
	310	}
	311
	312	/* the layer can't be set larger than screen */
	313	tmp_w = w, tmp_h = h;
	314	if (w > screen_w)
	315	w = screen_w;
	316	if (h > screen_h)
	317	h = screen_h;
	318	if (w != tmp_w \|\| h != tmp_h)
	319	log("layer resized %dx%d -> %dx%d to fit screen", tmp_w, tmp_h, w, h);
	320
	321	x = screen_w / 2 - w / 2;
	322	y = screen_h / 2 - h / 2;
	323	ret = osdl_setup_omapfb(pdata->saved_layer, fd, 1, x, y, w, h,
	324	width * height * ((bpp + 7) / 8), buffer_count);
	325	if (ret == 0) {
	326	pdata->layer_x = x;
	327	pdata->layer_y = y;
	328	pdata->layer_w = w;
	329	pdata->layer_h = h;
	330	}
	331
	332	retval = ret;
	333	out:
	334	close(fd);
	335	return retval;
	336	}
	337
	338	void osdl_video_set_mode(struct SDL_PrivateVideoData pdata,
	339	int border_l, int border_r, int border_t, int border_b,
	340	int width, int height, int bpp, int *doublebuf,
	341	const char *wm_title)
	342	{
	343	int buffers_try, buffers_set;
	344	const char *fbname;
	345	void *result;
	346	int ret;
	347
	348	fbname = get_fb_device();
	349
	350	if (pdata->fbdev != NULL) {
	351	vout_fbdev_finish(pdata->fbdev);
	352	pdata->fbdev = NULL;
	353	}
	354
	355	buffers_try = buffers_set = 1;
	356	if (*doublebuf)
	357	/* actually try tripple buffering for reduced chance of tearing */
	358	buffers_try = buffers_set = 3;
	359
	360	ret = osdl_setup_omap_layer(pdata, fbname, width, height, bpp, &buffers_set);
	361	if (ret < 0)
	362	goto fail;
	363
	364	pdata->fbdev = vout_fbdev_init(fbname, &width, &height, bpp, buffers_set);
	365	if (pdata->fbdev == NULL)
	366	goto fail;
	367
	368	if (border_l \| border_r \| border_t \| border_b) {
	369	width -= border_l + border_r;
	370	height -= border_t + border_b;
	371	result = vout_fbdev_resize(pdata->fbdev, width, height, bpp,
	372	border_l, border_r, border_t, border_b, buffers_set);
	373	}
	374	else {
	375	result = osdl_video_flip(pdata);
	376	}
	377	if (result == NULL)
	378	goto fail;
	379
	380	if (!pdata->xenv_up) {
	381	int xenv_flags = XENV_CAP_KEYS \| XENV_CAP_MOUSE;
	382	ret = xenv_init(&xenv_flags, wm_title);
	383	if (ret == 0) {
	384	pdata->xenv_up = 1;
	385	pdata->xenv_mouse = (xenv_flags & XENV_CAP_MOUSE) ? 1 : 0;
	386	}
	387	}
	388
	389	if (buffers_try != buffers_set) {
	390	log("only %d/%d buffers available, expect tearing\n",
	391	buffers_set, buffers_try);
	392	*doublebuf = buffers_set > 1;
	393	}
	394
	395	return result;
	396
	397	fail:
	398	osdl_video_finish(pdata);
	399	return NULL;
	400	}
	401
	402	void osdl_video_flip(struct SDL_PrivateVideoData pdata)
	403	{
	404	void *ret;
	405
	406	if (pdata->fbdev == NULL)
	407	return NULL;
	408
	409	ret = vout_fbdev_flip(pdata->fbdev);
	410
	411	if (pdata->cfg_force_vsync)
	412	vout_fbdev_wait_vsync(pdata->fbdev);
	413
	414	return ret;
	415	}
	416
	417	int osdl_video_pause(struct SDL_PrivateVideoData *pdata, int is_pause)
	418	{
	419	struct omapfb_state *state = pdata->saved_layer;
	420	struct omapfb_plane_info pi;
	421	struct omapfb_mem_info mi;
	422	int enabled;
	423	int fd = -1;
	424	int ret;
	425
	426	if (pdata->fbdev != NULL)
	427	fd = vout_fbdev_get_fd(pdata->fbdev);
	428	if (fd == -1) {
	429	err("bad fd %d", fd);
	430	return -1;
	431	}
	432	if (state == NULL) {
	433	err("missing layer state\n");
	434	return -1;
	435	}
	436
	437	if (is_pause) {
	438	ret = vout_fbdev_save(pdata->fbdev);
	439	if (ret != 0)
	440	return ret;
	441	pi = state->pi_old;
	442	mi = state->mi_old;
	443	enabled = pi.enabled;
	444	} else {
	445	pi = state->pi;
	446	mi = state->mi;
	447	enabled = 1;
	448	}
	449	pi.enabled = 0;
	450	ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
	451	if (ret != 0) {
	452	err_perror("SETUP_PLANE");
	453	return -1;
	454	}
	455
	456	ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi);
	457	if (ret != 0)
	458	err_perror("SETUP_MEM");
	459
	460	if (!is_pause) {
	461	ret = vout_fbdev_restore(pdata->fbdev);
	462	if (ret != 0) {
	463	err("fbdev_restore failed\n");
	464	return ret;
	465	}
	466	}
	467
	468	if (enabled) {
	469	pi.enabled = 1;
	470	ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
	471	if (ret != 0) {
	472	err_perror("SETUP_PLANE");
	473	return -1;
	474	}
	475	}
	476
	477	return 0;
	478	}
	479
	480	void osdl_video_finish(struct SDL_PrivateVideoData *pdata)
	481	{
	482	static const char *fbname;
	483
	484	fbname = get_fb_device();
	485	if (pdata->fbdev != NULL) {
	486	vout_fbdev_finish(pdata->fbdev);
	487	pdata->fbdev = NULL;
	488	}
	489
	490	/* restore the OMAP layer */
	491	if (pdata->saved_layer != NULL) {
	492	struct omapfb_state *slayer = pdata->saved_layer;
	493	int fd;
	494
	495	fd = open(fbname, O_RDWR);
	496	if (fd != -1) {
	497	int enabled = slayer->pi_old.enabled;
	498
	499	/* be sure to disable while setting up */
	500	slayer->pi_old.enabled = 0;
	501	ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi_old);
	502	ioctl(fd, OMAPFB_SETUP_MEM, &slayer->mi_old);
	503	if (enabled) {
	504	slayer->pi_old.enabled = enabled;
	505	ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi_old);
	506	}
	507	close(fd);
	508	}
	509	free(slayer);
	510	pdata->saved_layer = NULL;
	511	}
	512
	513	if (pdata->xenv_up) {
	514	xenv_finish();
	515	pdata->xenv_up = 0;
	516	}
	517	}
	518