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

	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 osdl_video_detect_screen(struct SDL_PrivateVideoData *pdata)
{
	int fb_id, overlay_id = -1, screen_id = -1;
	struct fb_var_screeninfo fbvar;
	char buff[64], screen_name[64];
	const char *fbname;
	struct stat status;
	int fd, i, ret;
	int w, h;
	FILE *f;

	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->screen_w = w;
	pdata->screen_h = h;
	return 0;

skip_screen:
	/* attempt to extract this from FB then */
	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) {
		err("VSCREENINFO has nothing meaningful");
		return -1;
	}

	pdata->screen_w = fbvar.xres;
	pdata->screen_h = fbvar.yres;
	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 ret, fd;

	if (pdata->screen_w != 0)
		screen_w = pdata->screen_w;
	if (pdata->screen_h != 0)
		screen_h = pdata->screen_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)
			return -1;

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

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

		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");
	}
	else {
		/* 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);
	close(fd);

	return ret;
}

int osdl_video_set_mode(struct SDL_PrivateVideoData *pdata,
			int width, int height, int bpp, int doublebuf)
{
	const char *fbname;
	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 -1;

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

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

	return 0;
}

void *osdl_video_flip(struct SDL_PrivateVideoData *pdata)
{
	if (pdata->fbdev == NULL)
		return NULL;

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

	return vout_fbdev_flip(pdata->fbdev);
}

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