SecBSD/xenocara
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

sync code with last improvements from OpenBSD

Browse source
This commit is contained in:
purplerain 2023-08-28 05:57:34 +00:00
commit 88965415ff
Signed by: purplerain
GPG key ID: F42C07F07E2E35B7
26235 changed files with 29195616 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

13
lib/libdrm/omap/Android.mk Normal file
View file

@ -0,0 +1,13 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := libdrm_omap
LOCAL_VENDOR_MODULE := true
LOCAL_SRC_FILES := omap_drm.c
LOCAL_SHARED_LIBRARIES := libdrm
include $(LIBDRM_COMMON_MK)
include $(BUILD_SHARED_LIBRARY)

11
lib/libdrm/omap/libdrm_omap.pc.in Normal file
View file

@ -0,0 +1,11 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: libdrm_omap
Description: Userspace interface to omap kernel DRM services
Version: 0.6
Libs: -L${libdir} -ldrm_omap
Cflags: -I${includedir} -I${includedir}/libdrm -I${includedir}/omap
Requires.private: libdrm

61
lib/libdrm/omap/meson.build Normal file
View file

@ -0,0 +1,61 @@
# Copyright © 2017 Intel Corporation
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
libdrm_omap = library(
'drm_omap',
[files('omap_drm.c'), config_file],
include_directories : [inc_root, inc_drm],
c_args : libdrm_c_args,
gnu_symbol_visibility : 'hidden',
link_with : libdrm,
dependencies : [dep_pthread_stubs, dep_atomic_ops],
version : '1.0.0',
install : true,
)
ext_libdrm_omap = declare_dependency(
link_with : [libdrm, libdrm_omap],
include_directories : [inc_drm, include_directories('.')],
)
if meson.version().version_compare('>= 0.54.0')
meson.override_dependency('libdrm_omap', ext_libdrm_omap)
endif
install_headers('omap_drmif.h', subdir : 'libdrm')
install_headers('omap_drm.h', subdir : 'omap')
pkg.generate(
libdrm_omap,
name : 'libdrm_omap',
subdirs : ['.', 'libdrm', 'omap'],
version : '0.6',
description : 'Userspace interface to omap kernel DRM services',
)
test(
'omap-symbols-check',
symbols_check,
args : [
'--lib', libdrm_omap,
'--symbols-file', files('omap-symbols.txt'),
'--nm', prog_nm.path(),
],
)

18
lib/libdrm/omap/omap-symbols.txt Normal file
View file

@ -0,0 +1,18 @@
omap_bo_cpu_fini
omap_bo_cpu_prep
omap_bo_del
omap_bo_dmabuf
omap_bo_from_dmabuf
omap_bo_from_name
omap_bo_get_name
omap_bo_handle
omap_bo_map
omap_bo_new
omap_bo_new_tiled
omap_bo_ref
omap_bo_size
omap_device_del
omap_device_new
omap_device_ref
omap_get_param
omap_set_param

468
lib/libdrm/omap/omap_drm.c Normal file
View file

@ -0,0 +1,468 @@
/* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */
/*
* Copyright (C) 2011 Texas Instruments, Inc
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Authors:
* Rob Clark <rob@ti.com>
*/
#include <stdlib.h>
#include <linux/stddef.h>
#include <linux/types.h>
#include <errno.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <libdrm_macros.h>
#include <xf86drm.h>
#include <xf86atomic.h>
#include "omap_drm.h"
#include "omap_drmif.h"
#define __round_mask(x, y) ((__typeof__(x))((y)-1))
#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
#define PAGE_SIZE 4096
static pthread_mutex_t table_lock = PTHREAD_MUTEX_INITIALIZER;
static void * dev_table;
struct omap_device {
int fd;
atomic_t refcnt;
/* The handle_table is used to track GEM bo handles associated w/
* this fd. This is needed, in particular, when importing
* dmabuf's because we don't want multiple 'struct omap_bo's
* floating around with the same handle. Otherwise, when the
* first one is omap_bo_del()'d the handle becomes no longer
* valid, and the remaining 'struct omap_bo's are left pointing
* to an invalid handle (and possible a GEM bo that is already
* free'd).
*/
void *handle_table;
};
/* a GEM buffer object allocated from the DRM device */
struct omap_bo {
struct omap_device *dev;
void *map; /* userspace mmap'ing (if there is one) */
uint32_t size;
uint32_t handle;
uint32_t name; /* flink global handle (DRI2 name) */
uint64_t offset; /* offset to mmap() */
int fd; /* dmabuf handle */
atomic_t refcnt;
};
static struct omap_device * omap_device_new_impl(int fd)
{
struct omap_device *dev = calloc(sizeof(*dev), 1);
if (!dev)
return NULL;
dev->fd = fd;
atomic_set(&dev->refcnt, 1);
dev->handle_table = drmHashCreate();
return dev;
}
drm_public struct omap_device * omap_device_new(int fd)
{
struct omap_device *dev = NULL;
pthread_mutex_lock(&table_lock);
if (!dev_table)
dev_table = drmHashCreate();
if (drmHashLookup(dev_table, fd, (void **)&dev)) {
/* not found, create new device */
dev = omap_device_new_impl(fd);
drmHashInsert(dev_table, fd, dev);
} else {
/* found, just incr refcnt */
dev = omap_device_ref(dev);
}
pthread_mutex_unlock(&table_lock);
return dev;
}
drm_public struct omap_device * omap_device_ref(struct omap_device *dev)
{
atomic_inc(&dev->refcnt);
return dev;
}
drm_public void omap_device_del(struct omap_device *dev)
{
if (!atomic_dec_and_test(&dev->refcnt))
return;
pthread_mutex_lock(&table_lock);
drmHashDestroy(dev->handle_table);
drmHashDelete(dev_table, dev->fd);
pthread_mutex_unlock(&table_lock);
free(dev);
}
drm_public int
omap_get_param(struct omap_device *dev, uint64_t param, uint64_t *value)
{
struct drm_omap_param req = {
.param = param,
};
int ret;
ret = drmCommandWriteRead(dev->fd, DRM_OMAP_GET_PARAM, &req, sizeof(req));
if (ret) {
return ret;
}
*value = req.value;
return 0;
}
drm_public int
omap_set_param(struct omap_device *dev, uint64_t param, uint64_t value)
{
struct drm_omap_param req = {
.param = param,
.value = value,
};
return drmCommandWrite(dev->fd, DRM_OMAP_SET_PARAM, &req, sizeof(req));
}
/* lookup a buffer from it's handle, call w/ table_lock held: */
static struct omap_bo * lookup_bo(struct omap_device *dev,
uint32_t handle)
{
struct omap_bo *bo = NULL;
if (!drmHashLookup(dev->handle_table, handle, (void **)&bo)) {
/* found, incr refcnt and return: */
bo = omap_bo_ref(bo);
}
return bo;
}
/* allocate a new buffer object, call w/ table_lock held */
static struct omap_bo * bo_from_handle(struct omap_device *dev,
uint32_t handle)
{
struct omap_bo *bo = calloc(sizeof(*bo), 1);
if (!bo) {
drmCloseBufferHandle(dev->fd, handle);
return NULL;
}
bo->dev = omap_device_ref(dev);
bo->handle = handle;
bo->fd = -1;
atomic_set(&bo->refcnt, 1);
/* add ourselves to the handle table: */
drmHashInsert(dev->handle_table, handle, bo);
return bo;
}
/* allocate a new buffer object */
static struct omap_bo * omap_bo_new_impl(struct omap_device *dev,
union omap_gem_size size, uint32_t flags)
{
struct omap_bo *bo = NULL;
struct drm_omap_gem_new req = {
.size = size,
.flags = flags,
};
if (size.bytes == 0) {
goto fail;
}
if (drmCommandWriteRead(dev->fd, DRM_OMAP_GEM_NEW, &req, sizeof(req))) {
goto fail;
}
pthread_mutex_lock(&table_lock);
bo = bo_from_handle(dev, req.handle);
pthread_mutex_unlock(&table_lock);
if (flags & OMAP_BO_TILED) {
bo->size = round_up(size.tiled.width, PAGE_SIZE) * size.tiled.height;
} else {
bo->size = size.bytes;
}
return bo;
fail:
free(bo);
return NULL;
}
/* allocate a new (un-tiled) buffer object */
drm_public struct omap_bo *
omap_bo_new(struct omap_device *dev, uint32_t size, uint32_t flags)
{
union omap_gem_size gsize = {
.bytes = size,
};
if (flags & OMAP_BO_TILED) {
return NULL;
}
return omap_bo_new_impl(dev, gsize, flags);
}
/* allocate a new buffer object */
drm_public struct omap_bo *
omap_bo_new_tiled(struct omap_device *dev, uint32_t width,
uint32_t height, uint32_t flags)
{
union omap_gem_size gsize = {
.tiled = {
.width = width,
.height = height,
},
};
if (!(flags & OMAP_BO_TILED)) {
return NULL;
}
return omap_bo_new_impl(dev, gsize, flags);
}
drm_public struct omap_bo *omap_bo_ref(struct omap_bo *bo)
{
atomic_inc(&bo->refcnt);
return bo;
}
/* get buffer info */
static int get_buffer_info(struct omap_bo *bo)
{
struct drm_omap_gem_info req = {
.handle = bo->handle,
};
int ret = drmCommandWriteRead(bo->dev->fd, DRM_OMAP_GEM_INFO,
&req, sizeof(req));
if (ret) {
return ret;
}
/* really all we need for now is mmap offset */
bo->offset = req.offset;
bo->size = req.size;
return 0;
}
/* import a buffer object from DRI2 name */
drm_public struct omap_bo *
omap_bo_from_name(struct omap_device *dev, uint32_t name)
{
struct omap_bo *bo = NULL;
struct drm_gem_open req = {
.name = name,
};
pthread_mutex_lock(&table_lock);
if (drmIoctl(dev->fd, DRM_IOCTL_GEM_OPEN, &req)) {
goto fail;
}
bo = lookup_bo(dev, req.handle);
if (!bo) {
bo = bo_from_handle(dev, req.handle);
bo->name = name;
}
pthread_mutex_unlock(&table_lock);
return bo;
fail:
pthread_mutex_unlock(&table_lock);
free(bo);
return NULL;
}
/* import a buffer from dmabuf fd, does not take ownership of the
* fd so caller should close() the fd when it is otherwise done
* with it (even if it is still using the 'struct omap_bo *')
*/
drm_public struct omap_bo *
omap_bo_from_dmabuf(struct omap_device *dev, int fd)
{
struct omap_bo *bo = NULL;
struct drm_prime_handle req = {
.fd = fd,
};
int ret;
pthread_mutex_lock(&table_lock);
ret = drmIoctl(dev->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &req);
if (ret) {
goto fail;
}
bo = lookup_bo(dev, req.handle);
if (!bo) {
bo = bo_from_handle(dev, req.handle);
}
pthread_mutex_unlock(&table_lock);
return bo;
fail:
pthread_mutex_unlock(&table_lock);
free(bo);
return NULL;
}
/* destroy a buffer object */
drm_public void omap_bo_del(struct omap_bo *bo)
{
if (!bo) {
return;
}
if (!atomic_dec_and_test(&bo->refcnt))
return;
if (bo->map) {
munmap(bo->map, bo->size);
}
if (bo->fd >= 0) {
close(bo->fd);
}
if (bo->handle) {
pthread_mutex_lock(&table_lock);
drmHashDelete(bo->dev->handle_table, bo->handle);
drmCloseBufferHandle(bo->dev->fd, bo->handle);
pthread_mutex_unlock(&table_lock);
}
omap_device_del(bo->dev);
free(bo);
}
/* get the global flink/DRI2 buffer name */
drm_public int omap_bo_get_name(struct omap_bo *bo, uint32_t *name)
{
if (!bo->name) {
struct drm_gem_flink req = {
.handle = bo->handle,
};
int ret;
ret = drmIoctl(bo->dev->fd, DRM_IOCTL_GEM_FLINK, &req);
if (ret) {
return ret;
}
bo->name = req.name;
}
*name = bo->name;
return 0;
}
drm_public uint32_t omap_bo_handle(struct omap_bo *bo)
{
return bo->handle;
}
/* caller owns the dmabuf fd that is returned and is responsible
* to close() it when done
*/
drm_public int omap_bo_dmabuf(struct omap_bo *bo)
{
if (bo->fd < 0) {
struct drm_prime_handle req = {
.handle = bo->handle,
.flags = DRM_CLOEXEC | DRM_RDWR,
};
int ret;
ret = drmIoctl(bo->dev->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &req);
if (ret) {
return ret;
}
bo->fd = req.fd;
}
return dup(bo->fd);
}
drm_public uint32_t omap_bo_size(struct omap_bo *bo)
{
if (!bo->size) {
get_buffer_info(bo);
}
return bo->size;
}
drm_public void *omap_bo_map(struct omap_bo *bo)
{
if (!bo->map) {
if (!bo->offset) {
get_buffer_info(bo);
}
bo->map = mmap(0, bo->size, PROT_READ | PROT_WRITE,
MAP_SHARED, bo->dev->fd, bo->offset);
if (bo->map == MAP_FAILED) {
bo->map = NULL;
}
}
return bo->map;
}
drm_public int omap_bo_cpu_prep(struct omap_bo *bo, enum omap_gem_op op)
{
struct drm_omap_gem_cpu_prep req = {
.handle = bo->handle,
.op = op,
};
return drmCommandWrite(bo->dev->fd,
DRM_OMAP_GEM_CPU_PREP, &req, sizeof(req));
}
drm_public int omap_bo_cpu_fini(struct omap_bo *bo, enum omap_gem_op op)
{
struct drm_omap_gem_cpu_fini req = {
.handle = bo->handle,
.op = op,
.nregions = 0,
};
return drmCommandWrite(bo->dev->fd,
DRM_OMAP_GEM_CPU_FINI, &req, sizeof(req));
}

135
lib/libdrm/omap/omap_drm.h Normal file
View file

@ -0,0 +1,135 @@
/* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */
/*
* Copyright (C) 2011 Texas Instruments, Inc
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Authors:
* Rob Clark <rob@ti.com>
*/
#ifndef __OMAP_DRM_H__
#define __OMAP_DRM_H__
#include <stdint.h>
#include <drm.h>
/* Please note that modifications to all structs defined here are
* subject to backwards-compatibility constraints.
*/
#define OMAP_PARAM_CHIPSET_ID 1 /* ie. 0x3430, 0x4430, etc */
struct drm_omap_param {
uint64_t param; /* in */
uint64_t value; /* in (set_param), out (get_param) */
};
struct drm_omap_get_base {
char plugin_name[64]; /* in */
uint32_t ioctl_base; /* out */
uint32_t __pad;
};
#define OMAP_BO_SCANOUT 0x00000001 /* scanout capable (phys contiguous) */
#define OMAP_BO_CACHE_MASK 0x00000006 /* cache type mask, see cache modes */
#define OMAP_BO_TILED_MASK 0x00000f00 /* tiled mapping mask, see tiled modes */
/* cache modes */
#define OMAP_BO_CACHED 0x00000000 /* default */
#define OMAP_BO_WC 0x00000002 /* write-combine */
#define OMAP_BO_UNCACHED 0x00000004 /* strongly-ordered (uncached) */
/* tiled modes */
#define OMAP_BO_TILED_8 0x00000100
#define OMAP_BO_TILED_16 0x00000200
#define OMAP_BO_TILED_32 0x00000300
#define OMAP_BO_TILED (OMAP_BO_TILED_8 | OMAP_BO_TILED_16 | OMAP_BO_TILED_32)
union omap_gem_size {
uint32_t bytes; /* (for non-tiled formats) */
struct {
uint16_t width;
uint16_t height;
} tiled; /* (for tiled formats) */
};
struct drm_omap_gem_new {
union omap_gem_size size; /* in */
uint32_t flags; /* in */
uint32_t handle; /* out */
uint32_t __pad;
};
/* mask of operations: */
enum omap_gem_op {
OMAP_GEM_READ = 0x01,
OMAP_GEM_WRITE = 0x02,
};
struct drm_omap_gem_cpu_prep {
uint32_t handle; /* buffer handle (in) */
uint32_t op; /* mask of omap_gem_op (in) */
};
struct drm_omap_gem_cpu_fini {
uint32_t handle; /* buffer handle (in) */
uint32_t op; /* mask of omap_gem_op (in) */
/* TODO maybe here we pass down info about what regions are touched
* by sw so we can be clever about cache ops? For now a placeholder,
* set to zero and we just do full buffer flush..
*/
uint32_t nregions;
uint32_t __pad;
};
struct drm_omap_gem_info {
uint32_t handle; /* buffer handle (in) */
uint32_t pad;
uint64_t offset; /* mmap offset (out) */
/* note: in case of tiled buffers, the user virtual size can be
* different from the physical size (ie. how many pages are needed
* to back the object) which is returned in DRM_IOCTL_GEM_OPEN..
* This size here is the one that should be used if you want to
* mmap() the buffer:
*/
uint32_t size; /* virtual size for mmap'ing (out) */
uint32_t __pad;
};
#define DRM_OMAP_GET_PARAM 0x00
#define DRM_OMAP_SET_PARAM 0x01
#define DRM_OMAP_GET_BASE 0x02
#define DRM_OMAP_GEM_NEW 0x03
#define DRM_OMAP_GEM_CPU_PREP 0x04
#define DRM_OMAP_GEM_CPU_FINI 0x05
#define DRM_OMAP_GEM_INFO 0x06
#define DRM_OMAP_NUM_IOCTLS 0x07
#define DRM_IOCTL_OMAP_GET_PARAM DRM_IOWR(DRM_COMMAND_BASE + DRM_OMAP_GET_PARAM, struct drm_omap_param)
#define DRM_IOCTL_OMAP_SET_PARAM DRM_IOW (DRM_COMMAND_BASE + DRM_OMAP_SET_PARAM, struct drm_omap_param)
#define DRM_IOCTL_OMAP_GET_BASE DRM_IOWR(DRM_COMMAND_BASE + DRM_OMAP_GET_BASE, struct drm_omap_get_base)
#define DRM_IOCTL_OMAP_GEM_NEW DRM_IOWR(DRM_COMMAND_BASE + DRM_OMAP_GEM_NEW, struct drm_omap_gem_new)
#define DRM_IOCTL_OMAP_GEM_CPU_PREP DRM_IOW (DRM_COMMAND_BASE + DRM_OMAP_GEM_CPU_PREP, struct drm_omap_gem_cpu_prep)
#define DRM_IOCTL_OMAP_GEM_CPU_FINI DRM_IOW (DRM_COMMAND_BASE + DRM_OMAP_GEM_CPU_FINI, struct drm_omap_gem_cpu_fini)
#define DRM_IOCTL_OMAP_GEM_INFO DRM_IOWR(DRM_COMMAND_BASE + DRM_OMAP_GEM_INFO, struct drm_omap_gem_info)
#endif /* __OMAP_DRM_H__ */

65
lib/libdrm/omap/omap_drmif.h Normal file
View file

@ -0,0 +1,65 @@
/*
* Copyright (C) 2011 Texas Instruments, Inc
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Authors:
* Rob Clark <rob@ti.com>
*/
#ifndef OMAP_DRMIF_H_
#define OMAP_DRMIF_H_
#include <xf86drm.h>
#include <stdint.h>
#include <omap_drm.h>
struct omap_bo;
struct omap_device;
/* device related functions:
*/
struct omap_device * omap_device_new(int fd);
struct omap_device * omap_device_ref(struct omap_device *dev);
void omap_device_del(struct omap_device *dev);
int omap_get_param(struct omap_device *dev, uint64_t param, uint64_t *value);
int omap_set_param(struct omap_device *dev, uint64_t param, uint64_t value);
/* buffer-object related functions:
*/
struct omap_bo * omap_bo_new(struct omap_device *dev,
uint32_t size, uint32_t flags);
struct omap_bo * omap_bo_new_tiled(struct omap_device *dev,
uint32_t width, uint32_t height, uint32_t flags);
struct omap_bo * omap_bo_ref(struct omap_bo *bo);
struct omap_bo * omap_bo_from_name(struct omap_device *dev, uint32_t name);
struct omap_bo * omap_bo_from_dmabuf(struct omap_device *dev, int fd);
void omap_bo_del(struct omap_bo *bo);
int omap_bo_get_name(struct omap_bo *bo, uint32_t *name);
uint32_t omap_bo_handle(struct omap_bo *bo);
int omap_bo_dmabuf(struct omap_bo *bo);
uint32_t omap_bo_size(struct omap_bo *bo);
void * omap_bo_map(struct omap_bo *bo);
int omap_bo_cpu_prep(struct omap_bo *bo, enum omap_gem_op op);
int omap_bo_cpu_fini(struct omap_bo *bo, enum omap_gem_op op);
#endif /* OMAP_DRMIF_H_ */