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

/*
 * (C) Gražvydas "notaz" Ignotas, 2010-2011
 *
 * 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 "omapsdl.h"
#include "omapfb.h"
#include "linux/fbdev.h"
#include "linux/xenv.h"

struct omapfb_saved_layer {
	struct omapfb_plane_info pi;
	struct omapfb_mem_info mi;
};

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(int fd, int enabled, int x, int y, int w, int h, int mem)
{
	struct omapfb_plane_info pi;
	struct omapfb_mem_info mi;
	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) {
		mi.size = mem;
		ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi);
		if (ret != 0) {
			err_perror("SETUP_MEM");
			return -1;
		}
	}

	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;
	}

	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 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_saved_layer *slayer;
		slayer = calloc(1, sizeof(*slayer));
		if (slayer == NULL)
			goto out;

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

		ret = ioctl(fd, OMAPFB_QUERY_MEM, &slayer->mi);
		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(fd, 1, x, y, w, h, width * height * ((bpp + 7) / 8) * 2);
	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 *fbname;
	void *result;
	int ret;

	fbname = get_fb_device();

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

	ret = osdl_setup_omap_layer(pdata, fbname, width, height, bpp);
	if (ret < 0)
		return NULL;

	pdata->fbdev = vout_fbdev_init(fbname, &width, &height, bpp, doublebuf ? 2 : 1);
	if (pdata->fbdev == NULL)
		return NULL;

	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, doublebuf ? 2 : 1);
	}
	else {
		result = osdl_video_flip(pdata);
	}
	if (result == NULL) {
		osdl_video_finish(pdata);
		return NULL;
	}

	if (!pdata->xenv_up) {
		ret = xenv_init();
		if (ret == 0)
			pdata->xenv_up = 1;
	}

	return result;
}

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;
}

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_saved_layer *slayer = pdata->saved_layer;
		int fd;

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

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

	if (pdata->xenv_up) {
		xenv_finish();
		pdata->xenv_up = 0;
	}
}
Commit	Line	Data
f641fccb	1	/*
f9b3f440	2	* (C) Gražvydas "notaz" Ignotas, 2010-2011
f641fccb	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 "omapsdl.h"
	21	#include "omapfb.h"
	22	#include "linux/fbdev.h"
f9b3f440	23	#include "linux/xenv.h"
f641fccb	24
	25	struct omapfb_saved_layer {
	26	struct omapfb_plane_info pi;
	27	struct omapfb_mem_info mi;
	28	};
	29
b9a19b44	30	static const char *get_fb_device(void)
	31	{
	32	const char *fbname = getenv("SDL_FBDEV");
	33	if (fbname == NULL)
	34	fbname = "/dev/fb1";
	35
	36	return fbname;
	37	}
	38
f641fccb	39	static int osdl_setup_omapfb(int fd, int enabled, int x, int y, int w, int h, int mem)
	40	{
	41	struct omapfb_plane_info pi;
	42	struct omapfb_mem_info mi;
	43	int ret;
	44
5f4b1fd3	45	memset(&pi, 0, sizeof(pi));
	46	memset(&mi, 0, sizeof(mi));
	47
f641fccb	48	ret = ioctl(fd, OMAPFB_QUERY_PLANE, &pi);
f641fccb	49	if (ret != 0) {
7b66578c	50	err_perror("QUERY_PLANE");
f641fccb	51	return -1;
	52	}
	53
	54	ret = ioctl(fd, OMAPFB_QUERY_MEM, &mi);
	55	if (ret != 0) {
7b66578c	56	err_perror("QUERY_MEM");
f641fccb	57	return -1;
	58	}
	59
	60	/* must disable when changing stuff */
	61	if (pi.enabled) {
	62	pi.enabled = 0;
	63	ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
	64	if (ret != 0)
7b66578c	65	err_perror("SETUP_PLANE");
f641fccb	66	}
f641fccb	67
13f953aa	68	if (mi.size < mem) {
	69	mi.size = mem;
	70	ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi);
	71	if (ret != 0) {
	72	err_perror("SETUP_MEM");
	73	return -1;
	74	}
f641fccb	75	}
	76
	77	pi.pos_x = x;
	78	pi.pos_y = y;
	79	pi.out_width = w;
	80	pi.out_height = h;
	81	pi.enabled = enabled;
	82
	83	ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
	84	if (ret != 0) {
7b66578c	85	err_perror("SETUP_PLANE");
6f13ad97	86	err("(%d %d %d %d)\n", x, y, w, h);
f641fccb	87	return -1;
	88	}
	89
	90	return 0;
	91	}
	92
	93	static int read_sysfs(const char fname, char buff, size_t size)
	94	{
	95	FILE *f;
	96	int ret;
	97
	98	f = fopen(fname, "r");
	99	if (f == NULL) {
7b66578c	100	err_perror("open %s: ", fname);
f641fccb	101	return -1;
	102	}
	103
	104	ret = fread(buff, 1, size - 1, f);
	105	fclose(f);
	106	if (ret <= 0) {
7b66578c	107	err_perror("read %s: ", fname);
f641fccb	108	return -1;
	109	}
	110
	111	buff[ret] = 0;
	112	for (ret--; ret >= 0 && isspace(buff[ret]); ret--)
	113	buff[ret] = 0;
	114
	115	return 0;
	116	}
	117
34edc246	118	int read_vscreeninfo(const char fbname, int w, int *h)
	119	{
	120	struct fb_var_screeninfo fbvar;
	121	int ret, fd;
	122
	123	fd = open(fbname, O_RDWR);
	124	if (fd == -1) {
	125	err_perror("open %s", fbname);
	126	return -1;
	127	}
	128
	129	ret = ioctl(fd, FBIOGET_VSCREENINFO, &fbvar);
	130	close(fd);
	131
	132	if (ret == -1) {
	133	err_perror("ioctl %s", fbname);
	134	return -1;
	135	}
	136
	137	if (fbvar.xres == 0 \|\| fbvar.yres == 0)
	138	return -1;
	139
	140	*w = fbvar.xres;
	141	*h = fbvar.yres;
	142	return 0;
	143	}
	144
b9a19b44	145	int osdl_video_detect_screen(struct SDL_PrivateVideoData *pdata)
f641fccb	146	{
f641fccb	147	int fb_id, overlay_id = -1, screen_id = -1;
f641fccb	148	char buff[64], screen_name[64];
b9a19b44	149	const char *fbname;
f641fccb	150	struct stat status;
b9a19b44	151	int fd, i, ret;
b9a19b44	152	int w, h;
f641fccb	153	FILE *f;
f641fccb	154
5f4b1fd3	155	pdata->phys_w = pdata->phys_h = 0;
5f4b1fd3	156
b9a19b44	157	fbname = get_fb_device();
f641fccb	158
b9a19b44	159	/* Figure out screen resolution, we need to know default resolution
b9a19b44	160	* to report to SDL and for centering stuff.
f641fccb	161	* The only way to achieve this seems to be walking some sysfs files.. */
	162	ret = stat(fbname, &status);
	163	if (ret != 0) {
7b66578c	164	err_perror("can't stat %s", fbname);
b9a19b44	165	goto skip_screen;
f641fccb	166	}
	167	fb_id = minor(status.st_rdev);
	168
	169	snprintf(buff, sizeof(buff), "/sys/class/graphics/fb%d/overlays", fb_id);
	170	f = fopen(buff, "r");
	171	if (f == NULL) {
7b66578c	172	err("can't open %s, skip screen detection", buff);
f641fccb	173	goto skip_screen;
	174	}
	175
	176	ret = fscanf(f, "%d", &overlay_id);
	177	fclose(f);
	178	if (ret != 1) {
7b66578c	179	err("can't parse %s, skip screen detection", buff);
f641fccb	180	goto skip_screen;
	181	}
	182
	183	snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/overlay%d/manager", overlay_id);
	184	ret = read_sysfs(buff, screen_name, sizeof(screen_name));
	185	if (ret < 0) {
7b66578c	186	err("skip screen detection");
f641fccb	187	goto skip_screen;
	188	}
	189
	190	for (i = 0; ; i++) {
	191	snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/display%d/name", i);
	192	ret = read_sysfs(buff, buff, sizeof(buff));
	193	if (ret < 0)
	194	break;
	195
	196	if (strcmp(screen_name, buff) == 0) {
	197	screen_id = i;
	198	break;
	199	}
	200	}
	201
	202	if (screen_id < 0) {
7b66578c	203	err("could not find screen");
f641fccb	204	goto skip_screen;
	205	}
	206
	207	snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/display%d/timings", screen_id);
	208	f = fopen(buff, "r");
	209	if (f == NULL) {
7b66578c	210	err("can't open %s, skip screen detection", buff);
f641fccb	211	goto skip_screen;
	212	}
	213
b9a19b44	214	ret = fscanf(f, "%d,%d/%d/%d/%d,%d/%d/%d/%*d", &w, &h);
f641fccb	215	fclose(f);
f641fccb	216	if (ret != 2) {
7b66578c	217	err("can't parse %s (%d), skip screen detection", buff, ret);
f641fccb	218	goto skip_screen;
	219	}
	220
7b66578c	221	log("detected %dx%d '%s' (%d) screen attached to fb %d and overlay %d",
b9a19b44	222	w, h, screen_name, screen_id, fb_id, overlay_id);
b9a19b44	223
5f4b1fd3	224	pdata->phys_w = w;
5f4b1fd3	225	pdata->phys_h = h;
b9a19b44	226	return 0;
f641fccb	227
f641fccb	228	skip_screen:
b9a19b44	229	/* attempt to extract this from FB then */
34edc246	230	ret = read_vscreeninfo(fbname, &pdata->phys_w, &pdata->phys_h);
	231	if (ret != 0 && strcmp(fbname, "/dev/fb0") != 0) {
	232	/* last resort */
	233	ret = read_vscreeninfo("/dev/fb0", &pdata->phys_w, &pdata->phys_h);
b9a19b44	234	}
b9a19b44	235
34edc246	236	if (ret != 0) {
b9a19b44	237	err("VSCREENINFO has nothing meaningful");
	238	return -1;
	239	}
	240
b9a19b44	241	return 0;
	242	}
	243
	244	static int osdl_setup_omap_layer(struct SDL_PrivateVideoData *pdata,
	245	const char *fbname, int width, int height, int bpp)
	246	{
	247	int x = 0, y = 0, w = width, h = height; /* layer size and pos */
	248	int screen_w = w, screen_h = h;
f151701d	249	int tmp_w, tmp_h;
b9a19b44	250	const char *tmp;
f11c56a6	251	int retval = -1;
b9a19b44	252	int ret, fd;
b9a19b44	253
5f4b1fd3	254	pdata->layer_x = pdata->layer_y = pdata->layer_w = pdata->layer_h = 0;
	255
	256	if (pdata->phys_w != 0)
	257	screen_w = pdata->phys_w;
	258	if (pdata->phys_h != 0)
	259	screen_h = pdata->phys_h;
b9a19b44	260
	261	fd = open(fbname, O_RDWR);
	262	if (fd == -1) {
	263	err_perror("open %s", fbname);
	264	return -1;
	265	}
	266
	267	/* FIXME: assuming layer doesn't change here */
	268	if (pdata->saved_layer == NULL) {
	269	struct omapfb_saved_layer *slayer;
	270	slayer = calloc(1, sizeof(*slayer));
	271	if (slayer == NULL)
f11c56a6	272	goto out;
b9a19b44	273
	274	ret = ioctl(fd, OMAPFB_QUERY_PLANE, &slayer->pi);
	275	if (ret != 0) {
	276	err_perror("QUERY_PLANE");
f11c56a6	277	goto out;
b9a19b44	278	}
	279
	280	ret = ioctl(fd, OMAPFB_QUERY_MEM, &slayer->mi);
	281	if (ret != 0) {
	282	err_perror("QUERY_MEM");
f11c56a6	283	goto out;
b9a19b44	284	}
	285
	286	pdata->saved_layer = slayer;
	287	}
	288
f641fccb	289	tmp = getenv("SDL_OMAP_LAYER_SIZE");
f641fccb	290	if (tmp != NULL) {
f641fccb	291	if (strcasecmp(tmp, "fullscreen") == 0)
f641fccb	292	w = screen_w, h = screen_h;
f151701d	293	else if (sscanf(tmp, "%dx%d", &tmp_w, &tmp_h) == 2)
f151701d	294	w = tmp_w, h = tmp_h;
f641fccb	295	else
7b66578c	296	err("layer size specified incorrectly, "
7b66578c	297	"should be like 800x480");
f641fccb	298	}
f11c56a6	299
	300	/* the layer can't be set larger than screen */
	301	tmp_w = w, tmp_h = h;
	302	if (w > screen_w)
	303	w = screen_w;
	304	if (h > screen_h)
	305	h = screen_h;
	306	if (w != tmp_w \|\| h != tmp_h)
	307	log("layer resized %dx%d -> %dx%d to fit screen", tmp_w, tmp_h, w, h);
f641fccb	308
	309	x = screen_w / 2 - w / 2;
	310	y = screen_h / 2 - h / 2;
f9b3f440	311	ret = osdl_setup_omapfb(fd, 1, x, y, w, h, width * height * ((bpp + 7) / 8) * 2);
5f4b1fd3	312	if (ret == 0) {
	313	pdata->layer_x = x;
	314	pdata->layer_y = y;
	315	pdata->layer_w = w;
	316	pdata->layer_h = h;
	317	}
f641fccb	318
f11c56a6	319	retval = ret;
	320	out:
	321	close(fd);
	322	return retval;
f641fccb	323	}
f641fccb	324
455c8c43	325	void osdl_video_set_mode(struct SDL_PrivateVideoData pdata,
	326	int border_l, int border_r, int border_t, int border_b,
	327	int width, int height, int bpp, int doublebuf)
f641fccb	328	{
f641fccb	329	const char *fbname;
455c8c43	330	void *result;
f641fccb	331	int ret;
f641fccb	332
b9a19b44	333	fbname = get_fb_device();
f641fccb	334
	335	if (pdata->fbdev != NULL) {
	336	vout_fbdev_finish(pdata->fbdev);
	337	pdata->fbdev = NULL;
	338	}
	339
f641fccb	340	ret = osdl_setup_omap_layer(pdata, fbname, width, height, bpp);
f641fccb	341	if (ret < 0)
455c8c43	342	return NULL;
f641fccb	343
0bb19c41	344	pdata->fbdev = vout_fbdev_init(fbname, &width, &height, bpp, doublebuf ? 2 : 1);
f641fccb	345	if (pdata->fbdev == NULL)
455c8c43	346	return NULL;
	347
	348	if (border_l \| border_r \| border_t \| border_b) {
	349	width -= border_l + border_r;
	350	height -= border_t + border_b;
	351	result = vout_fbdev_resize(pdata->fbdev, width, height, bpp,
	352	border_l, border_r, border_t, border_b, doublebuf ? 2 : 1);
	353	}
	354	else {
	355	result = osdl_video_flip(pdata);
	356	}
	357	if (result == NULL) {
	358	osdl_video_finish(pdata);
	359	return NULL;
	360	}
f641fccb	361
f9b3f440	362	if (!pdata->xenv_up) {
	363	ret = xenv_init();
	364	if (ret == 0)
	365	pdata->xenv_up = 1;
f641fccb	366	}
f641fccb	367
455c8c43	368	return result;
f641fccb	369	}
	370
	371	void osdl_video_flip(struct SDL_PrivateVideoData pdata)
	372	{
52a1749b	373	void *ret;
52a1749b	374
f641fccb	375	if (pdata->fbdev == NULL)
	376	return NULL;
	377
52a1749b	378	ret = vout_fbdev_flip(pdata->fbdev);
52a1749b	379
5f4b1fd3	380	if (pdata->cfg_force_vsync)
f641fccb	381	vout_fbdev_wait_vsync(pdata->fbdev);
f641fccb	382
52a1749b	383	return ret;
f641fccb	384	}
	385
	386	void osdl_video_finish(struct SDL_PrivateVideoData *pdata)
	387	{
	388	static const char *fbname;
	389
b9a19b44	390	fbname = get_fb_device();
f641fccb	391	if (pdata->fbdev != NULL) {
	392	vout_fbdev_finish(pdata->fbdev);
	393	pdata->fbdev = NULL;
	394	}
	395
	396	/* restore the OMAP layer */
	397	if (pdata->saved_layer != NULL) {
	398	struct omapfb_saved_layer *slayer = pdata->saved_layer;
	399	int fd;
	400
	401	fd = open(fbname, O_RDWR);
	402	if (fd != -1) {
	403	int enabled = slayer->pi.enabled;
	404
	405	/* be sure to disable while setting up */
	406	slayer->pi.enabled = 0;
	407	ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi);
	408	ioctl(fd, OMAPFB_SETUP_MEM, &slayer->mi);
	409	if (enabled) {
	410	slayer->pi.enabled = enabled;
	411	ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi);
	412	}
	413	close(fd);
	414	}
	415	free(slayer);
	416	pdata->saved_layer = NULL;
	417	}
	418
f9b3f440	419	if (pdata->xenv_up) {
	420	xenv_finish();
	421	pdata->xenv_up = 0;
f641fccb	422	}
	423	}
	424