return retval;
}
+/**
+ * Call ioctl, restarting if it is interupted
+ */
+static int
+drmIoctl(int fd, unsigned long request, void *arg)
+{
+ int ret;
+
+ do {
+ ret = ioctl(fd, request, arg);
+ } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+ return ret;
+}
static unsigned long drmGetKeyFromFd(int fd)
{
group = (serv_group >= 0) ? serv_group : DRM_DEV_GID;
}
+#if !defined(UDEV)
if (stat(DRM_DIR_NAME, &st)) {
if (!isroot)
return DRM_ERR_NOT_ROOT;
chown(buf, user, group);
chmod(buf, devmode);
}
+#else
+ /* if we modprobed then wait for udev */
+ {
+ int udev_count = 0;
+wait_for_udev:
+ if (stat(DRM_DIR_NAME, &st)) {
+ usleep(20);
+ udev_count++;
+
+ if (udev_count == 50)
+ return -1;
+ goto wait_for_udev;
+ }
+
+ if (stat(buf, &st)) {
+ usleep(20);
+ udev_count++;
+
+ if (udev_count == 50)
+ return -1;
+ goto wait_for_udev;
+ }
+ }
+#endif
fd = open(buf, O_RDWR, 0);
drmMsg("drmOpenDevice: open result is %d, (%s)\n",
version->desc_len = 0;
version->desc = NULL;
- if (ioctl(fd, DRM_IOCTL_VERSION, version)) {
+ if (drmIoctl(fd, DRM_IOCTL_VERSION, version)) {
drmFreeKernelVersion(version);
return NULL;
}
if (version->desc_len)
version->desc = drmMalloc(version->desc_len + 1);
- if (ioctl(fd, DRM_IOCTL_VERSION, version)) {
+ if (drmIoctl(fd, DRM_IOCTL_VERSION, version)) {
drmMsg("DRM_IOCTL_VERSION: %s\n", strerror(errno));
drmFreeKernelVersion(version);
return NULL;
u.unique_len = 0;
u.unique = NULL;
- if (ioctl(fd, DRM_IOCTL_GET_UNIQUE, &u))
+ if (drmIoctl(fd, DRM_IOCTL_GET_UNIQUE, &u))
return NULL;
u.unique = drmMalloc(u.unique_len + 1);
- if (ioctl(fd, DRM_IOCTL_GET_UNIQUE, &u))
+ if (drmIoctl(fd, DRM_IOCTL_GET_UNIQUE, &u))
return NULL;
u.unique[u.unique_len] = '\0';
u.unique = (char *)busid;
u.unique_len = strlen(busid);
- if (ioctl(fd, DRM_IOCTL_SET_UNIQUE, &u)) {
+ if (drmIoctl(fd, DRM_IOCTL_SET_UNIQUE, &u)) {
return -errno;
}
return 0;
drm_auth_t auth;
*magic = 0;
- if (ioctl(fd, DRM_IOCTL_GET_MAGIC, &auth))
+ if (drmIoctl(fd, DRM_IOCTL_GET_MAGIC, &auth))
return -errno;
*magic = auth.magic;
return 0;
drm_auth_t auth;
auth.magic = magic;
- if (ioctl(fd, DRM_IOCTL_AUTH_MAGIC, &auth))
+ if (drmIoctl(fd, DRM_IOCTL_AUTH_MAGIC, &auth))
return -errno;
return 0;
}
map.handle = 0;
map.type = type;
map.flags = flags;
- if (ioctl(fd, DRM_IOCTL_ADD_MAP, &map))
+ if (drmIoctl(fd, DRM_IOCTL_ADD_MAP, &map))
return -errno;
if (handle)
*handle = (drm_handle_t)map.handle;
map.handle = (void *)handle;
- if(ioctl(fd, DRM_IOCTL_RM_MAP, &map))
+ if(drmIoctl(fd, DRM_IOCTL_RM_MAP, &map))
return -errno;
return 0;
}
request.flags = flags;
request.agp_start = agp_offset;
- if (ioctl(fd, DRM_IOCTL_ADD_BUFS, &request))
+ if (drmIoctl(fd, DRM_IOCTL_ADD_BUFS, &request))
return -errno;
return request.count;
}
info.count = 0;
info.list = NULL;
- if (ioctl(fd, DRM_IOCTL_INFO_BUFS, &info))
+ if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info))
return -EINVAL;
if (!info.count)
if (!(info.list = drmMalloc(info.count * sizeof(*info.list))))
return -ENOMEM;
- if (ioctl(fd, DRM_IOCTL_INFO_BUFS, &info)) {
+ if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info)) {
int retval = -errno;
drmFree(info.list);
return retval;
for (i = 0; i < info.count; i++) {
info.list[i].low_mark = low * info.list[i].count;
info.list[i].high_mark = high * info.list[i].count;
- if (ioctl(fd, DRM_IOCTL_MARK_BUFS, &info.list[i])) {
+ if (drmIoctl(fd, DRM_IOCTL_MARK_BUFS, &info.list[i])) {
int retval = -errno;
drmFree(info.list);
return retval;
request.count = count;
request.list = list;
- if (ioctl(fd, DRM_IOCTL_FREE_BUFS, &request))
+ if (drmIoctl(fd, DRM_IOCTL_FREE_BUFS, &request))
return -errno;
return 0;
}
info.count = 0;
info.list = NULL;
- if (ioctl(fd, DRM_IOCTL_INFO_BUFS, &info))
+ if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info))
return NULL;
if (info.count) {
if (!(info.list = drmMalloc(info.count * sizeof(*info.list))))
return NULL;
- if (ioctl(fd, DRM_IOCTL_INFO_BUFS, &info)) {
+ if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info)) {
drmFree(info.list);
return NULL;
}
bufs.count = 0;
bufs.list = NULL;
bufs.virtual = NULL;
- if (ioctl(fd, DRM_IOCTL_MAP_BUFS, &bufs))
+ if (drmIoctl(fd, DRM_IOCTL_MAP_BUFS, &bufs))
return NULL;
if (!bufs.count)
if (!(bufs.list = drmMalloc(bufs.count * sizeof(*bufs.list))))
return NULL;
- if (ioctl(fd, DRM_IOCTL_MAP_BUFS, &bufs)) {
+ if (drmIoctl(fd, DRM_IOCTL_MAP_BUFS, &bufs)) {
drmFree(bufs.list);
return NULL;
}
if (flags & DRM_HALT_ALL_QUEUES) lock.flags |= _DRM_HALT_ALL_QUEUES;
if (flags & DRM_HALT_CUR_QUEUES) lock.flags |= _DRM_HALT_CUR_QUEUES;
- while (ioctl(fd, DRM_IOCTL_LOCK, &lock))
+ while (drmIoctl(fd, DRM_IOCTL_LOCK, &lock))
;
return 0;
}
lock.context = context;
lock.flags = 0;
- return ioctl(fd, DRM_IOCTL_UNLOCK, &lock);
+ return drmIoctl(fd, DRM_IOCTL_UNLOCK, &lock);
}
drm_context_t *drmGetReservedContextList(int fd, int *count)
res.count = 0;
res.contexts = NULL;
- if (ioctl(fd, DRM_IOCTL_RES_CTX, &res))
+ if (drmIoctl(fd, DRM_IOCTL_RES_CTX, &res))
return NULL;
if (!res.count)
}
res.contexts = list;
- if (ioctl(fd, DRM_IOCTL_RES_CTX, &res))
+ if (drmIoctl(fd, DRM_IOCTL_RES_CTX, &res))
return NULL;
for (i = 0; i < res.count; i++)
drm_ctx_t ctx;
ctx.flags = 0; /* Modified with functions below */
- if (ioctl(fd, DRM_IOCTL_ADD_CTX, &ctx))
+ if (drmIoctl(fd, DRM_IOCTL_ADD_CTX, &ctx))
return -errno;
*handle = ctx.handle;
return 0;
drm_ctx_t ctx;
ctx.handle = context;
- if (ioctl(fd, DRM_IOCTL_SWITCH_CTX, &ctx))
+ if (drmIoctl(fd, DRM_IOCTL_SWITCH_CTX, &ctx))
return -errno;
return 0;
}
ctx.flags |= _DRM_CONTEXT_PRESERVED;
if (flags & DRM_CONTEXT_2DONLY)
ctx.flags |= _DRM_CONTEXT_2DONLY;
- if (ioctl(fd, DRM_IOCTL_MOD_CTX, &ctx))
+ if (drmIoctl(fd, DRM_IOCTL_MOD_CTX, &ctx))
return -errno;
return 0;
}
drm_ctx_t ctx;
ctx.handle = context;
- if (ioctl(fd, DRM_IOCTL_GET_CTX, &ctx))
+ if (drmIoctl(fd, DRM_IOCTL_GET_CTX, &ctx))
return -errno;
*flags = 0;
if (ctx.flags & _DRM_CONTEXT_PRESERVED)
{
drm_ctx_t ctx;
ctx.handle = handle;
- if (ioctl(fd, DRM_IOCTL_RM_CTX, &ctx))
+ if (drmIoctl(fd, DRM_IOCTL_RM_CTX, &ctx))
return -errno;
return 0;
}
int drmCreateDrawable(int fd, drm_drawable_t *handle)
{
drm_draw_t draw;
- if (ioctl(fd, DRM_IOCTL_ADD_DRAW, &draw))
+ if (drmIoctl(fd, DRM_IOCTL_ADD_DRAW, &draw))
return -errno;
*handle = draw.handle;
return 0;
{
drm_draw_t draw;
draw.handle = handle;
- if (ioctl(fd, DRM_IOCTL_RM_DRAW, &draw))
+ if (drmIoctl(fd, DRM_IOCTL_RM_DRAW, &draw))
return -errno;
return 0;
}
update.num = num;
update.data = (unsigned long long)(unsigned long)data;
- if (ioctl(fd, DRM_IOCTL_UPDATE_DRAW, &update))
+ if (drmIoctl(fd, DRM_IOCTL_UPDATE_DRAW, &update))
return -errno;
return 0;
*/
int drmAgpAcquire(int fd)
{
- if (ioctl(fd, DRM_IOCTL_AGP_ACQUIRE, NULL))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_ACQUIRE, NULL))
return -errno;
return 0;
}
*/
int drmAgpRelease(int fd)
{
- if (ioctl(fd, DRM_IOCTL_AGP_RELEASE, NULL))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_RELEASE, NULL))
return -errno;
return 0;
}
drm_agp_mode_t m;
m.mode = mode;
- if (ioctl(fd, DRM_IOCTL_AGP_ENABLE, &m))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_ENABLE, &m))
return -errno;
return 0;
}
b.size = size;
b.handle = 0;
b.type = type;
- if (ioctl(fd, DRM_IOCTL_AGP_ALLOC, &b))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_ALLOC, &b))
return -errno;
if (address != 0UL)
*address = b.physical;
b.size = 0;
b.handle = handle;
- if (ioctl(fd, DRM_IOCTL_AGP_FREE, &b))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_FREE, &b))
return -errno;
return 0;
}
b.handle = handle;
b.offset = offset;
- if (ioctl(fd, DRM_IOCTL_AGP_BIND, &b))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_BIND, &b))
return -errno;
return 0;
}
b.handle = handle;
b.offset = 0;
- if (ioctl(fd, DRM_IOCTL_AGP_UNBIND, &b))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_UNBIND, &b))
return -errno;
return 0;
}
{
drm_agp_info_t i;
- if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
return -errno;
return i.agp_version_major;
}
{
drm_agp_info_t i;
- if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
return -errno;
return i.agp_version_minor;
}
{
drm_agp_info_t i;
- if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
return 0;
return i.mode;
}
{
drm_agp_info_t i;
- if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
return 0;
return i.aperture_base;
}
{
drm_agp_info_t i;
- if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
return 0;
return i.aperture_size;
}
{
drm_agp_info_t i;
- if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
return 0;
return i.memory_used;
}
{
drm_agp_info_t i;
- if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
return 0;
return i.memory_allowed;
}
{
drm_agp_info_t i;
- if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
return 0;
return i.id_vendor;
}
{
drm_agp_info_t i;
- if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
+ if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
return 0;
return i.id_device;
}
*handle = 0;
sg.size = size;
sg.handle = 0;
- if (ioctl(fd, DRM_IOCTL_SG_ALLOC, &sg))
+ if (drmIoctl(fd, DRM_IOCTL_SG_ALLOC, &sg))
return -errno;
*handle = sg.handle;
return 0;
sg.size = 0;
sg.handle = handle;
- if (ioctl(fd, DRM_IOCTL_SG_FREE, &sg))
+ if (drmIoctl(fd, DRM_IOCTL_SG_FREE, &sg))
return -errno;
return 0;
}
int ret;
do {
- ret = ioctl(fd, DRM_IOCTL_WAIT_VBLANK, vbl);
+ ret = drmIoctl(fd, DRM_IOCTL_WAIT_VBLANK, vbl);
vbl->request.type &= ~DRM_VBLANK_RELATIVE;
} while (ret && errno == EINTR);
ctl.func = DRM_INST_HANDLER;
ctl.irq = irq;
- if (ioctl(fd, DRM_IOCTL_CONTROL, &ctl))
+ if (drmIoctl(fd, DRM_IOCTL_CONTROL, &ctl))
return -errno;
return 0;
}
ctl.func = DRM_UNINST_HANDLER;
ctl.irq = 0;
- if (ioctl(fd, DRM_IOCTL_CONTROL, &ctl))
+ if (drmIoctl(fd, DRM_IOCTL_CONTROL, &ctl))
return -errno;
return 0;
}
if (flags & DRM_LOCK_FLUSH_ALL) lock.flags |= _DRM_LOCK_FLUSH_ALL;
if (flags & DRM_HALT_ALL_QUEUES) lock.flags |= _DRM_HALT_ALL_QUEUES;
if (flags & DRM_HALT_CUR_QUEUES) lock.flags |= _DRM_HALT_CUR_QUEUES;
- if (ioctl(fd, DRM_IOCTL_FINISH, &lock))
+ if (drmIoctl(fd, DRM_IOCTL_FINISH, &lock))
return -errno;
return 0;
}
p.busnum = busnum;
p.devnum = devnum;
p.funcnum = funcnum;
- if (ioctl(fd, DRM_IOCTL_IRQ_BUSID, &p))
+ if (drmIoctl(fd, DRM_IOCTL_IRQ_BUSID, &p))
return -errno;
return p.irq;
}
map.ctx_id = ctx_id;
map.handle = (void *)handle;
- if (ioctl(fd, DRM_IOCTL_SET_SAREA_CTX, &map))
+ if (drmIoctl(fd, DRM_IOCTL_SET_SAREA_CTX, &map))
return -errno;
return 0;
}
map.ctx_id = ctx_id;
- if (ioctl(fd, DRM_IOCTL_GET_SAREA_CTX, &map))
+ if (drmIoctl(fd, DRM_IOCTL_GET_SAREA_CTX, &map))
return -errno;
if (handle)
*handle = (drm_handle_t)map.handle;
drm_map_t map;
map.offset = idx;
- if (ioctl(fd, DRM_IOCTL_GET_MAP, &map))
+ if (drmIoctl(fd, DRM_IOCTL_GET_MAP, &map))
return -errno;
*offset = map.offset;
*size = map.size;
drm_client_t client;
client.idx = idx;
- if (ioctl(fd, DRM_IOCTL_GET_CLIENT, &client))
+ if (drmIoctl(fd, DRM_IOCTL_GET_CLIENT, &client))
return -errno;
*auth = client.auth;
*pid = client.pid;
drm_stats_t s;
int i;
- if (ioctl(fd, DRM_IOCTL_GET_STATS, &s))
+ if (drmIoctl(fd, DRM_IOCTL_GET_STATS, &s))
return -errno;
stats->count = 0;
sv.drm_dd_major = version->drm_dd_major;
sv.drm_dd_minor = version->drm_dd_minor;
- if (ioctl(fd, DRM_IOCTL_SET_VERSION, &sv)) {
+ if (drmIoctl(fd, DRM_IOCTL_SET_VERSION, &sv)) {
retcode = -errno;
}
request = DRM_IO( DRM_COMMAND_BASE + drmCommandIndex);
- if (ioctl(fd, request, data)) {
+ if (drmIoctl(fd, request, data)) {
return -errno;
}
return 0;
request = DRM_IOC( DRM_IOC_READ, DRM_IOCTL_BASE,
DRM_COMMAND_BASE + drmCommandIndex, size);
- if (ioctl(fd, request, data)) {
+ if (drmIoctl(fd, request, data)) {
return -errno;
}
return 0;
request = DRM_IOC( DRM_IOC_WRITE, DRM_IOCTL_BASE,
DRM_COMMAND_BASE + drmCommandIndex, size);
- if (ioctl(fd, request, data)) {
+ if (drmIoctl(fd, request, data)) {
return -errno;
}
return 0;
request = DRM_IOC( DRM_IOC_READ|DRM_IOC_WRITE, DRM_IOCTL_BASE,
DRM_COMMAND_BASE + drmCommandIndex, size);
- if (ioctl(fd, request, data)) {
- return -errno;
- }
- return 0;
-}
-
-
-/*
- * Valid flags are
- * DRM_FENCE_FLAG_EMIT
- * DRM_FENCE_FLAG_SHAREABLE
- * DRM_FENCE_MASK_DRIVER
- */
-
-int drmFenceCreate(int fd, unsigned flags, int fence_class, unsigned type,
- drmFence *fence)
-{
- drm_fence_arg_t arg;
-
- memset(&arg, 0, sizeof(arg));
- arg.flags = flags;
- arg.type = type;
- arg.fence_class = fence_class;
-
- if (ioctl(fd, DRM_IOCTL_FENCE_CREATE, &arg))
- return -errno;
- fence->handle = arg.handle;
- fence->fence_class = arg.fence_class;
- fence->type = arg.type;
- fence->flags = arg.flags;
- fence->signaled = 0;
- return 0;
-}
-
-/*
- * Valid flags are
- * DRM_FENCE_FLAG_SHAREABLE
- * DRM_FENCE_MASK_DRIVER
- */
-
-int drmFenceBuffers(int fd, unsigned flags, uint32_t fence_class, drmFence *fence)
-{
- drm_fence_arg_t arg;
-
- memset(&arg, 0, sizeof(arg));
- arg.flags = flags;
- arg.fence_class = fence_class;
-
- if (ioctl(fd, DRM_IOCTL_FENCE_BUFFERS, &arg))
- return -errno;
- fence->handle = arg.handle;
- fence->fence_class = arg.fence_class;
- fence->type = arg.type;
- fence->flags = arg.flags;
- fence->sequence = arg.sequence;
- fence->signaled = 0;
- return 0;
-}
-
-int drmFenceReference(int fd, unsigned handle, drmFence *fence)
-{
- drm_fence_arg_t arg;
-
- memset(&arg, 0, sizeof(arg));
- arg.handle = handle;
-
- if (ioctl(fd, DRM_IOCTL_FENCE_REFERENCE, &arg))
- return -errno;
- fence->handle = arg.handle;
- fence->fence_class = arg.fence_class;
- fence->type = arg.type;
- fence->flags = arg.flags;
- fence->signaled = arg.signaled;
- return 0;
-}
-
-int drmFenceUnreference(int fd, const drmFence *fence)
-{
- drm_fence_arg_t arg;
-
- memset(&arg, 0, sizeof(arg));
- arg.handle = fence->handle;
-
- if (ioctl(fd, DRM_IOCTL_FENCE_UNREFERENCE, &arg))
- return -errno;
- return 0;
-}
-
-int drmFenceFlush(int fd, drmFence *fence, unsigned flush_type)
-{
- drm_fence_arg_t arg;
-
- memset(&arg, 0, sizeof(arg));
- arg.handle = fence->handle;
- arg.type = flush_type;
-
- if (ioctl(fd, DRM_IOCTL_FENCE_FLUSH, &arg))
- return -errno;
- fence->fence_class = arg.fence_class;
- fence->type = arg.type;
- fence->signaled = arg.signaled;
- return arg.error;
-}
-
-int drmFenceUpdate(int fd, drmFence *fence)
-{
- drm_fence_arg_t arg;
-
- memset(&arg, 0, sizeof(arg));
- arg.handle = fence->handle;
-
- if (ioctl(fd, DRM_IOCTL_FENCE_SIGNALED, &arg))
- return -errno;
- fence->fence_class = arg.fence_class;
- fence->type = arg.type;
- fence->signaled = arg.signaled;
- return 0;
-}
-
-int drmFenceSignaled(int fd, drmFence *fence, unsigned fenceType,
- int *signaled)
-{
- if ((fence->flags & DRM_FENCE_FLAG_SHAREABLE) ||
- ((fenceType & fence->signaled) != fenceType)) {
- int ret = drmFenceFlush(fd, fence, fenceType);
- if (ret)
- return ret;
- }
-
- *signaled = ((fenceType & fence->signaled) == fenceType);
-
- return 0;
-}
-
-/*
- * Valid flags are
- * DRM_FENCE_FLAG_SHAREABLE
- * DRM_FENCE_MASK_DRIVER
- */
-
-
-int drmFenceEmit(int fd, unsigned flags, drmFence *fence, unsigned emit_type)
-{
- drm_fence_arg_t arg;
-
- memset(&arg, 0, sizeof(arg));
- arg.fence_class = fence->fence_class;
- arg.flags = flags;
- arg.handle = fence->handle;
- arg.type = emit_type;
-
- if (ioctl(fd, DRM_IOCTL_FENCE_EMIT, &arg))
+ if (drmIoctl(fd, request, data))
return -errno;
- fence->fence_class = arg.fence_class;
- fence->type = arg.type;
- fence->signaled = arg.signaled;
- fence->sequence = arg.sequence;
- return 0;
-}
-
-/*
- * Valid flags are
- * DRM_FENCE_FLAG_WAIT_LAZY
- * DRM_FENCE_FLAG_WAIT_IGNORE_SIGNALS
- */
-
-#define DRM_IOCTL_TIMEOUT_USEC 3000000UL
-
-static unsigned long
-drmTimeDiff(struct timeval *now, struct timeval *then)
-{
- uint64_t val;
-
- val = now->tv_sec - then->tv_sec;
- val *= 1000000LL;
- val += now->tv_usec;
- val -= then->tv_usec;
-
- return (unsigned long) val;
-}
-
-static int
-drmIoctlTimeout(int fd, unsigned long request, void *argp)
-{
- int haveThen = 0;
- struct timeval then, now;
- int ret;
-
- do {
- ret = ioctl(fd, request, argp);
- if (ret != 0 && errno == EAGAIN) {
- if (!haveThen) {
- gettimeofday(&then, NULL);
- haveThen = 1;
- }
- gettimeofday(&now, NULL);
- }
- } while (ret != 0 && errno == EAGAIN &&
- drmTimeDiff(&now, &then) < DRM_IOCTL_TIMEOUT_USEC);
-
- if (ret != 0)
- return ((errno == EAGAIN) ? -EBUSY : -errno);
-
return 0;
}
-
-
-
-
-int drmFenceWait(int fd, unsigned flags, drmFence *fence, unsigned flush_type)
-{
- drm_fence_arg_t arg;
- int ret;
-
- if (flush_type == 0) {
- flush_type = fence->type;
- }
-
- if (!(fence->flags & DRM_FENCE_FLAG_SHAREABLE)) {
- if ((flush_type & fence->signaled) == flush_type) {
- return 0;
- }
- }
-
- memset(&arg, 0, sizeof(arg));
- arg.handle = fence->handle;
- arg.type = flush_type;
- arg.flags = flags;
-
-
- ret = drmIoctlTimeout(fd, DRM_IOCTL_FENCE_WAIT, &arg);
- if (ret)
- return ret;
-
- fence->fence_class = arg.fence_class;
- fence->type = arg.type;
- fence->signaled = arg.signaled;
- return arg.error;
-}
-
-static void drmBOCopyReply(const struct drm_bo_info_rep *rep, drmBO *buf)
-{
- buf->handle = rep->handle;
- buf->flags = rep->flags;
- buf->size = rep->size;
- buf->offset = rep->offset;
- buf->mapHandle = rep->arg_handle;
- buf->proposedFlags = rep->proposed_flags;
- buf->start = rep->buffer_start;
- buf->fenceFlags = rep->fence_flags;
- buf->replyFlags = rep->rep_flags;
- buf->pageAlignment = rep->page_alignment;
- buf->tileInfo = rep->tile_info;
- buf->hwTileStride = rep->hw_tile_stride;
- buf->desiredTileStride = rep->desired_tile_stride;
-}
-
-
-
-int drmBOCreate(int fd, unsigned long size,
- unsigned pageAlignment, void *user_buffer,
- uint64_t flags,
- unsigned hint, drmBO *buf)
-{
- struct drm_bo_create_arg arg;
- struct drm_bo_create_req *req = &arg.d.req;
- struct drm_bo_info_rep *rep = &arg.d.rep;
- int ret;
-
- memset(buf, 0, sizeof(*buf));
- memset(&arg, 0, sizeof(arg));
- req->flags = flags;
- req->hint = hint;
- req->size = size;
- req->page_alignment = pageAlignment;
- req->buffer_start = (unsigned long) user_buffer;
-
- buf->virtual = NULL;
-
- ret = drmIoctlTimeout(fd, DRM_IOCTL_BO_CREATE, &arg);
- if (ret)
- return ret;
-
- drmBOCopyReply(rep, buf);
- buf->virtual = user_buffer;
- buf->mapCount = 0;
-
- return 0;
-}
-
-int drmBOReference(int fd, unsigned handle, drmBO *buf)
-{
- struct drm_bo_reference_info_arg arg;
- struct drm_bo_handle_arg *req = &arg.d.req;
- struct drm_bo_info_rep *rep = &arg.d.rep;
-
- memset(&arg, 0, sizeof(arg));
- req->handle = handle;
-
- if (ioctl(fd, DRM_IOCTL_BO_REFERENCE, &arg))
- return -errno;
-
- drmBOCopyReply(rep, buf);
- buf->mapVirtual = NULL;
- buf->mapCount = 0;
- buf->virtual = NULL;
-
- return 0;
-}
-
-int drmBOUnreference(int fd, drmBO *buf)
-{
- struct drm_bo_handle_arg arg;
-
- if (buf->mapVirtual && buf->mapHandle) {
- (void) munmap(buf->mapVirtual, buf->start + buf->size);
- buf->mapVirtual = NULL;
- buf->virtual = NULL;
- }
-
- memset(&arg, 0, sizeof(arg));
- arg.handle = buf->handle;
-
- if (ioctl(fd, DRM_IOCTL_BO_UNREFERENCE, &arg))
- return -errno;
-
- buf->handle = 0;
- return 0;
-}
-
-
-/*
- * Flags can be DRM_BO_FLAG_READ, DRM_BO_FLAG_WRITE or'ed together
- * Hint currently be DRM_BO_HINT_DONT_BLOCK, which makes the
- * call return an -EBUSY if it can' immediately honor the mapping request.
- */
-
-int drmBOMap(int fd, drmBO *buf, unsigned mapFlags, unsigned mapHint,
- void **address)
-{
- struct drm_bo_map_wait_idle_arg arg;
- struct drm_bo_info_req *req = &arg.d.req;
- struct drm_bo_info_rep *rep = &arg.d.rep;
- int ret = 0;
-
- /*
- * Make sure we have a virtual address of the buffer.
- */
-
- if (!buf->virtual) {
- drmAddress virtual;
- virtual = mmap(0, buf->size + buf->start,
- PROT_READ | PROT_WRITE, MAP_SHARED,
- fd, buf->mapHandle);
- if (virtual == MAP_FAILED) {
- ret = -errno;
- }
- if (ret)
- return ret;
- buf->mapVirtual = virtual;
- buf->virtual = ((char *) virtual) + buf->start;
- }
-
- memset(&arg, 0, sizeof(arg));
- req->handle = buf->handle;
- req->mask = mapFlags;
- req->hint = mapHint;
-
- /*
- * May hang if the buffer object is busy.
- * This IOCTL synchronizes the buffer.
- */
-
- ret = drmIoctlTimeout(fd, DRM_IOCTL_BO_MAP, &arg);
- if (ret)
- return ret;
-
- drmBOCopyReply(rep, buf);
- buf->mapFlags = mapFlags;
- ++buf->mapCount;
- *address = buf->virtual;
-
- return 0;
-}
-
-
-int drmBOUnmap(int fd, drmBO *buf)
-{
- struct drm_bo_handle_arg arg;
-
- memset(&arg, 0, sizeof(arg));
- arg.handle = buf->handle;
-
- if (ioctl(fd, DRM_IOCTL_BO_UNMAP, &arg)) {
- return -errno;
- }
- buf->mapCount--;
- return 0;
-}
-
-int drmBOSetStatus(int fd, drmBO *buf,
- uint64_t flags, uint64_t mask,
- unsigned int hint,
- unsigned int desired_tile_stride,
- unsigned int tile_info)
-{
-
- struct drm_bo_map_wait_idle_arg arg;
- struct drm_bo_info_req *req = &arg.d.req;
- struct drm_bo_info_rep *rep = &arg.d.rep;
- int ret = 0;
-
- memset(&arg, 0, sizeof(arg));
- req->mask = mask;
- req->flags = flags;
- req->handle = buf->handle;
- req->hint = hint;
- req->desired_tile_stride = desired_tile_stride;
- req->tile_info = tile_info;
-
- ret = drmIoctlTimeout(fd, DRM_IOCTL_BO_SETSTATUS, &arg);
- if (ret)
- return ret;
-
- drmBOCopyReply(rep, buf);
- return 0;
-}
-
-
-int drmBOInfo(int fd, drmBO *buf)
-{
- struct drm_bo_reference_info_arg arg;
- struct drm_bo_handle_arg *req = &arg.d.req;
- struct drm_bo_info_rep *rep = &arg.d.rep;
- int ret = 0;
-
- memset(&arg, 0, sizeof(arg));
- req->handle = buf->handle;
-
- ret = ioctl(fd, DRM_IOCTL_BO_INFO, &arg);
- if (ret)
- return -errno;
-
- drmBOCopyReply(rep, buf);
- return 0;
-}
-
-int drmBOWaitIdle(int fd, drmBO *buf, unsigned hint)
-{
- struct drm_bo_map_wait_idle_arg arg;
- struct drm_bo_info_req *req = &arg.d.req;
- struct drm_bo_info_rep *rep = &arg.d.rep;
- int ret = 0;
-
- if ((buf->flags & DRM_BO_FLAG_SHAREABLE) ||
- (buf->replyFlags & DRM_BO_REP_BUSY)) {
- memset(&arg, 0, sizeof(arg));
- req->handle = buf->handle;
- req->hint = hint;
-
- ret = drmIoctlTimeout(fd, DRM_IOCTL_BO_WAIT_IDLE, &arg);
- if (ret)
- return ret;
-
- drmBOCopyReply(rep, buf);
- }
- return 0;
-}
-
-int drmBOBusy(int fd, drmBO *buf, int *busy)
-{
- int ret = drmBOInfo(fd, buf);
-
- if (ret)
- return ret;
-
- *busy = (buf->replyFlags & DRM_BO_REP_BUSY);
- return 0;
-}
-
-int drmMMInit(int fd, unsigned long pOffset, unsigned long pSize,
- unsigned memType)
-{
- struct drm_mm_init_arg arg;
-
- memset(&arg, 0, sizeof(arg));
-
- arg.magic = DRM_BO_INIT_MAGIC;
- arg.major = DRM_BO_INIT_MAJOR;
- arg.minor = DRM_BO_INIT_MINOR;
- arg.p_offset = pOffset;
- arg.p_size = pSize;
- arg.mem_type = memType;
-
- if (ioctl(fd, DRM_IOCTL_MM_INIT, &arg))
- return -errno;
- return 0;
-}
-
-int drmMMTakedown(int fd, unsigned memType)
-{
- struct drm_mm_type_arg arg;
-
- memset(&arg, 0, sizeof(arg));
- arg.mem_type = memType;
-
- if (ioctl(fd, DRM_IOCTL_MM_TAKEDOWN, &arg))
- return -errno;
- return 0;
-}
-
-/*
- * If this function returns an error, and lockBM was set to 1,
- * the buffer manager is NOT locked.
- */
-
-int drmMMLock(int fd, unsigned memType, int lockBM, int ignoreNoEvict)
-{
- struct drm_mm_type_arg arg;
-
- memset(&arg, 0, sizeof(arg));
- arg.mem_type = memType;
- arg.lock_flags |= (lockBM) ? DRM_BO_LOCK_UNLOCK_BM : 0;
- arg.lock_flags |= (ignoreNoEvict) ? DRM_BO_LOCK_IGNORE_NO_EVICT : 0;
-
- return drmIoctlTimeout(fd, DRM_IOCTL_MM_LOCK, &arg);
-}
-
-int drmMMUnlock(int fd, unsigned memType, int unlockBM)
-{
- struct drm_mm_type_arg arg;
-
- memset(&arg, 0, sizeof(arg));
-
- arg.mem_type = memType;
- arg.lock_flags |= (unlockBM) ? DRM_BO_LOCK_UNLOCK_BM : 0;
-
- return drmIoctlTimeout(fd, DRM_IOCTL_MM_UNLOCK, &arg);
-}
-
-int drmMMInfo(int fd, unsigned memType, uint64_t *size)
-{
- struct drm_mm_info_arg arg;
-
- memset(&arg, 0, sizeof(arg));
-
- arg.mem_type = memType;
-
- if (ioctl(fd, DRM_IOCTL_MM_INFO, &arg))
- return -errno;
-
- *size = arg.p_size;
- return 0;
-}
-
-int drmBOVersion(int fd, unsigned int *major,
- unsigned int *minor,
- unsigned int *patchlevel)
-{
- struct drm_bo_version_arg arg;
- int ret;
-
- memset(&arg, 0, sizeof(arg));
- ret = ioctl(fd, DRM_IOCTL_BO_VERSION, &arg);
- if (ret)
- return -errno;
-
- if (major)
- *major = arg.major;
- if (minor)
- *minor = arg.minor;
- if (patchlevel)
- *patchlevel = arg.patchlevel;
-
- return 0;
-}
-
-
#define DRM_MAX_FDS 16
static struct {