ret = amdgpu_query_gpu(fd, &gpu_info);
if (ret) {
- fprintf(stderr, "[%s]failed with error =%d\n", __func__, ret);
+ drv_log("failed with error =%d\n", ret);
return NULL;
}
addr_ret = AddrCreate(&addr_create_input, &addr_create_output);
if (addr_ret != ADDR_OK) {
- fprintf(stderr, "[%s]failed error =%d\n", __func__, addr_ret);
+ drv_log("failed error =%d\n", addr_ret);
return NULL;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_AMDGPU_GEM_MMAP, &gem_map);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_AMDGPU_GEM_MMAP failed\n");
+ drv_log("DRM_IOCTL_AMDGPU_GEM_MMAP failed\n");
return MAP_FAILED;
}
* just use the first kernel buffer.
*/
if (drv_num_buffers_per_bo(bo_) != 1) {
- cros_gralloc_error("Can only support one buffer per bo.");
+ drv_log("Can only support one buffer per bo.\n");
return -EINVAL;
}
}
if (vaddr == MAP_FAILED) {
- cros_gralloc_error("Mapping failed.");
+ drv_log("Mapping failed.\n");
return -EFAULT;
}
}
int32_t cros_gralloc_buffer::unlock()
{
if (lockcount_ <= 0) {
- cros_gralloc_error("Buffer was not locked.");
+ drv_log("Buffer was not locked.\n");
return -EINVAL;
}
bo = drv_bo_create(drv_, descriptor->width, descriptor->height, resolved_format,
descriptor->use_flags);
if (!bo) {
- cros_gralloc_error("Failed to create bo.");
+ drv_log("Failed to create bo.\n");
return -ENOMEM;
}
*/
if (drv_num_buffers_per_bo(bo) != 1) {
drv_bo_destroy(bo);
- cros_gralloc_error("Can only support one buffer per bo.");
+ drv_log("Can only support one buffer per bo.\n");
return -EINVAL;
}
auto hnd = cros_gralloc_convert_handle(handle);
if (!hnd) {
- cros_gralloc_error("Invalid handle.");
+ drv_log("Invalid handle.\n");
return -EINVAL;
}
}
if (drmPrimeFDToHandle(drv_get_fd(drv_), hnd->fds[0], &id)) {
- cros_gralloc_error("drmPrimeFDToHandle failed.");
+ drv_log("drmPrimeFDToHandle failed.\n");
return -errno;
}
auto hnd = cros_gralloc_convert_handle(handle);
if (!hnd) {
- cros_gralloc_error("Invalid handle.");
+ drv_log("Invalid handle.\n");
return -EINVAL;
}
auto buffer = get_buffer(hnd);
if (!buffer) {
- cros_gralloc_error("Invalid Reference.");
+ drv_log("Invalid Reference.\n");
return -EINVAL;
}
std::lock_guard<std::mutex> lock(mutex_);
auto hnd = cros_gralloc_convert_handle(handle);
if (!hnd) {
- cros_gralloc_error("Invalid handle.");
+ drv_log("Invalid handle.\n");
return -EINVAL;
}
auto buffer = get_buffer(hnd);
if (!buffer) {
- cros_gralloc_error("Invalid Reference.");
+ drv_log("Invalid Reference.\n");
return -EINVAL;
}
auto hnd = cros_gralloc_convert_handle(handle);
if (!hnd) {
- cros_gralloc_error("Invalid handle.");
+ drv_log("Invalid handle.\n");
return -EINVAL;
}
auto buffer = get_buffer(hnd);
if (!buffer) {
- cros_gralloc_error("Invalid Reference.");
+ drv_log("Invalid Reference.\n");
return -EINVAL;
}
auto hnd = cros_gralloc_convert_handle(handle);
if (!hnd) {
- cros_gralloc_error("Invalid handle.");
+ drv_log("Invalid handle.\n");
return -EINVAL;
}
auto buffer = get_buffer(hnd);
if (!buffer) {
- cros_gralloc_error("Invalid Reference.");
+ drv_log("Invalid Reference.\n");
return -EINVAL;
}
#include "cros_gralloc_helpers.h"
-#include <cstdlib>
-#include <cutils/log.h>
#include <sync/sync.h>
uint32_t cros_gralloc_convert_format(int format)
*/
int err = sync_wait(acquire_fence, 1000);
if (err < 0) {
- cros_gralloc_error("Timed out on sync wait, err = %s", strerror(errno));
+ drv_log("Timed out on sync wait, err = %s\n", strerror(errno));
err = sync_wait(acquire_fence, -1);
if (err < 0) {
- cros_gralloc_error("sync wait error = %s", strerror(errno));
+ drv_log("sync wait error = %s\n", strerror(errno));
return -errno;
}
}
err = close(acquire_fence);
if (err) {
- cros_gralloc_error("Unable to close fence fd, err = %s", strerror(errno));
+ drv_log("Unable to close fence fd, err = %s\n", strerror(errno));
return -errno;
}
return 0;
}
-
-void cros_gralloc_log(const char *prefix, const char *file, int line, const char *format, ...)
-{
- char buf[50];
- snprintf(buf, sizeof(buf), "[%s:%s(%d)]", prefix, basename(file), line);
-
- va_list args;
- va_start(args, format);
- __android_log_vprint(ANDROID_LOG_ERROR, buf, format, args);
- va_end(args);
-}
int32_t cros_gralloc_sync_wait(int32_t acquire_fence);
-__attribute__((format(printf, 4, 5))) void cros_gralloc_log(const char *prefix, const char *file,
- int line, const char *format, ...);
-
-#define cros_gralloc_error(...) \
- do { \
- cros_gralloc_log("CROS_GRALLOC_ERROR", __FILE__, __LINE__, __VA_ARGS__); \
- } while (0)
-
#endif
}
if (!supported) {
- cros_gralloc_error("Unsupported combination -- HAL format: %u, HAL usage: %u, "
- "drv_format: %4.4s, use_flags: %llu",
- format, usage, reinterpret_cast<char *>(&descriptor.drm_format),
- static_cast<unsigned long long>(descriptor.use_flags));
+ drv_log("Unsupported combination -- HAL format: %u, HAL usage: %u, "
+ "drv_format: %4.4s, use_flags: %llu\n",
+ format, usage, reinterpret_cast<char *>(&descriptor.drm_format),
+ static_cast<unsigned long long>(descriptor.use_flags));
return -EINVAL;
}
mod->driver = std::make_unique<cros_gralloc_driver>();
if (mod->driver->init()) {
- cros_gralloc_error("Failed to initialize driver.");
+ drv_log("Failed to initialize driver.\n");
return -ENODEV;
}
}
if (strcmp(name, GRALLOC_HARDWARE_GPU0)) {
- cros_gralloc_error("Incorrect device name - %s.", name);
+ drv_log("Incorrect device name - %s.\n", name);
return -EINVAL;
}
handle = va_arg(args, buffer_handle_t);
auto hnd = cros_gralloc_convert_handle(handle);
if (!hnd) {
- cros_gralloc_error("Invalid handle.");
+ drv_log("Invalid handle.\n");
return -EINVAL;
}
auto hnd = cros_gralloc_convert_handle(handle);
if (!hnd) {
- cros_gralloc_error("Invalid handle.");
+ drv_log("Invalid handle.\n");
return -EINVAL;
}
if (hnd->droid_format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
- cros_gralloc_error("HAL_PIXEL_FORMAT_YCbCr_*_888 format not compatible.");
+ drv_log("HAL_PIXEL_FORMAT_YCbCr_*_888 format not compatible.\n");
return -EINVAL;
}
auto hnd = cros_gralloc_convert_handle(handle);
if (!hnd) {
- cros_gralloc_error("Invalid handle.");
+ drv_log("Invalid handle.\n");
return -EINVAL;
}
if ((hnd->droid_format != HAL_PIXEL_FORMAT_YCbCr_420_888) &&
(hnd->droid_format != HAL_PIXEL_FORMAT_YV12) &&
(hnd->droid_format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED)) {
- cros_gralloc_error("Non-YUV format not compatible.");
+ drv_log("Non-YUV format not compatible.\n");
return -EINVAL;
}
#include <unistd.h>
#include <xf86drm.h>
+#ifdef __ANDROID__
+#include <cutils/log.h>
+#include <libgen.h>
+#endif
+
#include "drv_priv.h"
#include "helpers.h"
#include "util.h"
seek_end = lseek(data->fds[plane], 0, SEEK_END);
if (seek_end == (off_t)(-1)) {
- fprintf(stderr, "drv: lseek() failed with %s\n", strerror(errno));
+ drv_log("lseek() failed with %s\n", strerror(errno));
goto destroy_bo;
}
bo->sizes[plane] = data->offsets[plane + 1] - data->offsets[plane];
if ((int64_t)bo->offsets[plane] + bo->sizes[plane] > seek_end) {
- fprintf(stderr, "drv: buffer size is too large.\n");
+ drv_log("buffer size is too large.\n");
goto destroy_bo;
}
return 3;
}
- fprintf(stderr, "drv: UNKNOWN FORMAT %d\n", format);
+ drv_log("UNKNOWN FORMAT %d\n", format);
return 0;
}
return count;
}
+
+void drv_log_prefix(const char *prefix, const char *file, int line, const char *format, ...)
+{
+ char buf[50];
+ snprintf(buf, sizeof(buf), "[%s:%s(%d)]", prefix, basename(file), line);
+
+ va_list args;
+ va_start(args, format);
+#ifdef __ANDROID__
+ __android_log_vprint(ANDROID_LOG_ERROR, buf, format, args);
+#else
+ fprintf(stderr, "%s ", buf);
+ vfprintf(stderr, format, args);
+#endif
+ va_end(args);
+}
uint32_t drv_num_buffers_per_bo(struct bo *bo);
+#define drv_log(format, ...) \
+ do { \
+ drv_log_prefix("minigbm", __FILE__, __LINE__, format, ##__VA_ARGS__); \
+ } while (0)
+
+__attribute__((format(printf, 4, 5))) void drv_log_prefix(const char *prefix, const char *file,
+ int line, const char *format, ...);
+
#ifdef __cplusplus
}
#endif
bo->total_size = bo->sizes[0] = height * bo->strides[0];
bo->offsets[0] = 0;
} else {
- fprintf(stderr, "drv: unsupported format %X\n", format);
+ drv_log("unsupported format %X\n", format);
assert(0);
return -EINVAL;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_EXYNOS_GEM_CREATE, &gem_create);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_EXYNOS_GEM_CREATE failed (size=%zu)\n",
- size);
+ drv_log("DRM_IOCTL_EXYNOS_GEM_CREATE failed (size=%zu)\n", size);
goto cleanup_planes;
}
gem_close.handle = bo->handles[plane - 1].u32;
int gem_close_ret = drmIoctl(bo->drv->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
if (gem_close_ret) {
- fprintf(stderr, "drv: DRM_IOCTL_GEM_CLOSE failed: %d\n", gem_close_ret);
+ drv_log("DRM_IOCTL_GEM_CLOSE failed: %d\n", gem_close_ret);
}
}
return 32;
}
- fprintf(stderr, "drv: UNKNOWN FORMAT %d\n", format);
+ drv_log("UNKNOWN FORMAT %d\n", format);
return 0;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_MODE_CREATE_DUMB failed\n");
+ drv_log("DRM_IOCTL_MODE_CREATE_DUMB failed (%d, %d)\n", bo->drv->fd, errno);
return ret;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_MODE_DESTROY_DUMB failed (handle=%x)\n",
- bo->handles[0].u32);
+ drv_log("DRM_IOCTL_MODE_DESTROY_DUMB failed (handle=%x)\n", bo->handles[0].u32);
return ret;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_GEM_CLOSE failed (handle=%x) error %d\n",
+ drv_log("DRM_IOCTL_GEM_CLOSE failed (handle=%x) error %d\n",
bo->handles[plane].u32, ret);
error = ret;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &prime_handle);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_PRIME_FD_TO_HANDLE failed (fd=%u)\n",
- prime_handle.fd);
+ drv_log("DRM_IOCTL_PRIME_FD_TO_HANDLE failed (fd=%u)\n", prime_handle.fd);
/*
* Need to call GEM close on planes that were opened,
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MODE_MAP_DUMB, &map_dumb);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_MODE_MAP_DUMB failed \n");
+ drv_log("DRM_IOCTL_MODE_MAP_DUMB failed\n");
return MAP_FAILED;
}
if (!--mapping->vma->refcount) {
ret = bo->drv->backend->bo_unmap(bo, mapping->vma);
if (ret) {
- fprintf(stderr, "drv: munmap failed");
+ drv_log("munmap failed\n");
return ret;
}
get_param.value = &device_id;
ret = drmIoctl(drv->fd, DRM_IOCTL_I915_GETPARAM, &get_param);
if (ret) {
- fprintf(stderr, "drv: Failed to get I915_PARAM_CHIPSET_ID\n");
+ drv_log("Failed to get I915_PARAM_CHIPSET_ID\n");
free(i915);
return -EINVAL;
}
get_param.value = &i915->has_llc;
ret = drmIoctl(drv->fd, DRM_IOCTL_I915_GETPARAM, &get_param);
if (ret) {
- fprintf(stderr, "drv: Failed to get I915_PARAM_HAS_LLC\n");
+ drv_log("Failed to get I915_PARAM_HAS_LLC\n");
free(i915);
return -EINVAL;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_I915_GEM_CREATE, &gem_create);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_I915_GEM_CREATE failed (size=%llu)\n",
- gem_create.size);
+ drv_log("DRM_IOCTL_I915_GEM_CREATE failed (size=%llu)\n", gem_create.size);
return ret;
}
gem_close.handle = bo->handles[0].u32;
drmIoctl(bo->drv->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
- fprintf(stderr, "drv: DRM_IOCTL_I915_GEM_SET_TILING failed with %d", errno);
+ drv_log("DRM_IOCTL_I915_GEM_SET_TILING failed with %d\n", errno);
return -errno;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_I915_GEM_GET_TILING, &gem_get_tiling);
if (ret) {
drv_gem_bo_destroy(bo);
- fprintf(stderr, "drv: DRM_IOCTL_I915_GEM_GET_TILING failed.");
+ drv_log("DRM_IOCTL_I915_GEM_GET_TILING failed.\n");
return ret;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_I915_GEM_MMAP, &gem_map);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_I915_GEM_MMAP failed\n");
+ drv_log("DRM_IOCTL_I915_GEM_MMAP failed\n");
return MAP_FAILED;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_I915_GEM_MMAP_GTT, &gem_map);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_I915_GEM_MMAP_GTT failed\n");
+ drv_log("DRM_IOCTL_I915_GEM_MMAP_GTT failed\n");
return MAP_FAILED;
}
}
if (addr == MAP_FAILED) {
- fprintf(stderr, "drv: i915 GEM mmap failed\n");
+ drv_log("i915 GEM mmap failed\n");
return addr;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_I915_GEM_SET_DOMAIN, &set_domain);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_I915_GEM_SET_DOMAIN with %d\n", ret);
+ drv_log("DRM_IOCTL_I915_GEM_SET_DOMAIN with %d\n", ret);
return ret;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MTK_GEM_CREATE, &gem_create);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_MTK_GEM_CREATE failed (size=%llu)\n",
- gem_create.size);
+ drv_log("DRM_IOCTL_MTK_GEM_CREATE failed (size=%llu)\n", gem_create.size);
return ret;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MTK_GEM_MAP_OFFSET, &gem_map);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_MTK_GEM_MAP_OFFSET failed\n");
+ drv_log("DRM_IOCTL_MTK_GEM_MAP_OFFSET failed\n");
return MAP_FAILED;
}
}
static int msm_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
- uint64_t flags)
+ uint64_t flags)
{
width = ALIGN(width, MESA_LLVMPIPE_TILE_SIZE);
height = ALIGN(height, MESA_LLVMPIPE_TILE_SIZE);
} else {
if (!has_modifier(modifiers, count, DRM_FORMAT_MOD_LINEAR)) {
errno = EINVAL;
- fprintf(stderr, "no usable modifier found\n");
+ drv_log("no usable modifier found\n");
return -1;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_ROCKCHIP_GEM_CREATE, &gem_create);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_ROCKCHIP_GEM_CREATE failed (size=%llu)\n",
- gem_create.size);
+ drv_log("DRM_IOCTL_ROCKCHIP_GEM_CREATE failed (size=%llu)\n", gem_create.size);
return ret;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_ROCKCHIP_GEM_MAP_OFFSET, &gem_map);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_ROCKCHIP_GEM_MAP_OFFSET failed\n");
+ drv_log("DRM_IOCTL_ROCKCHIP_GEM_MAP_OFFSET failed\n");
return MAP_FAILED;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_TEGRA_GEM_CREATE, &gem_create);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_TEGRA_GEM_CREATE failed (size=%zu)\n", size);
+ drv_log("DRM_IOCTL_TEGRA_GEM_CREATE failed (size=%zu)\n", size);
return ret;
}
} else if (gem_get_tiling.mode == DRM_TEGRA_GEM_TILING_MODE_BLOCK) {
bo->tiling = NV_MEM_KIND_C32_2CRA;
} else {
- fprintf(stderr, "tegra_bo_import: unknown tile format %d", gem_get_tiling.mode);
+ drv_log("%s: unknown tile format %d\n", __func__, gem_get_tiling.mode);
drv_gem_bo_destroy(bo);
assert(0);
}
ret = drmCommandWriteRead(bo->drv->fd, DRM_TEGRA_GEM_MMAP, &gem_map, sizeof(gem_map));
if (ret < 0) {
- fprintf(stderr, "drv: DRM_TEGRA_GEM_MMAP failed\n");
+ drv_log("DRM_TEGRA_GEM_MMAP failed\n");
return MAP_FAILED;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VC4_CREATE_BO, &bo_create);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_VC4_GEM_CREATE failed (size=%zu)\n",
- bo->total_size);
+ drv_log("DRM_IOCTL_VC4_GEM_CREATE failed (size=%zu)\n", bo->total_size);
return ret;
}
ret = drmCommandWriteRead(bo->drv->fd, DRM_VC4_MMAP_BO, &bo_map, sizeof(bo_map));
if (ret) {
- fprintf(stderr, "drv: DRM_VC4_MMAP_BO failed\n");
+ drv_log("DRM_VC4_MMAP_BO failed\n");
return MAP_FAILED;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE, &res_create);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_VIRTGPU_RESOURCE_CREATE failed with %s\n",
+ drv_log("DRM_IOCTL_VIRTGPU_RESOURCE_CREATE failed with %s\n",
strerror(errno));
goto fail;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_MAP, &gem_map);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_VIRTGPU_MAP failed with %s\n", strerror(errno));
+ drv_log("DRM_IOCTL_VIRTGPU_MAP failed with %s\n", strerror(errno));
return MAP_FAILED;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_TRANSFER_FROM_HOST, &xfer);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_VIRTGPU_TRANSFER_FROM_HOST failed with %s\n",
- strerror(errno));
+ drv_log("DRM_IOCTL_VIRTGPU_TRANSFER_FROM_HOST failed with %s\n", strerror(errno));
return ret;
}
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST, &xfer);
if (ret) {
- fprintf(stderr, "drv: DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST failed with %s\n",
- strerror(errno));
+ drv_log("DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST failed with %s\n", strerror(errno));
return ret;
}