src/tbm_bufmgr_emulator.c

   1 #ifdef HAVE_CONFIG_H
   2 #include "config.h"
   3 #endif
   4
   5 #include <tbm_bufmgr.h>
   6 #include <tbm_bufmgr_backend.h>
   7 #include "vigs.h"
   8 #include "tbm_emulator_log.h"
   9 #include <string.h>
  10 #include <stdlib.h>
  11
  12 static tbm_bo_handle get_tbm_bo_handle(struct vigs_drm_gem *gem,
  13                                        int device)
  14 {
  15     tbm_bo_handle bo_handle;
  16     int ret;
  17
  18     memset(&bo_handle, 0, sizeof(bo_handle));
  19
  20     switch (device) {
  21     case TBM_DEVICE_DEFAULT:
  22     case TBM_DEVICE_2D:
  23         bo_handle.u32 = gem->handle;
  24         break;
  25     case TBM_DEVICE_CPU:
  26         ret = vigs_drm_gem_map(gem);
  27
  28         if (ret == 0) {
  29             bo_handle.ptr = gem->vaddr;
  30         } else {
  31             TBM_EMULATOR_LOG_ERROR("vigs_drm_gem_map failed: %s",
  32                                    strerror(-ret));
  33         }
  34
  35         break;
  36     case TBM_DEVICE_3D:
  37         TBM_EMULATOR_LOG_ERROR("TBM_DEVICE_3D not supported");
  38         break;
  39     case TBM_DEVICE_MM:
  40         TBM_EMULATOR_LOG_ERROR("TBM_DEVICE_MM not supported");
  41         break;
  42     default:
  43         TBM_EMULATOR_LOG_ERROR("%d not supported", device);
  44         break;
  45     }
  46
  47     return bo_handle;
  48 }
  49
  50 static void tbm_bufmgr_emulator_deinit(void *priv)
  51 {
  52     struct vigs_drm_device *drm_dev = priv;
  53
  54     TBM_EMULATOR_LOG_DEBUG("enter");
  55
  56     vigs_drm_device_destroy(drm_dev);
  57 }
  58
  59 static int tbm_bufmgr_emulator_bo_size(tbm_bo bo)
  60 {
  61     struct vigs_drm_surface *sfc;
  62
  63     TBM_EMULATOR_LOG_DEBUG("bo = %p", bo);
  64
  65     sfc = (struct vigs_drm_surface*)tbm_backend_get_bo_priv(bo);
  66
  67     return sfc->gem.size;
  68 }
  69
  70 static void *tbm_bufmgr_emulator_bo_alloc(tbm_bo bo, int size, int flags)
  71 {
  72     TBM_EMULATOR_LOG_ERROR("not supported");
  73     return NULL;
  74 }
  75
  76 static void tbm_bufmgr_emulator_bo_free(tbm_bo bo)
  77 {
  78     struct vigs_drm_surface *sfc;
  79
  80     TBM_EMULATOR_LOG_DEBUG("bo = %p", bo);
  81
  82     sfc = (struct vigs_drm_surface*)tbm_backend_get_bo_priv(bo);
  83
  84     vigs_drm_gem_unref(&sfc->gem);
  85 }
  86
  87 static void *tbm_bufmgr_emulator_bo_import(tbm_bo bo, unsigned int key)
  88 {
  89     struct vigs_drm_device *drm_dev;
  90     int ret;
  91     struct vigs_drm_surface *sfc;
  92
  93     TBM_EMULATOR_LOG_DEBUG("bo = %p, key = %u", bo, key);
  94
  95     drm_dev = (struct vigs_drm_device*)tbm_backend_get_bufmgr_priv(bo);
  96
  97     ret = vigs_drm_surface_open(drm_dev, key, &sfc);
  98
  99     if (ret != 0) {
 100         TBM_EMULATOR_LOG_ERROR("vigs_drm_surface_open failed for key %u: %s",
 101                                key,
 102                                strerror(-ret));
 103         return NULL;
 104     }
 105
 106     TBM_EMULATOR_LOG_DEBUG("handle = %u", sfc->gem.handle);
 107
 108     return sfc;
 109 }
 110
 111 static unsigned int tbm_bufmgr_emulator_bo_export(tbm_bo bo)
 112 {
 113     struct vigs_drm_surface *sfc;
 114     int ret;
 115
 116     TBM_EMULATOR_LOG_DEBUG("bo = %p", bo);
 117
 118     sfc = (struct vigs_drm_surface*)tbm_backend_get_bo_priv(bo);
 119
 120     ret = vigs_drm_gem_get_name(&sfc->gem);
 121
 122     if (ret != 0) {
 123         TBM_EMULATOR_LOG_ERROR("vigs_drm_gem_get_name failed: %s",
 124                                strerror(-ret));
 125         return 0;
 126     }
 127
 128     return sfc->gem.name;
 129 }
 130
 131 static tbm_bo_handle tbm_bufmgr_emulator_bo_get_handle(tbm_bo bo, int device)
 132 {
 133     struct vigs_drm_surface *sfc;
 134
 135     TBM_EMULATOR_LOG_DEBUG("bo = %p, device = %d", bo, device);
 136
 137     sfc = (struct vigs_drm_surface*)tbm_backend_get_bo_priv(bo);
 138
 139     return get_tbm_bo_handle(&sfc->gem, device);
 140 }
 141
 142 static tbm_bo_handle tbm_bufmgr_emulator_bo_map(tbm_bo bo, int device, int opt)
 143 {
 144     struct vigs_drm_surface *sfc;
 145     tbm_bo_handle handle;
 146     uint32_t saf = 0;
 147
 148     TBM_EMULATOR_LOG_DEBUG("bo = %p, device = %d, opt = %d", bo, device, opt);
 149
 150     sfc = (struct vigs_drm_surface*)tbm_backend_get_bo_priv(bo);
 151
 152     handle = get_tbm_bo_handle(&sfc->gem, device);
 153
 154     if (!handle.ptr) {
 155         return handle;
 156     }
 157
 158     if ((opt & TBM_OPTION_READ) != 0) {
 159         saf |= VIGS_DRM_SAF_READ;
 160     }
 161
 162     if ((opt & TBM_OPTION_WRITE) != 0) {
 163         saf |= VIGS_DRM_SAF_WRITE;
 164     }
 165
 166     vigs_drm_surface_start_access(sfc, saf);
 167
 168     return handle;
 169 }
 170
 171 static int tbm_bufmgr_emulator_bo_unmap(tbm_bo bo)
 172 {
 173     struct vigs_drm_surface *sfc;
 174
 175     TBM_EMULATOR_LOG_DEBUG("bo = %p", bo);
 176
 177     sfc = (struct vigs_drm_surface*)tbm_backend_get_bo_priv(bo);
 178
 179     vigs_drm_surface_end_access(sfc, 1);
 180
 181     return 1;
 182 }
 183
 184 static int tbm_bufmgr_emulator_bo_cache_flush(tbm_bo bo, int flags)
 185 {
 186     TBM_EMULATOR_LOG_DEBUG("bo = %p, flags = %d", bo, flags);
 187     return 1;
 188 }
 189
 190 static int tbm_bufmgr_emulator_bo_get_global_key(tbm_bo bo)
 191 {
 192     struct vigs_drm_surface *sfc;
 193     int ret;
 194
 195     TBM_EMULATOR_LOG_DEBUG("bo = %p", bo);
 196
 197     sfc = (struct vigs_drm_surface*)tbm_backend_get_bo_priv(bo);
 198
 199     ret = vigs_drm_gem_get_name(&sfc->gem);
 200
 201     if (ret != 0) {
 202         TBM_EMULATOR_LOG_ERROR("vigs_drm_gem_get_name failed: %s",
 203                                strerror(-ret));
 204         return 0;
 205     }
 206
 207     return sfc->gem.name;
 208 }
 209
 210 MODULEINITPPROTO(tbm_bufmgr_emulator_init);
 211
 212 static TBMModuleVersionInfo EmulatorVersRec =
 213 {
 214     "emulator",
 215     "Samsung",
 216     TBM_ABI_VERSION,
 217 };
 218
 219 TBMModuleData tbmModuleData = { &EmulatorVersRec, tbm_bufmgr_emulator_init };
 220
 221 int tbm_bufmgr_emulator_init(tbm_bufmgr bufmgr, int fd)
 222 {
 223     int ret = 0;
 224     struct vigs_drm_device *drm_dev = NULL;
 225     tbm_bufmgr_backend backend = NULL;
 226
 227     TBM_EMULATOR_LOG_DEBUG("enter");
 228
 229     if (!bufmgr) {
 230         return 0;
 231     }
 232
 233     ret = vigs_drm_device_create(fd, &drm_dev);
 234
 235     if (ret != 0) {
 236         TBM_EMULATOR_LOG_ERROR("vigs_drm_device_create failed: %s", strerror(-ret));
 237         goto fail;
 238     }
 239
 240     backend = tbm_backend_alloc();
 241
 242     if (!backend) {
 243         TBM_EMULATOR_LOG_ERROR("tbm_backend_alloc failed");
 244         goto fail;
 245     }
 246
 247     backend->flags = 0;
 248     backend->priv = (void*)drm_dev;
 249     backend->bufmgr_deinit = tbm_bufmgr_emulator_deinit;
 250     backend->bo_size = tbm_bufmgr_emulator_bo_size;
 251     backend->bo_alloc = tbm_bufmgr_emulator_bo_alloc;
 252     backend->bo_free = tbm_bufmgr_emulator_bo_free;
 253     backend->bo_import = tbm_bufmgr_emulator_bo_import;
 254     backend->bo_export = tbm_bufmgr_emulator_bo_export;
 255     backend->bo_get_handle = tbm_bufmgr_emulator_bo_get_handle;
 256     backend->bo_map = tbm_bufmgr_emulator_bo_map;
 257     backend->bo_unmap = tbm_bufmgr_emulator_bo_unmap;
 258     backend->bo_cache_flush = tbm_bufmgr_emulator_bo_cache_flush;
 259     backend->bo_get_global_key = tbm_bufmgr_emulator_bo_get_global_key;
 260     backend->bo_lock = NULL;
 261     backend->bo_unlock = NULL;
 262
 263     if (!tbm_backend_init(bufmgr, backend)) {
 264         TBM_EMULATOR_LOG_ERROR("tbm_backend_init failed");
 265         goto fail;
 266     }
 267
 268     TBM_EMULATOR_LOG_INFO("initialized");
 269
 270     return 1;
 271
 272 fail:
 273     if (backend) {
 274         tbm_backend_free(backend);
 275     }
 276
 277     if (drm_dev) {
 278         vigs_drm_device_destroy(drm_dev);
 279     }
 280
 281     return 0;
 282 }