src/video/omapdss/osdl_video.c

   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