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

/*
 * (C) Gražvydas "notaz" Ignotas, 2010
 *
 * 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/oshide.h"

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

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) {
		perror("QUERY_PLANE");
		return -1;
	}

	ret = ioctl(fd, OMAPFB_QUERY_MEM, &mi);
	if (ret != 0) {
		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)
			perror("SETUP_PLANE");
	}

	mi.size = mem;
	ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi);
	if (ret != 0) {
		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) {
		perror("SETUP_PLANE");
		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) {
		fprintf(stderr, "open %s: ", fname);
		perror(NULL);
		return -1;
	}

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

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

	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 fb_id, overlay_id = -1, screen_id = -1;
	char buff[64], screen_name[64];
	struct stat status;
	const char *tmp;
	int i, ret, fd;
	FILE *f;

	fd = open(fbname, O_RDWR);
	if (fd == -1) {
		fprintf(stderr, "open %s: ", fbname);
		perror(NULL);
		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) {
			perror("QUERY_PLANE");
			return -1;
		}

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

		pdata->saved_layer = slayer;
	}

	/* Figure out screen resolution, we will want to center if scaling is not enabled.
	 * The only way to achieve this seems to be walking some sysfs files.. */
	ret = stat(fbname, &status);
	if (ret != 0) {
		fprintf(stderr, "can't stat %s: ", fbname);
		perror(NULL);
		return -1;
	}
	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) {
		fprintf(stderr, "can't open %s, skip screen detection\n", buff);
		goto skip_screen;
	}

	ret = fscanf(f, "%d", &overlay_id);
	fclose(f);
	if (ret != 1) {
		fprintf(stderr, "can't parse %s, skip screen detection\n", 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) {
		fprintf(stderr, "skip screen detection\n");
		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) {
		fprintf(stderr, "could not find screen\n");
		goto skip_screen;
	}

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

	ret = fscanf(f, "%*d,%d/%*d/%*d/%*d,%d/%*d/%*d/%*d", &screen_w, &screen_h);
	fclose(f);
	if (ret != 2) {
		fprintf(stderr, "can't parse %s (%d), skip screen detection\n", buff, ret);
		goto skip_screen;
	}

	printf("detected %dx%d '%s' (%d) screen attached to fb %d and overlay %d\n",
		screen_w, screen_h, screen_name, screen_id, fb_id, overlay_id);

skip_screen:
	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
			fprintf(stderr, "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) * 3);
	close(fd);

	return ret;
}

int osdl_video_set_mode(struct SDL_PrivateVideoData *pdata, int width, int height, int bpp)
{
	const char *fbname;
	int ret;

	bpp = 16; // FIXME

	fbname = getenv("SDL_FBDEV");
	if (fbname == NULL)
		fbname = "/dev/fb1";

	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, 0);
	if (pdata->fbdev == NULL)
		return -1;

	if (!pdata->oshide_done) {
		oshide_init();
		pdata->oshide_done = 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 = getenv("SDL_FBDEV");
	if (fbname == NULL)
		fbname = "/dev/fb1";

	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->oshide_done) {
		oshide_finish();
		pdata->oshide_done = 0;
	}
}
Commit	Line	Data
f641fccb	1	/*
	2	* (C) Gražvydas "notaz" Ignotas, 2010
	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"
	23	#include "linux/oshide.h"
	24
	25	struct omapfb_saved_layer {
	26	struct omapfb_plane_info pi;
	27	struct omapfb_mem_info mi;
	28	};
	29
	30	static int osdl_setup_omapfb(int fd, int enabled, int x, int y, int w, int h, int mem)
	31	{
	32	struct omapfb_plane_info pi;
	33	struct omapfb_mem_info mi;
	34	int ret;
	35
	36	ret = ioctl(fd, OMAPFB_QUERY_PLANE, &pi);
	37	if (ret != 0) {
	38	perror("QUERY_PLANE");
	39	return -1;
	40	}
	41
	42	ret = ioctl(fd, OMAPFB_QUERY_MEM, &mi);
	43	if (ret != 0) {
	44	perror("QUERY_MEM");
	45	return -1;
	46	}
	47
	48	/* must disable when changing stuff */
	49	if (pi.enabled) {
	50	pi.enabled = 0;
	51	ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
	52	if (ret != 0)
	53	perror("SETUP_PLANE");
	54	}
	55
	56	mi.size = mem;
	57	ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi);
	58	if (ret != 0) {
	59	perror("SETUP_MEM");
	60	return -1;
	61	}
	62
	63	pi.pos_x = x;
	64	pi.pos_y = y;
65	pi.out_width = w;
66	pi.out_height = h;
67	pi.enabled = enabled;
68
69	ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
70	if (ret != 0) {
71	perror("SETUP_PLANE");
72	return -1;
73	}
74
75	return 0;
76	}
77
78	static int read_sysfs(const char fname, char buff, size_t size)
79	{
80	FILE *f;
81	int ret;
82
83	f = fopen(fname, "r");
84	if (f == NULL) {
85	fprintf(stderr, "open %s: ", fname);
86	perror(NULL);
87	return -1;
88	}
89
90	ret = fread(buff, 1, size - 1, f);
91	fclose(f);
92	if (ret <= 0) {
93	fprintf(stderr, "read %s: ", fname);
94	perror(NULL);
95	return -1;
96	}
97
98	buff[ret] = 0;
99	for (ret--; ret >= 0 && isspace(buff[ret]); ret--)
100	buff[ret] = 0;
101
102	return 0;
103	}
104
105	static int osdl_setup_omap_layer(struct SDL_PrivateVideoData *pdata,
106	const char *fbname, int width, int height, int bpp)
107	{
108	int x = 0, y = 0, w = width, h = height; /* layer size and pos */
109	int screen_w = w, screen_h = h;
110	int fb_id, overlay_id = -1, screen_id = -1;
111	char buff[64], screen_name[64];
112	struct stat status;
113	const char *tmp;
114	int i, ret, fd;
115	FILE *f;
116
117	fd = open(fbname, O_RDWR);
118	if (fd == -1) {
119	fprintf(stderr, "open %s: ", fbname);
120	perror(NULL);
121	return -1;
122	}
123
124	/* FIXME: assuming layer doesn't change here */
125	if (pdata->saved_layer == NULL) {
126	struct omapfb_saved_layer *slayer;
127	slayer = calloc(1, sizeof(*slayer));
128	if (slayer == NULL)
129	return -1;
130
131	ret = ioctl(fd, OMAPFB_QUERY_PLANE, &slayer->pi);
132	if (ret != 0) {
133	perror("QUERY_PLANE");
134	return -1;
135	}
136
137	ret = ioctl(fd, OMAPFB_QUERY_MEM, &slayer->mi);
138	if (ret != 0) {
139	perror("QUERY_MEM");
140	return -1;
141	}
142
143	pdata->saved_layer = slayer;
144	}
145
146	/* Figure out screen resolution, we will want to center if scaling is not enabled.
147	* The only way to achieve this seems to be walking some sysfs files.. */
148	ret = stat(fbname, &status);
149	if (ret != 0) {
150	fprintf(stderr, "can't stat %s: ", fbname);
151	perror(NULL);
152	return -1;
153	}
154	fb_id = minor(status.st_rdev);
155
156	snprintf(buff, sizeof(buff), "/sys/class/graphics/fb%d/overlays", fb_id);
157	f = fopen(buff, "r");
158	if (f == NULL) {
159	fprintf(stderr, "can't open %s, skip screen detection\n", buff);
160	goto skip_screen;
161	}
162
163	ret = fscanf(f, "%d", &overlay_id);
164	fclose(f);
165	if (ret != 1) {
166	fprintf(stderr, "can't parse %s, skip screen detection\n", buff);
167	goto skip_screen;
168	}
169
170	snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/overlay%d/manager", overlay_id);
171	ret = read_sysfs(buff, screen_name, sizeof(screen_name));
172	if (ret < 0) {
173	fprintf(stderr, "skip screen detection\n");
174	goto skip_screen;
175	}
176
177	for (i = 0; ; i++) {
178	snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/display%d/name", i);
179	ret = read_sysfs(buff, buff, sizeof(buff));
180	if (ret < 0)
181	break;
182
183	if (strcmp(screen_name, buff) == 0) {
184	screen_id = i;
185	break;
186	}
187	}
188
189	if (screen_id < 0) {
190	fprintf(stderr, "could not find screen\n");
191	goto skip_screen;
192	}
193
194	snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/display%d/timings", screen_id);
195	f = fopen(buff, "r");
196	if (f == NULL) {
197	fprintf(stderr, "can't open %s, skip screen detection\n", buff);
198	goto skip_screen;
199	}
200
201	ret = fscanf(f, "%d,%d/%d/%d/%d,%d/%d/%d/%*d", &screen_w, &screen_h);
202	fclose(f);
203	if (ret != 2) {
204	fprintf(stderr, "can't parse %s (%d), skip screen detection\n", buff, ret);
205	goto skip_screen;
206	}
207
208	printf("detected %dx%d '%s' (%d) screen attached to fb %d and overlay %d\n",
209	screen_w, screen_h, screen_name, screen_id, fb_id, overlay_id);
210
211	skip_screen:
212	tmp = getenv("SDL_OMAP_LAYER_SIZE");
213	if (tmp != NULL) {
214	int w_, h_;
215	if (strcasecmp(tmp, "fullscreen") == 0)
216	w = screen_w, h = screen_h;
217	else if (sscanf(tmp, "%dx%d", &w_, &h_) == 2)
218	w = w_, h = h_;
219	else
220	fprintf(stderr, "layer size specified incorrectly, "
221	"should be like 800x480");
222	}
223
224	x = screen_w / 2 - w / 2;
225	y = screen_h / 2 - h / 2;
226	ret = osdl_setup_omapfb(fd, 1, x, y, w, h, width * height * ((bpp + 7) / 8) * 3);
227	close(fd);
228
229	return ret;
230	}
231
232	int osdl_video_set_mode(struct SDL_PrivateVideoData *pdata, int width, int height, int bpp)
233	{
234	const char *fbname;
235	int ret;
236
237	bpp = 16; // FIXME
238
239	fbname = getenv("SDL_FBDEV");
240	if (fbname == NULL)
241	fbname = "/dev/fb1";
242
243	if (pdata->fbdev != NULL) {
244	vout_fbdev_finish(pdata->fbdev);
245	pdata->fbdev = NULL;
246	}
247
248	omapsdl_config_from_env();
249
250	ret = osdl_setup_omap_layer(pdata, fbname, width, height, bpp);
251	if (ret < 0)
252	return -1;
253
254	pdata->fbdev = vout_fbdev_init(fbname, &width, &height, 0);
255	if (pdata->fbdev == NULL)
256	return -1;
257
258	if (!pdata->oshide_done) {
259	oshide_init();
260	pdata->oshide_done = 1;
261	}
262
263	return 0;
264	}
265
266	void osdl_video_flip(struct SDL_PrivateVideoData pdata)
267	{
268	if (pdata->fbdev == NULL)
269	return NULL;
270
271	if (gcfg_force_vsync)
272	vout_fbdev_wait_vsync(pdata->fbdev);
273
274	return vout_fbdev_flip(pdata->fbdev);
275	}
276
277	void osdl_video_finish(struct SDL_PrivateVideoData *pdata)
278	{
279	static const char *fbname;
280
281	fbname = getenv("SDL_FBDEV");
282	if (fbname == NULL)
283	fbname = "/dev/fb1";
284
285	if (pdata->fbdev != NULL) {
286	vout_fbdev_finish(pdata->fbdev);
287	pdata->fbdev = NULL;
288	}
289
290	/* restore the OMAP layer */
291	if (pdata->saved_layer != NULL) {
292	struct omapfb_saved_layer *slayer = pdata->saved_layer;
293	int fd;
294
295	fd = open(fbname, O_RDWR);
296	if (fd != -1) {
297	int enabled = slayer->pi.enabled;
298
299	/* be sure to disable while setting up */
300	slayer->pi.enabled = 0;
301	ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi);
302	ioctl(fd, OMAPFB_SETUP_MEM, &slayer->mi);
303	if (enabled) {
304	slayer->pi.enabled = enabled;
305	ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi);
306	}
307	close(fd);
308	}
309	free(slayer);
310	pdata->saved_layer = NULL;
311	}
312
313	if (pdata->oshide_done) {
314	oshide_finish();
315	pdata->oshide_done = 0;
316	}
317	}
318