/**
* Main entrypoint for syncpoint value waits.
*/
int nvhost_syncpt_wait_timeout(struct nvhost_syncpt *sp, u32 id,
u32 thresh, u32 timeout, u32 *value)
{
DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
void *ref;
int err = 0;
if (value)
*value = 0;
BUG_ON(!check_max(sp, id, thresh));
/* first check cache */
if (nvhost_syncpt_min_cmp(sp, id, thresh)) {
if (value)
*value = nvhost_syncpt_read_min(sp, id);
return 0;
}
/* keep host alive */
nvhost_module_busy(&syncpt_to_dev(sp)->mod);
if (client_managed(id) || !nvhost_syncpt_min_eq_max(sp, id)) {
/* try to read from register */
u32 val = nvhost_syncpt_update_min(sp, id);
if ((s32)(val - thresh) >= 0) {
if (value)
*value = val;
goto done;
}
}
if (!timeout) {
err = -EAGAIN;
goto done;
}
/* schedule a wakeup when the syncpoint value is reached */
err = nvhost_intr_add_action(&(syncpt_to_dev(sp)->intr), id, thresh,
NVHOST_INTR_ACTION_WAKEUP_INTERRUPTIBLE, &wq, &ref);
if (err)
goto done;
err = -EAGAIN;
/* wait for the syncpoint, or timeout, or signal */
while (timeout) {
u32 check = min_t(u32, SYNCPT_CHECK_PERIOD, timeout);
int remain = wait_event_interruptible_timeout(wq,
nvhost_syncpt_min_cmp(sp, id, thresh),
check);
if (remain > 0 || nvhost_syncpt_min_cmp(sp, id, thresh)) {
if (value)
*value = nvhost_syncpt_read_min(sp, id);
err = 0;
break;
}
if (remain < 0) {
err = remain;
break;
}
if (timeout != NVHOST_NO_TIMEOUT)
timeout -= check;
if (timeout) {
dev_warn(&syncpt_to_dev(sp)->pdev->dev,
"syncpoint id %d (%s) stuck waiting %d\n",
id, nvhost_syncpt_name(id), thresh);
nvhost_syncpt_debug(sp);
}
};
nvhost_intr_put_ref(&(syncpt_to_dev(sp)->intr), ref);
done:
nvhost_module_idle(&syncpt_to_dev(sp)->mod);
return err;
}
int nvhost_3dctx_prepare_power_off(struct nvhost_module *mod)
{
struct nvhost_channel *ch =
container_of(mod, struct nvhost_channel, mod);
struct nvhost_hwctx *hwctx_to_save;
DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
u32 syncpt_incrs, syncpt_val;
int err = 0;
void *ref;
void *ctx_waiter = NULL, *wakeup_waiter = NULL;
ctx_waiter = nvhost_intr_alloc_waiter();
wakeup_waiter = nvhost_intr_alloc_waiter();
if (!ctx_waiter || !wakeup_waiter) {
err = -ENOMEM;
goto done;
}
if (mod->desc->busy)
mod->desc->busy(mod);
mutex_lock(&ch->submitlock);
hwctx_to_save = ch->cur_ctx;
if (!hwctx_to_save) {
mutex_unlock(&ch->submitlock);
goto done;
}
err = nvhost_cdma_begin(&ch->cdma, hwctx_to_save->timeout);
if (err) {
mutex_unlock(&ch->submitlock);
goto done;
}
hwctx_to_save->valid = true;
ch->ctxhandler.get(hwctx_to_save);
ch->cur_ctx = NULL;
syncpt_incrs = hwctx_to_save->save_incrs;
syncpt_val = nvhost_syncpt_incr_max(&ch->dev->syncpt,
NVSYNCPT_3D, syncpt_incrs);
ch->ctxhandler.save_push(&ch->cdma, hwctx_to_save);
nvhost_cdma_end(&ch->cdma, ch->dev->nvmap, NVSYNCPT_3D, syncpt_val,
NULL, 0, hwctx_to_save->timeout);
err = nvhost_intr_add_action(&ch->dev->intr, NVSYNCPT_3D,
syncpt_val - syncpt_incrs + hwctx_to_save->save_thresh,
NVHOST_INTR_ACTION_CTXSAVE, hwctx_to_save,
ctx_waiter,
NULL);
ctx_waiter = NULL;
WARN(err, "Failed to set context save interrupt");
err = nvhost_intr_add_action(&ch->dev->intr, NVSYNCPT_3D, syncpt_val,
NVHOST_INTR_ACTION_WAKEUP, &wq,
wakeup_waiter,
&ref);
wakeup_waiter = NULL;
WARN(err, "Failed to set wakeup interrupt");
wait_event(wq,
nvhost_syncpt_min_cmp(&ch->dev->syncpt,
NVSYNCPT_3D, syncpt_val));
nvhost_intr_put_ref(&ch->dev->intr, ref);
nvhost_cdma_update(&ch->cdma);
mutex_unlock(&ch->submitlock);
done:
kfree(ctx_waiter);
kfree(wakeup_waiter);
return err;
}
/**
* Main entrypoint for syncpoint value waits.
*/
int nvhost_syncpt_wait_timeout(struct nvhost_syncpt *sp, u32 id,
u32 thresh, u32 timeout)
{
DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
void *ref;
int err = 0;
//struct nvhost_dev *dev = syncpt_to_dev(sp);
BUG_ON(!check_max(sp, id, thresh));
/* first check cache */
if (nvhost_syncpt_min_cmp(sp, id, thresh))
return 0;
/* keep host alive */
nvhost_module_busy(&syncpt_to_dev(sp)->mod);
if (client_managed(id) || !nvhost_syncpt_min_eq_max(sp, id)) {
/* try to read from register */
u32 val = nvhost_syncpt_update_min(sp, id);
if ((s32)(val - thresh) >= 0)
goto done;
}
if (!timeout) {
err = -EAGAIN;
goto done;
}
/* schedule a wakeup when the syncpoint value is reached */
err = nvhost_intr_add_action(&(syncpt_to_dev(sp)->intr), id, thresh,
NVHOST_INTR_ACTION_WAKEUP_INTERRUPTIBLE, &wq, &ref);
if (err)
goto done;
/* wait for the syncpoint, or timeout, or signal */
while (timeout) {
u32 check = min_t(u32, SYNCPT_CHECK_PERIOD, timeout);
err = wait_event_interruptible_timeout(wq,
nvhost_syncpt_min_cmp(sp, id, thresh),
check);
if (err != 0)
break;
if (timeout != NVHOST_NO_TIMEOUT)
timeout -= SYNCPT_CHECK_PERIOD;
if (timeout) {
dev_warn(&syncpt_to_dev(sp)->pdev->dev,
"syncpoint id %d (%s) stuck waiting %d timeout=%d\n",
id, nvhost_syncpt_name(id), thresh, timeout);
/* A wait queue in nvhost driver maybe run frequently
when early suspend/late resume. These log will be
printed,then the early suspend/late resume
maybe blocked,then it will triger early suspend/late
resume watchdog. Now we cancel these log. */
/*
nvhost_syncpt_debug(sp);
nvhost_channel_fifo_debug(dev);
nvhost_sync_reg_dump(dev);
*/
}
};
if (err > 0)
err = 0;
else if (err == 0)
err = -EAGAIN;
nvhost_intr_put_ref(&(syncpt_to_dev(sp)->intr), ref);
done:
nvhost_module_idle(&syncpt_to_dev(sp)->mod);
return err;
}
/**
* Main entrypoint for syncpoint value waits.
*/
int nvhost_syncpt_wait_timeout(struct nvhost_syncpt *sp, u32 id,
u32 thresh, u32 timeout, u32 *value)
{
DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
void *ref;
void *waiter;
int err = 0, check_count = 0, low_timeout = 0;
static int print_once = 0;
if (value)
*value = 0;
BUG_ON(!syncpt_op(sp).update_min);
if (!nvhost_syncpt_check_max(sp, id, thresh)) {
dev_warn(&syncpt_to_dev(sp)->pdev->dev,
"wait %d (%s) for (%d) wouldn't be met (max %d)\n",
id, syncpt_op(sp).name(sp, id), thresh,
nvhost_syncpt_read_max(sp, id));
nvhost_debug_dump(syncpt_to_dev(sp));
return -EINVAL;
}
/* first check cache */
if (nvhost_syncpt_min_cmp(sp, id, thresh)) {
if (value)
*value = nvhost_syncpt_read_min(sp, id);
return 0;
}
/* keep host alive */
nvhost_module_busy(syncpt_to_dev(sp)->dev);
if (client_managed(id) || !nvhost_syncpt_min_eq_max(sp, id)) {
/* try to read from register */
u32 val = syncpt_op(sp).update_min(sp, id);
if ((s32)(val - thresh) >= 0) {
if (value)
*value = val;
goto done;
}
}
if (!timeout) {
err = -EAGAIN;
goto done;
}
/* schedule a wakeup when the syncpoint value is reached */
waiter = nvhost_intr_alloc_waiter();
if (!waiter) {
err = -ENOMEM;
goto done;
}
err = nvhost_intr_add_action(&(syncpt_to_dev(sp)->intr), id, thresh,
NVHOST_INTR_ACTION_WAKEUP_INTERRUPTIBLE, &wq,
waiter,
&ref);
if (err)
goto done;
err = -EAGAIN;
/* wait for the syncpoint, or timeout, or signal */
while (timeout) {
u32 check = min_t(u32, SYNCPT_CHECK_PERIOD, timeout);
int remain = wait_event_interruptible_timeout(wq,
nvhost_syncpt_min_cmp(sp, id, thresh),
check);
if (remain > 0 || nvhost_syncpt_min_cmp(sp, id, thresh)) {
if (value)
*value = nvhost_syncpt_read_min(sp, id);
err = 0;
break;
}
if (remain < 0) {
err = remain;
break;
}
if (timeout != NVHOST_NO_TIMEOUT) {
if (timeout < SYNCPT_CHECK_PERIOD) {
/* Caller-specified timeout may be impractically low */
low_timeout = timeout;
}
timeout -= check;
}
if (timeout) {
dev_warn(&syncpt_to_dev(sp)->pdev->dev,
"%s: syncpoint id %d (%s) stuck waiting %d, timeout=%d\n",
current->comm, id, syncpt_op(sp).name(sp, id),
thresh, timeout);
syncpt_op(sp).debug(sp);
print_once++;
if (print_once == 1)
{
nvhost_debug_dump(syncpt_to_dev(sp));
debug_stuck_syncpoint();
}
if (check_count > MAX_STUCK_CHECK_COUNT) {
if (low_timeout) {
dev_warn(&syncpt_to_dev(sp)->pdev->dev,
"is timeout %d too low?\n",
low_timeout);
}
nvhost_debug_dump(syncpt_to_dev(sp));
BUG();
}
check_count++;
}
}
nvhost_intr_put_ref(&(syncpt_to_dev(sp)->intr), ref);
done:
nvhost_module_idle(syncpt_to_dev(sp)->dev);
return err;
}
/**
* For all sync queue entries that have already finished according to the
* current sync point registers:
* - unpin & unref their mems
* - pop their push buffer slots
* - remove them from the sync queue
* This is normally called from the host code's worker thread, but can be
* called manually if necessary.
* Must be called with the cdma lock held.
*/
static void update_cdma(struct nvhost_cdma *cdma)
{
bool signal = false;
struct nvhost_master *dev = cdma_to_dev(cdma);
BUG_ON(!cdma->running);
/*
* Walk the sync queue, reading the sync point registers as necessary,
* to consume as many sync queue entries as possible without blocking
*/
for (;;) {
u32 syncpt_id, syncpt_val;
u32 timeout;
struct nvhost_userctx_timeout *timeout_ref = NULL;
unsigned int nr_slots, nr_handles;
struct nvhost_syncpt *sp = &dev->syncpt;
struct nvmap_handle **handles;
struct nvmap_client *nvmap;
u32 *sync;
sync = sync_queue_head(&cdma->sync_queue);
if (!sync) {
if (cdma->event == CDMA_EVENT_SYNC_QUEUE_EMPTY)
signal = true;
break;
}
syncpt_id = sync[SQ_IDX_SYNCPT_ID];
syncpt_val = sync[SQ_IDX_SYNCPT_VAL];
timeout = sync[SQ_IDX_TIMEOUT];
timeout_ref = (struct nvhost_userctx_timeout *)
sync[SQ_IDX_TIMEOUT_CTX];
BUG_ON(syncpt_id == NVSYNCPT_INVALID);
/* Check whether this syncpt has completed, and bail if not */
if (!nvhost_syncpt_min_cmp(sp, syncpt_id, syncpt_val)) {
/* Start timer on next pending syncpt */
if (timeout) {
nvhost_cdma_start_timer(cdma, syncpt_id,
syncpt_val, timeout_ref);
}
break;
}
/* Cancel timeout, when a buffer completes */
if (cdma->timeout.ctx_timeout)
stop_cdma_timer(cdma);
nr_slots = sync[SQ_IDX_NUM_SLOTS];
nr_handles = sync[SQ_IDX_NUM_HANDLES];
nvmap = (struct nvmap_client *)sync[SQ_IDX_NVMAP_CTX];
handles = (struct nvmap_handle **)&sync[SQ_IDX_HANDLES];
BUG_ON(!nvmap);
/* Unpin the memory */
nvmap_unpin_handles(nvmap, handles, nr_handles);
nvmap_client_put(nvmap);
/* Pop push buffer slots */
if (nr_slots) {
struct push_buffer *pb = &cdma->push_buffer;
BUG_ON(!cdma_pb_op(cdma).pop_from);
cdma_pb_op(cdma).pop_from(pb, nr_slots);
if (cdma->event == CDMA_EVENT_PUSH_BUFFER_SPACE)
signal = true;
}
dequeue_sync_queue_head(&cdma->sync_queue);
if (cdma->event == CDMA_EVENT_SYNC_QUEUE_SPACE)
signal = true;
}
/* Wake up CdmaWait() if the requested event happened */
if (signal) {
cdma->event = CDMA_EVENT_NONE;
up(&cdma->sem);
}
}
