hwcomposer_import_nv_gralloc.cpp

/*
 * Copyright (C) 2015 The Android Open Source Project
 * Copyright (C) 2015 NVIDIA Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <cutils/log.h>
#include <hardware/gralloc.h>

#include <stdlib.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include "drm_hwcomposer.h"

#define ARRAY_SIZE(arr) (int)(sizeof(arr) / sizeof((arr)[0]))

struct hwc_import_context {
  const gralloc_module_t *gralloc_module;
};

int hwc_import_init(struct hwc_import_context **ctx) {
  struct hwc_import_context *import_ctx = (struct hwc_import_context *)calloc(1, sizeof(*import_ctx));
  if (!ctx) {
    ALOGE("Failed to allocate gralloc import context");
    return -ENOMEM;
  }

  int ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
                      (const hw_module_t **)&import_ctx->gralloc_module);
  if (ret) {
    ALOGE("Failed to open gralloc module");
    free(import_ctx);
    return ret;
  }

  if (!strcasecmp(import_ctx->gralloc_module->common.author, "NVIDIA"))
    ALOGW("Using non-NVIDIA gralloc module: %s\n",
          import_ctx->gralloc_module->common.name);

  *ctx = import_ctx;

  return 0;
}

int hwc_import_destroy(struct hwc_import_context *ctx) {
  free(ctx);
  return 0;
}

struct importer_priv {
  int drm_fd;
  struct hwc_drm_bo bo;
};

static void free_priv(void *p) {
  struct importer_priv *priv = (struct importer_priv *)p;
  if (priv->bo.fb_id) {
    int ret = drmModeRmFB(priv->drm_fd, priv->bo.fb_id);
    if (ret)
      ALOGE("Failed to rm fb %d", ret);
  }

  struct drm_gem_close gem_close;
  memset(&gem_close, 0, sizeof(gem_close));
  for (int i = 0; i < ARRAY_SIZE(priv->bo.gem_handles); i++) {
    if (!priv->bo.gem_handles[i])
      continue;
    gem_close.handle = priv->bo.gem_handles[i];
    int ret = drmIoctl(priv->drm_fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
    if (ret)
      ALOGE("Failed to close gem handle %d", ret);
  }

  free(priv);
}

static int hwc_import_set_priv(hwc_import_context *ctx, buffer_handle_t handle,
                               struct importer_priv *priv) {
  const gralloc_module_t *g = ctx->gralloc_module;
  return g->perform(g, GRALLOC_MODULE_PERFORM_SET_IMPORTER_PRIVATE, handle,
                    free_priv, priv);
}

static struct importer_priv *hwc_import_get_priv(hwc_import_context *ctx,
                                                 buffer_handle_t handle) {
  const gralloc_module_t *g = ctx->gralloc_module;
  void *priv = NULL;
  int ret = g->perform(g, GRALLOC_MODULE_PERFORM_GET_IMPORTER_PRIVATE, handle,
                   free_priv, &priv);
  return ret ? NULL : (struct importer_priv *)priv;
}

int hwc_import_bo_create(int fd, hwc_import_context *ctx,
                         buffer_handle_t handle, struct hwc_drm_bo *bo) {
  /* Get imported bo that is cached in gralloc buffer, or create a new one. */
  struct importer_priv *priv = hwc_import_get_priv(ctx, handle);
  if (priv) {
    *bo = priv->bo;
    return 0;
  }

  priv = (struct importer_priv *)calloc(1, sizeof(*priv));
  if (!priv)
    return -ENOMEM;
  priv->drm_fd = fd;

  const gralloc_module_t *g = ctx->gralloc_module;
  int ret =
      g->perform(g, GRALLOC_MODULE_PERFORM_DRM_IMPORT, fd, handle, &priv->bo);
  if (ret) {
    ALOGE("GRALLOC_MODULE_PERFORM_DRM_IMPORT failed %d", ret);
    free_priv(priv);
    return ret;
  }

  ret = drmModeAddFB2(fd, priv->bo.width, priv->bo.height, priv->bo.format,
                      priv->bo.gem_handles, priv->bo.pitches,
                      priv->bo.offsets, &priv->bo.fb_id, 0);
  if (ret) {
    ALOGE("Failed to add fb %d", ret);
    free_priv(priv);
    return ret;
  }

  ret = hwc_import_set_priv(ctx, handle, priv);
  if (ret) {
    /* This will happen is persist.tegra.gpu_mapping_cache is 0/off,
     * or if NV gralloc runs out of "priv slots" (currently 3 per buffer,
     * only one of which should be used by drm_hwcomposer). */
    ALOGE("Failed to register free callback for imported buffer %d", ret);
    free_priv(priv);
    return ret;
  }
  *bo = priv->bo;
  return ret;
}

bool hwc_import_bo_release(int fd, hwc_import_context *ctx,
                           struct hwc_drm_bo *bo) {
  /* hwc may not close the gem handles, we own them */
  return false;
}