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