.size = size
};
- int ret = v3dv_ioctl(device->fd, DRM_IOCTL_V3D_CREATE_BO, &create);
- if (ret != 0)
+ int ret = v3dv_ioctl(device->render_fd, DRM_IOCTL_V3D_CREATE_BO, &create);
+ if (ret != 0) {
return NULL;
+ }
assert(create.offset % page_align == 0);
assert((create.offset & 0xffffffff) == create.offset);
struct drm_gem_close c;
memset(&c, 0, sizeof(c));
c.handle = bo->handle;
- int ret = v3dv_ioctl(device->fd, DRM_IOCTL_GEM_CLOSE, &c);
+ int ret = v3dv_ioctl(device->render_fd, DRM_IOCTL_GEM_CLOSE, &c);
if (ret != 0)
fprintf(stderr, "close object %d: %s\n", bo->handle, strerror(errno));
struct drm_v3d_mmap_bo map;
memset(&map, 0, sizeof(map));
map.handle = bo->handle;
- int ret = v3dv_ioctl(device->fd, DRM_IOCTL_V3D_MMAP_BO, &map);
+ int ret = v3dv_ioctl(device->render_fd, DRM_IOCTL_V3D_MMAP_BO, &map);
if (ret != 0) {
fprintf(stderr, "map ioctl failure\n");
return false;
}
bo->map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
- device->fd, map.offset);
+ device->render_fd, map.offset);
if (bo->map == MAP_FAILED) {
fprintf(stderr, "mmap of bo %d (offset 0x%016llx, size %d) failed\n",
bo->handle, (long long)map.offset, (uint32_t)bo->size);
.handle = bo->handle,
.timeout_ns = timeout_ns,
};
- return v3dv_ioctl(device->fd, DRM_IOCTL_V3D_WAIT_BO, &wait) == 0;
+ return v3dv_ioctl(device->render_fd, DRM_IOCTL_V3D_WAIT_BO, &wait) == 0;
}
bool
static void
physical_device_finish(struct v3dv_physical_device *device)
{
- close(device->local_fd);
- if (device->master_fd >= 0)
- close(device->master_fd);
+ close(device->render_fd);
if (device->display_fd >= 0)
close(device->display_fd);
{
VkResult result = VK_SUCCESS;
int32_t display_fd = -1;
- int32_t master_fd = -1;
device->_loader_data.loaderMagic = ICD_LOADER_MAGIC;
device->instance = instance;
if (render_fd < 0)
return vk_error(instance, VK_ERROR_INCOMPATIBLE_DRIVER);
- assert(strlen(path) < ARRAY_SIZE(device->path));
- snprintf(device->path, ARRAY_SIZE(device->path), "%s", path);
-
/* If we are running on real hardware we need to open the vc4 display
* device so we can allocate winsys BOs for the v3d core to render into.
*/
}
#endif
- device->local_fd = render_fd; /* The v3d render node */
+ device->render_fd = render_fd; /* The v3d render node */
device->display_fd = display_fd; /* The vc4 primary node */
- device->master_fd = master_fd; /* For VK_KHR_display */
uint8_t zeroes[VK_UUID_SIZE] = { 0 };
memcpy(device->pipeline_cache_uuid, zeroes, VK_UUID_SIZE);
#if using_v3d_simulator
- device->sim_file = v3d_simulator_init(device->local_fd);
+ device->sim_file = v3d_simulator_init(device->render_fd);
#endif
- if (!v3d_get_device_info(device->local_fd, &device->devinfo, &v3dv_ioctl)) {
+ if (!v3d_get_device_info(device->render_fd, &device->devinfo, &v3dv_ioctl)) {
result = VK_ERROR_INCOMPATIBLE_DRIVER;
goto fail;
}
close(render_fd);
if (display_fd >= 0)
close(display_fd);
- if (master_fd >= 0)
- close(master_fd);
return result;
}
else
device->alloc = physical_device->instance->alloc;
- device->fd = physical_device->local_fd;
- if (device->fd == -1) {
+ device->render_fd = physical_device->render_fd;
+ if (device->render_fd == -1) {
result = VK_ERROR_INITIALIZATION_FAILED;
goto fail;
}
device->devinfo = physical_device->devinfo;
device->enabled_extensions = enabled_extensions;
- int ret = drmSyncobjCreate(device->fd,
+ int ret = drmSyncobjCreate(device->render_fd,
DRM_SYNCOBJ_CREATE_SIGNALED,
&device->last_job_sync);
if (ret) {
{
V3DV_FROM_HANDLE(v3dv_device, device, _device);
- drmSyncobjDestroy(device->fd, device->last_job_sync);
+ drmSyncobjDestroy(device->render_fd, device->last_job_sync);
queue_finish(&device->queue);
vk_free2(&default_alloc, pAllocator, device);
{
V3DV_FROM_HANDLE(v3dv_device, device, _device);
- int ret =
- drmSyncobjWait(device->fd, &device->last_job_sync, 1, INT64_MAX, 0, NULL);
+ int ret = drmSyncobjWait(device->render_fd,
+ &device->last_job_sync, 1, INT64_MAX, 0, NULL);
if (ret)
return VK_ERROR_DEVICE_LOST;
int ret;
uint32_t handle;
- ret = drmPrimeFDToHandle(device->fd, fd, &handle);
+ ret = drmPrimeFDToHandle(device->render_fd, fd, &handle);
if (ret) {
result = VK_ERROR_INVALID_EXTERNAL_HANDLE;
goto fail;
struct drm_v3d_get_bo_offset get_offset = {
.handle = handle,
};
- ret = v3dv_ioctl(device->fd, DRM_IOCTL_V3D_GET_BO_OFFSET, &get_offset);
+ ret = v3dv_ioctl(device->render_fd, DRM_IOCTL_V3D_GET_BO_OFFSET, &get_offset);
if (ret) {
result = VK_ERROR_INVALID_EXTERNAL_HANDLE;
goto fail;
pGetFdInfo->handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
int fd, ret;
- ret = drmPrimeHandleToFD(device->fd, mem->bo->handle, DRM_CLOEXEC, &fd);
+ ret =
+ drmPrimeHandleToFD(device->render_fd, mem->bo->handle, DRM_CLOEXEC, &fd);
if (ret)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
struct v3dv_device_extension_table supported_extensions;
struct v3dv_physical_device_dispatch_table dispatch;
- char path[20];
char *name;
- int32_t local_fd;
+ int32_t render_fd;
int32_t display_fd;
- int32_t master_fd;
uint8_t pipeline_cache_uuid[VK_UUID_SIZE];
struct wsi_device wsi_device;
struct v3dv_device_extension_table enabled_extensions;
struct v3dv_device_dispatch_table dispatch;
- int32_t fd;
+ int32_t render_fd;
int32_t display_fd;
struct v3d_device_info devinfo;
struct v3dv_queue queue;
sem->fd = -1;
int fd;
- drmSyncobjExportSyncFile(device->fd, device->last_job_sync, &fd);
+ drmSyncobjExportSyncFile(device->render_fd, device->last_job_sync, &fd);
if (fd == -1)
return VK_ERROR_DEVICE_LOST;
- int ret = drmSyncobjImportSyncFile(device->fd, sem->sync, fd);
+ int ret = drmSyncobjImportSyncFile(device->render_fd, sem->sync, fd);
if (ret)
return VK_ERROR_DEVICE_LOST;
fence->fd = -1;
int fd;
- drmSyncobjExportSyncFile(device->fd, device->last_job_sync, &fd);
+ drmSyncobjExportSyncFile(device->render_fd, device->last_job_sync, &fd);
if (fd == -1)
return VK_ERROR_DEVICE_LOST;
- int ret = drmSyncobjImportSyncFile(device->fd, fence->sync, fd);
+ int ret = drmSyncobjImportSyncFile(device->render_fd, fence->sync, fd);
if (ret)
return VK_ERROR_DEVICE_LOST;
struct v3dv_device *device = job->cmd_buffer->device;
v3dv_clif_dump(device, job, &submit);
- int ret = v3dv_ioctl(device->fd, DRM_IOCTL_V3D_SUBMIT_CL, &submit);
+ int ret = v3dv_ioctl(device->render_fd, DRM_IOCTL_V3D_SUBMIT_CL, &submit);
static bool warned = false;
if (ret && !warned) {
fprintf(stderr, "Draw call returned %s. Expect corruption.\n",
sem->fd = -1;
- int ret = drmSyncobjCreate(device->fd, 0, &sem->sync);
+ int ret = drmSyncobjCreate(device->render_fd, 0, &sem->sync);
if (ret) {
vk_free2(&device->alloc, pAllocator, sem);
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
if (sem == NULL)
return;
- drmSyncobjDestroy(device->fd, sem->sync);
+ drmSyncobjDestroy(device->render_fd, sem->sync);
if (sem->fd != -1)
close(sem->fd);
unsigned flags = 0;
if (pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT)
flags |= DRM_SYNCOBJ_CREATE_SIGNALED;
- int ret = drmSyncobjCreate(device->fd, flags, &fence->sync);
+ int ret = drmSyncobjCreate(device->render_fd, flags, &fence->sync);
if (ret) {
vk_free2(&device->alloc, pAllocator, fence);
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
if (fence == NULL)
return;
- drmSyncobjDestroy(device->fd, fence->sync);
+ drmSyncobjDestroy(device->render_fd, fence->sync);
if (fence->fd != -1)
close(fence->fd);
V3DV_FROM_HANDLE(v3dv_device, device, _device);
V3DV_FROM_HANDLE(v3dv_fence, fence, _fence);
- int ret = drmSyncobjWait(device->fd, &fence->sync, 1,
+ int ret = drmSyncobjWait(device->render_fd, &fence->sync, 1,
0, DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT, NULL);
if (ret == -ETIME)
return VK_NOT_READY;
syncobjs[i] = fence->sync;
}
- int ret = drmSyncobjReset(device->fd, syncobjs, fenceCount);
+ int ret = drmSyncobjReset(device->render_fd, syncobjs, fenceCount);
vk_free(&device->alloc, syncobjs);
int ret;
do {
- ret = drmSyncobjWait(device->fd, syncobjs, fenceCount,
+ ret = drmSyncobjWait(device->render_fd, syncobjs, fenceCount,
timeout, flags, NULL);
} while (ret == -ETIME && gettime_ns() < abs_timeout);
v3dv_physical_device_to_handle(physical_device),
v3dv_wsi_proc_addr,
&physical_device->instance->alloc,
- physical_device->master_fd,
- NULL, false);
+ -1, NULL, false);
if (result != VK_SUCCESS)
return result;