src/video/omapdss/osdl_video.c

   1 /*
   2  * (C) Gražvydas "notaz" Ignotas, 2010-2011
   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/xenv.h"
  24
  25 struct omapfb_saved_layer {
  26         struct omapfb_plane_info pi;
  27         struct omapfb_mem_info mi;
  28 };
  29
  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
  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         memset(&pi, 0, sizeof(pi));
  46         memset(&mi, 0, sizeof(mi));
  47
  48         ret = ioctl(fd, OMAPFB_QUERY_PLANE, &pi);
  49         if (ret != 0) {
  50                 err_perror("QUERY_PLANE");
  51                 return -1;
  52         }
  53
  54         ret = ioctl(fd, OMAPFB_QUERY_MEM, &mi);
  55         if (ret != 0) {
  56                 err_perror("QUERY_MEM");
  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)
  65                         err_perror("SETUP_PLANE");
  66         }
  67
  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                 }
  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) {
  85                 err_perror("SETUP_PLANE");
  86                 err("(%d %d %d %d)\n", x, y, w, h);
  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) {
 100                 err_perror("open %s: ", fname);
 101                 return -1;
 102         }
 103
 104         ret = fread(buff, 1, size - 1, f);
 105         fclose(f);
 106         if (ret <= 0) {
 107                 err_perror("read %s: ", fname);
 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
 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
 145 int osdl_video_detect_screen(struct SDL_PrivateVideoData *pdata)
 146 {
 147         int fb_id, overlay_id = -1, screen_id = -1;
 148         char buff[64], screen_name[64];
 149         const char *fbname;
 150         struct stat status;
 151         int fd, i, ret;
 152         int w, h;
 153         FILE *f;
 154
 155         pdata->phys_w = pdata->phys_h = 0;
 156
 157         fbname = get_fb_device();
 158
 159         /* Figure out screen resolution, we need to know default resolution
 160          * to report to SDL and for centering stuff.
 161          * The only way to achieve this seems to be walking some sysfs files.. */
 162         ret = stat(fbname, &status);
 163         if (ret != 0) {
 164                 err_perror("can't stat %s", fbname);
 165                 goto skip_screen;
 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) {
 172                 err("can't open %s, skip screen detection", buff);
 173                 goto skip_screen;
 174         }
 175
 176         ret = fscanf(f, "%d", &overlay_id);
 177         fclose(f);
 178         if (ret != 1) {
 179                 err("can't parse %s, skip screen detection", buff);
 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) {
 186                 err("skip screen detection");
 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) {
 203                 err("could not find screen");
 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) {
 210                 err("can't open %s, skip screen detection", buff);
 211                 goto skip_screen;
 212         }
 213
 214         ret = fscanf(f, "%*d,%d/%*d/%*d/%*d,%d/%*d/%*d/%*d", &w, &h);
 215         fclose(f);
 216         if (ret != 2) {
 217                 err("can't parse %s (%d), skip screen detection", buff, ret);
 218                 goto skip_screen;
 219         }
 220
 221         log("detected %dx%d '%s' (%d) screen attached to fb %d and overlay %d",
 222                 w, h, screen_name, screen_id, fb_id, overlay_id);
 223
 224         pdata->phys_w = w;
 225         pdata->phys_h = h;
 226         return 0;
 227
 228 skip_screen:
 229         /* attempt to extract this from FB then */
 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);
 234         }
 235
 236         if (ret != 0) {
 237                 err("VSCREENINFO has nothing meaningful");
 238                 return -1;
 239         }
 240
 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;
 249         int tmp_w, tmp_h;
 250         const char *tmp;
 251         int retval = -1;
 252         int ret, fd;
 253
 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;
 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)
 272                         goto out;
 273
 274                 ret = ioctl(fd, OMAPFB_QUERY_PLANE, &slayer->pi);
 275                 if (ret != 0) {
 276                         err_perror("QUERY_PLANE");
 277                         goto out;
 278                 }
 279
 280                 ret = ioctl(fd, OMAPFB_QUERY_MEM, &slayer->mi);
 281                 if (ret != 0) {
 282                         err_perror("QUERY_MEM");
 283                         goto out;
 284                 }
 285
 286                 pdata->saved_layer = slayer;
 287         }
 288
 289         tmp = getenv("SDL_OMAP_LAYER_SIZE");
 290         if (tmp != NULL) {
 291                 if (strcasecmp(tmp, "fullscreen") == 0)
 292                         w = screen_w, h = screen_h;
 293                 else if (sscanf(tmp, "%dx%d", &tmp_w, &tmp_h) == 2)
 294                         w = tmp_w, h = tmp_h;
 295                 else
 296                         err("layer size specified incorrectly, "
 297                                 "should be like 800x480");
 298         }
 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);
 308
 309         x = screen_w / 2 - w / 2;
 310         y = screen_h / 2 - h / 2;
 311         ret = osdl_setup_omapfb(fd, 1, x, y, w, h, width * height * ((bpp + 7) / 8) * 2);
 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         }
 318
 319         retval = ret;
 320 out:
 321         close(fd);
 322         return retval;
 323 }
 324
 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)
 328 {
 329         const char *fbname;
 330         void *result;
 331         int ret;
 332
 333         fbname = get_fb_device();
 334
 335         if (pdata->fbdev != NULL) {
 336                 vout_fbdev_finish(pdata->fbdev);
 337                 pdata->fbdev = NULL;
 338         }
 339
 340         ret = osdl_setup_omap_layer(pdata, fbname, width, height, bpp);
 341         if (ret < 0)
 342                 return NULL;
 343
 344         pdata->fbdev = vout_fbdev_init(fbname, &width, &height, bpp, doublebuf ? 2 : 1);
 345         if (pdata->fbdev == NULL)
 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         }
 361
 362         if (!pdata->xenv_up) {
 363                 ret = xenv_init();
 364                 if (ret == 0)
 365                         pdata->xenv_up = 1;
 366         }
 367
 368         return result;
 369 }
 370
 371 void *osdl_video_flip(struct SDL_PrivateVideoData *pdata)
 372 {
 373         void *ret;
 374
 375         if (pdata->fbdev == NULL)
 376                 return NULL;
 377
 378         ret = vout_fbdev_flip(pdata->fbdev);
 379
 380         if (pdata->cfg_force_vsync)
 381                 vout_fbdev_wait_vsync(pdata->fbdev);
 382
 383         return ret;
 384 }
 385
 386 void osdl_video_finish(struct SDL_PrivateVideoData *pdata)
 387 {
 388         static const char *fbname;
 389
 390         fbname = get_fb_device();
 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
 419         if (pdata->xenv_up) {
 420                 xenv_finish();
 421                 pdata->xenv_up = 0;
 422         }
 423 }
 424