frontend/plat_omap.c

   1 /*
   2  * (C) Gražvydas "notaz" Ignotas, 2010-2012
   3  *
   4  * This work is licensed under the terms of the GNU GPLv2 or later.
   5  * See the COPYING file in the top-level directory.
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <fcntl.h>
  13 #include <sys/ioctl.h>
  14 #include <unistd.h>
  15 #include <linux/omapfb.h>
  16
  17 #include "common/menu.h"
  18 #include "linux/fbdev.h"
  19 #include "linux/xenv.h"
  20 #include "plugin_lib.h"
  21 #include "pl_gun_ts.h"
  22 #include "plat.h"
  23 #include "plat_omap.h"
  24 #include "menu.h"
  25
  26 static struct vout_fbdev *main_fb, *layer_fb;
  27
  28 static int omap_setup_layer_(int fd, int enabled, int x, int y, int w, int h)
  29 {
  30         struct omapfb_plane_info pi = { 0, };
  31         struct omapfb_mem_info mi = { 0, };
  32         int ret;
  33
  34         ret = ioctl(fd, OMAPFB_QUERY_PLANE, &pi);
  35         if (ret != 0) {
  36                 perror("QUERY_PLANE");
  37                 return -1;
  38         }
  39
  40         ret = ioctl(fd, OMAPFB_QUERY_MEM, &mi);
  41         if (ret != 0) {
  42                 perror("QUERY_MEM");
  43                 return -1;
  44         }
  45
  46         /* must disable when changing stuff */
  47         if (pi.enabled) {
  48                 pi.enabled = 0;
  49                 ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
  50                 if (ret != 0)
  51                         perror("SETUP_PLANE");
  52         }
  53
  54         if (mi.size < 640*512*3*3) {
  55                 mi.size = 640*512*3*3;
  56                 ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi);
  57                 if (ret != 0) {
  58                         perror("SETUP_MEM");
  59                         return -1;
  60                 }
  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 omap_enable_layer(int enabled)
  79 {
  80         if (enabled)
  81                 pl_set_gun_rect(g_layer_x, g_layer_y, g_layer_w, g_layer_h);
  82
  83         return omap_setup_layer_(vout_fbdev_get_fd(layer_fb), enabled,
  84                 g_layer_x, g_layer_y, g_layer_w, g_layer_h);
  85 }
  86
  87 void plat_omap_gvideo_open(void)
  88 {
  89         omap_enable_layer(1);
  90
  91         // try to align redraws to vsync
  92         vout_fbdev_wait_vsync(layer_fb);
  93 }
  94
  95 void *plat_gvideo_set_mode(int *w, int *h, int *bpp)
  96 {
  97         void *buf;
  98
  99         vout_fbdev_clear(layer_fb);
 100         buf = vout_fbdev_resize(layer_fb, *w, *h, *bpp, 0, 0, 0, 0, 3);
 101
 102         omap_enable_layer(1);
 103
 104         return buf;
 105 }
 106
 107 void *plat_gvideo_flip(void)
 108 {
 109         return vout_fbdev_flip(layer_fb);
 110 }
 111
 112 void plat_gvideo_close(void)
 113 {
 114         omap_enable_layer(0);
 115 }
 116
 117 void plat_video_menu_enter(int is_rom_loaded)
 118 {
 119         g_menuscreen_ptr = vout_fbdev_resize(main_fb,
 120                 g_menuscreen_w, g_menuscreen_h, 16, 0, 0, 0, 0, 3);
 121         if (g_menuscreen_ptr == NULL)
 122                 fprintf(stderr, "warning: vout_fbdev_resize failed\n");
 123
 124         xenv_update(NULL, NULL, NULL, NULL);
 125 }
 126
 127 void plat_video_menu_begin(void)
 128 {
 129 }
 130
 131 void plat_video_menu_end(void)
 132 {
 133         g_menuscreen_ptr = vout_fbdev_flip(main_fb);
 134 }
 135
 136 void plat_video_menu_leave(void)
 137 {
 138         /* have to get rid of panning so that plugins that
 139          * use fb0 and don't ever pan can work. */
 140         vout_fbdev_clear(main_fb);
 141         g_menuscreen_ptr = vout_fbdev_resize(main_fb,
 142                 g_menuscreen_w, g_menuscreen_h, 16, 0, 0, 0, 0, 1);
 143         if (g_menuscreen_ptr == NULL)
 144                 fprintf(stderr, "warning: vout_fbdev_resize failed\n");
 145 }
 146
 147 void plat_minimize(void)
 148 {
 149         omap_enable_layer(0);
 150         xenv_minimize();
 151         omap_enable_layer(1);
 152 }
 153
 154 void *plat_prepare_screenshot(int *w, int *h, int *bpp)
 155 {
 156         return NULL;
 157 }
 158
 159 void plat_omap_init(void)
 160 {
 161         const char *main_fb_name, *layer_fb_name;
 162         int fd, ret, w, h;
 163
 164         main_fb_name = getenv("FBDEV_MAIN");
 165         if (main_fb_name == NULL)
 166                 main_fb_name = "/dev/fb0";
 167
 168         layer_fb_name = getenv("FBDEV_LAYER");
 169         if (layer_fb_name == NULL)
 170                 layer_fb_name = "/dev/fb1";
 171
 172         // must set the layer up first to be able to use it
 173         fd = open(layer_fb_name, O_RDWR);
 174         if (fd == -1) {
 175                 fprintf(stderr, "%s: ", layer_fb_name);
 176                 perror("open");
 177                 exit(1);
 178         }
 179
 180         g_layer_x = 80, g_layer_y = 0;
 181         g_layer_w = 640, g_layer_h = 480;
 182
 183         ret = omap_setup_layer_(fd, 0, g_layer_x, g_layer_y, g_layer_w, g_layer_h);
 184         close(fd);
 185         if (ret != 0) {
 186                 fprintf(stderr, "failed to set up layer, exiting.\n");
 187                 exit(1);
 188         }
 189
 190         xenv_init(NULL, "PCSX-ReARMed");
 191
 192         w = h = 0;
 193         main_fb = vout_fbdev_init(main_fb_name, &w, &h, 16, 2);
 194         if (main_fb == NULL) {
 195                 fprintf(stderr, "couldn't init fb: %s\n", main_fb_name);
 196                 exit(1);
 197         }
 198
 199         g_menuscreen_w = w;
 200         g_menuscreen_h = h;
 201         g_menuscreen_ptr = vout_fbdev_flip(main_fb);
 202         pl_rearmed_cbs.screen_w = w;
 203         pl_rearmed_cbs.screen_h = h;
 204
 205         w = 640;
 206         h = 512;
 207         layer_fb = vout_fbdev_init(layer_fb_name, &w, &h, 16, 3);
 208         if (layer_fb == NULL) {
 209                 fprintf(stderr, "couldn't init fb: %s\n", layer_fb_name);
 210                 goto fail0;
 211         }
 212
 213         return;
 214
 215 fail0:
 216         vout_fbdev_finish(main_fb);
 217         exit(1);
 218 }
 219
 220 void plat_omap_finish(void)
 221 {
 222         omap_enable_layer(0);
 223         vout_fbdev_finish(layer_fb);
 224         vout_fbdev_finish(main_fb);
 225         xenv_finish();
 226 }
 227