[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;
	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) {
		int w_, h_;
		if (strcasecmp(tmp, "fullscreen") == 0)
			w = screen_w, h = screen_h;
		else if (sscanf(tmp, "%dx%d", &w_, &h_) == 2)
			w = w_, h = h_;
		else
			err("layer size specified incorrectly, "
				"should be like 800x480");
	}

	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)
{
	const char *fbname;
	int ret;

	fbname = get_fb_device();

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

	omapsdl_config_from_env();

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

	pdata->fbdev = vout_fbdev_init(fbname, &width, &height, bpp, 2);
	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;
	227	const char *tmp;
	228	int ret, fd;
	229
	230	if (pdata->screen_w != 0)
	231	screen_w = pdata->screen_w;
	232	if (pdata->screen_h != 0)
	233	screen_h = pdata->screen_h;
	234
	235	fd = open(fbname, O_RDWR);
	236	if (fd == -1) {
	237	err_perror("open %s", fbname);
	238	return -1;
	239	}
	240
	241	/* FIXME: assuming layer doesn't change here */
	242	if (pdata->saved_layer == NULL) {
	243	struct omapfb_saved_layer *slayer;
	244	slayer = calloc(1, sizeof(*slayer));
	245	if (slayer == NULL)
	246	return -1;
	247
	248	ret = ioctl(fd, OMAPFB_QUERY_PLANE, &slayer->pi);
	249	if (ret != 0) {
	250	err_perror("QUERY_PLANE");
	251	return -1;
	252	}
	253
	254	ret = ioctl(fd, OMAPFB_QUERY_MEM, &slayer->mi);
	255	if (ret != 0) {
	256	err_perror("QUERY_MEM");
	257	return -1;
	258	}
	259
	260	pdata->saved_layer = slayer;
	261	}
262
f641fccb	263	tmp = getenv("SDL_OMAP_LAYER_SIZE");
	264	if (tmp != NULL) {
	265	int w_, h_;
	266	if (strcasecmp(tmp, "fullscreen") == 0)
	267	w = screen_w, h = screen_h;
	268	else if (sscanf(tmp, "%dx%d", &w_, &h_) == 2)
	269	w = w_, h = h_;
	270	else
7b66578c	271	err("layer size specified incorrectly, "
7b66578c	272	"should be like 800x480");
f641fccb	273	}
	274
	275	x = screen_w / 2 - w / 2;
	276	y = screen_h / 2 - h / 2;
f9b3f440	277	ret = osdl_setup_omapfb(fd, 1, x, y, w, h, width * height * ((bpp + 7) / 8) * 2);
f641fccb	278	close(fd);
	279
	280	return ret;
	281	}
	282
	283	int osdl_video_set_mode(struct SDL_PrivateVideoData *pdata, int width, int height, int bpp)
	284	{
	285	const char *fbname;
	286	int ret;
	287
b9a19b44	288	fbname = get_fb_device();
f641fccb	289
	290	if (pdata->fbdev != NULL) {
	291	vout_fbdev_finish(pdata->fbdev);
	292	pdata->fbdev = NULL;
	293	}
	294
	295	omapsdl_config_from_env();
	296
	297	ret = osdl_setup_omap_layer(pdata, fbname, width, height, bpp);
	298	if (ret < 0)
	299	return -1;
	300
f9b3f440	301	pdata->fbdev = vout_fbdev_init(fbname, &width, &height, bpp, 2);
f641fccb	302	if (pdata->fbdev == NULL)
	303	return -1;
	304
f9b3f440	305	if (!pdata->xenv_up) {
	306	ret = xenv_init();
	307	if (ret == 0)
	308	pdata->xenv_up = 1;
f641fccb	309	}
	310
	311	return 0;
	312	}
	313
	314	void osdl_video_flip(struct SDL_PrivateVideoData pdata)
	315	{
	316	if (pdata->fbdev == NULL)
	317	return NULL;
	318
	319	if (gcfg_force_vsync)
	320	vout_fbdev_wait_vsync(pdata->fbdev);
	321
	322	return vout_fbdev_flip(pdata->fbdev);
	323	}
	324
	325	void osdl_video_finish(struct SDL_PrivateVideoData *pdata)
	326	{
	327	static const char *fbname;
	328
b9a19b44	329	fbname = get_fb_device();
f641fccb	330	if (pdata->fbdev != NULL) {
	331	vout_fbdev_finish(pdata->fbdev);
	332	pdata->fbdev = NULL;
	333	}
	334
	335	/* restore the OMAP layer */
	336	if (pdata->saved_layer != NULL) {
	337	struct omapfb_saved_layer *slayer = pdata->saved_layer;
	338	int fd;
	339
	340	fd = open(fbname, O_RDWR);
	341	if (fd != -1) {
	342	int enabled = slayer->pi.enabled;
	343
	344	/* be sure to disable while setting up */
	345	slayer->pi.enabled = 0;
	346	ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi);
	347	ioctl(fd, OMAPFB_SETUP_MEM, &slayer->mi);
	348	if (enabled) {
	349	slayer->pi.enabled = enabled;
	350	ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi);
	351	}
	352	close(fd);
	353	}
	354	free(slayer);
	355	pdata->saved_layer = NULL;
	356	}
	357
f9b3f440	358	if (pdata->xenv_up) {
	359	xenv_finish();
	360	pdata->xenv_up = 0;
f641fccb	361	}
	362	}
	363