int etna_pipe_wait(struct etna_pipe *pipe, uint32_t timestamp, uint32_t ms) { struct etna_device *dev = pipe->gpu->dev; int ret; struct drm_etnaviv_wait_fence req = { .pipe = pipe->gpu->core, .fence = timestamp, }; if (ms == 0) req.flags |= ETNA_WAIT_NONBLOCK; get_abs_timeout(&req.timeout, ms); ret = drmCommandWrite(dev->fd, DRM_ETNAVIV_WAIT_FENCE, &req, sizeof(req)); if (ret) { ERROR_MSG("wait-fence failed! %d (%s)", ret, strerror(errno)); return ret; } return 0; } void etna_pipe_del(struct etna_pipe *pipe) { free(pipe); }
static int xen_timerop_set_next_event(unsigned long delta, struct clock_event_device *evt) { WARN_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT); if (HYPERVISOR_set_timer_op(get_abs_timeout(delta)) < 0) BUG(); return 0; }
static int xen_timerop_set_next_event(unsigned long delta, struct clock_event_device *evt) { WARN_ON(!clockevent_state_oneshot(evt)); if (HYPERVISOR_set_timer_op(get_abs_timeout(delta)) < 0) BUG(); /* We may have missed the deadline, but there's no real way of knowing for sure. If the event was in the past, then we'll get an immediate interrupt. */ return 0; }
static int xen_vcpuop_set_next_event(unsigned long delta, struct clock_event_device *evt) { int cpu = smp_processor_id(); struct vcpu_set_singleshot_timer single; int ret; WARN_ON(!clockevent_state_oneshot(evt)); single.timeout_abs_ns = get_abs_timeout(delta); single.flags = VCPU_SSHOTTMR_future; ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single); BUG_ON(ret != 0 && ret != -ETIME); return ret; }
static int msm_pipe_wait(struct fd_pipe *pipe, uint32_t timestamp) { struct fd_device *dev = pipe->dev; struct drm_msm_wait_fence req = { .fence = timestamp, }; int ret; get_abs_timeout(&req.timeout, 5000); ret = drmCommandWrite(dev->fd, DRM_MSM_WAIT_FENCE, &req, sizeof(req)); if (ret) { ERROR_MSG("wait-fence failed! %d (%s)", ret, strerror(errno)); return ret; } return 0; }
static int xen_vcpuop_set_next_event(unsigned long delta, struct clock_event_device *evt) { int cpu = smp_processor_id(); struct vcpu_set_singleshot_timer single; int ret; WARN_ON(!clockevent_state_oneshot(evt)); single.timeout_abs_ns = get_abs_timeout(delta); /* Get an event anyway, even if the timeout is already expired */ single.flags = 0; ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single); BUG_ON(ret != 0); return ret; }
static int bo_allocate(struct msm_bo *msm_bo) { struct fd_bo *bo = &msm_bo->base; if (!msm_bo->offset) { struct drm_msm_gem_info req = { .handle = bo->handle, }; int ret; /* if the buffer is already backed by pages then this * doesn't actually do anything (other than giving us * the offset) */ ret = drmCommandWriteRead(bo->dev->fd, DRM_MSM_GEM_INFO, &req, sizeof(req)); if (ret) { ERROR_MSG("alloc failed: %s", strerror(errno)); return ret; } msm_bo->offset = req.offset; } return 0; } static int msm_bo_offset(struct fd_bo *bo, uint64_t *offset) { struct msm_bo *msm_bo = to_msm_bo(bo); int ret = bo_allocate(msm_bo); if (ret) return ret; *offset = msm_bo->offset; return 0; } static int msm_bo_cpu_prep(struct fd_bo *bo, struct fd_pipe *pipe, uint32_t op) { struct drm_msm_gem_cpu_prep req = { .handle = bo->handle, .op = op, }; get_abs_timeout(&req.timeout, 5000000000); return drmCommandWrite(bo->dev->fd, DRM_MSM_GEM_CPU_PREP, &req, sizeof(req)); } static void msm_bo_cpu_fini(struct fd_bo *bo) { struct drm_msm_gem_cpu_fini req = { .handle = bo->handle, }; drmCommandWrite(bo->dev->fd, DRM_MSM_GEM_CPU_FINI, &req, sizeof(req)); } static void msm_bo_destroy(struct fd_bo *bo) { struct msm_bo *msm_bo = to_msm_bo(bo); free(msm_bo); } static const struct fd_bo_funcs funcs = { .offset = msm_bo_offset, .cpu_prep = msm_bo_cpu_prep, .cpu_fini = msm_bo_cpu_fini, .destroy = msm_bo_destroy, }; /* allocate a buffer handle: */ drm_private int msm_bo_new_handle(struct fd_device *dev, uint32_t size, uint32_t flags, uint32_t *handle) { struct drm_msm_gem_new req = { .size = size, .flags = MSM_BO_WC, // TODO figure out proper flags.. }; int ret; ret = drmCommandWriteRead(dev->fd, DRM_MSM_GEM_NEW, &req, sizeof(req)); if (ret) return ret; *handle = req.handle; return 0; } /* allocate a new buffer object */ drm_private struct fd_bo * msm_bo_from_handle(struct fd_device *dev, uint32_t size, uint32_t handle) { struct msm_bo *msm_bo; struct fd_bo *bo; msm_bo = calloc(1, sizeof(*msm_bo)); if (!msm_bo) return NULL; bo = &msm_bo->base; bo->funcs = &funcs; bo->fd = -1; return bo; }